Spring JDBC - Guía rápida

Mientras se trabaja con una base de datos usando JDBC simple, se vuelve engorroso escribir código innecesario para manejar excepciones, abrir y cerrar conexiones de bases de datos, etc. Sin embargo, Spring JDBC Framework se encarga de todos los detalles de bajo nivel comenzando por abrir la conexión, preparar y ejecutar la instrucción SQL, procesar excepciones, manejar transacciones y finalmente cerrar la conexión.

Lo que tiene que hacer es simplemente definir los parámetros de conexión y especificar la declaración SQL que se ejecutará y realizar el trabajo requerido para cada iteración mientras obtiene datos de la base de datos.

Spring JDBC proporciona varios enfoques y las correspondientes clases diferentes para interactuar con la base de datos. En este tutorial, tomaremos el enfoque clásico y más popular que hace uso de la clase JDBC Template del marco. Esta es la clase de marco central que administra toda la comunicación de la base de datos y el manejo de excepciones.

Clase de plantilla JDBC

La clase JDBC Template ejecuta consultas SQL, actualiza declaraciones y llamadas a procedimientos almacenados, realiza iteraciones sobre ResultSets y extracción de valores de parámetros devueltos. También detecta las excepciones de JDBC y las traduce a la jerarquía de excepciones genérica, más informativa, definida en el paquete org.springframework.dao.

Las instancias de la clase Plantilla JDBC son seguras para subprocesos una vez configuradas. Por lo tanto, puede configurar una sola instancia de una plantilla JDBC y luego inyectar de manera segura esta referencia compartida en múltiples DAO.

Una práctica común cuando se usa la clase JDBC Template es configurar un DataSource en su archivo de configuración de Spring y luego inyectar la dependencia ese bean de DataSource compartido en sus clases DAO. La plantilla JDBC se crea en el establecedor para el origen de datos.

Objeto de acceso a datos (DAO)

DAO significa Data Access Objectque se usa comúnmente para la interacción con la base de datos. Los DAO existen para proporcionar un medio para leer y escribir datos en la base de datos y deben exponer esta funcionalidad a través de una interfaz mediante la cual el resto de la aplicación accederá a ellos.

El soporte de objeto de acceso a datos (DAO) en Spring facilita el trabajo con tecnologías de acceso a datos como JDBC, Hibernate, JPA o JDO de manera coherente.

Este capítulo lo lleva a través del proceso de configuración de Spring-AOP en sistemas basados ​​en Windows y Linux. Spring AOP se puede instalar e integrar fácilmente con su entorno Java actual y MAVEN siguiendo unos sencillos pasos sin ningún procedimiento de configuración complejo. Se requiere la administración de usuarios durante la instalación.

Requisitos del sistema

JDK Java SE 2 JDK 1.5 o superior
Memoria 1 GB de RAM (recomendado)
Espacio del disco Sin requisito mínimo
Versión del sistema operativo Windows XP o superior, Linux

Procedamos ahora con los pasos para instalar Spring AOP.

Paso 1: verificar la instalación de Java

En primer lugar, debe tener el kit de desarrollo de software Java (SDK) instalado en su sistema. Para verificar esto, ejecute cualquiera de los siguientes dos comandos dependiendo de la plataforma en la que esté trabajando.

Si la instalación de Java se ha realizado correctamente, mostrará la versión actual y la especificación de su instalación de Java. En la siguiente tabla se proporciona un resultado de muestra.

Plataforma Mando Salida de muestra
Ventanas

Abra la consola de comandos y escriba -

\>java -version

Versión de Java "1.7.0_60"

Entorno de tiempo de ejecución Java (TM) SE (compilación 1.7.0_60-b19)

VM de servidor Java Hotspot (TM) de 64 bits (compilación 24.60-b09, modo mixto)

Linux

Abra el terminal de comando y escriba -

$java -version

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución abierto de JDK (rhel-2.3.10.4.el6_4-x86_64)

Abra la máquina virtual del servidor JDK de 64 bits (compilación 23.7-b01, modo mixto)

Suponemos que los lectores de este tutorial tienen la versión 1.7.0_60 de Java SDK instalada en su sistema. En caso de que no tenga Java SDK, descargue su versión actual desdehttps://www.oracle.com/technetwork/java/javase/downloads/index.html y tenerlo instalado.

Paso 2: configura tu entorno Java

Configure la variable de entorno JAVA_HOME para que apunte a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo,

Plataforma Descripción
Ventanas Establezca JAVA_HOME en C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux Exportar JAVA_HOME = / usr / local / java-current

Agregue la ruta completa de la ubicación del compilador de Java a la ruta del sistema.

Plataforma Descripción
Ventanas Agregue la cadena "C: \ Archivos de programa \ Java \ jdk1.7.0_60 \ bin" al final de la variable de sistema PATH.
Linux Exportar RUTA = $ RUTA: $ JAVA_HOME / bin /

Ejecuta el comando java -version desde el símbolo del sistema como se explicó anteriormente.

Paso 3: descarga el archivo de Maven

Descarga Maven 3.3.3 desde https://maven.apache.org/download.cgi

SO Nombre de archivo
Ventanas apache-maven-3.3.3-bin.zip
Linux apache-maven-3.3.3-bin.tar.gz
Mac apache-maven-3.3.3-bin.tar.gz

Paso 4: extraiga el archivo de Maven

Extraiga el archivo en el directorio en el que desea instalar Maven 3.3.3. El subdirectorio apache-maven-3.3.3 se creará a partir del archivo.

SO Ubicación (puede ser diferente según su instalación)
Ventanas C: \ Archivos de programa \ Apache Software Foundation \ apache-maven-3.3.3
Linux / usr / local / apache-maven
Mac / usr / local / apache-maven

Paso 5: establece las variables de entorno de Maven

Agregue M2_HOME, M2, MAVEN_OPTS a las variables de entorno.

SO Salida
Ventanas

Establezca las variables de entorno mediante las propiedades del sistema.

M2_HOME = C: \ Archivos de programa \ Apache Software Foundation \ apachemaven-3.3.3

M2 =% M2_HOME% \ bin

MAVEN_OPTS = -Xms256m -Xmx512m

Linux

Abra el terminal de comando y configure las variables de entorno.

exportar M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3

exportar M2 = $ M2_HOME / bin

exportar MAVEN_OPTS = -Xms256m -Xmx512m

Mac

Abra el terminal de comando y configure las variables de entorno.

exportar M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3

exportar M2 = $ M2_HOME / bin

exportar MAVEN_OPTS = -Xms256m -Xmx512m

Paso 6: agregue la ubicación del directorio Maven Bin a la ruta del sistema

Ahora agregue la variable M2 a la ruta del sistema.

SO Salida
Ventanas Agregue la cadena;% M2% al final de la variable de sistema, Ruta.
Linux export PATH = $ M2: $ PATH
Mac export PATH = $ M2: $ PATH

Paso 7: verificar la instalación de Maven

Ahora abra la consola, ejecute lo siguiente mvn mando.

SO Tarea Mando
Ventanas Abrir consola de comandos c: \> mvn --version
Linux Terminal de comando abierto $ mvn --version
Mac Terminal abierta máquina: <joseph $ mvn --version

Finalmente, verifique la salida de los comandos anteriores, que deberían ser como sigue:

