La conectividad de base de datos de Java (API de JDBC) proporciona acceso universal a datos desde cualquier fuente de datos (incluidas bases de datos relacionales, hojas de cálculo y archivos sin formato). JdbcTemplate es el enfoque más básico y clásico para el acceso a datos. NamedParameterJdbcTemplate envuelve JdbcTemplate y permite el uso de parámetros con nombre en lugar del tradicional JDBC ‘?’ marcador de posición
Ejemplo
En este ejemplo, insertaremos los datos del estudiante (id, nombre, departamento) en nuestra fuente de datos usando parámetros con nombre. NamedParameterJdbcTemplate tiene varios métodos, usaremos el método execute() para este ejemplo.
Sintaxis del método execute() de NamedParameterJdbcTemplate:
pubic T execute(String sql, Map map, PreparedStatementCallback psc)
Para este tutorial, usaremos el siguiente esquema para la tabla Student.
Student(id INT, name VARCHAR(45), department VARCHAR(45))
Implementación paso a paso
Paso 1: Crear tabla
En este paso, crearemos una tabla de Estudiantes para almacenar la información de los estudiantes. Para este tutorial, asumiremos que ha creado la siguiente tabla en su base de datos.
CREATE TABLE STUDENT( id INT, name VARCHAR(45), department VARCHAR(45));
Paso 2: Agregar dependencias
En este paso, agregaremos las dependencias de maven a nuestra aplicación. Agregue las siguientes dependencias a su pom.xml
XML
<dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.16</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.8.RELEASE</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.44</version> </dependency> </dependencies>
Paso 3: crea una clase modelo
Ahora, crearemos una clase modelo para nuestros estudiantes. Esta clase tendrá id, nombre y departamento de variables de tres miembros. También definiremos su método getters y setters junto con el método toString() y los constructores.
Java
public class Student {
// member variables
private int id;
private String name;
private String department;
public Student() {}
// parameterized constructor
public Student(int id, String name, String department) {
super();
this.id = id;
this.name = name;
this.department = department;
}
// getters and setters method
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
// toString() method
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", department=" + department + "]";
}
}
Paso 4: Crea una clase StudentDao
En este paso, crearemos una clase StudentDao y definiremos el método insertStudentInfo() y proporcionaremos su definición para insertar datos en nuestra fuente de datos.
Java
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.PreparedStatementCallback;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import com.geeksforgeeks.model.Student;
public class StudentDao{
// Defining NamedParameterJdbcTemplate as member variable in order
// to use the execute() method of the NamedParameterJdbcTemplate's class
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
// Constructor
public StudentDao(NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
}
// User defined method to insert query data in data source
public void insertStudentInfo(Student student) {
String sqlQuery = "INSERT INTO student VALUES(:id, :name, :department)";
Map<String, Object> map = new HashMap<String, Object>();
map.put("id", student.getId());
map.put("name", student.getName());
map.put("department", student.getDepartment());
namedParameterJdbcTemplate.execute(sqlQuery, map, new PreparedStatementCallback() {
public Object doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
return ps.executeUpdate();
}
});
}
}
Paso 5: Configuración de Bean
En este paso, crearemos el archivo de configuración Spring y lo llamaremos application-contex.xml . Configuraremos nuestros beans y usaremos el atributo de método de fábrica para la creación de beans. Para realizar una conexión a la base de datos, necesitamos la siguiente información: nombre de usuario, contraseña, conexión a la base de datos, URL y el nombre de la clase del controlador. Toda esta información está contenida en la clase DriverManagerDataSource , tiene el método getConnection() que devuelve una conexión de tipo java. Usamos la instancia de NamedParameterJdbcTemplate en nuestra clase StudentDao y la pasamos usando el método de inyección del constructor.
Nota : en el contexto de la aplicación, debe definir la ruta completa de su clase dao
XML
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/student_db?autoReconnect=true&useSSL=false" /> <property name="username" value="root" /> <property name="password" value="root" /> </bean> <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"> <constructor-arg ref="dataSource"></constructor-arg> </bean> <bean id="studentDao" class="com.geeksforgeeks.dao.StudentDao"> <constructor-arg><ref bean="namedParameterJdbcTemplate"/></constructor-arg> </bean> </beans>
Paso 6: Creando Clase de Utilidades
Ahora, crearemos una clase de utilidad para probar nuestra aplicación. Para esto, cree una nueva clase y asígnele el nombre TestNamedParameterJdbcTemplate.java y agregue el siguiente código.
Java
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import com.geeksforgeeks.dao.StudentDao;
import com.geeksforgeeks.model.Student;
public class TestNamedParameterJdbcTemplate {
public static void main(String[] agrs) {
// Reading the application-context file using
// class path of spring context xml file
Resource resource = new ClassPathResource("application-context.xml");
BeanFactory factory = new XmlBeanFactory(resource);
// Spring check the blueprint for studentDao bean
// from application-context.xml file and return it
StudentDao studentDao = (StudentDao)factory.getBean("studentDao");
Student studentObj = new Student(1, "geek", "computer science department");
studentDao.insertStudentInfo(studentObj);
System.out.println(studentObj);
}
}
Paso 7: Salida
Ahora ejecutaremos nuestra aplicación.
