Skip to content

Details of the Libraries Used in the Project

1. Spring Boot Starter Data JPA

Theory

Spring Boot Starter Data JPA is a library that facilitates the implementation of data persistence in Java applications through the Java Persistence API (JPA). It offers abstractions and implementations to access data more simply, using repositories.

Usefulness

  • Persistence Abstraction: Allows developers to interact with databases without writing SQL directly.

  • Ease of Use: With repositories, you can perform CRUD (Create, Read, Update, Delete) operations with just a few lines of code.

  • Integration with Hibernate: Hibernate is the default JPA provider, offering advanced tools and features.

Usage Example

1.1. Configuration in 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. Entity:

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 and Setters
}

1.3. Repository:

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

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

1.4. Service:

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. Controller:

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

Theory

Spring Boot Starter Security provides support for authentication and authorization in applications. It uses Spring Security, which is a robust and widely used framework for securing Java applications.

Usefulness

  • Authentication: Verifies the user's identity.

  • Authorization: Controls access to resources based on the user's permissions.

  • Customizable Security: Allows for security configuration according to the application's needs.

Usage Example

2.1. Security Configuration:

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() // Allow public access
                .anyRequest().authenticated() // Require authentication for any other request
                .and()
            .formLogin(); // Enable form-based login
    }

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

3. Spring Boot Starter Web

Theory

Spring Boot Starter Web is a library that facilitates the construction of web applications, including RESTful services, using Spring MVC. It brings all the necessary dependencies for web development.

Usefulness

  • Ease of API Creation: Allows for the quick creation of REST endpoints.

  • Templating Support: Integrates with templating libraries like Thymeleaf.

  • Request and Response Management: Facilitates HTTP handling.

Usage Example

3.1. Controller:

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

Theory

Spring Boot DevTools is a set of tools that enhances the development experience. It allows the application to restart automatically when changes are detected.

Usefulness

  • Automatic Reloading: Facilitates development, as you don't need to restart the application manually.
  • Improvements in Development Experience: Enables settings that simplify the development workflow.

Usage Example

4.1. Configuration:

Just add the dependency to pom.xml and then run the application. When you make changes to the code, the application will restart automatically.

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

5. H2 Database

Theory

H2 is a lightweight relational database that can run in-memory and is primarily used for development and testing. It is easy to configure and requires no installation.

Usefulness

  • Quick Testing: Ideal for unit tests and rapid development.

  • No Complex Configuration: Just configure the JDBC to use it.

  • Web Console: Offers a web console to interact with the database.

Usage Example

5.1. Configuration in 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. Accessing the H2 Console:

Access the console at http://localhost:8080/h2-console after starting the application.

6. PostgreSQL

Theory

PostgreSQL is an object-relational database management system (ORDBMS) that is widely used for its robust features and standards compliance.

Usefulness

  • Transaction Support: Manages complex transactions securely.

  • Scalability: Capable of handling large volumes of data.

  • Extensibility: Allows the creation of custom data types.

Usage Example

6.1. Configuration in 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. Database Connection:

Ensure that the PostgreSQL server is running and that the database and credentials are correct.

7. Lombok

Theory

Lombok is a library that helps reduce the amount of boilerplate code, such as getters, setters, constructors, and toString methods, through annotations.

Usefulness

  • Reduce Boilerplate Code: Makes writing model classes easier.

  • Facilitates Maintenance: Less code results in fewer errors and easier maintenance.

Usage Example

7.1. Model with Lombok:

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

@Entity
@Data // Automatically generates getter and setter methods
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Double price;
}

8. Spring Boot Starter Test

Theory

Spring Boot Starter Test provides all the necessary dependencies for testing Spring Boot applications, including JUnit, Mockito, and Spring Test.

Usefulness

  • Ease of Test Creation: Simplifies the setup of unit and integration tests.

  • Support for Testing Spring Components: Allows for easy testing of Spring components.

Usage Example

8.1. Unit Test:

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

Theory

Spring Security Test provides functionalities for testing the security of Spring applications, allowing the simulation of authenticated users and verification of access control.

Usefulness

  • Simplified Security Tests: Facilitates the creation of tests that verify application security.

  • User Simulation: Allows simulating users with different roles and permissions.

Usage Example

9.1. Security Test:

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 // Simulates an authenticated user
    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

Theory

Auth0 Java JWT is a library that facilitates the handling of JWTs (JSON Web Tokens) in Java applications. JWTs are widely used for authentication and secure information exchange between parties.

Usefulness

  • Token Generation: Allows creating JWTs to authenticate users.

  • Token Validation: Provides functionalities to verify the authenticity and integrity of tokens.

  • Claim Handling: Facilitates the inclusion and reading of claims in the token, which are additional pieces of information.

Usage Example

10.1. JWT Generation and Validation:

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

Theory

Jackson Databind is a library from the Jackson project that provides functionalities for serializing and deserializing Java objects to and from JSON. It is widely used in applications that need to interact with RESTful APIs.

Usefulness

  • Serialization: Converts Java objects into JSON strings.

  • Deserialization: Converts JSON strings into Java objects.

  • Annotation Support: Allows customization of serialization and deserialization with annotations.

Usage Example

11.1. Serialization and Deserialization:

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

Theory

Springdoc OpenAPI is a library that automatically generates documentation for REST APIs based on Spring. It uses the OpenAPI specification to describe an application's endpoints, facilitating API integration and usage.

Usefulness

  • Automatic Documentation: Generates real-time documentation from annotations in the classes.

  • Interactive Interface: Provides a graphical interface to test the API endpoints.

  • Versioning Support: Facilitates the management of API versions.

Usage Example

12.1. Springdoc Configuration:

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("Example API documentation"));
    }
}