Spring es uno de los marcos Java EE más populares. Es un marco ligero de código abierto que permite a los desarrolladores de Java EE 7 crear aplicaciones empresariales sencillas, fiables y escalables. Este marco se centra principalmente en proporcionar varias formas de ayudarlo a administrar sus objetos comerciales. Hizo que el desarrollo de aplicaciones web fuera mucho más fácil en comparación con los marcos Java clásicos y las interfaces de programación de aplicaciones (API), como la conectividad de base de datos Java (JDBC), JavaServer Pages (JSP) y Java Servlet. Este marco utiliza varias técnicas nuevas, como la programación orientada a aspectos (AOP), el objeto Java antiguo simple (POJO) y la inyección de dependencia (DI), para desarrollar aplicaciones empresariales. En Spring, la interfaz RowMapper se usa para obtener los registros de la base de datos usando elmétodo query() de la clase JdbcTemplate .
Sintaxis para el método query() de la clase JdbcTemplate:
public T query(String sqlQuery, RowMapper<T> rowMapper)
RowMapper es una interfaz de devolución de llamada que se llama para cada fila y asigna la fila de relaciones con las instancias a la clase modelo (definida por el usuario). A diferencia de ResultSetExtractor, RowMapper itera el ResultSet internamente y agrega los datos extraídos a una colección. Y no necesitamos escribir el código para las colecciones como lo hacemos en ResultSetExtractor. Solo tiene un método mapRow() que toma dos argumentos ResultSet y rowNumber respectivamente. Para usar RowMapper, necesitamos implementar esta interfaz y proporcionar la definición del método mapRow().
Sintaxis para el método rowMapper():
public T mapRow(ResultSet resultSet, int rowNumber)throws SQLException
Ejemplo
En este ejemplo, extraeremos todos los registros de una tabla de Estudiante usando RowMapper. 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>RowMapper</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
package com.geeksforgeeks.model;
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 RowMapper y proporcionaremos la definición de su método mapRow() .
Java
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
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 RowMapper interface
return jdbcTemplate.query("SELECT * FROM student", new RowMapper<Student>() {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt(1));
student.setName(rs.getString(2));
student.setDepartment(rs.getString(3));
return student;
}
});
}
}
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 TestRowMapper.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 TestRowMapper {
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.