SO Salida
Ventanas

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Inicio de Maven: C: \ Archivos de programa \ Apache Software Foundation \ apache-maven-3.3.3

Versión de Java: 1.7.0_75, proveedor: Oracle Corporation

Inicio de Java: C: \ Archivos de programa \ Java \ jdk1.7.0_75 \ jre

Configuración regional predeterminada: en_US, codificación de plataforma: Cp1252

Linux

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Hogar de Maven: /usr/local/apache-maven/apache-maven-3.3.3

Versión de Java: 1.7.0_75, proveedor: Oracle Corporation

Inicio de Java: /usr/local/java-current/jdk1.7.0_75/jre

Mac

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Hogar de Maven: /usr/local/apache-maven/apache-maven-3.3.3

Versión de Java: 1.7.0_75, proveedor: Oracle Corporation

Inicio de Java: /Library/Java/Home/jdk1.7.0_75/jre

Paso 8: configurar el IDE de Eclipse

Todos los ejemplos de este tutorial se han escrito utilizando Eclipse IDE. Por lo tanto, le sugiero que tenga instalada la última versión de Eclipse en su máquina.

Para instalar Eclipse IDE, descargue los últimos binarios de Eclipse desde https://www.eclipse.org/downloads/. Una vez que haya descargado la instalación, descomprima la distribución binaria en una ubicación conveniente. Por ejemplo, en C: \ eclipse en Windows o / usr / local / eclipse en Linux / Unix. Finalmente, establezca la variable PATH de manera apropiada.

Eclipse se puede iniciar ejecutando los siguientes comandos en una máquina con Windows, o simplemente puede hacer doble clic en eclipse.exe.

%C:\eclipse\eclipse.exe

Eclipse se puede iniciar ejecutando los siguientes comandos en una máquina Unix (Solaris, Linux, etc.).

$/usr/local/eclipse/eclipse

Después de un inicio exitoso, si todo está bien, debería mostrar el siguiente resultado.

Una vez que haya terminado con este último paso, estará listo para continuar con su primer ejemplo de JDBC que verá en el siguiente capítulo.

Creemos una tabla de base de datos Student en nuestra base de datos TEST. Supongo que está trabajando con la base de datos MySQL, si trabaja con cualquier otra base de datos, puede cambiar sus consultas DDL y SQL en consecuencia.

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Ahora necesitamos proporcionar una fuente de datos a la plantilla JDBC para que pueda configurarse para obtener acceso a la base de datos. Puede configurar DataSource en el archivo XML con un fragmento de código que se muestra a continuación:

<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/TEST"/>
   <property name = "username" value = "root"/>
   <property name = "password" value = "admin"/>
</bean>

En el próximo capítulo, escribiremos la primera aplicación usando la base de datos configurada.

Para comprender los conceptos relacionados con el marco Spring JDBC con la clase Plantilla JDBC, escribamos un ejemplo simple que implementará operaciones de inserción y lectura en la siguiente tabla de estudiantes.

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Procedamos a escribir una aplicación Spring JDBC simple basada en consola, que demostrará los conceptos de JDBC.

Crear proyecto

Abramos la consola de comandos, vayamos al directorio C: \ MVN y ejecutemos lo siguiente mvn mando.

C:\MVN>mvn archetype:generate -DgroupId = com.tutorialspoint -DartifactId = Student
   -DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false

