यह एनोटेशन व्यावसायिक तरीकों में सुरक्षा कॉन्फ़िगरेशन जोड़ने का एक तरीका प्रदान करता है।

यह जांचने के लिए भूमिकाओं का उपयोग करेगा कि उपयोगकर्ता के पास इस पद्धति को कॉल करने की अनुमति है या नहीं। एनोटेशन स्प्रिंग सुरक्षा का हिस्सा है। इसलिए इसके उपयोग को सक्षम करने के लिए आपको स्प्रिंग सुरक्षा निर्भरता की आवश्यकता है।

उदाहरण परिदृश्य

आपके पास एक एप्लिकेशन है जिसमें एक उत्पाद CRUD है। इस सीआरयूडी में आप दो विशिष्ट भूमिकाओं का उपयोग करके संचालन को नियंत्रित करना चाहते हैं।

• उपयोगकर्ता: उत्पाद बना सकता है और उत्पाद देख सकता है। लेकिन किसी उत्पाद को अद्यतन या हटा नहीं सकते।
• एडमिन: जो सभी उपयोगकर्ता ऑपरेशन कर सकता है और किसी उत्पाद को अपडेट और हटा भी सकता है।

आप प्रत्येक ऑपरेशन पर उन भूमिकाओं की पहुंच को प्रबंधित करने के लिए @Secured का उपयोग कर सकते हैं।

संचालन के लिए भूमिकाएँ

हम अपने उदाहरण परिदृश्य में निम्नलिखित भूमिकाओं को परिभाषित कर सकते हैं।

• ROLE_USER, ROLE_ADMIN

पढ़ने के लिए:

• ROLE_USER, ROLE_ADMIN

अद्यतन करने के लिए:

• ROLE_ADMIN

हटाना:

• ROLE_ADMIN

आइए एक कोड उदाहरण देखें और एप्लिकेशन व्यवहार का निरीक्षण करें।

स्प्रिंग सुरक्षा निर्भरता जोड़ना

@Secured एनोटेशन के साथ काम करने के लिए, स्प्रिंग सिक्योरिटी के लिए मावेन निर्भरता जोड़ें:

org.springframework.bootspring-boot-starter-security

@Secured के साथ एनोटेट करने के तरीके

हम @Secured के साथ विधियों को एनोटेट करते हैं, यह परिभाषित करते हुए कि कौन सी भूमिकाएं विधि व्यवहार तक पहुंच सकती हैं।

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

एप्लिकेशन कॉन्फ़िगरेशन

आपको @Secured का उपयोग करके सक्षम विधि सुरक्षा का उपयोग करने के लिए अपने स्प्रिंग एप्लिकेशन को कॉन्फ़िगर करने के लिए @EnableGlobalMethodSecurity(securedEnabled = true) जोड़ने की आवश्यकता है।

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

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

}

व्यवहार का परीक्षण

हमारे उदाहरण में हम परीक्षणों का उपयोग करके व्यवहार का परीक्षण करने जा रहे हैं, इसलिए हम स्प्रिंग बूट परीक्षण निर्भरता जोड़ते हैं।

org.springframework.securityspring-security-testtest

फिर हम एक नकली उपयोगकर्ता का उपयोग करने पर सत्यापन करने के लिए परीक्षण बनाते हैं और उसे विशिष्ट भूमिकाएँ सौंपते हैं, हम प्रत्येक भूमिका में उपयोगकर्ताओं का परीक्षण कर सकते हैं और हमारा एप्लिकेशन कैसे व्यवहार करता है। ऐसा करके हम यह सुनिश्चित कर सकते हैं कि केवल सही भूमिकाएँ ही अनुमत कार्य कर सकती हैं।

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

बस, अब आप @Secured एनोटेशन के साथ भूमिकाओं का उपयोग करके एप्लिकेशन तक उपयोगकर्ता की पहुंच प्रबंधित कर सकते हैं।

यदि आपको यह विषय पसंद है, तो मुझे फ़ॉलो करना सुनिश्चित करें। अगले दिनों में, मैं स्प्रिंग एनोटेशन के बारे में और अधिक बताऊंगा! बने रहें!

मेरे पीछे आओ!