S04L09 - स्प्रिंग बूट भूमिका और अधिकार

html

Spring Boot में Roles और Authorities का प्रबंधन: एक व्यापक मार्गदर्शिका
सामग्री तालिका




		
		
			
			
Java
			
			<ol>
<li><strong>परिचय</strong>..................................1</li>
<li><strong>Roles और Authorities को समझना</strong>...............3
    <ul>
        <li><strong>Roles क्या हैं?</strong>..........................3</li>
        <li><strong>Authorities क्या हैं?</strong>...................5</li>
        <li><strong>Roles और Authorities के बीच अंतर</strong>........7</li>
    </ul>
</li>
<li><strong>Spring Boot में नामकरण सम्मेलन</strong>..................9</li>
<li><strong>Roles और Authorities को लागू करना</strong>.....................11
    <ul>
        <li><strong>प्रोजेक्ट सेटअप करना</strong>..................11</li>
        <li><strong>Roles और Authorities को परिभाषित करना</strong>.....................13</li>
        <li><strong>नमूना Program Code</strong>..................15</li>
        <li><strong>Code का स्पष्टीकरण और Output</strong>...................19</li>
    </ul>
</li>
<li><strong>Endpoints पर Roles और Authorities लागू करना</strong>..................23
    <ul>
        <li><strong>Endpoints को सुरक्षित करना</strong>..................23</li>
        <li><strong>उदाहरण Use Cases</strong>..................25</li>
    </ul>
</li>
<li><strong>निष्कर्ष</strong>...................................29</li>
<li><strong>अतिरिक्त संसाधन</strong>...................31</li>
</ol>
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						<ol>
<li><strong>परिचय</strong>..................................1</li>
<li><strong>Roles और Authorities को समझना</strong>...............3
    <ul>
        <li><strong>Roles क्या हैं?</strong>..........................3</li>
        <li><strong>Authorities क्या हैं?</strong>...................5</li>
        <li><strong>Roles और Authorities के बीच अंतर</strong>........7</li>
    </ul>
</li>
<li><strong>Spring Boot में नामकरण सम्मेलन</strong>..................9</li>
<li><strong>Roles और Authorities को लागू करना</strong>.....................11
    <ul>
        <li><strong>प्रोजेक्ट सेटअप करना</strong>..................11</li>
        <li><strong>Roles और Authorities को परिभाषित करना</strong>.....................13</li>
        <li><strong>नमूना Program Code</strong>..................15</li>
        <li><strong>Code का स्पष्टीकरण और Output</strong>...................19</li>
    </ul>
</li>
<li><strong>Endpoints पर Roles और Authorities लागू करना</strong>..................23
    <ul>
        <li><strong>Endpoints को सुरक्षित करना</strong>..................23</li>
        <li><strong>उदाहरण Use Cases</strong>..................25</li>
    </ul>
</li>
<li><strong>निष्कर्ष</strong>...................................29</li>
<li><strong>अतिरिक्त संसाधन</strong>...................31</li>
</ol>
					
				
			
		



परिचय
वेब एप्लिकेशन सुरक्षा के क्षेत्र में, उपयोगकर्ता एक्सेस को प्रभावी ढंग से प्रबंधित करना महत्वपूर्ण है। Java-आधारित एप्लिकेशनों के निर्माण के लिए एक शक्तिशाली framework, Spring Boot, authentication और authorization को संभालने के लिए मजबूत mechanisms प्रदान करता है। यह मार्गदर्शिका Spring Boot में Roles और Authorities की अवधारणाओं में गहराई से प्रवेश करती है, उनके अंतर, implementation strategies, और best practices को स्पष्ट करती है।
Roles और Authorities का महत्व

सुरक्षा: यह सुनिश्चित करता है कि उपयोगकर्ताओं के पास उपयुक्त access स्तर हों।
स्केलेबिलिटी: एप्लिकेशन के बढ़ने पर permissions का प्रबंधन करना आसान बनाता है।
रखरखाव: उपयोगकर्ता permissions में updates और संशोधनों को सरल बनाता है।

Pros और Cons


Pros
Cons


एप्लिकेशन की सुरक्षा में वृद्धि करता है
बड़ी एप्लिकेशनों में जटिलता


