Bota de resorte – JDBC

Hoy en día, la mayoría de las aplicaciones necesitan una base de datos por varias razones, como almacenar los detalles del usuario. Además, también se usa para la autenticación, para almacenar productos, información de pedidos, etc. En tal situación, mientras trabajamos con aplicaciones Java, usamos la API JDBC . JDBC ( Java Database Connectivity ) es una API (Interfaz de programación de aplicaciones) estándar para hacer DBMS (Sistema de gestión de bases de datos) accesible para los programas Java.

JDBC consta de dos partes, como se muestra en la siguiente tabla:

Spring Boot ofrece muchas formas de trabajar con bases de datos (p. ej., JdbcTemplate) sin el engorroso esfuerzo que necesita JDBC. Puede usar JDBC sin procesar para configurar manualmente el funcionamiento.

Para trabajar con una base de datos usando Spring-Boot necesitamos agregar las siguientes dependencias

A. API de JDBC

La API de conectividad de la base de datos especifica cómo el cliente se conecta y consulta una base de datos.

Maven - pom.xml

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

B. Controlador MySQL

Controlador MySQL JDBC y R2DBC para trabajar con la base de datos.

Maven - pom.xml

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

Estructura del proyecto – Maven

Implementación: 

A. pom.xml (Configuración)

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>GFG</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>GFG</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
  
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
          
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
  
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
  
</project>

B. Arranque de la aplicación Spring (GfgApplication.java)

// Java Program to Illustrate Boot of Spring Application
  
package gfg;
  
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
  
// Annotation
@SpringBootApplication
  
// Application(Main) Class
public class GfgApplication {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        SpringApplication.run(GfgApplication.class, args);
    }
}

C. Configuración de DataSource (ConfigDataSource.java)

DataSourceBuilder<T> es una clase útil para construir un DataSource.

- org.springframework.boot.jdbc.DataSourceBuilder<T>
- public final class DataSourceBuilder<T extends DataSource> extends Object

Métodos de la clase DataSourceBuilder<T>

Este constructor admite las siguientes implementaciones de fuentes de datos de agrupación.

Nota: La primera implementación de grupo disponible se usa cuando no se ha establecido explícitamente ningún tipo.

Consola

Ejemplo:

// Java Program Illustrating Configuration of
// DataSourceConfiguration of DataSource
  
package gfg;
  
import javax.sql.DataSource;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
  
// Annotation
@Configuration
  
// Class
public class ConfigDataSource {
  
    @Bean public static DataSource source()
    {
  
        DataSourceBuilder<?> dSB
            = DataSourceBuilder.create();
        dSB.driverClassName("com.mysql.jdbc.Driver");
  
        // MySQL specific url with database name
        dSB.url("jdbc:mysql://localhost:3306/userdetails");
  
        // MySQL username credential
        dSB.username("user");
  
        // MySQL password credential
        dSB.password("password");
  
        return dSB.build();
    }
}

Nota : el nombre de clase del controlador: ‘com.mysql.jdbc.Driver’ ha quedado obsoleto. No daría error porque el controlador se carga automáticamente y no es necesaria la carga manual. El nuevo nombre de clase de controlador es ‘com.mysql.cj.jdbc.Driver‘.

D. Credenciales de usuario que se almacenarán en la base de datos (UserDetails.java)

Se puede agregar la biblioteca ‘Lombok’ para omitir los métodos Getter/Setter, construir el constructor sin argumentos, el constructor para los campos finales, etc.

Experto – pom.xml

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

Ejemplo:

// Java Program Illustrating User Credentials to
// be Stored in the Database
  
package geek.details;
  
import lombok.Data;
  
// Annotation for Getter/Setter methods
@Data
public class UserDetails {
  
    String user;
    String userName;
    String password;
}

E. Clase de utilidad para conectar y consultar la base de datos (JDBC.java)

La codificación de contraseñas es imprescindible por muchas razones de seguridad. Para usar Spring Security, agregue la siguiente dependencia:

Experto – pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
        
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-test</artifactId>
    <scope>test</scope>
</dependency>

Los requisitos previos son los siguientes: 

1. Al agregar la dependencia anterior, la página de inicio de sesión se activa de forma predeterminada.
2. El nombre de usuario predeterminado es – ‘usuario’
3. Spring Security genera automáticamente la contraseña que se muestra en la consola después de iniciar la aplicación.