Maven comenzará a procesar y creará la estructura completa del proyecto de la aplicación Java.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.4:generate (default-cli) > generate-sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.4:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.4:generate (default-cli) @ standalone-pom --
-
[INFO] Generating project in Batch mode
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar (5 KB at 1.1 KB/s
ec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom (703 B at 1.2 KB/
sec)
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
 maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\Student
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:17 min
[INFO] Finished at: 2017-02-19T21:11:14+05:30
[INFO] Final Memory: 15M/114M
[INFO] ------------------------------------------------------------------------

Ahora vaya al directorio C: / MVN. Verá un proyecto de aplicación Java creado llamado student (como se especifica en artifactId). Actualice POM.xml para incluir las dependencias de Spring JDBC. Agregue los archivos Student.java, StudentMapper.java, MainApp.java, StudentDAO.java y StudentJDBCTemplate.java.

POM.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 
   http://maven.apache.org/maven-v4_0_0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>Student</artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>Student</name>
   <url>http://maven.apache.org</url>
   
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId>
         <version>4.1.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>4.1.4.RELEASE</version>
      </dependency>
   </dependencies>
   
</project>

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to create
      * a record in the Student table.
   */
   public void create(String name, Integer age);
   public Student getStudent(Integer id);
   
   /** 
     * This is the method to be used to list down
     * all the records from the Student table.
   */
   public List<Student> listStudents();
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void create(String name, Integer age) {
      String SQL = "insert into Student (name, age) values (?, ?)";
      
      jdbcTemplateObject.update( SQL, name, age);
      System.out.println("Created Record Name = " + name + " Age = " + age);
      return;
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = (StudentJDBCTemplate)
         context.getBean("studentJDBCTemplate");
      
      System.out.println("------Records Creation--------" );
      studentJDBCTemplate.create("Zara", 11);
      studentJDBCTemplate.create("Nuha", 2);
      studentJDBCTemplate.create("Ayan", 15);

      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Records Creation--------
Created Record Name = Zara Age = 11
Created Record Name = Nuha Age = 2
Created Record Name = Ayan Age = 15
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15

El siguiente ejemplo demostrará cómo crear una consulta usando Insertar consulta con la ayuda de Spring JDBC. Insertaremos algunos registros en la tabla de estudiantes.

Sintaxis

String insertQuery = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);

Dónde,

  • insertQuery - Insertar consulta con marcadores de posición.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para insertar el objeto del alumno en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que insertará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto creado por el estudiante en el capítuloSpring JDBC - First Application.
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
     * This is the method to be used to create
     * a record in the Student table.
   */
   public void create(String name, Integer age);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void create(String name, Integer age) {
      String insertQuery = "insert into Student (name, age) values (?, ?)";
      jdbcTemplateObject.update( insertQuery, name, age);
      System.out.println("Created Record Name = " + name + " Age = " + age);
      return;
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Records Creation--------" );
      studentJDBCTemplate.create("Zara", 11);
      studentJDBCTemplate.create("Nuha", 2);
      studentJDBCTemplate.create("Ayan", 15);

      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Records Creation--------
Created Record Name = Zara Age = 11
Created Record Name = Nuha Age = 2
Created Record Name = Ayan Age = 15
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15

El siguiente ejemplo demostrará cómo leer una consulta usando Spring JDBC. Leeremos los registros disponibles en la tabla de estudiantes.

Sintaxis

String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());

Dónde,

  • selectQuery - Seleccionar consulta para leer alumnos.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer el objeto del alumno desde la base de datos.

  • StudentMapper - StudentMapper es un objeto RowMapper para asignar cada registro obtenido a un objeto de estudiante.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que seleccionará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id="studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15

El siguiente ejemplo demostrará cómo actualizar una consulta usando Spring JDBC. Actualizaremos los registros disponibles en la tabla de estudiantes.

Sintaxis

String updateQuery = "update Student set age = ? where id = ?";
jdbcTemplateObject.update(updateQuery, age, id);

Dónde,

  • updateQuery - Consulta de actualización para actualizar al alumno con marcadores de posición.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para actualizar el objeto Student en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que actualizará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to update
      * a record into the Student table.
   */
   public void update(Integer id, Integer age);

   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void update(Integer id, Integer age){
      String SQL = "update Student set age = ? where id = ?";
      jdbcTemplateObject.update(SQL, age, id);
      System.out.println("Updated Record with ID = " + id );
      return;
   }
   public Student getStudent(Integer id) {
      String SQL = "select * from Student where id = ?";
      Student student = jdbcTemplateObject.queryForObject(
         SQL, new Object[]{id}, new StudentMapper());
      
      return student;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("----Updating Record with ID = 2 -----" );
      studentJDBCTemplate.update(2, 20);
      
      System.out.println("----Listing Record with ID = 2 -----" );
      Student student = studentJDBCTemplate.getStudent(2);
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
      System.out.println(", Age : " + student.getAge());  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20

El siguiente ejemplo demostrará cómo eliminar una consulta usando Spring JDBC. Eliminaremos uno de los registros disponibles en Student Table.

Sintaxis

String deleteQuery = "delete from Student where id = ?";
jdbcTemplateObject.update(deleteQuery, id);

Dónde,

  • deleteQuery - Eliminar consulta para eliminar al alumno con marcadores de posición.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para eliminar el objeto Student en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que eliminará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();
   
   /** 
      * This is the method to be used to delete
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public void delete(Integer id); 
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
   public void delete(Integer id){
      String SQL = "delete from Student where id = ?";
      jdbcTemplateObject.update(SQL, id);
      System.out.println("Deleted Record with ID = " + id );
      return;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("----Delete Record with ID = 2 -----" );
      studentJDBCTemplate.delete(2);

      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }     
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource"  ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20

El siguiente ejemplo demostrará cómo llamar a un procedimiento almacenado usando Spring JDBC. Leeremos uno de los registros disponibles en Student Table llamando a un procedimiento almacenado. Pasaremos una identificación y recibiremos un registro de estudiante.

Sintaxis

SimpleJdbcCall jdbcCall = new SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);

Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));

Dónde,

  • jdbcCall - Objeto SimpleJdbcCall para representar un procedimiento almacenado.

  • in - Objeto SqlParameterSource para pasar un parámetro a un procedimiento almacenado.

  • student - Objeto de estudiante.

  • out - Objeto de mapa para representar la salida del resultado de la llamada al procedimiento almacenado.

los SimpleJdbcCallLa clase se puede usar para llamar a un procedimiento almacenado con parámetros IN y OUT. Puede utilizar este enfoque mientras trabaja con cualquiera de los RDBMS como Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle y Sybase.

Para comprender el enfoque, considere el siguiente procedimiento almacenado de MySQL, que toma la identificación del estudiante y devuelve el nombre y la edad del estudiante correspondiente utilizando los parámetros OUT. Creemos este procedimiento almacenado en la base de datos TEST usando el símbolo del sistema de MySQL -

DELIMITER $$ DROP PROCEDURE IF EXISTS `TEST`.`getRecord` $$
CREATE PROCEDURE `TEST`.`getRecord` (
IN in_id INTEGER,
OUT out_name VARCHAR(20),
OUT out_age  INTEGER)
BEGIN
   SELECT name, age
   INTO out_name, out_age
   FROM Student where id = in_id;
END $$

DELIMITER ;

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que llamará a un procedimiento almacenado. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);  
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public Student getStudent(Integer id) {
      SimpleJdbcCall jdbcCall = new 
         SimpleJdbcCall(dataSource).withProcedureName("getRecord");

      SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
      Map<String, Object> out = jdbcCall.execute(in);

      Student student = new Student();
      student.setId(id);
      student.setName((String) out.get("out_name"));
      student.setAge((Integer) out.get("out_age"));
      return student;      
   }
}

El código que escribe para la ejecución de la llamada implica la creación de un SqlParameterSource que contiene el parámetro IN. Es importante hacer coincidir el nombre proporcionado para el valor de entrada con el nombre del parámetro declarado en el procedimiento almacenado. El método de ejecución toma los parámetros IN y devuelve un mapa que contiene los parámetros de salida introducidos por el nombre especificado en el procedimiento almacenado.

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      Student student = studentJDBCTemplate.getStudent(1);
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
      System.out.println(", Age : " + student.getAge()); 
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

ID : 1, Name : Zara, Age : 11

El siguiente ejemplo demostrará cómo llamar a una función almacenada usando Spring JDBC. Leeremos uno de los registros disponibles en Student Table llamando a una función almacenada. Pasaremos una identificación y recibiremos un nombre de estudiante.

Sintaxis

SimpleJdbcCall jdbcCall = new 
   SimpleJdbcCall(dataSource).withFunctionName("get_student_name");

SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
String name = jdbcCall.executeFunction(String.class, in);

Student student = new Student();
student.setId(id);
student.setName(name);

Dónde,

  • in - Objeto SqlParameterSource para pasar un parámetro a una función almacenada.

  • jdbcCall - Objeto SimpleJdbcCall para representar una función almacenada.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate a la función almacenada llamada desde la base de datos.

  • student - Objeto de estudiante.

los SimpleJdbcCallLa clase se puede usar para llamar a una función almacenada con el parámetro IN y un valor de retorno. Puede utilizar este enfoque mientras trabaja con cualquiera de los RDBMS como Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle y Sybase.

Para comprender el enfoque, considere el siguiente procedimiento almacenado de MySQL, que toma la identificación del estudiante y devuelve el nombre del estudiante correspondiente. Así que permítanos crear esta función almacenada en su base de datos TEST usando el símbolo del sistema de MySQL -

DELIMITER $$

DROP FUNCTION IF EXISTS `TEST`.`get_student_name` $$
CREATE FUNCTION `get_student_name` (in_id INTEGER)
RETURNS varchar(200)
BEGIN
DECLARE out_name VARCHAR(200);
   SELECT name
   INTO out_name
   FROM Student where id = in_id;

RETURN out_name;

DELIMITER ;

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que llamará a una función almacenada. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);  
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public Student getStudent(Integer id) {
      SimpleJdbcCall jdbcCall = new 
         SimpleJdbcCall(dataSource).withFunctionName("get_student_name");
	   
      SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
      String name = jdbcCall.executeFunction(String.class, in);
      Student student = new Student();
      student.setId(id);
      student.setName(name);
      return student;      
   }
}

El código que escribe para la ejecución de la llamada implica la creación de un SqlParameterSource que contiene el parámetro IN. Es importante hacer coincidir el nombre proporcionado para el valor de entrada con el nombre del parámetro declarado en la función almacenada. El método executeFunction toma los parámetros IN y devuelve una cadena como se especifica en la función almacenada.

A continuación se muestra el contenido de la MainApp.java archivo

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      Student student = studentJDBCTemplate.getStudent(1);
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

ID : 1, Name : Zara

El siguiente ejemplo demostrará cómo actualizar un BLOB usando una consulta de actualización con la ayuda de Spring JDBC. Actualizaremos los registros disponibles en la tabla de estudiantes.

Mesa de estudiantes

CREATE TABLE Student(
   ID INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE INT NOT NULL,
   IMAGE BLOB,
   PRIMARY KEY (ID)
);

Sintaxis

MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("image",  new SqlLobValue(new ByteArrayInputStream(imageData), 
   imageData.length, new DefaultLobHandler()), Types.BLOB);

String SQL = "update Student set image = :image where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);

Dónde,

  • in - Objeto SqlParameterSource para pasar un parámetro para actualizar una consulta.

  • SqlLobValue - Objeto para representar un parámetro de valor SQL BLOB / CLOB.

  • jdbcTemplateObject - Objeto NamedParameterJdbcTemplate para actualizar el objeto del estudiante en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que actualizará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to update
      * a record into the Student table.
   */
   public void updateImage(Integer id, byte[] imageData);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;
   private byte[] image;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
   public byte[] getImage() {
      return image;
   }
   public void setImage(byte[] image) {
      this.image = image;
   }
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      student.setImage(rs.getBytes("image"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;

import java.io.ByteArrayInputStream;
import java.sql.Types;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
   }
   public void updateImage(Integer id, byte[] imageData) {
      MapSqlParameterSource in = new MapSqlParameterSource();
      in.addValue("id", id);
      in.addValue("image",  new SqlLobValue(new ByteArrayInputStream(imageData), 
         imageData.length, new DefaultLobHandler()), Types.BLOB);

      String SQL = "update Student set image = :image where id = :id";
      NamedParameterJdbcTemplate jdbcTemplateObject = new 
         NamedParameterJdbcTemplate(dataSource);
      
      jdbcTemplateObject.update(SQL, in);
      System.out.println("Updated Record with ID = " + id );
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      byte[] imageData = {0,1,0,8,20,40,95};
      studentJDBCTemplate.updateImage(1, imageData);  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

Updated Record with ID = 1

Puede comprobar el byte [] almacenado consultando la base de datos.

El siguiente ejemplo demostrará cómo actualizar un CLOB usando una consulta de actualización con la ayuda de Spring JDBC. Actualizaremos los registros disponibles en la tabla de estudiantes.

Mesa de estudiantes

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   DESCRIPTION LONGTEXT,
   PRIMARY KEY (ID)
);

Sintaxis

MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description",  new SqlLobValue(
   description, new DefaultLobHandler()), Types.CLOB);

String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);

