S02L08 - Usar usuario de la base de datos usando JPA para JWT

html

Aprovechando JPA para la Gestión de Usuarios en Spring Boot con Autenticación JWT
Tabla de Contenidos

Introducción
Configuración del Proyecto Spring Boot

Añadiendo Dependencias
Configurando Propiedades de la Aplicación


Creando el Modelo de Datos

Entidad Account
Repositorio Account


Implementando la Capa de Servicio

Servicio Account


Inicialización de Datos Iniciales
Configuración de Seguridad

Bean de Codificador de Contraseña


Configuración del Controller

Controller Account
Controller Auth


Ejecutando la Aplicación
Conclusión


Introducción
En las aplicaciones web modernas, gestionar la autenticación y autorización de usuarios es primordial para garantizar la seguridad y experiencias personalizadas para los usuarios. Este eBook profundiza en el aprovechamiento de Java Persistence API (JPA) en una aplicación Spring Boot para manejar los detalles de los usuarios almacenados directamente en una base de datos, integrados con JSON Web Token (JWT) para una autenticación segura.
Puntos Clave:

Transición de detalles de usuarios en memoria a gestión de usuarios basada en bases de datos.
Configuración de Spring Boot con JPA y H2 Database.
Implementación de una codificación segura de contraseñas.
Configuración de autenticación basada en JWT.

Pros y Contras



Pros
Contras




Seguridad mejorada al almacenar datos de usuarios en una base de datos
Complejidad adicional en la configuración y puesta en marcha


Escalabilidad para manejar un gran número de usuarios
Requiere comprensión de JPA y Spring Security


Flexibilidad en la gestión de roles y permisos de usuarios
Posible sobrecarga de rendimiento con interacciones de base de datos



Cuándo y Dónde Usar
Esta configuración es ideal para aplicaciones que requieren una gestión robusta de usuarios, escalabilidad y características de seguridad mejoradas, como aplicaciones empresariales, plataformas de comercio electrónico y servicios de redes sociales.

Configuración del Proyecto Spring Boot
Añadiendo Dependencias
Para comenzar, inicializaremos un proyecto Spring Boot utilizando Spring Initializer con las siguientes dependencias:

Maven: Como herramienta de automatización de compilación.
Spring Data JPA: Para capacidades ORM.
H2 Database: Una base de datos en memoria para desarrollo y pruebas.
Validation: Para aplicar restricciones en la entrada de usuarios.

Pasos:

Navega a Spring Initializer.
Selecciona Maven como el tipo de proyecto.
Añade las siguientes dependencias:

Spring Data JPA
H2 Database
Spring Boot Starter Validation


Haz clic en Generate para descargar el archivo del proyecto.
Extrae el archivo y abre el proyecto en tu IDE preferido.

fragmento de pom.xml:




		
		
			
			
Java
			
			
<dependencies>
    <!-- Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <!-- Otras dependencias -->
    <!-- ... -->
</dependencies>

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						 
<dependencies>
    <!-- Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <!-- Otras dependencias -->
    <!-- ... -->
</dependencies>
 
					
				
			
		



Configurando Propiedades de la Aplicación
A continuación, configura las propiedades de la aplicación para establecer la conexión a la base de datos y otras configuraciones esenciales.
src/main/resources/application.properties:




		
		
			
			
Java
			
			
# Configuración del Servidor
server.port=8080

# Configuración de H2 Database
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# Configuración de Hibernate
spring.jpa.hibernate.ddl-auto=create-drop

# Habilitar Consola H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
# Configuración del Servidor
server.port=8080
 
# Configuración de H2 Database
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
 
# Configuración de Hibernate
spring.jpa.hibernate.ddl-auto=create-drop
 
# Habilitar Consola H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
 
					
				
			
		


Configuraciones Clave Explicadas:



Propiedad
Descripción




server.port
Define el puerto en el que se ejecuta la aplicación. El valor por defecto es 8080.


spring.datasource.url
URL JDBC para conectar a la base de datos H2.


spring.jpa.hibernate.ddl-auto
Gestiona la generación del esquema de la base de datos. create-drop creará el esquema al inicio y lo eliminará al cerrar.


spring.h2.console.enabled
Habilita la consola de la base de datos H2 para interacciones directas con la base de datos.


spring.h2.console.path
Especifica la ruta URL para acceder a la consola H2.




Creando el Modelo de Datos
Entidad Account
La entidad Account representa los detalles del usuario almacenados en la base de datos. Incluye campos como id, email, password y role.
src/main/java/org/studyeasy/SpringRestdemo/model/Account.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.model;

import javax.persistence.*;

@Entity
public class Account {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    @Column(unique = true, nullable = false)
    private String email;

    @Column(nullable = false)
    private String password;

    private String role;

    // Constructores
    public Account() {}

    public Account(String email, String password, String role) {
        this.email = email;
        this.password = password;
        this.role = role;
    }

    // Getters y Setters
    // método toString
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
				
						 
package org.studyeasy.SpringRestdemo.model;
 
import javax.persistence.*;
 
@Entity
public class Account {
 
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String email;
 
