RowMapper

RowMapper is a core interface in Spring JDBC that helps map rows of a database ResultSet into Java objects. It allows developers to convert SQL query results into domain objects cleanly and efficiently, avoiding manual iteration over the ResultSet.

What is RowMapper in Spring JDBC?

RowMapper is an interface with a single method mapRow(ResultSet rs, int rowNum) that maps a single row of a ResultSet to a Java object.

• Purpose: To separate database query results from Java object creation, keeping code clean, reusable, and maintainable.
• Usage: Used with JdbcTemplate.query() methods to fetch single or multiple rows from the database.

👉 In simple words:

RowMapper = How each row of a query result becomes a Java object.

Example:

publicclassUserRowMapperimplementsRowMapper<User> {
@Override
public UsermapRow(ResultSet rs, int rowNum)throws SQLException {
Useruser=newUser();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
return user;
    }
}

// Usage with JdbcTemplate
List<User> users = jdbcTemplate.query("SELECT * FROM users",newUserRowMapper());

Alternative: BeanPropertyRowMapper can be used for automatic mapping based on field names:

List<User> users = jdbcTemplate.query(
"SELECT * FROM users",
newBeanPropertyRowMapper<>(User.class)
);

Why Use RowMapper?

• Simplifies ResultSet Handling: Automatically maps each row of a ResultSet to a Java object, avoiding manual iteration.
• Keeps Code Clean & Reusable: Encapsulates mapping logic in one place, making it reusable across queries.
• Reduces Boilerplate Code: Eliminates repetitive code for extracting columns and setting object fields.
• Supports Custom and Automatic Mapping
  • Custom mapping via RowMapper implementation
  • Automatic mapping via BeanPropertyRowMapper

• Works Seamlessly with JdbcTemplate: Used directly in query() methods for single or multiple row results.

String sql = "SELECT * FROM users";
List<User> users = jdbcTemplate.query(sql, (rs, rowNum) -> {
    User user = new User();
    user.setId(rs.getLong("id"));
    user.setName(rs.getString("name"));
    user.setEmail(rs.getString("email"));
    return user;
});

Core Concept

• Interface: org.springframework.jdbc.core.RowMapper<T> — a generic interface for mapping rows.
• Method to Implement: T mapRow(ResultSet rs, int rowNum) — called for each row in the ResultSet.
• Purpose: Transform a single database row into a corresponding Java object of type T.

Optional example for completeness:

publicclassUserRowMapperimplementsRowMapper<User> {
@Override
public UsermapRow(ResultSet rs, int rowNum)throws SQLException {
Useruser=newUser();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
return user;
    }
}

How to Use RowMapper

RowMapper is used to map each row of a ResultSet to a Java object. You can implement it using an anonymous class, a lambda expression, or a separate reusable class for clean and maintainable code.

1. Using an Anonymous Class

Maps each row of the ResultSet to a Java object directly in-place, without creating a separate class. Good for quick, one-off queries.

Stringsql="SELECT * FROM users";

List<User> users = jdbcTemplate.query(sql,newRowMapper<User>() {
@Override
public UsermapRow(ResultSet rs, int rowNum)throws SQLException {
Useruser=newUser();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
return user;
    }
});

2. Using Lambda Expression (Java 8+)

Provides a concise way to implement RowMapper inline using a lambda, reducing boilerplate and improving readability.

List<User> users = jdbcTemplate.query(sql, (rs, rowNum) -> {
returnnewUser(
        rs.getLong("id"),
        rs.getString("name"),
        rs.getString("email")
    );
});

3. Creating a Separate RowMapper Class (Reusable)

Encapsulates mapping logic in a dedicated class, making it reusable across multiple queries and keeping business logic clean and separate.

publicclassUserRowMapperimplementsRowMapper<User> {
@Override
public UsermapRow(ResultSet rs, int rowNum)throws SQLException {
returnnewUser(
            rs.getLong("id"),
            rs.getString("name"),
            rs.getString("email")
        );
    }
}

Usage:

List<User> users = jdbcTemplate.query("SELECT * FROM users",newUserRowMapper());

When to Use RowMapper

Use RowMapper when:

• You need custom mapping from ResultSet to Java objects
• Queries return complex objects or multiple columns
• You want reusable mapping logic

Not necessary when:

• Query returns a single column (use queryForObject)
• You are using Spring Data JPA (JPA handles mapping automatically)

RowMapper vs BeanPropertyRowMapper

Example: Using BeanPropertyRowMapper

List<User> users = jdbcTemplate.query(
"SELECT * FROM users",
newBeanPropertyRowMapper<>(User.class)
);

Conclusion

RowMapper is a core interface in Spring JDBC for mapping database rows to Java objects.

• Provides clean, reusable mapping logic
• Works with both JdbcTemplate and NamedParameterJdbcTemplate
• Ideal for reading multiple rows into domain objects
• Can be custom or automatic (BeanPropertyRowMapper) depending on the use case