permission प्रबंधन को सरल बनाता है
सावधानीपूर्वक योजना बनाना आवश्यक


role-based access control को सुविधाजनक बनाता है
misconfiguration की संभावना


कब और कहाँ उपयोग करें


परिदृश्य
अनुशंसित दृष्टिकोण


Admin panel access
उच्च-स्तरीय Authorities के साथ Roles का उपयोग करें


User-specific operations
विशिष्ट Authorities का उपयोग करें


Content management
लचीलापन के लिए Roles और Authorities को मिलाएं


Spring Boot में role और authority प्रबंधन में महारत हासिल करने की यात्रा पर निकलें, यह सुनिश्चित करते हुए कि आपके एप्लिकेशन सुरक्षित और कुशल दोनों हैं।

Roles और Authorities को समझना
Roles क्या हैं?
Spring Boot में, Roles उपयोगकर्ताओं के व्यापक श्रेणियों का प्रतिनिधित्व करते हैं जिनके पास विभिन्न access स्तर होते हैं। वे परिभाषित करते हैं कि एक उपयोगकर्ता एप्लिकेशन के भीतर कौन से operations कर सकता है।
Roles के उदाहरण:

ROLE_ADMIN: किसी भी operation को perform कर सकता है, जिसमें resources बनाना, अपडेट करना, और हटाना शामिल है।
ROLE_USER: अपने स्वयं की जानकारी देखने और अपडेट करने जैसे बेसिक operations तक सीमित।
ROLE_EDITOR: कंटेंट प्रबंधन कर सकता है, जैसे पोस्ट जोड़ना या संपादित करना।

Roles, Authorities का एक संग्रह के रूप में कार्य करते हैं, उपयोगकर्ता की जिम्मेदारियों के आधार पर permissions सौंपने का एक संरचित तरीका प्रदान करते हैं।
Authorities क्या हैं?
Authorities विशिष्ट permissions हैं जो यह निर्धारित करते हैं कि एक उपयोगकर्ता कौन से actions कर सकता है। वे सूक्ष्म होते हैं और एप्लिकेशन के भीतर व्यक्तिगत operations पर केंद्रित होते हैं।
Authorities के उदाहरण:

VIEW_PRIVILEGE: resources देखने का permission।
WRITE_PRIVILEGE: resources बनाने या अपडेट करने का permission।
DELETE_PRIVILEGE: resources हटाने का permission।
UPDATE_PRIVILEGE: मौजूदा resources को संशोधित करने का permission।

Authorities उपयोगकर्ता कार्यों पर सटीक नियंत्रण प्रदान करते हैं, जिससे developers एप्लिकेशन की आवश्यकताओं के अनुसार permissions को अनुकूलित कर सकते हैं।
Roles और Authorities के बीच अंतर


Aspect
Roles
Authorities


Scope
व्यापक श्रेणियां
विशिष्ट permissions


Purpose
संबंधित authorities को समूहित करना
व्यक्तिगत permissions को परिभाषित करना


Example
ROLE_ADMIN, ROLE_USER
VIEW_PRIVILEGE, WRITE_PRIVILEGE


Usage
उपयोगकर्ताओं को उनकी जिम्मेदारियों के आधार पर सौंपना
allowed actions को परिभाषित करने के लिए roles को सौंपना


Spring Boot एप्लिकेशनों में प्रभावी access control को लागू करने के लिए Roles और Authorities के बीच अंतर को समझना आवश्यक है।

Spring Boot में नामकरण सम्मेलन
सुसंगत नामकरण सम्मेलनों का पालन करने से code की readability और maintainability में सुधार होता है। Spring Boot विशेष तौर पर Roles के लिए specific patterns enforce करता है।
Roles नामकरण सम्मेलन

Prefix: ROLE_
Format: uppercase letters with underscores separating words.

उदाहरण:

ROLE_ADMIN
ROLE_USER
ROLE_EDITOR

Note: ROLE_ prefix Spring Security में Roles के लिए अनिवार्य है। इसे छोड़ने से authorization failures हो सकते हैं।
Authorities नामकरण सम्मेलन

