Saltar a contenido

Detalles de las librerías usadas en el proyecto

1. Spring Boot Starter Data JPA

Teoría

Spring Boot Starter Data JPA es una librería que facilita la implementación de la persistencia de datos en aplicaciones Java a través de la Java Persistence API (JPA). Ofrece abstracciones e implementaciones para acceder a los datos de forma más sencilla, utilizando repositorios.

Utilidad

  • Abstracción de la Persistencia: Permite a los desarrolladores interactuar con bases de datos sin escribir SQL directamente.

  • Facilidad de Uso: Con los repositorios, se pueden realizar operaciones CRUD (Crear, Leer, Actualizar, Borrar) con pocas líneas de código.

  • Integración con Hibernate: Hibernate es el proveedor JPA por defecto, que ofrece herramientas y funcionalidades avanzadas.

Ejemplo de Uso

1.1. Configuración en application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

1.2. Entidad:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters y Setters
}

1.3. Repositorio:

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

1.4. Servicio:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }
}

1.5. Controlador:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

2. Spring Boot Starter Security

Teoría

Spring Boot Starter Security proporciona soporte para autenticación y autorización en aplicaciones. Utiliza Spring Security, que es un framework robusto y ampliamente utilizado para proteger aplicaciones Java.

Utilidad

  • Autenticación: Verifica la identidad del usuario.

  • Autorización: Controla el acceso a recursos con base en los permisos del usuario.

  • Seguridad Personalizable: Permite la configuración de seguridad de acuerdo con las necesidades de la aplicación.

Ejemplo de Uso

2.1. Configuración de Seguridad:

import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll() // Permitir acceso público
                .anyRequest().authenticated() // Requiere autenticación para cualquier otra solicitud
                .and()
            .formLogin(); // Habilitar inicio de sesión basado en formulario
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

3. Spring Boot Starter Web

Teoría

Spring Boot Starter Web es una librería que facilita la construcción de aplicaciones web, incluyendo servicios RESTful, utilizando Spring MVC. Trae todas las dependencias necesarias para el desarrollo web.

Utilidad

  • Facilidad en la Creación de APIs: Permite la creación de endpoints REST de manera rápida.

  • Soporte para Motores de Plantillas: Se integra con librerías de plantillas como Thymeleaf.

  • Gestión de Solicitudes y Respuestas: Facilita la manipulación de HTTP.

Ejemplo de Uso

3.1. Controlador:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

4. Spring Boot DevTools

Teoría

Spring Boot DevTools es un conjunto de herramientas que mejora la experiencia de desarrollo. Permite que la aplicación se reinicie automáticamente cuando se detectan cambios.

Utilidad

  • Recarga Automática: Facilita el desarrollo, ya que no es necesario reiniciar la aplicación manualmente.
  • Mejoras en la Experiencia de Desarrollo: Habilita configuraciones que simplifican el flujo de trabajo de desarrollo.

Ejemplo de Uso

4.1. Configuración:

Basta con agregar la dependencia en el pom.xml y luego ejecutar la aplicación. Al realizar cambios en el código, la aplicación se reiniciará automáticamente.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

5. H2 Database

Teoría

H2 es una base de datos relacional ligera que puede ejecutarse en memoria y se utiliza principalmente para desarrollo y pruebas. Es fácil de configurar y no requiere instalación.

Utilidad

  • Pruebas Rápidas: Ideal para pruebas unitarias y desarrollo rápido.

  • Sin Configuración Compleja: Basta con configurar el JDBC para usarla.

  • Consola Web: Ofrece una consola web para interactuar con la base de datos.

Ejemplo de Uso

5.1. Configuración en application.properties:

spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password

5.2. Acceso a la Consola H2:

Acceda a la consola en http://localhost:8080/h2-console después de iniciar la aplicación.

6. PostgreSQL

Teoría

PostgreSQL es un sistema de gestión de bases de datos objeto-relacional (ORDBMS) que es ampliamente utilizado por sus robustas funcionalidades y conformidad con los estándares.

Utilidad

  • Soporte para Transacciones: Gestiona transacciones complejas con seguridad.

  • Escalabilidad: Capaz de manejar grandes volúmenes de datos.

  • Extensibilidad: Permite la creación de tipos de datos personalizados.

Ejemplo de Uso

6.1. Configuración en application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.jpa.hibernate.ddl-auto=update

6.2. Conexión a la Base de Datos:

Asegúrese de que el servidor PostgreSQL esté en ejecución y que la base de datos y las credenciales sean correctas.

7. Lombok

Teoría

Lombok es una librería que ayuda a reducir la cantidad de código repetitivo (boilerplate), como getters, setters, constructores y métodos toString, a través de anotaciones.

