JdbcTemplate (Spring JDBC)

JdbcTemplate is a core Spring JDBC utility that makes working with relational databases simple and clean by handling low-level JDBC operations automatically. It lets developers focus on writing SQL and business logic instead of boilerplate code.

What is JdbcTemplate (Spring JDBC)?

JdbcTemplate is a Spring-provided helper class that:

• Executes SQL queries and updates
• Manages database connections, statements, and result sets
• Converts SQLException into Spring’s unchecked DataAccessException
• Integrates smoothly with Spring transactions (@Transactional)

In simple words:

JdbcTemplate = Write SQL directly in Spring without worrying about JDBC complexity

It is lightweight, fast, and SQL-centric, making it ideal when you need full control over queries without using an ORM like JPA or Hibernate.

Why Use JdbcTemplate?

Without JdbcTemplate (Plain JDBC):

• Too much boilerplate code
• Manual connection and resource handling
• Error-prone exception management

With JdbcTemplate:

• Automatic connection & resource management
• Clean and readable code
• Consistent exception handling
• Full control over SQL queries

How JdbcTemplate Works

Application Code
      ↓
JdbcTemplate
      ↓
DataSource (Connection Pool)
      ↓
Database (MySQL / PostgreSQL icon)

Key Features of JdbcTemplate

Basic Setup

1. Dependency (Spring Boot)

Adds Spring JDBC support to the project and enables auto-configuration for DataSource and JdbcTemplate.

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

2. Database Configuration (application.properties)

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=pass
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Auto-Configuration

With the dependency and properties in place, Spring Boot automatically creates DataSource and JdbcTemplate beans—no manual setup required.

Once auto-configuration is done, you can directly inject and use JdbcTemplate:

@Service
publicclassUserService {

@Autowired
private JdbcTemplate jdbcTemplate;

publicintcountUsers() {
return jdbcTemplate.queryForObject(
"SELECT COUNT(*) FROM users",
            Integer.class
        );
    }
}

Common Operations

1. Insert / Update / Delete

update() executes INSERT, UPDATE, or DELETE queries and returns the number of affected rows.

@Autowired
private JdbcTemplate jdbcTemplate;

public int saveUser(String name, String email) {
    String sql = "INSERT INTO users(name, email) VALUES (?, ?)";
    return jdbcTemplate.update(sql, name, email);
}

2. Query for Single Object

Fetches exactly one record from the database and maps it to a Java object or simple value.

public User getUserById(Long id) {
    String sql = "SELECT * FROM users WHERE id = ?";
    return jdbcTemplate.queryForObject(
        sql,
        new BeanPropertyRowMapper<>(User.class),
        id
    );
}

3. Query for Multiple Rows

Executes a SELECT query and returns a list of mapped objects, one for each row in the result set.

public List<User> getAllUsers() {
    String sql = "SELECT * FROM users";
    return jdbcTemplate.query(
        sql,
        new BeanPropertyRowMapper<>(User.class)
    );
}

4. Custom RowMapper (Optional)

Gives full control over how each database row is converted into a Java object, useful for complex mappings.

public List<User> getUsers() {
    return jdbcTemplate.query(
        "SELECT * FROM users",
        (rs, rowNum) -> new User(
            rs.getLong("id"),
            rs.getString("name"),
            rs.getString("email")
        )
    );
}

JdbcTemplate vs Spring Data JDBC vs JPA

When to Use JdbcTemplate?

Use JdbcTemplate when:

• You want full control over SQL
• Performance is critical
• Queries are complex
• No need for ORM features

Avoid when:

• You need lazy loading or entity relationships
• Large domain models with many entities
• Prefer minimal SQL writing

Real-World Use Cases

• Reporting & Analytics Queries: Ideal for complex SQL queries and reports where performance and full SQL control are required.
• Legacy Database Integration: Works well with existing databases that do not fit clean ORM models.
• High-Performance Read/Write Services: Suitable for performance-critical applications where predictable execution is important.
• Microservices with Simple DB Logic: Perfect for small, focused services that need straightforward database operations without ORM overhead.

Conclusion

JdbcTemplate is the simplest and most reliable way to work with JDBC in Spring.

It provides full SQL control, reduces boilerplate, and ensures clean, maintainable code without ORM complexity.

Use it when you need explicit SQL management, high performance, and predictable behavior in database operations.