Esta anotación proporciona una manera de agregar configuración de seguridad a los métodos comerciales.

Utilizará roles para verificar si un usuario tiene permiso para llamar a este método. La anotación es parte de la seguridad de primavera. Entonces, para habilitar su uso, necesita la dependencia de seguridad de Spring.

Escenario de ejemplo

Tienes una aplicación que tiene un producto CRUD. En este CRUD desea controlar las operaciones utilizando dos roles específicos.

• Usuario: puede crear el producto y verlo. Pero no puedo actualizar ni eliminar un producto.
• Administrador: que puede realizar todas las operaciones del usuario y también puede actualizar y eliminar un producto.

Puedes usar @Secured para administrar el acceso de esos roles en cada operación.

Roles para operaciones

Podemos definir los siguientes roles en nuestro escenario de ejemplo.

• ROLE_USUARIO, ROLE_ADMIN

Leer:

• ROLE_USUARIO, ROLE_ADMIN

Actualizar:

• ROLE_ADMIN

Borrar:

• ROLE_ADMIN

Veamos un ejemplo de código y observemos el comportamiento de la aplicación.

Agregar dependencia de seguridad de Spring

Para trabajar con la anotación @Secured, agregue la dependencia Maven para Spring Security:

    org.springframework.boot
    spring-boot-starter-security

Métodos de anotación con @Secured

Anotamos los métodos con @Secured definiendo qué roles pueden acceder al comportamiento del método.

public class Product {

    private Long id;
    private String name;
    private BigDecimal value;

    //getters and setters
}

@Service
public class ProductService {

    @Secured({"ROLE_USER", "ROLE_ADMIN"})
    public Product createProduct(Product product) {
        // Logic for creating a product
        return product;
    }

    @Secured({"ROLE_USER", "ROLE_ADMIN"})
    public Product getProductById(Long id) {
        // Logic for fetching a product
        return null;
    }

    @Secured("ROLE_ADMIN")
    public Product updateProduct(Product product) {
        // Logic for updating a product
        return product;
    }

    @Secured("ROLE_ADMIN")
    public void deleteProduct(Long id) {
        // Logic for deleting a product
    }
}

Configuración de la aplicación

Debe agregar @EnableGlobalMethodSecurity(securedEnabled = true) para configurar su aplicación Spring para usar la seguridad del método de habilitación usando @Secured.

@SpringBootApplication
@EnableTransactionManagement
@EnableGlobalMethodSecurity(securedEnabled = true)
public class MasteryApplication {

    public static void main(String[] args) {
        SpringApplication.run(MasteryApplication.class, args);
    }

}

Probando el comportamiento

En nuestro ejemplo vamos a probar el comportamiento usando pruebas, por lo que agregamos la dependencia de prueba de arranque de primavera.

    org.springframework.security
    spring-security-test
    test

Luego creamos pruebas para validar si usamos un usuario simulado y le asignamos roles específicos, podemos probar a los usuarios en cada rol y cómo se comporta nuestra aplicación. Al hacerlo, podemos garantizar que solo los roles correctos puedan realizar las acciones permitidas.

@SpringBootTest
class ProductServiceTests {

    @Autowired
    private ProductService productService;

    @Test
    @WithMockUser(roles = "USER")
    void testCreateProductAsUser() {
        Product product = new Product();
        assertDoesNotThrow(() -> productService.createProduct(product));
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void testCreateProductAsAdmin() {
        Product product = new Product();
        assertDoesNotThrow(() -> productService.createProduct(product));
    }

    @Test
    @WithAnonymousUser
    void testCreateProductAsAnonymous() {
        Product product = new Product();
        assertThrows(AccessDeniedException.class, () -> productService.createProduct(product));
    }

    @Test
    @WithMockUser(roles = "USER")
    void testGetProductByIdAsUser() {
        assertDoesNotThrow(() -> productService.getProductById(1L)); // Assuming product with ID 1 exists
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void testGetProductByIdAsAdmin() {
        assertDoesNotThrow(() -> productService.getProductById(1L));
    }

    @Test
    @WithAnonymousUser
    void testGetProductByIdAsAnonymous() {
        assertThrows(AccessDeniedException.class, () -> productService.getProductById(1L));
    }

    @Test
    @WithMockUser(roles = "USER")
    void testUpdateProductAsUser() {
        Product product = new Product();
        assertThrows(AccessDeniedException.class, () -> productService.updateProduct(product));
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void testUpdateProductAsAdmin() {
        Product product = new Product();
        assertDoesNotThrow(() -> productService.updateProduct(product));
    }

    @Test
    @WithAnonymousUser
    void testUpdateProductAsAnonymous() {
        Product product = new Product();
        assertThrows(AccessDeniedException.class, () -> productService.updateProduct(product));
    }

    @Test
    @WithMockUser(roles = "USER")
    void testDeleteProductAsUser() {
        assertThrows(AccessDeniedException.class, () -> productService.deleteProduct(1L));
    }

    @Test
    @WithMockUser(roles = "ADMIN")
    void testDeleteProductAsAdmin() {
        assertDoesNotThrow(() -> productService.deleteProduct(1L));
    }

    @Test
    @WithAnonymousUser
    void testDeleteProductAsAnonymous() {
        assertThrows(AccessDeniedException.class, () -> productService.deleteProduct(1L));
    }
}

Eso es todo, ahora puedes administrar el acceso de los usuarios a la aplicación usando roles con la anotación @Secured.

Si te gusta este tema, asegúrate de seguirme. ¡En los próximos días, explicaré más sobre las anotaciones de Spring! ¡Manténganse al tanto!

¡Sígueme!