    @Column(nullable = false)
    private String password;
 
    private String role;
 
    // Constructores
    public Account() {}
 
    public Account(String email, String password, String role) {
        this.email = email;
        this.password = password;
        this.role = role;
    }
 
    // Getters y Setters
    // método toString
    // ...
}
 
					
				
			
		


Anotaciones Clave:

@Entity: Marca la clase como una entidad JPA.
@Id: Especifica la clave primaria.
@GeneratedValue: Define la estrategia para la generación de la clave primaria.
@Column: Configura ajustes específicos de la columna como unicidad y nulabilidad.

Repositorio Account
La interfaz AccountRepository extiende JpaRepository para proporcionar operaciones CRUD para la entidad Account.
src/main/java/org/studyeasy/SpringRestdemo/repository/AccountRepository.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.repository;

import org.studyeasy.SpringRestdemo.model.Account;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByEmail(String email);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						 
package org.studyeasy.SpringRestdemo.repository;
 
import org.studyeasy.SpringRestdemo.model.Account;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
 
public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByEmail(String email);
}
 
					
				
			
		


Métodos Clave:

findByEmail(String email): Método de consulta personalizada para recuperar una cuenta por email.


Implementando la Capa de Servicio
Servicio Account
La capa de servicio contiene la lógica de negocio e interactúa con el repositorio para gestionar entidades Account.
src/main/java/org/studyeasy/SpringRestdemo/service/AccountService.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.service;

import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.repository.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class AccountService {

    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public Account save(Account account) {
        account.setPassword(passwordEncoder.encode(account.getPassword()));
        return accountRepository.save(account);
    }
    
    // Métodos adicionales del servicio
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						 
package org.studyeasy.SpringRestdemo.service;
 
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.repository.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
 
@Service
public class AccountService {
 
    @Autowired
    private AccountRepository accountRepository;
 
    @Autowired
    private PasswordEncoder passwordEncoder;
 
    public Account save(Account account) {
        account.setPassword(passwordEncoder.encode(account.getPassword()));
        return accountRepository.save(account);
    }
    
    // Métodos adicionales del servicio
    // ...
}
 
					
				
			
		


Funcionalidad:

save(Account account): Codifica la contraseña del usuario antes de guardar la cuenta en la base de datos, asegurando la seguridad de la contraseña.


Inicialización de Datos Iniciales
Para poblar la base de datos con datos iniciales de usuarios, el componente SeedData implementa CommandLineRunner.
src/main/java/org/studyeasy/SpringRestdemo/config/SeedData.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.config;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AccountService accountService;

    @Override
    public void run(String... args) throws Exception {
        Account account1 = new Account("user1@user.com", "password1", "ROLE_USER");
        Account account2 = new Account("user2@user.com", "password2", "ROLE_USER");
        accountService.save(account1);
        accountService.save(account2);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						 
package org.studyeasy.SpringRestdemo.config;
 
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AccountService accountService;
 
    @Override
    public void run(String... args) throws Exception {
        Account account1 = new Account("[email protected]", "password1", "ROLE_USER");
        Account account2 = new Account("[email protected]", "password2", "ROLE_USER");
        accountService.save(account1);
        accountService.save(account2);
    }
}
 
					
				
			
		


Explicación:

@Component: Marca la clase como un componente gestionado por Spring.
CommandLineRunner: Ejecuta el método run después del inicio de la aplicación para insertar datos iniciales.
Cuentas Seed: Crea dos cuentas de usuario con contraseñas codificadas.


Configuración de Seguridad
Bean de Codificador de Contraseña
Para manejar la codificación de contraseñas, define un bean PasswordEncoder utilizando BCrypt.
src/main/java/org/studyeasy/SpringRestdemo/config/SecurityConfig.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    // Configuraciones de seguridad adicionales
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy.SpringRestdemo.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 
@Configuration
public class SecurityConfig {
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    // Configuraciones de seguridad adicionales
    // ...
}
 
					
				
			
		


Puntos Clave:

BCryptPasswordEncoder: Proporciona una encriptación robusta para contraseñas.
@Bean: Registra el PasswordEncoder en el contexto de Spring para la inyección de dependencias.


Configuración del Controller
Controller Account
Maneja solicitudes HTTP relacionadas con usuarios, como el registro y la recuperación.
src/main/java/org/studyeasy/SpringRestdemo/controller/AccountController.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;

@RestController
@RequestMapping("/api/accounts")
public class AccountController {

    @Autowired
    private AccountService accountService;

    @PostMapping("/register")
    public Account registerAccount(@RequestBody Account account) {
        return accountService.save(account);
    }

    // Endpoints adicionales
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						 
package org.studyeasy.SpringRestdemo.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.model.Account;
import org.studyeasy.SpringRestdemo.service.AccountService;
 
@RestController
@RequestMapping("/api/accounts")
public class AccountController {
 
    @Autowired
    private AccountService accountService;
 
    @PostMapping("/register")
    public Account registerAccount(@RequestBody Account account) {
        return accountService.save(account);
    }
 
    // Endpoints adicionales
    // ...
}
 
					
				
			
		


Endpoints:

POST /api/accounts/register: Registra una nueva cuenta de usuario al guardarla en la base de datos con una contraseña codificada.

Controller Auth
Maneja procesos de autenticación, incluyendo el inicio de sesión y la generación de tokens.
src/main/java/org/studyeasy/SpringRestdemo/controller/AuthController.java:




		
		
			
			
Java
			
			
package org.studyeasy.SpringRestdemo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.payload.auth.UserLogin;
import org.studyeasy.SpringRestdemo.payload.auth.Token;
import org.studyeasy.SpringRestdemo.service.TokenService;

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    @Autowired
    private TokenService tokenService;

    @PostMapping("/login")
    public Token login(@RequestBody UserLogin userLogin) {
        // Lógica de autenticación
        // Generación de token
        return tokenService.generateToken(userLogin);
    }
    
    // Endpoints adicionales de autenticación
    // ...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						 
package org.studyeasy.SpringRestdemo.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.studyeasy.SpringRestdemo.payload.auth.UserLogin;
import org.studyeasy.SpringRestdemo.payload.auth.Token;
import org.studyeasy.SpringRestdemo.service.TokenService;
 
@RestController
@RequestMapping("/api/auth")
public class AuthController {
 
    @Autowired
    private TokenService tokenService;
 
    @PostMapping("/login")
    public Token login(@RequestBody UserLogin userLogin) {
        // Lógica de autenticación
        // Generación de token
        return tokenService.generateToken(userLogin);
    }
    
    // Endpoints adicionales de autenticación
    // ...
}
 
					
				
			
		


Funcionalidad:

POST /api/auth/login: Autentica al usuario y devuelve un token JWT tras un inicio de sesión exitoso.


Ejecutando la Aplicación

Construir el Proyecto: Asegúrate de que todas las dependencias estén resueltas y que el proyecto se compile exitosamente.

        



		
		
			
			
Java
			
			mvn clean install
			
				
					
				
					1
				
						mvn clean install
					
				
			
		


    
Ejecutar la Aplicación: Inicia la aplicación Spring Boot.

        



		
		
			
			
Java
			
			mvn spring-boot:run
			
				
					
				
					1
				
						mvn spring-boot:run
					
				
			
		


    
Acceder a la Consola H2: Navega a http://localhost:8080/h2-console para ver la base de datos en memoria. Utiliza la URL JDBC jdbc:h2:mem:testdb con el usuario sa y sin contraseña.
Probar Endpoints: Utiliza herramientas como Postman para probar los endpoints de la API para el registro y autenticación de usuarios.


Conclusión
Este eBook proporcionó una guía comprensiva para implementar un sistema robusto de gestión de usuarios en una aplicación Spring Boot utilizando JPA y JWT para la autenticación. Al pasar de los detalles de usuarios en memoria a un enfoque basado en bases de datos, los desarrolladores pueden lograr una mayor seguridad, escalabilidad y flexibilidad en la gestión de datos de usuarios.
Puntos Clave:

Integración de Spring Boot & JPA: Gestiona las entidades de usuario de manera fluida con Spring Data JPA.
Seguridad de Contraseñas: Utiliza BCrypt para codificar contraseñas, asegurando que se almacenen de manera segura.
Autenticación JWT: Implementa autenticación basada en tokens para sesiones de usuario seguras y sin estado.
Inicialización de Datos Iniciales: Población automática de datos iniciales de usuarios durante el inicio de la aplicación.

Palabras Clave SEO:
Spring Boot, JPA, Autenticación JWT, Gestión de Usuarios, H2 Database, Spring Security, Codificador de Contraseña, BCrypt, REST API, Spring Data JPA, Autenticación en Memoria, Detalles de Usuarios Basados en Base de Datos, Spring Initializer, CommandLineRunner, Datos Seed, Autenticación Basada en Tokens, Almacenamiento Seguro de Contraseñas, Servicios RESTful, Spring Controller, Servicio Account, Repositorio Account
Este artículo es generado por IA.
Propiedad	Descripción
server.port	Define el puerto en el que se ejecuta la aplicación. El valor por defecto es 8080.
spring.datasource.url	URL JDBC para conectar a la base de datos H2.
spring.jpa.hibernate.ddl-auto	Gestiona la generación del esquema de la base de datos. create-drop creará el esquema al inicio y lo eliminará al cerrar.
spring.h2.console.enabled	Habilita la consola de la base de datos H2 para interacciones directas con la base de datos.
spring.h2.console.path	Especifica la ruta URL para acceder a la consola H2.
Pros	Contras
Seguridad mejorada al almacenar datos de usuarios en una base de datos	Complejidad adicional en la configuración y puesta en marcha
Escalabilidad para manejar un gran número de usuarios	Requiere comprensión de JPA y Spring Security
Flexibilidad en la gestión de roles y permisos de usuarios	Posible sobrecarga de rendimiento con interacciones de base de datos