Cette annotation fournit un moyen d'ajouter une configuration de sécurité aux méthodes métier.

Il utilisera des rôles pour vérifier si un utilisateur est autorisé à appeler cette méthode. L'annotation fait partie de la sécurité du printemps. Donc, pour permettre son utilisation, vous avez besoin de la dépendance de sécurité Spring.

Exemple de scénario

Vous disposez d'une application qui possède un produit CRUD. Dans ce CRUD, vous souhaitez contrôler les opérations en utilisant deux rôles spécifiques.

• Utilisateur : peut créer le produit et voir le produit. Mais impossible de mettre à jour ou de supprimer un produit.
• Administrateur : qui peut effectuer toutes les opérations de l'utilisateur et peut également mettre à jour et supprimer un produit.

Vous pouvez utiliser @Secured pour gérer l'accès de ces rôles sur chaque opération.

Rôles pour les opérations

Nous pouvons définir les rôles suivants dans notre exemple de scénario.

• ROLE_USER, ROLE_ADMIN

Lire:

• ROLE_USER, ROLE_ADMIN

Mettre à jour:

• ROLE_ADMIN

Supprimer:

• ROLE_ADMIN

Regardons un exemple de code et observons le comportement de l'application.

Ajout d'une dépendance de sécurité Spring

Pour travailler avec l'annotation @Secured, ajoutez la dépendance Maven pour Spring Security :

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

Annotation de méthodes avec @Secured

Nous annotons les méthodes avec @Secured définissant quels rôles peuvent accéder au comportement de la méthode.

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

Configuration des applications

Vous devez ajouter @EnableGlobalMethodSecurity(securedEnabled = true) pour configurer votre application Spring afin qu'elle utilise la méthode d'activation de la sécurité à l'aide de @Secured.

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

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

}

Tester le comportement

Dans notre exemple, nous allons tester le comportement à l'aide de tests, nous ajoutons donc la dépendance du test Spring Boot.

    org.springframework.security
    spring-security-test
    test

Ensuite, nous créons des tests pour valider si vous utilisez un utilisateur fictif et lui attribuer des rôles spécifiques, nous pouvons tester les utilisateurs dans chaque rôle et comment notre application se comporte. Ce faisant, nous pouvons garantir que seuls les rôles appropriés peuvent effectuer les actions autorisées.

@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));
    }
}

Ça y est, vous pouvez désormais gérer l'accès des utilisateurs à l'application à l'aide de rôles avec l'annotation @Secured.

Si vous aimez ce sujet, assurez-vous de me suivre. Dans les prochains jours, j'expliquerai davantage les annotations Spring ! Restez à l'écoute!

Suis-moi!