Spring NamedParameterJdbcTemplate (original) (raw)

Last Updated : 4 May, 2026

NamedParameterJdbcTemplate is a class in the Spring JDBC framework that enhances database access by allowing the use of named parameters instead of traditional ? placeholders. It works as a wrapper around JdbcTemplate and internally delegates execution to it.

Allows use of named parameters (e.g., :id, :name) instead of positional parameters.
Supports passing parameters using Map or SqlParameterSource for flexibility.
Improves readability and reduces errors caused by incorrect parameter ordering.

Syntax of execute()

public T execute(String sql, SqlParameterSource paramSource, PreparedStatementCallback action)

**sql: SQL query with named parameters (e.g., :id, :name)
**paramSource: SqlParameterSource implementation (like MapSqlParameterSource) for binding parameters
**paramMap: Map-based parameter binding (simpler alternative)
**action: Callback interface used to execute operations on PreparedStatement

Step-by-Step Implementation

This section demonstrates how to configure, implement, and run a Spring application using NamedParameterJdbcTemplate to perform database operations in a structured manner.

Step 1: Create Database Table

Create a table to store student data.
Ensure id is the primary key.

CREATE TABLE STUDENT (

id INT PRIMARY KEY,

name VARCHAR(45),

department VARCHAR(45)

);

**Step 2: Add Maven Dependencies

Add Spring JDBC and Context for database operations.
Add MySQL driver for database connectivity. XML `

org.springframework spring-jdbc 5.3.23

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.23</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>

**Step 3: Configure Spring Beans (AppConfig.java)

Configure DataSource to connect to the database.
Define NamedParameterJdbcTemplate bean. Java `

@Configuration @ComponentScan(basePackages = "com.example") public class AppConfig {

@Bean
public DataSource dataSource() {
    DriverManagerDataSource ds = new DriverManagerDataSource();
    ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
    ds.setUrl("jdbc:mysql://localhost:3306/school_db");
    ds.setUsername("dbuser");
    ds.setPassword("securepassword");
    return ds;
}

@Bean
public NamedParameterJdbcTemplate namedParameterJdbcTemplate() {
    return new NamedParameterJdbcTemplate(dataSource());
}

}

Step 4: Create Model Class (Student.java)

Represents the STUDENT table.
Contains fields, constructor, and getters/setters. Java `

public class Student { private int id; private String name; private String department;

public Student(int id, String name, String department) {
    this.id = id;
    this.name = name;
    this.department = department;
}

// getters and setters

}

Step 5: Create DAO Class (StudentDao.java**)

Handles database operations.
Uses named parameters for SQL queries. Java `

@Repository public class StudentDao {

private final NamedParameterJdbcTemplate jdbcTemplate;

@Autowired
public StudentDao(NamedParameterJdbcTemplate jdbcTemplate) {
    this.jdbcTemplate = jdbcTemplate;
}

public void insertStudent(Student student) {
    String sql = "INSERT INTO STUDENT (id, name, department) VALUES (:id, :name, :dept)";

    MapSqlParameterSource params = new MapSqlParameterSource()
            .addValue("id", student.getId())
            .addValue("name", student.getName())
            .addValue("dept", student.getDepartment());

    jdbcTemplate.update(sql, params);
}

public Optional<Student> findById(int id) {
    String sql = "SELECT * FROM STUDENT WHERE id = :id";

    try {
        Student student = jdbcTemplate.queryForObject(
                sql,
                Collections.singletonMap("id", id),
                (rs, rowNum) -> new Student(
                        rs.getInt("id"),
                        rs.getString("name"),
                        rs.getString("department"))
        );
        return Optional.of(student);
    } catch (EmptyResultDataAccessException e) {
        return Optional.empty();
    }
}

}

**Step 6: Run the Application

Load Spring context.
Insert and fetch student data. Java `

public class StudentApplication { public static void main(String[] args) {

    AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);

    StudentDao dao = context.getBean(StudentDao.class);

    Student student = new Student(1, "Geek", "Computer Science");
    dao.insertStudent(student);

    dao.findById(1).ifPresent(System.out::println);

    context.close();
}

}

**Output:

Output

Outputc

Student [id=1, name=Geek, department=Computer Science]

Benefits of NamedParameterJdbcTemplate over JdbcTemplate

Uses named parameters instead of ? placeholders.
Queries are easier to read and maintain.
Reduces errors in complex SQL queries.
Simplifies parameter mapping and improves code clarity.