Flexibility: कोई enforced prefix नहीं।
Format: specific permissions को reflect करने के लिए customizable हो सकता है।

उदाहरण:

VIEW_PRIVILEGE
WRITE_PRIVILEGE
DELETE_PRIVILEGE
UPDATE_PRIVILEGE

Best Practices:

constants के लिए uppercase letters का उपयोग करें।
verbs का इस्तेमाल करें जो action को describe करें (जैसे, VIEW, WRITE)।
application में consistency बनाए रखें।

Consistency का महत्व
सुसंगत नामकरण सम्मेलन विकास के दौरान भ्रम और errors को रोकते हैं। वे सुनिश्चित करते हैं कि Roles और Authorities आसानी से identifiable और manageable हों application lifecycle के दौरान।

Roles और Authorities को लागू करना
प्रोजेक्ट सेटअप करना
Spring Boot में Roles और Authorities को implement करने के लिए, निम्नलिखित setup steps का पालन करें:

Spring Boot Project को Initialize करें:

Spring Initializr या अपने पसंदीदा IDE का उपयोग करें।
dependencies शामिल करें:

Spring Web
Spring Security
Spring Data JPA
H2 Database (सादगी के लिए)




Database को Configure करें:

application.properties को database configurations के साथ सेटअप करें।
उदाहरण:







		
		
			
			
Java
			
			spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
			
				
					
				
					1
2
3
4
5
6
				
						spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
					
				
			
		



Entity Models बनाएं:

User, Role, और Authority entities को परिभाषित करें।
entities के बीच संबंध स्थापित करें।


Repositories को Implement करें:

data access के लिए repositories बनाएं।


Spring Security को Configure करें:

Roles और Authorities के आधार पर authentication और authorization को संभालने के लिए security configurations सेटअप करें।



Roles और Authorities को परिभाषित करना
अपने एप्लिकेशन में Roles और Authorities की संरचना स्थापित करें।
Role Entity का उदाहरण:




		
		
			
			
Java
			
			@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String name; // e.g., ROLE_ADMIN

    @ManyToMany(fetch = FetchType.EAGER)
    private Set<Authority> authorities = new HashSet<>();

    // Getters and Setters
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String name; // e.g., ROLE_ADMIN
 
    @ManyToMany(fetch = FetchType.EAGER)
    private Set<Authority> authorities = new HashSet<>();
 
    // Getters and Setters
}
					
				
			
		


Authority Entity का उदाहरण:




		
		
			
			
Java
			
			@Entity
public class Authority {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String name; // e.g., VIEW_PRIVILEGE

    // Getters and Setters
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						@Entity
public class Authority {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String name; // e.g., VIEW_PRIVILEGE
 
    // Getters and Setters
}
					
				
			
		


User Entity का उदाहरण:




		
		
			
			
Java
			
			@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    private String password;

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "users_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles;

    // Getters and Setters
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String username;
 
    private String password;
 
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "users_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles;
 
    // Getters and Setters
}
					
				
			
		


Best Practices

Roles और Authorities के लिए Enums का उपयोग करें: constants को प्रभावी ढंग से manage करने में मदद करता है।
Roles और Authorities के लिए Eager Fetching: यह सुनिश्चित करता है कि permissions उपयोगकर्ता विवरण के साथ loaded हों।
Secure Passwords: हमेशा passwords को BCryptPasswordEncoder या समान का उपयोग करके encode करें।


नमूना Program Code
नीचे Spring Boot एप्लिकेशन में Roles और Authorities का एक नमूना implementation है।
1. Entity Definitions
Role.java




		
		
			
			
Java
			
			package com.example.demo.model;

import javax.persistence.*;
import java.util.Set;

@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String name; // e.g., ROLE_ADMIN

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "roles_authorities",
        joinColumns = @JoinColumn(name = "role_id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id")
    )
    private Set<Authority> authorities;

    // Constructors, Getters, and Setters
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						package com.example.demo.model;
 
import javax.persistence.*;
import java.util.Set;
 
@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String name; // e.g., ROLE_ADMIN
 
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "roles_authorities",
        joinColumns = @JoinColumn(name = "role_id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id")
    )
    private Set<Authority> authorities;
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Authority.java




		
		
			
			
