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:
Partes |
Descripción |
---|---|
interfaces JDBC |
Los paquetes java.sql / javax.sql tienen clases/interfaces de API JDBC. |
Controladores JDBC |
El controlador JDBC permite que los programas Java interactúen con la base de datos. |
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>
Implementación:
A. pom.xml (Configuración)
XML
<?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
// 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>
Método |
Descripción |
---|---|
crear() |
Crea una nueva instancia de DataSourceBuilder. |
driverClassName(String driverClassName) |
Especifica el nombre de la clase de controlador que se utilizará para crear la fuente de datos. |
URL (string de URL) |
Especifica la URL que se utilizará para crear la fuente de datos. |
nombre de usuario (string de nombre de usuario) |
Especifica el nombre de usuario que se utilizará para construir la fuente de datos. |
contraseña (string de contraseña) |
Especifica la contraseña que se utilizará para crear la fuente de datos. |
construir() |
Devuelve una instancia de DataSource recién creada . |
Este constructor admite las siguientes implementaciones de fuentes de datos de agrupación.
Nombre |
Descripción |
---|---|
Hikari |
com.zaxxer.hikari.HikariDataSource |
Grupo JDBC de Tomcat |
org.apache.tomcat.jdbc.pool.Fuente de datos |
apache DBCP2 |
org.apache.commons.dbcp2.BasicDataSource |
UCP de Oracle |
oracle.ucp.jdbc.PoolDataSourceImpl |
Nota: La primera implementación de grupo disponible se usa cuando no se ha establecido explícitamente ningún tipo.
Ejemplo:
Java
// 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
// 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:
- Al agregar la dependencia anterior, la página de inicio de sesión se activa de forma predeterminada.
- El nombre de usuario predeterminado es – ‘usuario’
- Spring Security genera automáticamente la contraseña que se muestra en la consola después de iniciar la aplicación.
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.
- 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
Constructor |
Descripción |
---|---|
BCryptPasswordEncoder( ) | Constructor predeterminado. |
BCryptPasswordEncoder (intensidad de int) | La fuerza es el registro de rondas para usar entre 4 y 31. El valor predeterminado es 10. |
BCryptPasswordEncoder (intensidad de int, SecureRandom aleatorio) | La instancia aleatoria segura que se utilizará. |
BCryptPasswordEncoder (versión BCryptVersion) | Versión de BCrypt – 2a, 2b, 2y. |
BCryptPasswordEncoder (versión de BCryptVersion, fuerza int) | Versiones de Bcrypt / rondas de registro. |
BCryptPasswordEncoder (versión de BCryptVersion, fuerza int, SecureRandom aleatorio) | Versiones de Bcrypt/rondas de registro/instancia aleatoria segura. |
BCryptPasswordEncoder (versión BCryptVersion, SecureRandom aleatorio) | Versiones de Bcrypt / Instancia aleatoria segura. |
Métodos de la clase BCryptPasswordEncoder
Método |
Descripción |
---|---|
codificar (CharSequence rawPassword) |
Codifica una contraseña sin formato proporcionada con SHA-1 o un hash superior combinado con un valor salt generado aleatoriamente de 8 bytes o superior. |
coincidencias (CharSequence rawPassword, String encodedPassword) |
Verifica que la contraseña codificada almacenada coincida con la contraseña sin procesar codificada enviada. Devuelve verdadero si coincide, de lo contrario, es falso. |
upgradeEncoding(String encodedPassword) |
Devuelve verdadero si la contraseña codificada debe volver a codificarse para mayor seguridad; de lo contrario, devuelve falso. La implementación predeterminada siempre devuelve falso. |
Ejemplo:
Java
// 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
// 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
HTML
<!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:
B. Estado.html
Mostrar el mensaje de la operación JDBC
HTML
<!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 :
C. Base de datos MySQL
Producción:
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.
Publicación traducida automáticamente
Artículo escrito por pawardarshan461 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA