Spring Boot: Spring JDBC frente a Spring Data JDBC

Primavera JDBC

Spring puede realizar operaciones JDBC al tener conectividad con cualquiera de los jars de RDBMS como MySQL, Oracle o SQL Server, etc. Por ejemplo, si nos estamos conectando con MySQL, entonces necesitamos conectar «mysql-connector-java». Veamos cómo se ve un archivo pom.xml de un proyecto maven.

<?xml version="1.0" encoding="UTF-8"?>
<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.gfg.common</groupId>
   <artifactId>SpringJDBCExample</artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>SpringJDBCExample</name>
   <url>http://maven.apache.org</url>
   
   <dependencies>
      
      <!-- Spring framework -->
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring</artifactId>
         <version>2.5.6</version>
         <!-- You can change corresponding version here -->
      </dependency>
      
      <!-- MySQL database driver -->
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.9</version>
         <!-- You can change corresponding version here -->
      </dependency>
      
   </dependencies>
   
</project>

Clase de modelo:

Necesitamos una clase MODEL para comenzar

public class <ModelClass>
{
    int column1;
    String column2;
    int column3;
    // ....
    // corresponding getter and setter
    // methods for each and every column
     
}

Patrón DAO:

public interface <SampleDAO>
{
    // To insert the records
    public void insert(ModelClass object);
     
    // To get the records
    public ModelClass findByXXX(int xxx);
}

Implementación de la interfaz DAO:

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
 
// Provide necessary interface imports
// Provide necessary ModelClass imports
public class JdbcSampleDAO implements SampleDAO {
    private DataSource dataSource;
 
    public void setDataSource(DataSource dataSource)
    {
        this.dataSource = dataSource;
    }
 
    public void insert(ModelClass object)
    {
        // Write the necessary statements like providing SQL
        // insert statement
        // and execute them for making record insertion
    }
 
    public ModelClass findByXXX(int XXX)
    {
        // Write the necessary statements like providing SQL
        // select statement
        // and execute them for making record display
    }
}

JDBC de datos de primavera

Pertenece a la familia Spring Data. Básicamente, proporciona abstracciones para la capa de acceso a datos basada en JDBC. Proporciona un marco de mapeo relacional de objetos (ORM) fácil de usar para trabajar con bases de datos. Puede admitir objetos de entidad y repositorios. Debido a esto, se reducen muchas complejidades. La capa de acceso a datos es simple. Por lo tanto, se omiten características de JPA como Lazy Loading, almacenamiento en caché de entidades, etc. Debido a esto, las operaciones de JDBC en las entidades están bien atendidas. Veamos cuáles son las dependencias necesarias para Spring Data JDBC en el proyecto maven de Spring Boot .

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>

Veamos cuáles son las dependencias necesarias para Spring Data JDBC en el proyecto Spring maven.

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jdbc</artifactId>
      <!-- Specify the required version here -->
    <version>{version}</version>
</dependency>

Clase POJO:

Para crear la entidad, necesitamos usar un POJO (objeto Java simple y antiguo). Spring Data JDBC puede asignar nuestro POJO a una tabla de base de datos. Los siguientes puntos clave deben ser observados

1. El POJO creado debe coincidir con la tabla de la base de datos. Si no, usa la anotación @Table y esto ayuda a hacer referencia al nombre real de la tabla.
2. Se requiere la anotación @Id para identificar la clave principal
3. Es una buena práctica que todos los campos de persistencia en POJO y las columnas de la tabla de la base de datos deben coincidir. De lo contrario, la anotación @Column es útil para proporcionar nombres de columna.

Ejemplo de clase POJO

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;
 
// Required for generating default getter and setter
@Data
 
// If POJO class name and db table name differs
@Table("<mention the name of db table>")
public class <POJOClass> {
    // For representing Primary key
    @Id
    private Long id;
    private String <columnName1>;
    private String <columnName2>;
    private Integer <columnName3>;
}

Para una clase POJO, no es obligatorio tener

1. Un constructor parametrizado.
2. Métodos de acceso.

Interfaz del repositorio:

Se admiten la interfaz de repositorio junto con los métodos de consulta y las anotaciones @Query. Los repositorios creados pueden ser una subinterfaz de CrudRepository.

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
 
@Repository
public interface <SampleRepository> extends CrudRepository<<POJOClass>, Long> {
    // XXX can be firstName, lastName, age, gender etc.,
    List<POJOClass> findByXXX(String XXX);
}

La consulta nombrada se puede construir como

@Query("select * from <tableName> where condition = :<param>")
List<POJOClass> findByXXX(@Param("param") String XXX);

Diferencia entre Spring JDBC y Spring Data JDBC