Primavera: plantilla JDBC de declaración preparada

En las aplicaciones empresariales, el acceso a los datos/almacenamiento en bases de datos relacionales es un requisito común. Como parte esencial de Java SE, Java Database Connectivity (JDBC) define un conjunto de API estándar para acceder a bases de datos relacionales de forma independiente al proveedor. Sin embargo, al usar JDBC, el desarrollador tiene que administrar todos los recursos relacionados con la base de datos y manejar las excepciones de la base de datos de manera explícita. 

Para hacer que JDBC sea más fácil de usar, Spring Framework proporciona un marco de abstracción para interactuar con JDBC. La clase de plantilla JDBC en Spring está diseñada para proporcionar métodos de plantilla para diferentes tipos de operaciones JDBC. Cada método de plantilla es responsable de controlar el proceso general y permite anular tareas particulares del proceso.

Interfaz PreparedStatementSetter

Spring proporciona la interfaz PreparedStatementSetter en el paquete org.springframework.jdbc.core utilizado por la clase JdbcTemplate. Esta es una interfaz de devolución de llamada que establece valores en una declaración preparada proporcionada por la clase JdbcTemplate , para cada una de las actualizaciones en un lote usando el mismo SQL. Proporciona marcadores de posición al SQL, las implementaciones son responsables de establecer los parámetros necesarios. JdbcTemplate creará PreparedStatement y la devolución de llamada solo será responsable de establecer los valores de los parámetros.

@FunctionalInterface
public interface PreparedStatementSetter

Esta interfaz contiene un método a saber, 

setValues(PreparedStatement ps): Establece los valores de los parámetros en el PreparedStatement dado.

void setValues(PreparedStatement ps) lanza SQLException

• ps: PreparedStatement para invocar métodos setter.
• Lanza SQLException: si se encuentra una SQLException (es decir, no hay necesidad de capturar SQLException)

Aplicación Spring JDBC

Para comprender el concepto anterior, crearemos una aplicación Spring JDBC básica para acceder a los datos de la base de datos. Usaremos la base de datos PostgreSQL y el IDE de Eclipse para crear este proyecto.

Pasos para crear la aplicación

Paso 1: Crear una tabla de base de datos en PostgreSQL

Cree una tabla: ‘ marcos ‘ en la base de datos PostgreSQL con columnas: ‘id’, ‘nombre’, ‘descripción’.

marcos – tabla

Inserte algunos datos en la tabla como se muestra a continuación.

Tabla – Datos

Paso 2: Cree una aplicación Spring en Eclipse

• Crear proyecto Spring – Spring_JDBC. Agregue archivos postgresql jar y spring jar al proyecto.
• Los archivos jar están disponibles en Maven Repository .
• La estructura final del proyecto será como se muestra a continuación,

Estructura del proyecto

Paso 3: cree archivos de clase Bean, clase DAO y clase Mapper en el paquete ‘com.geeks.beans’

Cree un archivo de clase de bean ‘ Framework.java ‘ con ‘id’, ‘nombre’, ‘descripción’ como propiedades y sus métodos getter/setter.

Archivo Framework.java:

package com.geeks.beans;
  
public class Framework {
      
    private int id;
    private String name;
    private String description;
      
    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 getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
      
}

Cree un archivo ‘ FrameworkDao.java ‘ que importe la clase ‘Plantilla JDBC’ y la interfaz ‘PreparedStatementSetter’ utilizada para crear SQL para consultar la base de datos con los valores usando ‘PreparedStatement’.

Archivo FrameworkDao.java:

package com.geeks.beans;
  
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
  
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
  
public class FrameworkDao {
      
    private JdbcTemplate jdbcTemp;
  
    public JdbcTemplate getJdbcTemp() {
        return jdbcTemp;
    }
  
    public void setJdbcTemp(JdbcTemplate jdbcTemp) {
        this.jdbcTemp = jdbcTemp;
    }
      
     public Framework getDetail(final String name) {
          final String SQL = "select * from public.frameworks where name = ? ";
          List <Framework> details = jdbcTemp.query(
             SQL, new PreparedStatementSetter() {
                 
             public void setValues(PreparedStatement preparedStatement) throws SQLException {
                preparedStatement.setString(1, name);
             }
          },
          new FrameworkMapper());
          return details.get(0);
       }
  
}

• Estamos utilizando la consulta de selección para obtener los detalles de la tabla de la base de datos.
• Mediante el uso de la plantilla JDBC, consulte la base de datos sin pasar por tres parámetros, SQL (consulta), PreparedStatementSetter (para establecer el valor) y FrameworkMapper (para asignar los datos a las propiedades respectivas).
• Cree un archivo ‘ FrameworkMapper.java ‘ que implemente la interfaz RowMapper que se utiliza para asignar los datos obtenidos de la base de datos a los valores de propiedad del bean.

Archivo FrameworkMapper.java:

package com.geeks.beans;
  
import java.sql.ResultSet;
import java.sql.SQLException;
  
import org.springframework.jdbc.core.RowMapper;
  
public class FrameworkMapper implements RowMapper<Framework>{
  
    @Override
    public Framework mapRow(ResultSet rs, int map) throws SQLException {
  
        Framework framework = new Framework();
        framework.setId(rs.getInt("id"));
        framework.setName(rs.getString("name"));
        framework.setDescription(rs.getString("description"));
        return framework;
    }
  
}

• Necesitamos anular el método ‘mapRow()’ de la interfaz RowMapper .
• Obtenga el objeto de bean Framework y asigne/establezca los valores de propiedad con los valores obtenidos de la base de datos.

Paso 4: Cree un archivo de recursos: configuración XML en el paquete ‘com.geeks.resources’

Cree el archivo ‘ applicationContext.xml ‘ para configurar el origen de datos y los objetos de bean.

archivo applicationContext.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.xsd">
  
    <bean id = "dataSource" 
        class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name = "driverClassName" value = "org.postgresql.Driver"/>
        <property name = "url" value = "jdbc:postgresql://localhost/postgres"/>
        <property name = "username" value = "root"/>
        <property name = "password" value = "root"/>
    </bean>
     
    <bean id="jdbcTemp" class="org.springframework.jdbc.core.JdbcTemplate">  
         <property name="dataSource" ref="dataSource"></property>  
    </bean> 
  
    <bean id="framework" class="com.geeks.beans.FrameworkDao">  
         <property name="jdbcTemp" ref="jdbcTemp"></property>  
    </bean>     
  
</beans>

• Como estamos usando postgresql, necesitamos especificar el respectivo ‘driverClassName’, ‘url’, ‘username’ y ‘password’ de la base de datos postgresql.
• Configure el archivo de clase de bean FrameworkDao con referencia al objeto Plantilla JDBC.

Paso 5: cree un archivo de prueba para ejecutar la aplicación en el paquete ‘com.geeks.test’

Cree un archivo ‘ FrameworkTest.java ‘ que contenga el método main() para ejecutar el proyecto.

Archivo FrameworkTest.java:

package com.geeks.test;
  
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
  
import com.geeks.beans.Framework;
import com.geeks.beans.FrameworkDao;
  
public class FrameworkTest {
  
    public static void main(String[] args) {
  
        ApplicationContext con = new ClassPathXmlApplicationContext("com/geeks/resources/applicationContext.xml");
        FrameworkDao dao = (FrameworkDao) con.getBean("framework");
        Framework frame = dao.getDetail("spring");
        System.out.println("Java Framework");
        System.out.println(frame.getId()+". "+frame.getName()+": "+frame.getDescription());
          
    }
  
}

• Obtenga el objeto ‘ApplicationContext’ y usándolo, obtenga el objeto bean.
• Llame al método ‘getDetail()’ en la clase ‘FrameworkDao.java’ para consultar la base de datos y obtener los valores.
• Finalmente, imprima los datos obtenidos en la consola.

Paso 6: Ejecute la aplicación

• Para ejecutar el archivo de prueba, haga clic con el botón derecho en ‘Ejecutar como -> Aplicación Java’.
• Obtendremos el siguiente resultado en la consola.

Producción