Esta anotação fornece uma maneira de adicionar configuração de segurança aos métodos de negócios.

Ele usará funções para verificar se um usuário tem permissão para chamar este método. A anotação faz parte da segurança da primavera. Portanto, para ativar seu uso, você precisa da dependência de segurança Spring.

Cenário de exemplo

Você tem um aplicativo que possui um produto CRUD. Neste CRUD você deseja controlar as operações usando duas funções específicas.

• Usuário: pode criar o produto e vê-lo. Mas não é possível atualizar ou excluir um produto.
• Admin: que pode realizar todas as operações do usuário e também pode atualizar e excluir um produto.

Você pode usar @Secured para gerenciar o acesso dessas funções em cada operação.

Funções para Operações

Podemos definir as seguintes funções em nosso cenário de exemplo.

• ROLE_USER, ROLE_ADMIN

Ler:

• ROLE_USER, ROLE_ADMIN

Atualizar:

• ROLE_ADMIN

Deletar:

• ROLE_ADMIN

Vejamos um exemplo de código e observemos o comportamento do aplicativo.

Adicionando dependência de Spring Security

Para trabalhar com a anotação @Secured, adicione a dependência Maven para Spring Security:

org.springframework.bootspring-boot-starter-security

Anotando métodos com @Secured

Anotamos os métodos com @Secured definindo quais funções podem acessar o comportamento do 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
    }
}

Configuração do aplicativo

Você precisa adicionar @EnableGlobalMethodSecurity(securedEnabled = true) para configurar seu aplicativo Spring para usar a segurança do método enable usando @Secured.

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

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

}

Testando o comportamento

Em nosso exemplo, vamos testar o comportamento usando testes, então adicionamos a dependência de teste de inicialização de primavera.

org.springframework.securityspring-security-testtest

Depois criamos testes para validar se estamos usando um usuário simulado e atribuímos funções específicas a ele, podemos testar os usuários em cada função e como nossa aplicação se comporta. Ao fazer isso, podemos garantir que apenas as funções corretas possam executar as ações 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));
    }
}

É isso, agora você pode gerenciar o acesso do usuário ao aplicativo usando funções com a anotação @Secured.

Se você gosta deste tópico, não deixe de me seguir. Nos próximos dias estarei explicando mais sobre as anotações do Spring! Fique atento!

Me siga!