Diese Anmerkung bietet eine Möglichkeit, Sicherheitskonfiguration zu Geschäftsmethoden hinzuzufügen.

Es werden Rollen verwendet, um zu prüfen, ob ein Benutzer die Berechtigung zum Aufrufen dieser Methode hat. Die Anmerkung ist Teil der Federsicherheit. Um die Verwendung zu ermöglichen, benötigen Sie die Spring-Sicherheitsabhängigkeit.

Beispielszenario

Sie haben eine Anwendung, die über ein Produkt-CRUD verfügt. In diesem CRUD möchten Sie die Vorgänge mithilfe von zwei spezifischen Rollen steuern.

• Benutzer: kann das Produkt erstellen und sehen. Ein Produkt kann jedoch nicht aktualisiert oder gelöscht werden.
• Administrator:, der alle Benutzervorgänge ausführen und auch ein Produkt aktualisieren und löschen kann.

Sie können @Secured verwenden, um den Zugriff dieser Rollen bei jedem Vorgang zu verwalten.

Rollen für den Betrieb

In unserem Beispielszenario können wir die folgenden Rollen definieren.

• ROLE_USER, ROLE_ADMIN

Lesen:

• ROLE_USER, ROLE_ADMIN

Aktualisieren:

• ROLE_ADMIN

Löschen:

• ROLE_ADMIN

Sehen wir uns ein Codebeispiel an und beobachten das Anwendungsverhalten.

Hinzufügen einer Spring-Sicherheitsabhängigkeit

Um mit der @Secured-Annotation zu arbeiten, fügen Sie die Maven-Abhängigkeit für Spring Security hinzu:

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

Kommentieren von Methoden mit @Secured

Wir kommentieren die Methoden mit @Secured und definieren, welche Rollen auf das Methodenverhalten zugreifen können.

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

Anwendungskonfiguration

Sie müssen @EnableGlobalMethodSecurity(securedEnabled = true) hinzufügen, um Ihre Spring-Anwendung für die Verwendung der Aktivierungsmethodensicherheit mithilfe von @Secured zu konfigurieren.

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

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

}

Testen des Verhaltens

In unserem Beispiel werden wir das Verhalten mithilfe von Tests testen, also fügen wir die Spring-Boot-Testabhängigkeit hinzu.

    org.springframework.security
    spring-security-test
    test

Dann erstellen wir Tests, um zu überprüfen, ob wir einen Scheinbenutzer verwenden und ihm bestimmte Rollen zuweisen. Wir können Benutzer in jeder Rolle und das Verhalten unserer Anwendung testen. Dadurch können wir sicherstellen, dass nur die richtigen Rollen die erlaubten Aktionen ausführen können.

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

Jetzt können Sie den Benutzerzugriff auf die Anwendung mithilfe von Rollen mit der Annotation @Secured verwalten.

Wenn Ihnen dieses Thema gefällt, folgen Sie mir unbedingt. In den folgenden Tagen werde ich mehr über Frühlingsanmerkungen erklären! Bleiben Sie dran!

Folgen Sie mir!