Consola

Nota: La contraseña generada deja de ser válida para la próxima iteración/ejecutar la aplicación cuando se genera la nueva contraseña pero el nombre de usuario sigue siendo el mismo.

Página de inicio de sesión predeterminada

• Para la codificación, Spring ofrece muchas formas como la siguiente: ‘BCryptPasswordEncoder’.
• Es una implementación de PasswordEncoder que utiliza el algoritmo hash fuerte de BCrypt.
• Las instancias de Version, Strength y SecureRandom se pueden modificar.

- org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder
- public class BCryptPasswordEncoder extends java.lang.Object implements PasswordEncoder

Constructores de la clase BCryptPasswordEncoder 

Métodos de la clase BCryptPasswordEncoder 

Ejemplo:

// Java Program Illustrating Utility class for Connecting
// and Querying the Database
  
package gfg;
  
import geek.details.UserDetails;
import java.security.SecureRandom;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import javax.sql.DataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  
// Annotation to provide logging feature
@Slf4j
  
// Class
public class JDBC {
  
    public int insert(UserDetails user)
    {
        DataSource dataSource = null;
        Connection connection = null;
        PreparedStatement prepStatement = null;
  
        int result = 0;
        try {
  
            // Get the configured datasourse
            dataSource = ConfigDataSource.source();
            // Attempt for connection to MySQL
            connection = dataSource.getConnection();
            prepStatement = connection.prepareStatement(
                "insert into user (user,username,password) values (?,?,?)");
            prepStatement.setString(1, user.getUser());
            prepStatement.setString(2, user.getUserName());
  
            BCryptPasswordEncoder bCryptPasswordEncoder
                = new BCryptPasswordEncoder(
                    10, new SecureRandom());
            String encodedPassword
                = bCryptPasswordEncoder.encode(
                    user.getPassword());
  
            prepStatement.setString(3, encodedPassword);
            result = prepStatement.executeUpdate();
        }
        catch (SQLException e) {
            log.getName();
        }
  
        return result;
    }
}

F. Controlador de la aplicación Spring (JdbcController.java)

// Java Program to Illustrate Controller of Spring Application
  
package gfg;
  
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
  
import geek.details.UserDetails;
  
@Controller
@RequestMapping("/jdbc")
public class JdbcController {
      
    @GetMapping
    public String get(Model model) {
          
      // Add object to be bound by user provided details
        model.addAttribute("obj", new UserDetails()); 
        return "template";
    }
      
    @PostMapping
    public String post(@ModelAttribute("obj") UserDetails user, Model model) {
          
        JDBC SQL = new JDBC();
        int result = SQL.insert(user);
        if(result == 1)
            model.addAttribute("message", "Successful JDBC connection and execution of SQL statement");
        else
            model.addAttribute("message", "Query not submitted!");
        return "Status";
    }
}

Plantillas ( hoja de tomillo )

A. template.html: obtiene los datos del usuario y los vincula al objeto UserDetails

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
 <head>
 <title>GFG</title>
 </head>
 <body>
 <h1>Register Geek</h1>
   
 <form method="POST" th:action="@{/jdbc}" th:object="${obj}">
   
 <label for="user">User: </label><br/>
 <input type="text" th:field="*{user}"/><br/>
   
 <label for="username">Username: </label><br/>
 <input type="text" th:field="*{userName}"/><br/>
   
 <label for="password">Password: </label><br/>
 <input type="password" th:field="*{password}"/>
   
 <input type="submit" value="Register"/>
   
 </form>
 </body>
</html>

Producción:

Rellenar los datos del usuario 

B. Estado.html

Mostrar el mensaje de la operación JDBC

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
 <head>
 <title>GFG</title>
 </head>
 <body>
 <h1>STATUS</h1>
 <h2 th:text="${message}">
       <span>message will print here</span>
 </h2> 
 </body>
</html>

Salida : 

Visualización del mensaje

C. Base de datos MySQL 

Producción:

Recuperó los detalles de usuario almacenados

Nota: Spring-Boot ofrece muchas formas convenientes de trabajar con datos , por ejemplo, Spring Data JPA, que tiene una implementación predeterminada de Hibernate. Podemos usarlos para aprovechar la API de persistencia de Java (JPA) para el mapeo de objetos/relaciones y evitar esfuerzos engorrosos.