Java
			
			package com.example.demo.model;

import javax.persistence.*;

@Entity
public class Authority {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String name; // e.g., VIEW_PRIVILEGE

    // Constructors, Getters, and Setters
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						package com.example.demo.model;
 
import javax.persistence.*;
 
@Entity
public class Authority {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String name; // e.g., VIEW_PRIVILEGE
 
    // Constructors, Getters, and Setters
}
					
				
			
		


User.java




		
		
			
			
Java
			
			package com.example.demo.model;

import javax.persistence.*;
import java.util.Set;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    private String password;

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "users_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles;

    // Constructors, Getters, and Setters
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						package com.example.demo.model;
 
import javax.persistence.*;
import java.util.Set;
 
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true, nullable = false)
    private String username;
 
    private String password;
 
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "users_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles;
 
    // Constructors, Getters, and Setters
}
					
				
			
		


2. Repository Interfaces
RoleRepository.java




		
		
			
			
Java
			
			package com.example.demo.repository;

import com.example.demo.model.Role;
import org.springframework.data.jpa.repository.JpaRepository;

public interface RoleRepository extends JpaRepository<Role, Long> {
    Role findByName(String name);
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						package com.example.demo.repository;
 
import com.example.demo.model.Role;
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface RoleRepository extends JpaRepository<Role, Long> {
    Role findByName(String name);
}
					
				
			
		


AuthorityRepository.java




		
		
			
			
Java
			
			package com.example.demo.repository;

import com.example.demo.model.Authority;
import org.springframework.data.jpa.repository.JpaRepository;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
    Authority findByName(String name);
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						package com.example.demo.repository;
 
import com.example.demo.model.Authority;
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
    Authority findByName(String name);
}
					
				
			
		


UserRepository.java




		
		
			
			
Java
			
			package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						package com.example.demo.repository;
 
import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}
					
				
			
		


3. Service लेयर
UserService.java




		
		
			
			
Java
			
			package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.HashSet;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public User registerNewUser(String username, String password) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(passwordEncoder.encode(password));
        user.setRoles(new HashSet<>()); // Assign roles as needed
        return userRepository.save(user);
    }

    // Additional methods for user management
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
				
						package com.example.demo.service;
 
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
 
import java.util.HashSet;
 
@Service
public class UserService {
 
    @Autowired
    private UserRepository userRepository;
 
    @Autowired
    private PasswordEncoder passwordEncoder;
 
    public User registerNewUser(String username, String password) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(passwordEncoder.encode(password));
        user.setRoles(new HashSet<>()); // Assign roles as needed
        return userRepository.save(user);
    }
 
    // Additional methods for user management
}
					
				
			
		


4. Security Configuration
SecurityConfig.java




		
		
			
			
Java
			
			package com.example.demo.config;