jdbcTemplateObject.update(SQL, in);

Dónde,

  • in - Objeto SqlParameterSource para pasar un parámetro para actualizar una consulta.

  • SqlLobValue - Objeto para representar un parámetro de valor SQL BLOB / CLOB.

  • jdbcTemplateObject - Objeto NamedParameterJdbcTemplate para actualizar el objeto del estudiante en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo, que actualizará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to update
      * a record into the Student table.
   */
   public void updateDescription(Integer id, String description);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;
   private String description;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
   public String getDescription() {
      return description;
   }
   public void setDescription(String description) {
      this.description = description;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      student.setDescription(rs.getString("description"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;

import java.io.ByteArrayInputStream;
import java.sql.Types;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
   }
   public void updateDescription(Integer id, String description) {
      MapSqlParameterSource in = new MapSqlParameterSource();
      in.addValue("id", id);
      in.addValue("description",  new SqlLobValue(description, 
         new DefaultLobHandler()), Types.CLOB);

      String SQL = "update Student set description = :description where id = :id";
      NamedParameterJdbcTemplate jdbcTemplateObject = new 
         NamedParameterJdbcTemplate(dataSource);
      
      jdbcTemplateObject.update(SQL, in);
      System.out.println("Updated Record with ID = " + id );
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      studentJDBCTemplate.updateDescription(1, 
         "This can be a very long text upto 4 GB of size."); 
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

Updated Record with ID = 1

Puede comprobar la descripción almacenada consultando la base de datos.

El siguiente ejemplo demostrará cómo realizar una actualización por lotes utilizando Spring JDBC. Actualizaremos los registros disponibles en la tabla Student en una sola operación por lotes.

Sintaxis

String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
   new BatchPreparedStatementSetter() {
   
   public void setValues(PreparedStatement ps, int i) throws SQLException {
      ps.setInt(1, students.get(i).getAge());						
      ps.setInt(2, students.get(i).getId());	
   }
   public int getBatchSize() {
      return students.size();
   }
});

Dónde,

  • SQL - Actualizar consulta para actualizar la edad del estudiante.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para actualizar el objeto del alumno en la base de datos.

  • BatchPreparedStatementSetter- Ejecutor de lote, establecer valores en PerparedStatement por elemento identificado por lista de objetos estudiante e índice i. getBatchSize () devuelve el tamaño del lote.

  • updateCounts - Array int que contiene el recuento de filas actualizado por consulta de actualización.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que actualizará una operación por lotes. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();  

   public void batchUpdate(final List<Student> students);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import java.sql.SQLException;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, 
                                new StudentMapper());
      return students;
   }
   public void batchUpdate(final List<Student> students){
      String SQL = "update Student set age = ? where id = ?";
      int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
         new BatchPreparedStatementSetter() {
         
         public void setValues(PreparedStatement ps, int i) throws SQLException {
            ps.setInt(1, students.get(i).getAge());						
            ps.setInt(2, students.get(i).getId());	
         }
         public int getBatchSize() {
            return students.size();
         }
      }); 
      System.out.println("Records updated!");
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");

      List<Student> initialStudents = studentJDBCTemplate.listStudents();
      System.out.println("Initial Students");
      
      for(Student student2: initialStudents){
         System.out.print("ID : " + student2.getId() );
         System.out.println(", Age : " + student2.getAge()); 
      }

      Student student = new Student();
      student.setId(1);
      student.setAge(10);

      Student student1 = new Student();
      student1.setId(3);
      student1.setAge(10);

      List<Student> students = new ArrayList<Student>();
      students.add(student);
      students.add(student1);

      studentJDBCTemplate.batchUpdate(students);

      List<Student> updatedStudents = studentJDBCTemplate.listStudents();
      System.out.println("Updated Students");
      
      for(Student student3: updatedStudents){
         System.out.print("ID : " + student3.getId() );
         System.out.println(", Age : " + student3.getAge()); 
      }
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

Initial Students
ID : 1, Age : 11
ID : 3, Age : 15
Records updated!
Updated Students
ID : 1, Age : 10
ID : 3, Age : 10

El siguiente ejemplo demostrará cómo realizar una actualización por lotes utilizando objetos en Spring JDBC. Actualizaremos los registros disponibles en la tabla Student en una sola operación por lotes.

Sintaxis

String SQL = "update Student set age = :age where id = :id";
SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(students.toArray());

NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);

int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,batch);
System.out.println("records updated!");

Dónde,

  • SQL - Actualizar consulta para actualizar la edad del estudiante.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para actualizar el objeto del alumno en la base de datos.

  • batch - Objeto SqlParameterSource para representar un lote de objeto.

  • updateCounts - Array int que contiene el recuento de filas actualizado por consulta de actualización.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que actualizará una operación por lotes. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();  

   public void batchUpdate(final List<Student> students);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
   public void batchUpdate(final List<Student> students){
      String SQL = "update Student set age = :age where id = :id";
      SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(students.toArray());
      NamedParameterJdbcTemplate jdbcTemplateObject = new 
         NamedParameterJdbcTemplate(dataSource);

      int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,batch);
      System.out.println("Records updated!");
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");

      List<Student> initialStudents = studentJDBCTemplate.listStudents();
      System.out.println("Initial Students");
      
      for(Student student2: initialStudents){
         System.out.print("ID : " + student2.getId() );
         System.out.println(", Age : " + student2.getAge()); 
      }
      Student student = new Student();
      student.setId(1);
      student.setAge(15);

      Student student1 = new Student();
      student1.setId(3);
      student1.setAge(16);

      List<Student> students = new ArrayList<Student>();
      students.add(student);
      students.add(student1);

      studentJDBCTemplate.batchUpdate(students);

      List<Student> updatedStudents = studentJDBCTemplate.listStudents();
      System.out.println("Updated Students");
      
      for(Student student3: updatedStudents){
         System.out.print("ID : " + student3.getId() );
         System.out.println(", Age : " + student3.getAge()); 
      }
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

Initial Students
ID : 1, Age : 10
ID : 3, Age : 10
Records updated!
Updated Students
ID : 1, Age : 15
ID : 3, Age : 16

El siguiente ejemplo demostrará cómo realizar múltiples actualizaciones por lotes en una sola llamada usando Spring JDBC. Actualizaremos los registros disponibles en la tabla Student en una operación por lotes múltiples donde el tamaño del lote es 1.

Sintaxis

String SQL = "update Student set age = ? where id = ?";
int[][] updateCounts = jdbcTemplateObject.batchUpdate(SQL,students,1,
   new ParameterizedPreparedStatementSetter<Student>() {
   
   public void setValues(PreparedStatement ps, Student student)
      throws SQLException {
      ps.setInt(1, student.getAge());						
      ps.setInt(2, student.getId());	
   }
});

Dónde,

  • SQL - Actualizar consulta para actualizar la edad del estudiante.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para actualizar el objeto Student en la base de datos.

  • ParameterizedPreparedStatementSetter - Ejecutor de lote, establece valores en PerparedStatement por elemento identificado por la lista de objetos del estudiante.

  • updateCounts - Array Int [] [] que contiene el recuento de filas actualizado por consulta de actualización por lote.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que actualizará la operación por lotes múltiples. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();  

   public void batchUpdate(final List<Student> students);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ParameterizedPreparedStatementSetter;

import java.sql.SQLException;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
   public void batchUpdate(final List<Student> students){
      String SQL = "update Student set age = ? where id = ?";
      int[][] updateCounts = jdbcTemplateObject.batchUpdate(SQL,students,1,
         new ParameterizedPreparedStatementSetter<Student>() {
         
         public void setValues(PreparedStatement ps, Student student)
            throws SQLException {
            ps.setInt(1, student.getAge());						
            ps.setInt(2, student.getId());	
         }
      });
      System.out.println("Records updated!");
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");

      List<Student> initialStudents = studentJDBCTemplate.listStudents();
      System.out.println("Initial Students");
      
      for(Student student2: initialStudents){
         System.out.print("ID : " + student2.getId() );
         System.out.println(", Age : " + student2.getAge()); 
      }

      Student student = new Student();
      student.setId(1);
      student.setAge(17);

      Student student1 = new Student();
      student1.setId(3);
      student1.setAge(18);

      List<Student> students = new ArrayList<Student>();
      students.add(student);
      students.add(student1);
      studentJDBCTemplate.batchUpdate(students);

      List<Student> updatedStudents = studentJDBCTemplate.listStudents();
      System.out.println("Updated Students");
      
      for(Student student3: updatedStudents){
         System.out.print("ID : " + student3.getId() );
         System.out.println(", Age : " + student3.getAge()); 
      }
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

Initial Students
ID : 1, Age : 15
ID : 3, Age : 16
records updated!
Updated Students
ID : 1, Age : 17
ID : 3, Age : 18

los org.springframework.jdbc.core.JdbcTemplateclass es la clase central en el paquete principal de JDBC. Simplifica el uso de JDBC y ayuda a evitar errores comunes. Ejecuta el flujo de trabajo principal de JDBC, dejando que el código de la aplicación proporcione SQL y extraiga los resultados. Esta clase ejecuta consultas o actualizaciones SQL, iniciando la iteración sobre ResultSets y capturando excepciones JDBC y traduciéndolas a la jerarquía de excepciones genérica y más informativa definida en elorg.springframework.dao paquete.

Declaración de clase

A continuación se muestra la declaración de la clase org.springframework.jdbc.core.JdbcTemplate:

public class JdbcTemplate
   extends JdbcAccessor
      implements JdbcOperations

Uso

Step 1 - Cree un objeto JdbcTemplate utilizando una fuente de datos configurada.

Step 2 - Utilice los métodos del objeto JdbcTemplate para realizar operaciones en la base de datos.

Ejemplo

El siguiente ejemplo demostrará cómo leer una consulta usando la clase JdbcTemplate. Leeremos los registros disponibles en Student Table.

Sintaxis

String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());

Dónde,

  • selectQuery - Seleccionar consulta para leer alumnos.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer el objeto Student de la base de datos.

  • StudentMapper - StudentMapper es un objeto RowMapper para asignar cada registro obtenido al objeto del estudiante.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que seleccionará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id="studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15

los org.springframework.jdbc.core.PreparedStatementSetterLa interfaz actúa como una interfaz de devolución de llamada general utilizada por la clase JdbcTemplate. Esta interfaz establece valores en un PreparedStatement proporcionado por la clase JdbcTemplate, para cada una de las actualizaciones en un lote utilizando el mismo SQL.

Las implementaciones son responsables de establecer los parámetros necesarios. Ya se habrá proporcionado SQL con marcadores de posición. Es más fácil usar esta interfaz que PreparedStatementCreator. El JdbcTemplate creará el PreparedStatement, y la devolución de llamada solo será responsable de configurar los valores de los parámetros.

Declaración de interfaz

A continuación se muestra la declaración de la interfaz org.springframework.jdbc.core.PreparedStatementSetter:

public interface PreparedStatementSetter

Uso

Step 1 - Cree un objeto JdbcTemplate utilizando una fuente de datos configurada.

Step 2 - Utilice los métodos del objeto JdbcTemplate para realizar operaciones en la base de datos mientras pasa el objeto PreparedStatementSetter para reemplazar los marcadores de posición en la consulta.

Ejemplo

El siguiente ejemplo demostrará cómo leer una consulta usando la clase JdbcTemplate y la interfaz PreparedStatementSetter. Leeremos el registro disponible de un estudiante en Student Table.

Sintaxis

final String SQL = "select * from Student where id = ? ";
List <Student> students = jdbcTemplateObject.query(
   SQL, new PreparedStatementSetter() {
   
   public void setValues(PreparedStatement preparedStatement) throws SQLException {
      preparedStatement.setInt(1, id);
   }
},
new StudentMapper());

Dónde,

  • SQL - Seleccionar consulta para leer alumnos.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer el objeto del alumno desde la base de datos.

  • PreparedStatementSetter - Objeto PreparedStatementSetter para establecer parámetros en la consulta.

  • StudentMapper - StudentMapper es un objeto RowMapper para asignar cada registro obtenido a un objeto de estudiante.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que seleccionará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public Student getStudent(final Integer id) {
      final String SQL = "select * from Student where id = ? ";
      List <Student> students = jdbcTemplateObject.query(
         SQL, new PreparedStatementSetter() {
		   
         public void setValues(PreparedStatement preparedStatement) throws SQLException {
            preparedStatement.setInt(1, id);
         }
      },
      new StudentMapper());
      return students.get(0);
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      Student student = studentJDBCTemplate.getStudent(1);
      System.out.print("ID : " + student.getId() );
      System.out.println(", Age : " + student.getAge()); 
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

ID : 1, Age : 17

los org.springframework.jdbc.core.ResultSetExtractorLa interfaz es una interfaz de devolución de llamada utilizada por los métodos de consulta de JdbcTemplate. Las implementaciones de esta interfaz realizan el trabajo real de extraer resultados de un ResultSet, pero no necesita preocuparse por el manejo de excepciones.

Las SQLExceptions serán capturadas y manejadas por el JdbcTemplate que llama. Esta interfaz se utiliza principalmente dentro del propio marco JDBC. Un RowMapper suele ser una opción más simple para el procesamiento de ResultSet, mapeando un objeto de resultado por fila en lugar de un objeto de resultado para todo el ResultSet.

Declaración de interfaz

A continuación se muestra la declaración de la interfaz org.springframework.jdbc.core.ResultSetExtractor:

public interface ResultSetExtractor

Uso

Step 1 - Cree un objeto JdbcTemplate utilizando una fuente de datos configurada.

Step 2 - Utilice los métodos del objeto JdbcTemplate para realizar operaciones en la base de datos mientras analiza el conjunto de resultados utilizando ResultSetExtractor.

Ejemplo

El siguiente ejemplo demostrará cómo leer una consulta usando la clase JdbcTemplate y la interfaz ResultSetExtractor. Leeremos el registro disponible de un estudiante en Student Table.

Sintaxis

public List<Student> listStudents() {
   String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, 
         new ResultSetExtractor<List<Student>>(){
         
         public List<Student> extractData(
            ResultSet rs) throws SQLException, DataAccessException {
            
            List<Student> list = new ArrayList<Student>();  
            while(rs.next()){  
               Student student = new Student();
               student.setId(rs.getInt("id"));
               student.setName(rs.getString("name"));
               student.setAge(rs.getInt("age"));
               student.setDescription(rs.getString("description"));
               student.setImage(rs.getBytes("image"));
               list.add(student);  
            }  
            return list;  
         }    	  
      });
   return students;
}

Dónde,

  • SQL - Seleccionar consulta para leer alumnos.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer el objeto del alumno desde la base de datos.

  • ResultSetExtractor - Objeto ResultSetExtractor para analizar el objeto del conjunto de resultados.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que seleccionará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import java.util.ArrayList;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, 
         new ResultSetExtractor<List<Student>>(){
         
         public List<Student> extractData(
            ResultSet rs) throws SQLException, DataAccessException {
            
            List<Student> list = new ArrayList<Student>();  
            while(rs.next()){  
               Student student = new Student();
               student.setId(rs.getInt("id"));
               student.setName(rs.getString("name"));
               student.setAge(rs.getInt("age"));
               student.setDescription(rs.getString("description"));
               student.setImage(rs.getBytes("image"));
               list.add(student);  
            }  
            return list;  
         }    	  
      });
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = 
         new ClassPathXmlApplicationContext("Beans.xml");
      
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");

      List<Student> students = studentJDBCTemplate.listStudents();

      for(Student student: students){
         System.out.print("ID : " + student.getId() );
         System.out.println(", Age : " + student.getAge()); 
      }
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

ID : 1, Age : 17
ID : 3, Age : 18

los org.springframework.jdbc.core.RowMapper<T>JdbcTemplate utiliza la interfaz para mapear filas de un ResultSet por filas. Las implementaciones de esta interfaz realizan el trabajo real de mapear cada fila a un objeto de resultado. SQLExceptions si alguno arrojado será detectado y manejado por el JdbcTemplate que llama.

Declaración de interfaz

A continuación se muestra la declaración de org.springframework.jdbc.core.RowMapper<T> interfaz -

public interface RowMapper<T>

Uso

Step 1 - Cree un objeto JdbcTemplate utilizando una fuente de datos configurada.

Step 2 - Cree un objeto StudentMapper implementando la interfaz RowMapper.

Step 3 - Utilice los métodos del objeto JdbcTemplate para realizar operaciones en la base de datos mientras utiliza el objeto StudentMapper.

El siguiente ejemplo demostrará cómo leer una consulta usando Spring jdbc. Asignaremos registros de lectura de la tabla de estudiantes al objeto de estudiante utilizando el objeto StudentMapper.

Sintaxis

String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());

Dónde

  • SQL - Consulta de lectura para leer todos los registros de los estudiantes.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer registros de estudiantes de la base de datos.

  • StudentMapper - Objeto StudentMapper para mapear registros de estudiantes a objetos de estudiantes.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que leerá un resultado de consulta y mapa utilizando el objeto StudentMapper. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDao.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDao {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class StudentJDBCTemplate implements StudentDao {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18

los org.springframework.jdbc.core.NamedParameterJdbcTemplateclass es una clase de plantilla con un conjunto básico de operaciones JDBC, que permite el uso de parámetros con nombre en lugar del tradicional '?' marcadores de posición. Esta clase delega a un JdbcTemplate envuelto una vez que la sustitución de los parámetros con nombre al estilo JDBC '?' los marcadores de posición se realizan en el momento de la ejecución. También permite expandir una lista de valores al número apropiado de marcadores de posición.

Declaración de interfaz

A continuación se muestra la declaración de org.springframework.jdbc.core.NamedParameterJdbcTemplate clase -

public class NamedParameterJdbcTemplate
   extends Object
      implements NamedParameterJdbcOperations

Sintaxis

MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description",  new SqlLobValue(description, new DefaultLobHandler()), Types.CLOB);

String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);

Dónde,

  • in - Objeto SqlParameterSource para pasar un parámetro para actualizar una consulta.

  • SqlLobValue - Objeto para representar un parámetro de valor SQL BLOB / CLOB.

  • jdbcTemplateObject - Objeto NamedParameterJdbcTemplate para actualizar el objeto del estudiante en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que actualizará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to update
      * a record into the Student table.
   */
   public void updateDescription(Integer id, String description);
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;
   private String description;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
   public String getDescription() {
      return description;
   }
   public void setDescription(String description) {
      this.description = description;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      student.setDescription(rs.getString("description"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;

import java.io.ByteArrayInputStream;
import java.sql.Types;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
   }
   public void updateDescription(Integer id, String description) {
      MapSqlParameterSource in = new MapSqlParameterSource();
      in.addValue("id", id);
      in.addValue("description",  new SqlLobValue(
         description, new DefaultLobHandler()), Types.CLOB);

      String SQL = "update Student set description = :description where id = :id";
      NamedParameterJdbcTemplate jdbcTemplateObject = 
         new NamedParameterJdbcTemplate(dataSource);
      
      jdbcTemplateObject.update(SQL, in);
      System.out.println("Updated Record with ID = " + id );
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      studentJDBCTemplate.updateDescription(1, 
         "This can be a very long text upto 4 GB of size."); 
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

Updated Record with ID = 1

Puede comprobar la descripción almacenada consultando la base de datos.

los org.springframework.jdbc.core.SimpleJdbcInsertclass es un objeto reutilizable de subprocesos múltiples que proporciona capacidades de inserción fáciles para una tabla. Proporciona procesamiento de metadatos para simplificar el código necesario para construir una declaración de inserción básica. La inserción real se maneja usando Spring's JdbcTemplate

Declaración de clase

A continuación se muestra la declaración de org.springframework.jdbc.core.SimpleJdbcInsert clase -

public class SimpleJdbcInsert
   extends AbstractJdbcInsert
      implements SimpleJdbcInsertOperations

El siguiente ejemplo demostrará cómo insertar una consulta usando Spring JDBC. Insertaremos un registro en la tabla de estudiantes usando el objeto SimpleJdbcInsert.

Sintaxis

jdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("Student");
Map<String,Object> parameters = new HashMap<String,Object>();

parameters.put("name", name);
parameters.put("age", age);
jdbcInsert.execute(parameters);

Dónde,

  • jdbcInsert - Objeto SimpleJdbcInsert para insertar un registro en la tabla de estudiantes.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer el objeto del alumno en la base de datos.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que insertará una consulta. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to create
      * a record in the Student table.
   */
   public void create(String name, Integer age);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;

public class StudentJDBCTemplate implements StudentDao {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   SimpleJdbcInsert jdbcInsert;

   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
      this.jdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("Student");
   }
   public void create(String name, Integer age) {
      Map<String,Object> parameters = new HashMap<String,Object>();
      parameters.put("name", name);
      parameters.put("age", age);
      
      jdbcInsert.execute(parameters);
      System.out.println("Created Record Name = " + name + " Age = " + age);
      return;
   }
   public List<Student> listStudents() {
      String SQL = "select * from Student";
      List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Records Creation--------" );
      studentJDBCTemplate.create("Nuha", 2);

      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Records Creation--------
Created Record Name = Nuha Age = 12
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12

los org.springframework.jdbc.core.SimpleJdbcCallLa clase es un objeto reutilizable de subprocesos múltiples que representa una llamada a un procedimiento almacenado o una función almacenada. Proporciona procesamiento de metadatos para simplificar el código necesario para acceder a funciones / procedimientos almacenados básicos.

Todo lo que necesita proporcionar es el nombre del procedimiento / función y un mapa que contiene los parámetros cuando ejecuta la llamada. Los nombres de los parámetros proporcionados se compararán con los parámetros de entrada y salida declarados cuando se creó el procedimiento almacenado.

Declaración de clase

A continuación se muestra la declaración de org.springframework.jdbc.core.SimpleJdbcCall clase -

public class SimpleJdbcCall
   extends AbstractJdbcCall
      implements SimpleJdbcCallOperations

El siguiente ejemplo demostrará cómo llamar a un procedimiento almacenado usando Spring SimpleJdbcCall. Leeremos uno de los registros disponibles en Student Table llamando a un procedimiento almacenado. Pasaremos una identificación y recibiremos un registro de estudiante.

Sintaxis

SimpleJdbcCall jdbcCall = new SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);

Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));

Dónde,

  • jdbcCall - Objeto SimpleJdbcCall para representar un procedimiento almacenado.

  • in - Objeto SqlParameterSource para pasar un parámetro a un procedimiento almacenado.

  • student - Objeto de estudiante.

  • out - Asignar objeto para representar la salida del resultado de la llamada al procedimiento almacenado.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que llamará a un procedimiento almacenado. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);  
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public Student getStudent(Integer id) {
      SimpleJdbcCall jdbcCall = new 
         SimpleJdbcCall(dataSource).withProcedureName("getRecord");

      SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
      Map<String, Object> out = jdbcCall.execute(in);

      Student student = new Student();
      student.setId(id);
      student.setName((String) out.get("out_name"));
      student.setAge((Integer) out.get("out_age"));
      return student;      
   }
}

El código que escribe para la ejecución de la llamada implica la creación de un SqlParameterSource que contiene el parámetro IN. Es importante hacer coincidir el nombre proporcionado para el valor de entrada con el nombre del parámetro declarado en el procedimiento almacenado. El método de ejecución toma los parámetros IN y devuelve un mapa que contiene los parámetros de salida introducidos por el nombre especificado en el procedimiento almacenado.

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      Student student = studentJDBCTemplate.getStudent(1);
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
      System.out.println(", Age : " + student.getAge()); 
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

ID : 1, Name : Zara, Age : 11

los org.springframework.jdbc.object.SqlQuery La clase proporciona un objeto de operación reutilizable que representa una consulta SQL.

Declaración de clase

A continuación se muestra la declaración de org.springframework.jdbc.object.SqlQuery clase -

public abstract class SqlQuery<T>
   extends SqlOperation

Uso

  • Step 1 - Cree un objeto JdbcTemplate utilizando una fuente de datos configurada.

  • Step 2 - Cree un objeto StudentMapper implementando la interfaz RowMapper.

  • Step 3 - Utilice los métodos del objeto JdbcTemplate para realizar operaciones en la base de datos mientras utiliza el objeto SqlQuery.

El siguiente ejemplo demostrará cómo leer una consulta usando el objeto SqlQuery. Asignaremos registros de lectura de la tabla de estudiantes al objeto de estudiante utilizando el objeto StudentMapper.

Sintaxis

String sql = "select * from Student";
SqlQuery<Student> sqlQuery = new SqlQuery<Student>() {
   @Override
   protected RowMapper<Student> newRowMapper(Object[] parameters,
      Map<?, ?> context) {
      return new StudentMapper();
   }
};
sqlQuery.setDataSource(dataSource);
sqlQuery.setSql(sql);
List <Student> students = sqlQuery.execute();

Dónde,

  • SQL - Consulta de lectura para leer todos los registros de los estudiantes.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer registros de estudiantes de la base de datos.

  • StudentMapper - Objeto StudentMapper para asignar los registros de los estudiantes a los objetos de los estudiantes.

  • SqlQuery - Objeto SqlQuery para consultar registros de estudiantes y asignarlos a objetos de estudiantes.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que leerá una consulta y mapeará el resultado usando el objeto StudentMapper. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDao.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDao {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student table.
   */
   public List<Student> listStudents();   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.object.SqlQuery;

public class StudentJDBCTemplate implements StudentDao {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);     
   }
   public List<Student> listStudents() {
      String sql = "select * from Student";
      SqlQuery<Student> sqlQuery = new SqlQuery<Student>() {
         @Override
         protected RowMapper<Student> newRowMapper(Object[] parameters, Map<?, ?> context){
            
            return new StudentMapper();
         }
      };
      sqlQuery.setDataSource(dataSource);
      sqlQuery.setSql(sql);
      List <Student> students = sqlQuery.execute();
      return students;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Listing Multiple Records--------" );
      List<Student> students = studentJDBCTemplate.listStudents();
      
      for (Student record : students) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.println(", Age : " + record.getAge());
      }  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12

los org.springframework.jdbc.object.SqlUpdate La clase proporciona un objeto de operación reutilizable que representa una actualización de SQL.

Declaración de clase

A continuación se muestra la declaración de org.springframework.jdbc.object.SqlUpdate clase -

public abstract class SqlUpdate<T>
   extends SqlOperation

Uso

Step 1 - Cree un objeto JdbcTemplate utilizando una fuente de datos configurada.

Step 2 - Cree un objeto StudentMapper implementando la interfaz RowMapper.

Step 3 - Utilice los métodos del objeto JdbcTemplate para realizar operaciones de base de datos mientras utiliza el objeto SqlUpdate.

El siguiente ejemplo demostrará cómo actualizar una consulta mediante el objeto SqlUpdate. Asignaremos los registros de actualización de la tabla de estudiantes al objeto de estudiante utilizando el objeto StudentMapper.

Sintaxis

String SQL = "update Student set age = ? where id = ?";

SqlUpdate sqlUpdate = new SqlUpdate(dataSource,SQL);
sqlUpdate.declareParameter(new SqlParameter("age", Types.INTEGER));
sqlUpdate.declareParameter(new SqlParameter("id", Types.INTEGER));
sqlUpdate.compile();

sqlUpdate.update(age.intValue(),id.intValue());

Dónde,

  • SQL - Consulta de actualización para actualizar los registros de los estudiantes.

  • jdbcTemplateObject - Objeto StudentJDBCTemplate para leer los registros de los estudiantes desde la base de datos.

  • StudentMapper - Objeto StudentMapper para mapear registros de estudiantes a objetos de estudiantes.

  • sqlUpdate - Objeto SqlUpdate para actualizar los registros de los estudiantes.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que leerá un resultado de consulta y mapa utilizando el objeto StudentMapper. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDao.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDao {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to update
      * a record into the Student table.
   */
   public void update(Integer id, Integer age);

   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);   
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.sql.Types;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.SqlUpdate;

public class StudentJDBCTemplate implements StudentDao {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void update(Integer id, Integer age){
      String SQL = "update Student set age = ? where id = ?";
      
      SqlUpdate sqlUpdate = new SqlUpdate(dataSource,SQL);
      sqlUpdate.declareParameter(new SqlParameter("age", Types.INTEGER));
      sqlUpdate.declareParameter(new SqlParameter("id", Types.INTEGER));
      sqlUpdate.compile();
      
      sqlUpdate.update(age.intValue(),id.intValue());
      System.out.println("Updated Record with ID = " + id );
      return;
   }
   public Student getStudent(Integer id) {
      String SQL = "select * from Student where id = ?";
      Student student = jdbcTemplateObject.queryForObject(
         SQL, new Object[]{id}, new StudentMapper());
      
      return student;
   }
}

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("----Updating Record with ID = 1 -----" );
      studentJDBCTemplate.update(1, 10);
      
      System.out.println("----Listing Record with ID = 1 -----" );
      Student student = studentJDBCTemplate.getStudent(1);
      
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
      System.out.println(", Age : " + student.getAge());  
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

----Updating Record with ID = 1 -----
Updated Record with ID = 1
----Listing Record with ID = 1 -----
ID : 1, Name : Zara, Age : 10

los org.springframework.jdbc.core.StoredProcedureclass es la superclase para abstracciones de objetos de procedimientos almacenados RDBMS. Esta clase es abstracta y se pretende que las subclases proporcionen un método escrito para la invocación que delegue al método de ejecución (java.lang.Object ...) proporcionado. La propiedad SQL heredada es el nombre del procedimiento almacenado en RDBMS.

Declaración de clase

A continuación se muestra la declaración de org.springframework.jdbc.core.StoredProcedure clase -

public abstract class StoredProcedure
   extends SqlCall

El siguiente ejemplo demostrará cómo llamar a un procedimiento almacenado usando Spring StoredProcedure. Leeremos uno de los registros disponibles en Student Table llamando a un procedimiento almacenado. Pasaremos una identificación y recibiremos un registro de estudiante.

Sintaxis

class StudentProcedure extends StoredProcedure{
   public StudentProcedure(DataSource dataSource, String procedureName){
      super(dataSource,procedureName);
      declareParameter(new SqlParameter("in_id", Types.INTEGER));
      declareParameter(new SqlOutParameter("out_name", Types.VARCHAR));
      declareParameter(new SqlOutParameter("out_age", Types.INTEGER));
      compile();
   }
   public Student execute(Integer id){
      Map<String, Object> out = super.execute(id);
      Student student = new Student();
      student.setId(id);
      student.setName((String) out.get("out_name"));
      student.setAge((Integer) out.get("out_age"));
      return student;  	
   }
}

Dónde,

  • StoredProcedure - Objeto StoredProcedure para representar un procedimiento almacenado.

  • StudentProcedure - El objeto StudentProcedure extiende StoredProcedure para declarar la entrada, la variable de salida y el resultado del mapa al objeto Student.

  • student - Objeto de estudiante.

Para comprender los conceptos mencionados anteriormente relacionados con Spring JDBC, escribamos un ejemplo que llamará a un procedimiento almacenado. Para escribir nuestro ejemplo, tengamos un IDE de Eclipse en funcionamiento y usemos los siguientes pasos para crear una aplicación Spring.

Paso Descripción
1 Actualice el proyecto que Student creó en el capítulo Spring JDBC - Primera aplicación .
2 Actualice la configuración del bean y ejecute la aplicación como se explica a continuación.

A continuación se muestra el contenido del archivo de interfaz del objeto de acceso a datos StudentDAO.java.

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to list down
      * a record from the Student table corresponding
      * to a passed student id.
   */
   public Student getStudent(Integer id);  
}

A continuación se muestra el contenido de la Student.java archivo.

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;
   private Integer id;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
}

A continuación se muestra el contenido de la StudentMapper.java archivo.

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMapper implements RowMapper<Student> {
   public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
      Student student = new Student();
      student.setId(rs.getInt("id"));
      student.setName(rs.getString("name"));
      student.setAge(rs.getInt("age"));
      return student;
   }
}

A continuación se muestra el archivo de clase de implementación StudentJDBCTemplate.java para la interfaz DAO definida StudentDAO.

package com.tutorialspoint;

import java.sql.Types;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlOutParameter;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.object.StoredProcedure;

public class StudentJDBCTemplate implements StudentDao {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   
   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public Student getStudent(Integer id) {    
      StudentProcedure studentProcedure = new StudentProcedure(dataSource, "getRecord");
      return studentProcedure.execute(id);      
   }    
}
class StudentProcedure extends StoredProcedure{
   public StudentProcedure(DataSource dataSource, String procedureName) {
      super(dataSource,procedureName);
      declareParameter(new SqlParameter("in_id", Types.INTEGER));
      declareParameter(new SqlOutParameter("out_name", Types.VARCHAR));
      declareParameter(new SqlOutParameter("out_age", Types.INTEGER));
      compile();
   }
   public Student execute(Integer id){
      Map<String, Object> out = super.execute(id);
      Student student = new Student();
      student.setId(id);
      student.setName((String) out.get("out_name"));
      student.setAge((Integer) out.get("out_age"));
      return student;  	
   }
}

El código que escribe para la ejecución de la llamada implica la creación de un SqlParameterSource que contiene el parámetro IN. Es importante hacer coincidir el nombre proporcionado para el valor de entrada con el nombre del parámetro declarado en el procedimiento almacenado. El método de ejecución toma los parámetros IN y devuelve un mapa que contiene los parámetros de salida introducidos por el nombre especificado en el procedimiento almacenado.

A continuación se muestra el contenido de la MainApp.java archivo.

package com.tutorialspoint;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      Student student = studentJDBCTemplate.getStudent(1);
      System.out.print("ID : " + student.getId() );
      System.out.print(", Name : " + student.getName() );
      System.out.println(", Age : " + student.getAge()); 
   }
}

A continuación se muestra el archivo de configuración Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <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/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "admin"/>
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate" 
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />    
   </bean>
      
</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje.

ID : 1, Name : Zara, Age : 10