ResultSetExtractor es una interfaz que se utiliza para obtener los registros de la base de datos. Es una interfaz de devolución de llamada que utiliza el método query() de JDBC Template donde necesitamos pasar la instancia de ResultSetExtractor para obtener los datos.
Sintaxis del método query() de ResultSetExtractor:
public T query(String sqlQuery, ResultSetExtractor<T> resultSetExtractor)
Para obtener los datos mediante ResultSetExtractor, debemos implementar la interfaz de ResultSetExtractor y proporcionar la definición de su método. Tiene un solo método. es decir, extractData() que toma una instancia de ResultSet como argumento y devuelve la lista.
Sintaxis del método extractData():
public T extractData(ResultSet resultSet) throws SQL Exception, DataAccessException
Ejemplo
En este ejemplo, extraeremos todos los registros de una tabla de Estudiante usando ResultSetExtractor. Para este tutorial, usaremos el siguiente esquema para la tabla Student.
Student(id INT, name VARCHAR(45), department VARCHAR(45))
Implementación paso a paso:
Paso 1: Crear tabla
En este paso, crearemos una tabla de Estudiantes para almacenar la información de los estudiantes. Para este tutorial, asumiremos que ha creado la siguiente tabla en su base de datos.
CREATE TABLE STUDENT( id INT, name VARCHAR(45), department VARCHAR(45));
Después de crear la tabla, insertaremos los siguientes datos en nuestra tabla.
INSERT INTO STUDENT VALUES(1, "geek", "computer science");
Paso 2: Agregar dependencias
En este paso, agregaremos las dependencias de maven a nuestra aplicación. Agregue las siguientes dependencias a su pom.xml
XML
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.geeksforgeeks</groupId> <artifactId>ResultSetExtractorExample</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.16</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.8.RELEASE</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.44</version> </dependency> </dependencies> </project>
Paso 3: crea una clase modelo
Ahora, crearemos una clase modelo para nuestros estudiantes. Esta clase tendrá id, nombre y departamento de variables de tres miembros. También definiremos su método getters y setters junto con el método toString().
Java
public class Student {
// Member variables
private int id;
private String name;
private String department;
// Getters and Setters method
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
// toString() method
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", department=" + department + "]";
}
}
Paso 4: Cree una interfaz Dao
Ahora, crearemos una interfaz y la llamaremos StudentDao , que usaremos para acceder a los datos de la base de datos de almacenamiento de datos. Necesitamos definir el método getAllStudentDetails() que devolverá todos los detalles del estudiante.
Java
import java.util.List;
import com.geeksforgeeks.model.Student;
public interface StudentDao {
// This method will return all
// the details of the students
public List<Student> getAllStudentDetails();
}
Paso 5: Cree una clase de implementación para la interfaz Dao
En este paso, crearemos una clase de implementación StudentDaoImpl.java . Esta clase implementa la interfaz StudentDao y proporciona la definición del método getAllStudentDetails() de la interfaz StudentDao. En esta clase, también implementaremos la interfaz ResultSetExtractor y proporcionaremos la definición de su método extractData() .
Java
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import com.geeksforgeeks.model.Student;
public class StudentDaoImpl implements StudentDao{
// Defining JdbcTemplate as member variable in order
// to use the query() method of the JdbcTemplate's class
private JdbcTemplate jdbcTemplate;
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
// This method will return the list
// of all the details of student
public List<Student> getAllStudentDetails() {
// Implementation of ResultSetExtractor interface
return jdbcTemplate.query("SELECT * FROM student", new ResultSetExtractor<List<Student>>() {
// extractData() is ResultSetExtractor
// interface's method
public List<Student> extractData(ResultSet rs) throws SQLException, DataAccessException {
List<Student> studentDetailList = new ArrayList<Student>();
while(rs.next()) {
Student student = new Student();
// 1, 2 and 3 are the indices of the data present
// in the database respectively
student.setId(rs.getInt(1));
student.setName(rs.getString(2));
student.setDepartment(rs.getString(3));
studentDetailList.add(student);
}
return studentDetailList;
}
});
}
}
Paso 6: Configuración de Bean
En este paso, crearemos el archivo de configuración Spring y lo llamaremos application-contex.xml . Configuraremos nuestros beans y usaremos el atributo de método de fábrica para la creación de beans. Para realizar una conexión a la base de datos, necesitamos la siguiente información: nombre de usuario, contraseña, conexión a la base de datos, URL y el nombre de la clase del controlador. Toda esta información está contenida en la clase DriverManagerDataSource , tiene el método getConnection() que devuelve una conexión de tipo java. Usamos la instancia de JdbcTemplate en nuestra clase StudentDao y la pasamos usando el método de inyección setter.
Nota : en el contexto de la aplicación, debe definir la ruta completa de su clase dao
XML
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/student_db?autoReconnect=true&useSSL=false" /> <property name="username" value="root" /> <property name="password" value="root" /> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean> <bean id="studentDao" class="com.geeksforgeeks.dao.StudentDaoImpl"> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean> </beans>
Paso 7: Creando Clase de Utilidades
Ahora, crearemos una clase de utilidad para probar nuestra aplicación. Para esto, cree una nueva clase y asígnele el nombre TestResultSetExtractor.java y agregue el siguiente código.
Java
import java.util.List;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.geeksforgeeks.dao.StudentDaoImpl;
import com.geeksforgeeks.model.Student;
public class TestResultSetExtractor {
public static void main(String[] args) {
// Reading the application-context file using
// class path of spring context xml file
AbstractApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
// Spring check the blueprint for studentDao bean
// from application-context.xml file and return it
StudentDaoImpl studentDaoImpl = (StudentDaoImpl)context.getBean("studentDao");
// Getting student data
List<Student> studentDetailList = studentDaoImpl.getAllStudentDetails();
for(Student index : studentDetailList) {
System.out.println(index);
}
}
}
Paso 8: Salida
Ahora ejecutaremos nuestra aplicación.
Producción