SimpleJDBCTemplate incluye todas las características y funcionalidades de la clase JdbcTemplate y también es compatible con las características de Java5 , como var-args (argumentos variables) y autoboxing. Junto con la clase JdbcTemplate, también proporciona el método update() que toma dos argumentos, la consulta SQL y argumentos arbitrarios que dependen de la consulta SQL. Para acceder a los métodos de la antigua clase JdbcTemplate, usamos el método getJdbcOperations() y llamamos a todos esos métodos sobre SimpleJdbcTemplate.
Nota : Necesitamos pasar los parámetros dentro del método update() en el mismo orden en que los definimos en la consulta parametrizada.
Sintaxis para el método update() de la clase SimpleJDBCTemplate:
int update(String sqlQuery, Object parameters)
Ejemplo
En este ejemplo, actualizaremos los detalles de un estudiante usando el método update() de la clase SimpleJDBCTemplate. 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));
Después de crear la tabla, insertaremos los siguientes datos en nuestra tabla.
INSERT INTO STUDENT VALUES(1, "geek", "computer science");
Paso 2: Agregar dependencias
En este paso, agregaremos las dependencias de maven a nuestra aplicación. Agregue las siguientes dependencias a su pom.xml
Nota : Spring 3 JDBC admite la clase SimpleJDBCTemplate y las características de Java5
XML
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.geeksforgeeks</groupId> <artifactId>SimpleJDBCTemplate</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>3.0.0.RELEASE</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> </project>
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 sus constructores, métodos getters y setters, y el método toString().
Java
public class Student {
// member variables
private int id;
private String name;
private String department;
// no args constructor
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 DAO
En este paso, crearemos una clase StudentDao.java. En esta clase, definiremos el método SimpleJdbcTemplate y update() y proporcionaremos su definición para actualizar nuestros datos.
Java
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import com.geeksforgeeks.model.Student;
public class StudentDao{
// Defining SimpleJdbcTemplate as member variable in order
// to use the update() method of the SimpleJdbcTemplate's class
private SimpleJdbcTemplate simpleJdbcTemplate;
// Constructor - used to inject dependency
// using constructor injection
// defined in application-context
public StudentDao(SimpleJdbcTemplate simpleJdbcTemplate) {
super();
this.simpleJdbcTemplate = simpleJdbcTemplate;
}
// we will maintain the order of parameters with the
// parameters present in parameterized query
// here, first we have passed name and then id as
// we define in query first name then id
public int update(Student student) {
String sqlQuery = "UPDATE student SET name=? WHERE id=?";
return simpleJdbcTemplate.update(sqlQuery, student.getName(), student.getId());
}
}
Paso 5: Configuración de Bean
En este paso, crearemos el archivo de configuración de Spring y lo llamaremos application-contex.xml . 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 SimpleJdbcTemplate en nuestra clase StudentDao y la pasamos usando el método de inyección del constructor.
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="simpleJdbcTemplate" class="org.springframework.jdbc.core.simple.SimpleJdbcTemplate"> <constructor-arg ref = "dataSource"></constructor-arg> </bean> <bean id="studentDao" class="com.geeksforgeeks.dao.StudentDao"> <constructor-arg><ref bean = "simpleJdbcTemplate"/></constructor-arg> </bean> </beans>
Nota : en el contexto de la aplicación, debe definir la ruta completa de su clase dao
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 TestSimpleJDBCTemplate.java y agregue el siguiente código.
Java
import org.springframework.core.io.Resource;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import com.geeksforgeeks.dao.StudentDao;
import com.geeksforgeeks.model.Student;
public class TestSimpleJDBCTemplate {
public static void main(String[] args) {
// Reading the application-context using ClassPathResources
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");
// This will return a boolean value as 1 or 0
int res = studentDao.update(new Student(1, "Rohan", "computer science"));
System.out.println(res);
}
}
Producción:
Ahora ejecutaremos nuestra aplicación. Si el método update() devuelve 1, significa que la consulta se ejecuta correctamente, de lo contrario no.
Fig. 1 – Salida de la consola
También lo cotejaremos ejecutando la consulta en la base de datos. Hemos creado una tabla de estudiantes e insertado los siguientes datos 1, «geek», «informática» respectivamente.
SELECT * FROM student;
Fig. 2 – Salida de la base de datos