Utilidad

  • Reducir Código Repetitivo: Facilita la escritura de clases de modelo.

  • Facilita el Mantenimiento: Menos código resulta en menos errores y facilita el mantenimiento.

Ejemplo de Uso

7.1. Modelo con Lombok:

import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
@Data // Genera automáticamente los métodos getters y setters
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Double price;
}

8. Spring Boot Starter Test

Teoría

Spring Boot Starter Test proporciona todas las dependencias necesarias para realizar pruebas en aplicaciones Spring Boot, incluyendo JUnit, Mockito y Spring Test.

Utilidad

  • Facilidad en la Creación de Pruebas: Simplifica la configuración de pruebas unitarias y de integración.

  • Soporte para Pruebas de Componentes de Spring: Permite probar fácilmente componentes de Spring.

Ejemplo de Uso

8.1. Prueba Unitaria:

import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetUsers() throws Exception {
        mockMvc.perform(get("/users"))
            .andExpect(status().isOk());
    }
}

9. Spring Security Test

Teoría

Spring Security Test proporciona funcionalidades para probar la seguridad de aplicaciones Spring, permitiendo simular usuarios autenticados y verificar el control de acceso.

Utilidad

  • Pruebas de Seguridad Simplificadas: Facilita la creación de pruebas que verifican la seguridad de la aplicación.

  • Simulación de Usuarios: Permite simular usuarios con diferentes roles y permisos.

Ejemplo de Uso

9.1. Prueba de Seguridad:

import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.web.servlet.MockMvc;

@WebMvcTest(UserController.class)
public class UserControllerSecurityTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    @WithMockUser // Simula un usuario autenticado
    public void testGetUsersWithAuthentication() throws Exception {
        mockMvc.perform(get("/users"))
            .andExpect(status().isOk());
    }

    @Test
    public void testGetUsersWithoutAuthentication() throws Exception {
        mockMvc.perform(get("/users"))
            .andExpect(status().isUnauthorized());
    }
}

10. Auth0 Java JWT

Teoría

Auth0 Java JWT es una librería que facilita la manipulación de tokens JWT (JSON Web Tokens) en aplicaciones Java. Los JWTs son ampliamente utilizados para la autenticación y el intercambio seguro de información entre partes.

Utilidad

  • Generación de Tokens: Permite crear tokens JWT para autenticar usuarios.

  • Validación de Tokens: Proporciona funcionalidades para verificar la autenticidad e integridad de los tokens.

  • Manipulación de Claims: Facilita la inclusión y lectura de claims en el token, que son informaciones adicionales.

Ejemplo de Uso

10.1. Generación y Validación de JWT:

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.JWTVerifier;

public class JwtUtil {
    private static final String SECRET = "mySecretKey";

    public String generateToken(String username) {
        return JWT.create()
                .withSubject(username)
                .sign(Algorithm.HMAC256(SECRET));
    }

    public String validateToken(String token) {
        JWTVerifier verifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
        DecodedJWT jwt = verifier.verify(token);
        return jwt.getSubject();
    }
}

11. Jackson Databind

Teoría

Jackson Databind es una librería del proyecto Jackson que proporciona funcionalidades para la serialización y deserialización de objetos Java a JSON y viceversa. Es ampliamente utilizada en aplicaciones que necesitan interactuar con APIs RESTful.

Utilidad

  • Serialización: Convierte objetos Java en cadenas JSON.

  • Deserialización: Convierte cadenas JSON en objetos Java.

  • Soporte para Anotaciones: Permite personalizar la serialización y deserialización con anotaciones.

Ejemplo de Uso

11.1. Serialización y Deserialización:

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public String serialize(Object obj) throws Exception {
        return objectMapper.writeValueAsString(obj);
    }

    public <T> T deserialize(String json, Class<T> clazz) throws Exception {
        return objectMapper.readValue(json, clazz);
    }
}

12. Springdoc OpenAPI

Teoría

Springdoc OpenAPI es una librería que genera documentación automática para APIs REST basadas en Spring. Utiliza la especificación OpenAPI para describir los endpoints de una aplicación, facilitando la integración y el uso de la API.

Utilidad

  • Documentación Automática: Genera documentación en tiempo real a partir de las anotaciones en las clases.

  • Interfaz Interactiva: Proporciona una interfaz gráfica para probar los endpoints de la API.

  • Soporte para Versionado: Facilita la gestión de versiones de la API.

Ejemplo de Uso

12.1. Configuración de Springdoc:

import org.springdoc.core.annotations.SpringDocConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@SpringDocConfig
public class OpenApiConfig {
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("API Example")
                        .version("1.0")
                        .description("Documentación de la API de ejemplo"));
    }
}