import com.example.demo.service.CustomUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private CustomUserDetailsService userDetailsService;

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder());
        return authProvider;
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/editor/**").hasAuthority("WRITE_PRIVILEGE")
                .antMatchers("/user/**").hasRole("USER")
                .anyRequest().authenticated()
            .and()
            .formLogin();
        return http.build();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
				
						package com.example.demo.config;
 
import com.example.demo.service.CustomUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig {
 
    @Autowired
    private CustomUserDetailsService userDetailsService;
 
    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
 
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService);
        authProvider.setPasswordEncoder(passwordEncoder());
        return authProvider;
    }
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/editor/**").hasAuthority("WRITE_PRIVILEGE")
                .antMatchers("/user/**").hasRole("USER")
                .anyRequest().authenticated()
            .and()
            .formLogin();
        return http.build();
    }
}
					
				
			
		


5. Custom User Details Service
CustomUserDetailsService.java




		
		
			
			
Java
			
			package com.example.demo.service;

import com.example.demo.model.Authority;
import com.example.demo.model.Role;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.*;

import org.springframework.stereotype.Service;

import java.util.HashSet;
import java.util.Set;

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) 
            throw new UsernameNotFoundException("User not found");

        Set<GrantedAuthority> grantedAuthorities = new HashSet<>();

        for (Role role : user.getRoles()) {
            // Add role with prefix
            grantedAuthorities.add(new SimpleGrantedAuthority(role.getName()));
            for (Authority authority : role.getAuthorities()) {
                // Add authorities without prefix
                grantedAuthorities.add(new SimpleGrantedAuthority(authority.getName()));
            }
        }

        return new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(),
                grantedAuthorities
        );
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
				
						package com.example.demo.service;
 
import com.example.demo.model.Authority;
import com.example.demo.model.Role;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.*;
 
import org.springframework.stereotype.Service;
 
import java.util.HashSet;
import java.util.Set;
 
@Service
public class CustomUserDetailsService implements UserDetailsService {
 
    @Autowired
    private UserRepository userRepository;
 
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) 
            throw new UsernameNotFoundException("User not found");
 
        Set<GrantedAuthority> grantedAuthorities = new HashSet<>();
 
        for (Role role : user.getRoles()) {
            // Add role with prefix
            grantedAuthorities.add(new SimpleGrantedAuthority(role.getName()));
            for (Authority authority : role.getAuthorities()) {
                // Add authorities without prefix
                grantedAuthorities.add(new SimpleGrantedAuthority(authority.getName()));
            }
        }
 
        return new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(),
                grantedAuthorities
        );
    }
}
					
				
			
		


6. Sample Controller
AdminController.java




		
		
			
			
Java
			
			package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AdminController {

    @GetMapping("/admin/dashboard")
    public String adminDashboard() {
        return "Welcome to Admin Dashboard!";
    }

    @GetMapping("/admin/settings")
    public String adminSettings() {
        return "Admin Settings Page";
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						package com.example.demo.controller;
 
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class AdminController {
 
    @GetMapping("/admin/dashboard")
    public String adminDashboard() {
        return "Welcome to Admin Dashboard!";
    }
 
    @GetMapping("/admin/settings")
    public String adminSettings() {
        return "Admin Settings Page";
    }
}
					
				
			
		


EditorController.java




		
		
			
			
Java
			
			package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EditorController {

    @GetMapping("/editor/posts")
    public String managePosts() {
        return "Manage your posts here.";
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						package com.example.demo.controller;
 
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class EditorController {
 
    @GetMapping("/editor/posts")
    public String managePosts() {
        return "Manage your posts here.";
    }
}
					
				
			
		


UserController.java




		
		
			
			
Java
			
			package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/user/profile")
    public String userProfile() {
        return "User Profile Page";
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						package com.example.demo.controller;
 
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class UserController {
 
    @GetMapping("/user/profile")
    public String userProfile() {
        return "User Profile Page";
    }
}
					
				
			
		


7. Initial Data Setup
DataInitializer.java




		
		
			
			
Java
			
			package com.example.demo;

import com.example.demo.model.Authority;
import com.example.demo.model.Role;
import com.example.demo.repository.AuthorityRepository;
import com.example.demo.repository.RoleRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.HashSet;

@Component
public class DataInitializer implements CommandLineRunner {

    @Autowired
    private AuthorityRepository authorityRepository;

    @Autowired
    private RoleRepository roleRepository;

    @Override
    public void run(String... args) throws Exception {
        // Create Authorities
        Authority view = new Authority();
        view.setName("VIEW_PRIVILEGE");
        authorityRepository.save(view);

        Authority write = new Authority();
        write.setName("WRITE_PRIVILEGE");
        authorityRepository.save(write);

        Authority delete = new Authority();
        delete.setName("DELETE_PRIVILEGE");
        authorityRepository.save(delete);

        Authority update = new Authority();
        update.setName("UPDATE_PRIVILEGE");
        authorityRepository.save(update);

        // Create Roles
        Role admin = new Role();
        admin.setName("ROLE_ADMIN");
        admin.setAuthorities(new HashSet<>());
        admin.getAuthorities().add(view);
        admin.getAuthorities().add(write);
        admin.getAuthorities().add(delete);
        admin.getAuthorities().add(update);
        roleRepository.save(admin);

        Role editor = new Role();
        editor.setName("ROLE_EDITOR");
        editor.setAuthorities(new HashSet<>());
        editor.getAuthorities().add(view);
        editor.getAuthorities().add(write);
        roleRepository.save(editor);

        Role user = new Role();
        user.setName("ROLE_USER");
        user.setAuthorities(new HashSet<>());
        user.getAuthorities().add(view);
        roleRepository.save(user);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
				
						package com.example.demo;
 
import com.example.demo.model.Authority;
import com.example.demo.model.Role;
import com.example.demo.repository.AuthorityRepository;
import com.example.demo.repository.RoleRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
 
import java.util.HashSet;
 
@Component
public class DataInitializer implements CommandLineRunner {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    @Autowired
    private RoleRepository roleRepository;
 
    @Override
    public void run(String... args) throws Exception {
        // Create Authorities
        Authority view = new Authority();
        view.setName("VIEW_PRIVILEGE");
        authorityRepository.save(view);
 
        Authority write = new Authority();
        write.setName("WRITE_PRIVILEGE");
        authorityRepository.save(write);
 
        Authority delete = new Authority();
        delete.setName("DELETE_PRIVILEGE");
        authorityRepository.save(delete);
 
        Authority update = new Authority();
        update.setName("UPDATE_PRIVILEGE");
        authorityRepository.save(update);
 
        // Create Roles
        Role admin = new Role();
        admin.setName("ROLE_ADMIN");
        admin.setAuthorities(new HashSet<>());
        admin.getAuthorities().add(view);
        admin.getAuthorities().add(write);
        admin.getAuthorities().add(delete);
        admin.getAuthorities().add(update);
        roleRepository.save(admin);
 
        Role editor = new Role();
        editor.setName("ROLE_EDITOR");
        editor.setAuthorities(new HashSet<>());
        editor.getAuthorities().add(view);
        editor.getAuthorities().add(write);
        roleRepository.save(editor);
 
        Role user = new Role();
        user.setName("ROLE_USER");
        user.setAuthorities(new HashSet<>());
        user.getAuthorities().add(view);
        roleRepository.save(user);
    }
}
					
				
			
		



Code का स्पष्टीकरण और Output
Step-by-Step Breakdown

Entity Definitions:

Role, Authority, और User entities को उपयुक्त relationships के साथ परिभाषित किया गया है।
ManyToMany relationships Users, Roles, और Authorities के बीच associations को manage करते हैं।


Repository Interfaces:

प्रत्येक entity के लिए CRUD operations प्रदान करते हैं।
findByName जैसे custom query methods entities को उनके नामों के अनुसार खोजने में मदद करते हैं।


Service लेयर:

UserService user-related operations को संभालता है, जैसे कि encoded passwords के साथ नए users को register करना।


Security Configuration:

SecurityConfig authentication और authorization सेटअप करता है।
DaoAuthenticationProvider custom UserDetailsService का उपयोग करता है।
Roles और Authorities के आधार पर विभिन्न endpoints के लिए access rules परिभाषित करता है।


Custom User Details Service:

CustomUserDetailsService UserDetailsService को implement करता है ताकि user-specific data लोड किया जा सके।
user roles और authorities को Spring Security के लिए GrantedAuthority objects में बदलता है।


Sample Controllers:

AdminController, EditorController, और UserController विभिन्न endpoints को सुरक्षित करने का प्रदर्शन करते हैं।
प्रत्येक controller के endpoints उपयोगकर्ता के Roles और Authorities के आधार पर सुरक्षित होते हैं।


Initial Data Setup:

DataInitializer predefined Roles और Authorities के साथ database को populate करता है।
नमूना Roles बनाता है: ROLE_ADMIN, ROLE_EDITOR, और ROLE_USER उनके respective Authorities के साथ।



Expected Output
एप्लिकेशन को चलाने के बाद:

Admin Endpoints को Access करना:

URL: http://localhost:8080/admin/dashboard
Response: Welcome to Admin Dashboard!
Access Control: केवल ROLE_ADMIN वाले users ही access कर सकते हैं।


Editor Endpoints को Access करना:

URL: http://localhost:8080/editor/posts
Response: Manage your posts here.
Access Control: WRITE_PRIVILEGE authority वाले users।


User Endpoints को Access करना:

URL: http://localhost:8080/user/profile
Response: User Profile Page
Access Control: ROLE_USER वाले users।



Application का परीक्षण करना

Users को Register करना:

registration endpoint (जैसा कि आवश्यक हो implement करें) का उपयोग करके विभिन्न Roles वाले users को create करें।


Users को Authenticate करना:

संबंधित user credentials के साथ login करने के बाद secured endpoints तक access करें।


Access Control को Verify करना:

सुनिश्चित करें कि users केवल उन endpoints तक access कर सकते हैं जो उनके Roles और Authorities द्वारा अनुमति प्राप्त हैं।



Sample Scenario:

Admin User:

सभी endpoints (/admin/**, /editor/**, /user/**) तक access करता है।


Editor User:

/editor/** और अगर उन्होंने VIEW_PRIVILEGE प्राप्त किया है तो /user/** तक access होता है।
/admin/** तक access नहीं कर सकता।


Regular User:

केवल /user/** तक access करता है।
/admin/** या /editor/** तक access नहीं कर सकता।




निष्कर्ष
Roles और Authorities का प्रभावी प्रबंधन Spring Boot एप्लिकेशनों की सुरक्षा के लिए महत्वपूर्ण है। व्यापक Roles और सूक्ष्म Authorities के बीच अंतर को निर्धारित करके, developers एक लचीला और मजबूत access control system implement कर सकते हैं। नामकरण सम्मेलनों और best practices का पालन करने से maintainability और scalability सुनिश्चित होती है जब एप्लिकेशन विकसित होती है।
मुख्य takeaways

Roles व्यापक श्रेणियां हैं जो user के access स्तर को परिभाषित करते हैं।
Authorities विशिष्ट permissions हैं जो अनुमत actions को निर्दिष्ट करते हैं।
सुसंगत नामकरण सम्मेलन, खासकर Roles को ROLE_ से prefix करना, आवश्यक हैं।
well-structured security configuration को implement करना एप्लिकेशन की सुरक्षा को बढ़ाता है।
initial data setup Roles और Authorities के assignment को streamline करता है।

Spring Boot में Roles और Authorities में महारत हासिल करके, आप secure, efficient, और maintainable web applications बनाने की नींव रखते हैं।
SEO Keywords: Spring Boot, Roles और Authorities, Spring Security, User Authentication, Authorization, Role-Based Access Control, Spring Boot Tutorial, Spring Security Configuration, Java Security, Web Application Security, Spring Boot Roles, Spring Boot Authorities, Managing User Roles, Spring Boot Access Control, Security Best Practices, Spring Boot Guide

अतिरिक्त संसाधन

Official Spring Security Documentation
Spring Boot Reference Guide
Baeldung's Spring Security Tutorials
Spring Security Fundamentals
Building a Secure REST API with Spring Boot
Understanding JWT with Spring Boot

ये संसाधन Spring Boot एप्लिकेशनों में security की समझ और implementation को बेहतर बनाने के लिए आगे की insights और advanced तकनीकों को प्रदान करते हैं।
Note: यह article AI generated है।
Pros	Cons
एप्लिकेशन की सुरक्षा में वृद्धि करता है	बड़ी एप्लिकेशनों में जटिलता
permission प्रबंधन को सरल बनाता है	सावधानीपूर्वक योजना बनाना आवश्यक
role-based access control को सुविधाजनक बनाता है	misconfiguration की संभावना
परिदृश्य	अनुशंसित दृष्टिकोण
Admin panel access	उच्च-स्तरीय Authorities के साथ Roles का उपयोग करें
User-specific operations	विशिष्ट Authorities का उपयोग करें
Content management	लचीलापन के लिए Roles और Authorities को मिलाएं
Aspect	Roles	Authorities
Scope	व्यापक श्रेणियां	विशिष्ट permissions
Purpose	संबंधित authorities को समूहित करना	व्यक्तिगत permissions को परिभाषित करना
Example	ROLE_ADMIN, ROLE_USER	VIEW_PRIVILEGE, WRITE_PRIVILEGE
Usage	उपयोगकर्ताओं को उनकी जिम्मेदारियों के आधार पर सौंपना	allowed actions को परिभाषित करने के लिए roles को सौंपना
Translation: