S04L11 - स्प्रिंग बूट में उपयोगकर्ता खाते में अधिकार जोड़ें

**Hindi Translation:**

html


उपयोगकर्ता प्रबंधन में सुधार: Spring Boot में अधिकार तालिकाओं को जोड़ना
सूचक तालिका

परिचय ........................................................... 1
अधिकार एंटिटी सेटअप करना ............... 3
अधिकार रिपॉजिटरी और सेवा बनाना ................................................................. 7
एनम्स के साथ विशेषाधिकारों को परिभाषित करना .................. 11
सीड डेटा भरना ......................................... 15
बहु-से-बहुत संबंध स्थापित करना .................................................................................................... 19
निष्कर्ष ............................................................. 25


परिचय
आधुनिक वेब अनुप्रयोगों में, user management और authorization महत्वपूर्ण घटक हैं जो संसाधनों तक सुरक्षित पहुँच सुनिश्चित करते हैं। एक मजबूत authority system को लागू करने से डेवलपर्स को user roles और privileges को प्रभावी ढंग से परिभाषित और प्रबंधित करने की सुविधा मिलती है। यह eBook Spring Boot अनुप्रयोग में user accounts में authority तालिकाओं को जोड़ने की प्रक्रिया में गहराई से उतरता है, जिससे सुरक्षा और स्केलेबिलिटी में सुधार होता है।
Authority प्रबंधन का महत्व

Security: संवेदनशील कार्यात्मकताओं तक पहुँच को प्रतिबंधित करता है।
Scalability: नए roles और privileges को आसानी से जोड़ने की सुविधा देता है।
Maintainability: user permissions का प्रबंधन सरल बनाता है।

फायदे और नुकसान


फायदे
नुकसान


सुधरी हुई सुरक्षा और एक्सेस कंट्रोल
प्रारंभिक सेटअप समय लेने वाला हो सकता है


user roles और privileges का आसान प्रबंधन
roles और permissions की सावधानीपूर्वक योजना की आवश्यकता होती है


भविष्य के विस्तार के लिए स्केलेबिलिटी में सुधार
बड़े अनुप्रयोगों में संभावित जटिलता


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

Enterprise Applications: विविध user roles का प्रबंधन करना।
E-commerce Platforms: ग्राहकों, विक्रेताओं, और प्रशासकों के बीच अंतर करना।
Content Management Systems: सामग्री निर्माण और संपादन तक पहुँच को नियंत्रित करना।


अधिकार एंटिटी सेटअप करना
Authority एंटिटी स्थापित करना user permissions प्रबंधन के लिए बुनियादी है। इस एंटिटी में आमतौर पर एक ID और एक name होता है जो विभिन्न authorities का प्रतिनिधित्व करता है।
Authority मॉडल बनाना




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


व्याख्या

@Entity: क्लास को एक JPA entity के रूप में मार्क करता है।
@Id: प्राथमिक कुंजी को दर्शाता है।
Fields: id और name authority के पहचानकर्ता और उसके नाम का प्रतिनिधित्व करते हैं।
Constructor & Getters/Setters: ऑब्जेक्ट निर्माण और properties तक पहुँच को सुविधाजनक बनाते हैं।


अधिकार रिपॉजिटरी और सेवा बनाना
Authority एंटिटी के साथ इंटरैक्ट करने के लिए, हमें एक repository और एक service लेयर बनाने की आवश्यकता है।
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


व्याख्या

AuthorityRepository: JpaRepository को विस्तारित करता है ताकि Authority एंटिटी के लिए CRUD operations प्रदान किए जा सकें।
AuthorityService: AuthorityRepository का उपयोग करके authorities का प्रबंधन करता है, जिससे business logic संलग्न होती है।


एनम्स के साथ विशेषाधिकारों को परिभाषित करना
Enums एक स्थिर सेट के constants को परिभाषित करने का एक कुशल तरीका हैं, जैसे user privileges।
Privileges Enum बनाना




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


व्याख्या

Enum Constants: RESET_PASSWORD और ACCESS_ADMIN_PANEL अलग-अलग privileges का प्रतिनिधित्व करते हैं।
Fields: प्रत्येक enum constant का अपना id और name होता है।
Constructor & Getters: privilege properties के निर्माण और पुनर्प्राप्ति की सुविधा प्रदान करते हैं।


सीड डेटा भरना
Seed data डिफ़ॉल्ट authorities के साथ डेटाबेस को प्रारंभ करता है, यह सुनिश्चित करता है कि आवश्यक roles अनुप्रयोग स्टार्टअप पर उपलब्ध हों।
Seed Data लागू करना




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


व्याख्या

@Component: क्लास को एक Spring bean के रूप में रजिस्टर करता है।
CommandLineRunner: अनुप्रयोग शुरू होने के बाद run मेथड को निष्पादित करता है।
Looping Through Privileges: सभी enum मानों पर iterates करता है ताकि संबंधित authorities बनाए और सहेजे जा सकें।
Error Handling: छोटे मुद्दे, जैसे type mismatches, को consistent data types (Long vs. int) सुनिश्चित करके हल किया जाता है।

Seed Data निष्पादन का आउटपुट
अनुप्रयोग चलाने पर, Authority तालिका निम्नलिखित privileges के साथ भरी जाती है:


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



बहु-से-बहुत संबंध स्थापित करना
users को कई authorities के साथ और vice versa जोड़ने के लिए, many-to-many relationship को Account और Authority एंटिटीज़ के बीच स्थापित किया जाता है।
Account मॉडल को अपडेट करना




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


व्याख्या

@ManyToMany: Account और Authority के बीच एक बहु-से-बहुत संबंध परिभाषित करता है।
@JoinTable: join table account_authority को निर्दिष्ट करता है जो संबंध को सुविधाजनक बनाता है।

joinColumns: Account एंटिटी को संदर्भित करता है।
inverseJoinColumns: Authority एंटिटी को संदर्भित करता है।


Set<Authority>: एक Set का उपयोग करता है ताकि एक account के लिए duplicate authorities से बचा जा सके।

Join Table बनाना
account_authority join table स्वतः ही annotations के आधार पर बन जाता है, जिसका निम्न संरचना होता है:


Column Name
Data Type
Constraints


account_id
Long
Foreign Key to Account.id


authority_id
Long
Foreign Key to Authority.id


बहु-से-बहुत संबंधों के लाभ

Flexibility: एक user के लिए कई authorities और vice versa की अनुमति देता है।
Data Integrity: join table के माध्यम से consistent और non-redundant data सुनिश्चित करता है।


निष्कर्ष
Spring Boot अनुप्रयोग में authority तालिकाओं को लागू करना मजबूत user management और authorization के लिए महत्वपूर्ण है। इस व्यापक गाइड में आवश्यक कदमों को शामिल किया गया है:

Setting Up the Authority Entity: user roles का प्रतिनिधित्व करने के लिए बुनियादी एंटिटी स्थापित करना।
Creating the Authority Repository and Service: डेटा एक्सेस और business logic को सुविधाजनक बनाना।
Defining Privileges with Enums: स्पष्टता और सुसंगतता के लिए अलग-अलग user privileges को enum में परिभाषित करना।
Populating Seed Data: अनुप्रयोग स्टार्टअप पर आवश्यक roles को initialize करना सुनिश्चित करना।
Establishing Many-to-Many Relationships: users और उनकी authorities के बीच लचीले associations सक्षम करना।

इन कदमों का पालन करके, डेवलपर्स अपने Spring Boot अनुप्रयोगों के भीतर एक सुरक्षित और स्केलेबल authority प्रबंधन प्रणाली बना सकते हैं।
SEO ऑप्टिमाइज्ड कीवर्ड्स
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

फायदे	नुकसान
सुधरी हुई सुरक्षा और एक्सेस कंट्रोल	प्रारंभिक सेटअप समय लेने वाला हो सकता है
user roles और privileges का आसान प्रबंधन	roles और permissions की सावधानीपूर्वक योजना की आवश्यकता होती है
भविष्य के विस्तार के लिए स्केलेबिलिटी में सुधार	बड़े अनुप्रयोगों में संभावित जटिलता

ID	Name
1	RESET_PASSWORD
2	ACCESS_ADMIN_PANEL

Column Name	Data Type	Constraints
account_id	Long	Foreign Key to Account.id
authority_id	Long	Foreign Key to Authority.id

**Chinese Translation:**

html


增强用户管理：在 Spring Boot 中添加权限表
目录

介绍 ........................................................... 1
设置 Authority 实体 ............... 3
创建 Authority 仓库和服务 ................................................................. 7
使用 Enums 定义权限 .................. 11
填充种子数据 ......................................... 15
建立多对多关系 .................................................................................................... 19
结论 ............................................................. 25


介绍
在现代 web 应用程序中，user management 和 authorization 是确保对资源安全访问的关键组件。实施一个强大的 authority system 允许开发人员有效地定义和管理用户角色和权限。本电子书深入探讨了在 Spring Boot 应用程序中向用户账户添加 authority 表的过程，以增强安全性和可扩展性。
Authority 管理的重要性

Security: 限制对敏感功能的访问。
Scalability: 便于轻松添加新角色和权限。
Maintainability: 简化用户权限的管理。

优缺点


优点
缺点


改善的安全性和访问控制
初始设置可能耗时


易于管理用户角色和权限
需要仔细规划角色和权限


增强未来扩展的可扩展性
大型应用程序中可能的复杂性


何时何地使用

Enterprise Applications: 管理多样化的用户角色。
E-commerce Platforms: 区分客户、供应商和管理员。
Content Management Systems: 控制内容创建和编辑的访问。


设置 Authority 实体
建立 Authority 实体是管理用户权限的基础。该实体通常包含一个 ID 和一个 name，代表不同的 authorities。
创建 Authority 模型




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


解释

@Entity: 将类标记为 JPA 实体。
@Id: 表示主键。
Fields: id 和 name 分别代表 authority 的标识符和名称。
Constructor & Getters/Setters: 促进对象创建和属性访问。


创建 Authority 仓库和服务
要与 Authority 实体进行交互，我们需要创建一个 repository 和一个 service 层。
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


解释

AuthorityRepository: 扩展 JpaRepository 以提供 Authority 实体的 CRUD 操作。
AuthorityService: 使用 AuthorityRepository 管理 authorities，封装业务逻辑。


使用 Enums 定义权限
Enums 是定义固定常量集（如用户权限）的高效方式。
创建 Privileges Enum




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


解释

Enum Constants: RESET_PASSWORD 和 ACCESS_ADMIN_PANEL 表示不同的权限。
Fields: 每个 enum 常量都有自己的 id 和 name。
Constructor & Getters: 促进权限属性的创建和检索。


填充种子数据
种子数据在数据库中初始化默认 authorities，确保在应用程序启动时可用的基本角色。
实现种子数据




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


解释

@Component: 将类注册为 Spring bean。
CommandLineRunner: 在应用程序启动后执行 run 方法。
Looping Through Privileges: 遍历所有 enum 值，以创建和保存相应的 authorities。
Error Handling: 通过确保一致的数据类型（Long vs. int）来解决类型不匹配等小问题。

种子数据执行的输出
运行应用程序后，Authority 表将使用定义的权限填充：


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



建立多对多关系
为了将用户与多个 authorities 及其反向关联，many-to-many relationship 在 Account 和 Authority 实体之间建立。
更新 Account 模型




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


解释

@ManyToMany: 定义 Account 和 Authority 之间的多对多关系。
@JoinTable: 指定 join table account_authority 以促进关系。

joinColumns: 引用 Account 实体。
inverseJoinColumns: 引用 Authority 实体。


Set<Authority>: 使用 Set 以防止一个 account 拥有重复的 authorities。

创建 Join Table
account_authority join table 根据注解自动创建，具有以下结构：


列名
数据类型
约束


account_id
Long
Foreign Key 到 Account.id


authority_id
Long
Foreign Key 到 Authority.id


多对多关系的优势

Flexibility: 允许每个用户拥有多个 authorities，反之亦然。
Data Integrity: 通过 join table 确保数据的一致性和非冗余性。


结论
在 Spring Boot 应用程序中实现 authority 表对于强大的 user management 和 authorization 至关重要。本全面指南涵盖了必要的步骤：

Setting Up the Authority Entity: 建立一个基础实体来表示用户角色。
Creating the Authority Repository and Service: 促进数据访问和业务逻辑。
Defining Privileges with Enums: 使用枚举清晰且一致地列举不同的用户权限。
Populating Seed Data: 确保在应用程序启动时初始化必要的角色。
Establishing Many-to-Many Relationships: 启用用户与其 authorities 之间的灵活关联。

通过遵循这些步骤，开发人员可以在其 Spring Boot 应用程序中创建一个安全且可扩展的 authority 管理系统。
SEO 优化关键词
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

优点	缺点
改善的安全性和访问控制	初始设置可能耗时
易于管理用户角色和权限	需要仔细规划角色和权限
增强未来扩展的可扩展性	大型应用程序中可能的复杂性

ID	Name
1	RESET_PASSWORD
2	ACCESS_ADMIN_PANEL

列名	数据类型	约束
account_id	Long	Foreign Key 到 Account.id
authority_id	Long	Foreign Key 到 Authority.id

**Korean Translation:**

html


사용자 관리 향상: Spring Boot에서 권한 테이블 추가하기
목차

소개 ........................................................... 1
Authority 엔터티 설정 ............... 3
Authority 저장소 및 서비스 생성 ................................................................. 7
Enums를 사용한 권한 정의 .................. 11
시드 데이터 채우기 ......................................... 15
다대다 관계 설정 .................................................................................................... 19
결론 ............................................................. 25


소개
현대 웹 애플리케이션에서 user management와 authorization은 리소스에 대한 안전한 접근을 보장하는 중요한 구성 요소입니다. 강력한 authority system을 구현하면 개발자가 사용자 역할과 권한을 효과적으로 정의하고 관리할 수 있습니다. 이 전자책은 Spring Boot 애플리케이션에서 사용자 계정에 authority 테이블을 추가하여 보안과 확장성을 향상시키는 과정을 자세히 다룹니다.
Authority 관리의 중요성

Security: 민감한 기능에 대한 접근을 제한합니다.
Scalability: 새로운 역할과 권한을 쉽게 추가할 수 있게 합니다.
Maintainability: 사용자 권한 관리를 단순화합니다.

장단점


장점
단점


향상된 보안 및 접근 제어
초기 설정에 시간이 걸릴 수 있음


사용자 역할과 권한의 쉬운 관리
역할과 권한을 신중하게 계획해야 함


미래 확장을 위한 확장성 향상
대규모 애플리케이션에서의 잠재적 복잡성


언제 어디서 사용하나요

Enterprise Applications: 다양한 사용자 역할 관리.
E-commerce Platforms: 고객, 공급업체 및 관리자를 구분.
Content Management Systems: 콘텐츠 생성 및 편집에 대한 접근 제어.


Authority 엔터티 설정
Authority 엔터티를 설정하는 것은 사용자 권한을 관리하는 기초입니다. 이 엔터티는 일반적으로 다양한 권한을 나타내는 ID와 name을 포함합니다.
Authority 모델 생성




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


설명

@Entity: 클래스를 JPA 엔터티로 표시합니다.
@Id: 기본 키를 나타냅니다.
Fields: id와 name은 각각 권한의 식별자와 이름을 나타냅니다.
Constructor & Getters/Setters: 객체 생성 및 속성 접근을 용이하게 합니다.


Authority 저장소 및 서비스 생성
Authority 엔터티와 상호 작용하려면 repository와 service 계층을 생성해야 합니다.
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


설명

AuthorityRepository: JpaRepository를 확장하여 Authority 엔터티에 대한 CRUD 작업을 제공합니다.
AuthorityService: AuthorityRepository를 사용하여 authorities를 관리하며, 비즈니스 로직을 캡슐화합니다.


Enums를 사용한 권한 정의
Enums는 사용자 권한과 같은 고정된 상수 집합을 정의하는 효율적인 방법입니다.
Privileges Enum 생성




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


설명

Enum Constants: RESET_PASSWORD와 ACCESS_ADMIN_PANEL은 뚜렷한 권한을 나타냅니다。
Fields: 각 enum 상수는 id와 name을 가지고 있습니다。
Constructor & Getters: 권한 속성의 생성 및 검색을 용이하게 합니다。


시드 데이터 채우기
시드 데이터는 기본 authorities로 데이터베이스를 초기화하여 애플리케이션 시작 시 필수 역할이 사용 가능하도록 보장합니다。
시드 데이터 구현




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


설명

@Component: 클래스를 Spring bean으로 등록합니다。
CommandLineRunner: 애플리케이션 시작 후 run 메서드를 실행합니다。
Looping Through Privileges: 모든 enum 값을 순회하여 해당하는 authorities를 생성하고 저장합니다。
Error Handling: 일관된 데이터 타입(Long vs. int)을 보장하여 타입 불일치와 같은 작은 문제를 해결합니다。

시드 데이터 실행 결과
애플리케이션을 실행하면 Authority 테이블이 정의된 권한으로 채워집니다：


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



다대다 관계 설정
사용자를 여러 권한과 연결하고 그 반대도 가능하게 하기 위해, many-to-many relationship이 Account와 Authority 엔터티 간에 설정됩니다。
Account 모델 업데이트




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


설명

@ManyToMany: Account와 Authority 간의 다대다 관계를 정의합니다。
@JoinTable: 관계를 촉진하는 join table account_authority를 지정합니다。

joinColumns: Account 엔터티를 참조합니다。
inverseJoinColumns: Authority 엔터티를 참조합니다。


Set<Authority>: account에 중복 authority가 없도록 Set을 사용합니다。

Join Table 생성
account_authority join table은 주석을 기반으로 자동 생성되며, 다음과 같은 구조를 갖습니다：


열 이름
데이터 유형
제약 조건


account_id
Long
Account.id에 대한 외래 키


authority_id
Long
Authority.id에 대한 외래 키


다대다 관계의 이점

Flexibility: 사용자당 여러 권한과 그 반대도 허용합니다。
Data Integrity: join table을 통해 일관성과 비중복 데이터를 보장합니다。


결론
Spring Boot 애플리케이션에서 authority 테이블을 구현하는 것은 강력한 user management와 authorization을 위해 매우 중요합니다。이 포괄적인 가이드는 필수 단계들을 다루었습니다：

Setting Up the Authority Entity: 사용자 역할을 나타내는 기본 엔터티 설정.
Creating the Authority Repository and Service: 데이터 접근 및 비즈니스 로직 촉진.
Defining Privileges with Enums: 명확성과 일관성을 위한 서로 다른 사용자 권한 열거.
Populating Seed Data: 애플리케이션 시작 시 필수 역할 초기화 보장.
Establishing Many-to-Many Relationships: 사용자와 그들의 권한 간의 유연한 연결 가능하게 하기.

이 단계를 따르면 개발자는 Spring Boot 애플리케이션 내에서 안전하고 확장 가능한 authority 관리 시스템을 구축할 수 있습니다。
SEO 최적화 키워드
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

장점	단점
향상된 보안 및 접근 제어	초기 설정에 시간이 걸릴 수 있음
사용자 역할과 권한의 쉬운 관리	역할과 권한을 신중하게 계획해야 함
미래 확장을 위한 확장성 향상	대규모 애플리케이션에서의 잠재적 복잡성

ID	Name
1	RESET_PASSWORD
2	ACCESS_ADMIN_PANEL

열 이름	데이터 유형	제약 조건
account_id	Long	Account.id에 대한 외래 키
authority_id	Long	Authority.id에 대한 외래 키

**Portuguese Translation:**

html


Melhorando a Gestão de Usuários: Adicionando Tabelas de Autoridade no Spring Boot
Tabela de Conteúdos

Introdução ........................................................... 1
Configurando a Entidade Authority ............... 3
Criando o Repositório e Serviço Authority ................................................................. 7
Definindo Privilégios com Enums .................. 11
Populando Dados Iniciais ......................................... 15
Estabelecendo Relacionamentos Muitos-para-Muitos .................................................................................................... 19
Conclusão ............................................................. 25


Introdução
Em aplicações web modernas, user management e authorization são componentes críticos que garantem acesso seguro a recursos. Implementar um sistema robusto de authority permite que desenvolvedores definam e gerenciem papéis e privilégios de usuários de forma eficaz. Este eBook explora o processo de adicionar tabelas de authority a contas de usuários em uma aplicação Spring Boot, aumentando a segurança e a escalabilidade.
Importância da Gestão de Authority

Security: Restringe o acesso a funcionalidades sensíveis.
Scalability: Facilita a adição de novos papéis e privilégios.
Maintainability: Simplifica a gestão de permissões de usuários.

Prós e Contras


Prós
Contras


Melhoria na segurança e controle de acesso
A configuração inicial pode ser demorada


Fácil gestão de papéis e privilégios de usuários
Requer planejamento cuidadoso de papéis e permissões


Aumenta a escalabilidade para expansões futuras
Complexidade potencial em aplicações maiores


Quando e Onde Usar

Enterprise Applications: Gerenciamento de papéis de usuários diversos.
E-commerce Platforms: Diferenciação entre clientes, vendedores e administradores.
Content Management Systems: Controle de acesso à criação e edição de conteúdo.


Configurando a Entidade Authority
Estabelecer a entidade Authority é fundamental para gerir permissões de usuários. Esta entidade normalmente contém um ID e um name que representam diferentes authorities.
Criando o Modelo Authority




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


Explicação

@Entity: Marca a classe como uma entidade JPA.
@Id: Denota a chave primária.
Fields: id e name representam o identificador da authority e seu nome, respectivamente.
Constructor & Getters/Setters: Facilitam a criação de objetos e o acesso às propriedades.


Criando o Repositório e Serviço Authority
Para interagir com a entidade Authority, precisamos criar uma camada de repository e service.
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


Explicação

AuthorityRepository: Estende JpaRepository para fornecer operações CRUD para a entidade Authority.
AuthorityService: Utiliza AuthorityRepository para gerenciar authorities, encapsulando a lógica de negócios.


Definindo Privilégios com Enums
Enums são uma maneira eficiente de definir um conjunto fixo de constantes, como privilégios de usuários.
Criando o Enum Privileges




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


Explicação

Enum Constants: RESET_PASSWORD e ACCESS_ADMIN_PANEL representam privilégios distintos.
Fields: Cada constante enum possui um id e um name.
Constructor & Getters: Facilitam a criação e a recuperação das propriedades do privilégio.


Populando Dados Iniciais
Dados iniciais inicializam o banco de dados com authorities padrão, garantindo que papéis essenciais estejam disponíveis no início da aplicação.
Implementando Dados Iniciais




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


Explicação

@Component: Registra a classe como um bean Spring.
CommandLineRunner: Executa o método run após a inicialização da aplicação.
Looping Through Privileges: Itera sobre todos os valores do enum para criar e salvar as authorities correspondentes.
Error Handling: Problemas menores, como incompatibilidades de tipo, são resolvidos garantindo tipos de dados consistentes (Long vs. int).

Saída da Execução dos Dados Iniciais
Ao executar a aplicação, a tabela Authority é populada com os privilégios definidos:


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



Estabelecendo Relacionamentos Muitos-para-Muitos
Para associar usuários com múltiplas authorities e vice-versa, é estabelecido um many-to-many relationship entre as entidades Account e Authority.
Atualizando o Modelo Account




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Explicação

@ManyToMany: Define um relacionamento muitos-para-muitos entre Account e Authority.
@JoinTable: Especifica a tabela de junção account_authority que facilita o relacionamento.

joinColumns: Refere-se à entidade Account.
inverseJoinColumns: Refere-se à entidade Authority.


Set<Authority>: Utiliza um Set para prevenir authorities duplicadas para uma conta.

Criando a Tabela de Junção
A tabela de junção account_authority é criada automaticamente com base nas anotações, com a seguinte estrutura:


Nome da Coluna
Tipo de Dados
Restrições


account_id
Long
Chave Estrangeira para Account.id


authority_id
Long
Chave Estrangeira para Authority.id


Benefícios dos Relacionamentos Muitos-para-Muitos

Flexibility: Permite múltiplas authorities por usuário e vice-versa.
Data Integrity: Garante dados consistentes e não redundantes através da tabela de junção.


Conclusão
Implementar tabelas de authority em uma aplicação Spring Boot é essencial para uma robusta user management e authorization. Este guia abrangente cobriu os passos essenciais:

Setting Up the Authority Entity: Estabelecendo uma entidade fundamental para representar papéis de usuários.
Creating the Authority Repository and Service: Facilitando o acesso a dados e a lógica de negócios.
Defining Privileges with Enums: Enumerando privilégios distintos de usuários para clareza e consistência.
Populating Seed Data: Garantindo que papéis essenciais sejam inicializados no início da aplicação.
Establishing Many-to-Many Relationships: Habilitando associações flexíveis entre usuários e suas authorities.

Seguindo estes passos, desenvolvedores podem criar um sistema de gestão de authority seguro e escalável dentro de suas aplicações Spring Boot.
SEO Otimizado Palavras-chave
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

Prós	Contras
Melhoria na segurança e controle de acesso	A configuração inicial pode ser demorada
Fácil gestão de papéis e privilégios de usuários	Requer planejamento cuidadoso de papéis e permissões
Aumenta a escalabilidade para expansões futuras	Complexidade potencial em aplicações maiores

ID	Name
1	RESET_PASSWORD
2	ACCESS_ADMIN_PANEL

Nome da Coluna	Tipo de Dados	Restrições
account_id	Long	Chave Estrangeira para Account.id
authority_id	Long	Chave Estrangeira para Authority.id

**Spanish Translation:**

html


Mejorando la Gestión de Usuarios: Añadiendo Tablas de Autoridad en Spring Boot
Tabla de Contenidos

Introducción ........................................................... 1
Configurando la Entidad Authority ............... 3
Creando el Repositorio y Servicio Authority ................................................................. 7
Definiendo Privilegios con Enums .................. 11
Población de Datos Iniciales ......................................... 15
Estableciendo Relaciones Muchos-a-Muchos .................................................................................................... 19
Conclusión ............................................................. 25


Introducción
En las aplicaciones web modernas, user management y authorization son componentes críticos que aseguran el acceso seguro a los recursos. Implementar un sistema robusto de authority permite a los desarrolladores definir y gestionar roles y privilegios de usuarios de manera efectiva. Este eBook profundiza en el proceso de añadir tablas de authority a las cuentas de usuario en una aplicación Spring Boot, mejorando la seguridad y la escalabilidad.
Importancia de la Gestión de Authority

Security: Restringe el acceso a funcionalidades sensibles.
Scalability: Facilita la adición de nuevos roles y privilegios.
Maintainability: Simplifica la gestión de permisos de usuarios.

Pros y Contras


Pros
Contras


Mejora la seguridad y el control de acceso
La configuración inicial puede llevar tiempo


Fácil gestión de roles y privilegios de usuarios
Requiere planificación cuidadosa de roles y permisos


Aumenta la escalabilidad para futuras expansiones
Complejidad potencial en aplicaciones grandes


Cuándo y Dónde Usar

Enterprise Applications: Gestión de roles de usuarios variados.
E-commerce Platforms: Diferenciación entre clientes, vendedores y administradores.
Content Management Systems: Controlar el acceso a la creación y edición de contenido.


Configurando la Entidad Authority
Establecer la entidad Authority es fundamental para gestionar los permisos de los usuarios. Esta entidad generalmente contiene un ID y un name que representan diferentes authorities.
Creando el Modelo Authority




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


Explicación

@Entity: Marca la clase como una entidad JPA.
@Id: Denota la clave primaria.
Fields: id y name representan el identificador de la authority y su nombre, respectivamente.
Constructor & Getters/Setters: Facilitan la creación de objetos y el acceso a las propiedades.


Creando el Repositorio y Servicio Authority
Para interactuar con la entidad Authority, necesitamos crear una capa de repository y service.
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


Explicación

AuthorityRepository: Extiende JpaRepository para proporcionar operaciones CRUD para la entidad Authority.
AuthorityService: Utiliza AuthorityRepository para gestionar authorities, encapsulando la lógica de negocio.


Definiendo Privilegios con Enums
Los Enums son una forma eficiente de definir un conjunto fijo de constantes, como privilegios de usuarios.
Creando el Enum Privileges




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


Explicación

Enum Constants: RESET_PASSWORD y ACCESS_ADMIN_PANEL representan privilegios distintos.
Fields: Cada constante enum tiene un id y un name.
Constructor & Getters: Facilitan la creación y recuperación de las propiedades del privilegio.


Población de Datos Iniciales
Los datos iniciales inicializan la base de datos con authorities predeterminadas, asegurando que los roles esenciales estén disponibles al inicio de la aplicación.
Implementando Datos Iniciales




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


Explicación

@Component: Registra la clase como un bean de Spring.
CommandLineRunner: Ejecuta el método run después de que la aplicación arranca.
Looping Through Privileges: Itera sobre todos los valores del enum para crear y guardar las authorities correspondientes.
Error Handling: Problemas menores, como incompatibilidades de tipos, se resuelven asegurando tipos de datos consistentes (Long vs. int).

Salida de la Ejecución de Datos Iniciales
Al ejecutar la aplicación, la tabla Authority se llena con los privilegios definidos:


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



Estableciendo Relaciones Muchos-a-Muchos
Para asociar usuarios con múltiples authorities y viceversa, se establece una many-to-many relationship entre las entidades Account y Authority.
Actualizando el Modelo Account




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Explicación

@ManyToMany: Define una relación muchos-a-muchos entre Account y Authority.
@JoinTable: Especifica la tabla de unión account_authority que facilita la relación.

joinColumns: Referencia a la entidad Account.
inverseJoinColumns: Referencia a la entidad Authority.


Set<Authority>: Utiliza un Set para prevenir authorities duplicados para una cuenta.

Creando la Tabla de Unión
La tabla de unión account_authority se crea automáticamente basado en las anotaciones, con la siguiente estructura:


Nombre de la Columna
Tipo de Datos
Restricciones


account_id
Long
Foreign Key a Account.id


authority_id
Long
Foreign Key a Authority.id


Beneficios de las Relaciones Muchos-a-Muchos

Flexibility: Permite múltiples authorities por usuario y viceversa.
Data Integrity: Asegura datos consistentes y no redundantes a través de la tabla de unión.


Conclusión
Implementar tablas de authority en una aplicación Spring Boot es fundamental para una robusta user management y authorization. Esta guía integral cubrió los pasos esenciales:

Setting Up the Authority Entity: Estableciendo una entidad fundamental para representar roles de usuarios.
Creating the Authority Repository and Service: Facilitando el acceso a datos y la lógica de negocio.
Defining Privileges with Enums: Enumerando privilegios de usuarios distintos para claridad y consistencia.
Populating Seed Data: Asegurando que roles esenciales sean inicializados al inicio de la aplicación.
Establishing Many-to-Many Relationships: Habilitando asociaciones flexibles entre usuarios y sus authorities.

Siguiendo estos pasos, los desarrolladores pueden crear un sistema de gestión de authority seguro y escalable dentro de sus aplicaciones Spring Boot.
SEO Optimized Keywords
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

Pros	Contras
Mejora la seguridad y el control de acceso	La configuración inicial puede llevar tiempo
Fácil gestión de roles y privilegios de usuarios	Requiere planificación cuidadosa de roles y permisos
Aumenta la escalabilidad para futuras expansiones	Complejidad potencial en aplicaciones grandes

ID	Name
1	RESET_PASSWORD
2	ACCESS_ADMIN_PANEL

Nombre de la Columna	Tipo de Datos	Restricciones
account_id	Long	Foreign Key a Account.id
authority_id	Long	Foreign Key a Authority.id

**Chinese (Simplified) Translation:**

html


增强用户管理：在 Spring Boot 中添加权限表
目录

介绍 ........................................................... 1
设置 Authority 实体 ............... 3
创建 Authority 仓库和服务 ................................................................. 7
使用 Enums 定义权限 .................. 11
填充种子数据 ......................................... 15
建立多对多关系 .................................................................................................... 19
结论 ............................................................. 25


介绍
在现代 web 应用程序中，user management 和 authorization 是确保对资源安全访问的关键组件。实施一个强大的 authority system 允许开发人员有效地定义和管理用户角色和权限。本电子书深入探讨了在 Spring Boot 应用程序中向用户账户添加 authority 表的过程，以增强安全性和可扩展性。
Authority 管理的重要性

Security: 限制对敏感功能的访问。
Scalability: 便于轻松添加新角色和权限。
Maintainability: 简化用户权限的管理。

优缺点


优点
缺点


改善的安全性和访问控制
初始设置可能耗时


易于管理用户角色和权限
需要仔细规划角色和权限


增强未来扩展的可扩展性
大型应用程序中可能的复杂性


何时何地使用

Enterprise Applications: 管理多样化的用户角色。
E-commerce Platforms: 区分客户、供应商和管理员。
Content Management Systems: 控制内容创建和编辑的访问。


设置 Authority 实体
建立 Authority 实体是管理用户权限的基础。该实体通常包含一个 ID 和一个 name，代表不同的 authorities。
创建 Authority 模型




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


解释

@Entity: 将类标记为 JPA 实体。
@Id: 表示主键。
Fields: id 和 name 分别代表 authority 的标识符和名称。
Constructor & Getters/Setters: 促进对象创建和属性访问。


创建 Authority 仓库和服务
要与 Authority 实体进行交互，我们需要创建一个 repository 和一个 service 层。
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


解释

AuthorityRepository: 扩展 JpaRepository 以提供 Authority 实体的 CRUD 操作。
AuthorityService: 使用 AuthorityRepository 管理 authorities，封装业务逻辑。


使用 Enums 定义权限
Enums 是定义固定常量集（如用户权限）的高效方法。
创建 Privileges Enum




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


解释

Enum Constants: RESET_PASSWORD 和 ACCESS_ADMIN_PANEL 表示不同的权限。
Fields: 每个 enum 常量都有自己的 id 和 name。
Constructor & Getters: 促进权限属性的创建和检索。


填充种子数据
种子数据使用默认 authorities 初始化数据库，确保在应用程序启动时可用的基本角色。
实施种子数据




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


解释

@Component: 注册类为 Spring bean。
CommandLineRunner: 在应用程序启动后执行 run 方法。
Looping Through Privileges: 遍历所有 enum 值以创建和保存相应的 authorities。
Error Handling: 通过确保一致的数据类型（Long vs. int）来解决类型不匹配等小问题。

种子数据执行的输出
运行应用程序后，Authority 表将使用定义的权限填充：


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



Estableciendo Relaciones Muchos-a-Muchos
Para asociar usuarios con múltiples authorities y viceversa, se establece una many-to-many relationship entre las entidades Account y Authority.
Actualizando el Modelo Account




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Explicación

@ManyToMany: Define una relación muchos-a-muchos entre Account y Authority.
@JoinTable: Especifica la tabla de unión account_authority que facilita la relación.

joinColumns: Refleja la entidad Account.
inverseJoinColumns: Refleja la entidad Authority.


Set<Authority>: Utiliza un Set para prevenir authorities duplicados para una cuenta.

Creando la Tabla de Unión
La tabla de unión account_authority se crea automáticamente basado en las anotaciones, con la siguiente estructura:


Nombre de la Columna
Tipo de Datos
Restricciones


account_id
Long
Foreign Key a Account.id


authority_id
Long
Foreign Key a Authority.id


Beneficios de las Relaciones Muchos-a-Muchos

Flexibility: Permite múltiples authorities por usuario y viceversa.
Data Integrity: Asegura datos consistentes y no redundantes a través de la tabla de unión.


Conclusión
Implementar tablas de authority en una aplicación Spring Boot es esencial para una robusta user management y authorization. Esta guía integral cubrió los pasos esenciales:

Setting Up the Authority Entity: Estableciendo una entidad fundamental para representar roles de usuarios.
Creating the Authority Repository and Service: Facilitando el acceso a datos y la lógica de negocio.
Defining Privileges with Enums: Enumerando privilegios de usuarios distintos para claridad y consistencia.
Populating Seed Data: Asegurando que roles esenciales sean inicializados al inicio de la aplicación.
Establishing Many-to-Many Relationships: Habilitando asociaciones flexibles entre usuarios y sus authorities.

Siguiendo estos pasos, los desarrolladores pueden crear un sistema de gestión de authority seguro y escalable dentro de sus aplicaciones Spring Boot.
SEO Optimized Keywords
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

优点	缺点
改善的安全性和访问控制	初始设置可能耗时
易于管理用户角色和权限	需要仔细规划角色和权限
增强未来扩展的可扩展性	大型应用程序中可能的复杂性

**Korean (Hangul) Translation:**

html


사용자 관리 향상: Spring Boot에서 권한 테이블 추가하기
목차

소개 ........................................................... 1
Authority 엔터티 설정 ............... 3
Authority 저장소 및 서비스 생성 ................................................................. 7
Enums를 사용한 권한 정의 .................. 11
시드 데이터 채우기 ......................................... 15
다대다 관계 설정 .................................................................................................... 19
결론 ............................................................. 25


소개
현대 웹 애플리케이션에서 user management와 authorization은 리소스에 대한 안전한 접근을 보장하는 중요한 구성 요소입니다. 강력한 authority system을 구현하면 개발자가 사용자 역할과 권한을 효과적으로 정의하고 관리할 수 있습니다. 이 전자책은 Spring Boot 애플리케이션에서 사용자 계정에 authority 테이블을 추가하여 보안과 확장성을 향상시키는 과정을 자세히 다룹니다.
Authority 관리의 중요성

Security: 민감한 기능에 대한 접근을 제한합니다.
Scalability: 새로운 역할과 권한을 쉽게 추가할 수 있게 합니다.
Maintainability: 사용자 권한 관리를 단순화합니다.

장단점


장점
단점


향상된 보안 및 접근 제어
초기 설정에 시간이 걸릴 수 있음


사용자 역할과 권한의 쉬운 관리
역할과 권한을 신중하게 계획해야 함


미래 확장을 위한 확장성 향상
대규모 애플리케이션에서의 잠재적 복잡성


언제 어디서 사용하나요

Enterprise Applications: 다양한 사용자 역할 관리.
E-commerce Platforms: 고객, 공급업체 및 관리자를 구분.
Content Management Systems: 콘텐츠 생성 및 편집에 대한 접근 제어.


Authority 엔터티 설정
Authority 엔터티를 설정하는 것은 사용자 권한을 관리하는 기초입니다. 이 엔터티는 일반적으로 다양한 권한을 나타내는 ID와 name을 포함합니다.
Authority 모델 생성




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


설명

@Entity: 클래스를 JPA 엔터티로 표시합니다.
@Id: 기본 키를 나타냅니다.
Fields: id과 name은 각각 authority의 식별자와 이름을 나타냅니다.
Constructor & Getters/Setters: 객체 생성 및 속성 접근을 용이하게 합니다.


Creando el Repositorio y Servicio Authority
Para interactuar con la entidad Authority, necesitamos crear una capa de repository y service.
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBoot.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBoot.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


解释

@Entity: 将类标记为 JPA 实体。
@Id: 表示主键。
Fields: id 和 name 分别代表 authority 的标识符和名称。
Constructor & Getters/Setters: 促进对象创建和属性访问。


Creando el Repositorio y Servicio Authority
Para interactuar con la entidad Authority, necesitamos crear una capa de repository y service.
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


Explicación

AuthorityRepository: Extiende JpaRepository para proporcionar operaciones CRUD para la entidad Authority.
AuthorityService: Utiliza AuthorityRepository para gestionar authorities, encapsulando la lógica de negocio.


Definiendo Privilegios con Enums
Los Enums son una forma eficiente de definir un conjunto fijo de constantes, como privilegios de usuarios.
Creando el Enum Privileges




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


Explicación

Enum Constants: RESET_PASSWORD y ACCESS_ADMIN_PANEL representan privilegios distintos.
Fields: Cada constante enum tiene un id y un name.
Constructor & Getters: Facilitan la creación y recuperación de las propiedades del privilegio.


Población de Datos Iniciales
Los datos iniciales inicializan la base de datos con authorities predeterminadas, asegurando que los roles esenciales estén disponibles al inicio de la aplicación.
Implementando Datos Iniciales




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


Explicación

@Component: Registra la clase como un bean de Spring.
CommandLineRunner: Ejecuta el método run después de que la aplicación arranca.
Looping Through Privileges: Itera sobre todos los valores del enum para crear y guardar las authorities correspondientes.
Error Handling: Problemas menores, como incompatibilidades de tipo, se resuelven asegurando tipos de datos consistentes (Long vs. int).

Salida de la Ejecución de Datos Iniciales
Al ejecutar la aplicación, la tabla Authority se llena con los privilegios definidos:


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



Estableciendo Relaciones Muchos-a-Muchos
Para asociar usuarios con múltiples authorities y viceversa, se establece una many-to-many relationship entre las entidades Account y Authority.
Actualizando el Modelo Account




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Explicación

@ManyToMany: Define una relación muchos-a-muchos entre Account y Authority.
@JoinTable: Especifica la tabla de unión account_authority que facilita la relación.

joinColumns: Refleja la entidad Account.
inverseJoinColumns: Refleja la entidad Authority.


Set<Authority>: Utiliza un Set para prevenir authorities duplicados para una cuenta.

Creando la Tabla de Unión
La tabla de unión account_authority se crea automáticamente basado en las anotaciones, con la siguiente estructura:


Nombre de la Columna
Tipo de Datos
Restricciones


account_id
Long
Foreign Key a Account.id


authority_id
Long
Foreign Key a Authority.id


Beneficios de las Relaciones Muchos-a-Muchos

Flexibility: Permite múltiples authorities por usuario y viceversa.
Data Integrity: Asegura datos consistentes y no redundantes a través de la tabla de unión.


Conclusión
Implementar tablas de authority en una aplicación Spring Boot es fundamental para una robusta user management y authorization. Esta guía integral cubrió los pasos esenciales:

Setting Up the Authority Entity: Estableciendo una entidad fundamental para representar roles de usuarios.
Creating the Authority Repository and Service: Facilitando el acceso a datos y la lógica de negocio.
Defining Privileges with Enums: Enumerando privilegios de usuarios distintos para claridad y consistencia.
Populating Seed Data: Asegurando que roles esenciales sean inicializados al inicio de la aplicación.
Establishing Many-to-Many Relationships: Habilitando asociaciones flexibles entre usuarios y sus authorities.

Siguiendo estos pasos, los desarrolladores pueden crear un sistema de gestión de authority seguro y escalable dentro de sus aplicaciones Spring Boot.
SEO Optimized Keywords
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.

**Spanish (Latin American) Translation:**

html


Mejorando la Gestión de Usuarios: Añadiendo Tablas de Autoridad en Spring Boot
Tabla de Contenidos

Introducción ........................................................... 1
Configurando la Entidad Authority ............... 3
Creando el Repositorio y Servicio Authority ................................................................. 7
Definiendo Privilegios con Enums .................. 11
Población de Datos Iniciales ......................................... 15
Estableciendo Relaciones Muchos-a-Muchos .................................................................................................... 19
Conclusión ............................................................. 25


Introducción
En las aplicaciones web modernas, user management y authorization son componentes críticos que aseguran el acceso seguro a los recursos. Implementar un sistema robusto de authority permite a los desarrolladores definir y gestionar roles y privilegios de usuarios de manera efectiva. Este eBook profundiza en el proceso de añadir tablas de authority a las cuentas de usuario en una aplicación Spring Boot, mejorando la seguridad y la escalabilidad.
Importancia de la Gestión de Authority

Security: Restringe el acceso a funcionalidades sensibles.
Scalability: Facilita la adición de nuevos roles y privilegios.
Maintainability: Simplifica la gestión de permisos de usuarios.

Pros y Contras


Pros
Contras


Mejora la seguridad y el control de acceso
La configuración inicial puede llevar tiempo


Fácil gestión de roles y privilegios de usuarios
Requiere planificación cuidadosa de roles y permisos


Aumenta la escalabilidad para futuras expansiones
Complejidad potencial en aplicaciones grandes


Cuándo y Dónde Usar

Enterprise Applications: Gestión de roles de usuarios variados.
E-commerce Platforms: Diferenciación entre clientes, vendedores y administradores.
Content Management Systems: Controlar el acceso a la creación y edición de contenido.


Configurando la Entidad Authority
Establecer la entidad Authority es fundamental para gestionar los permisos de los usuarios. Esta entidad generalmente contiene un ID y un name que representan diferentes authorities.
Creando el Modelo Authority




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;

    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setters
    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.models;
 
import javax.persistence.Entity;
import javax.persistence.Id;
 
@Entity
public class Authority {
    
    @Id
    private Long id;
    private String name;
 
    // Constructor
    public Authority(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    // Setters
    public void setId(Long id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
					
				
			
		


Explicación

@Entity: Marca la clase como una entidad JPA.
@Id: Denota la clave primaria.
Fields: id y name representan el identificador de la authority y su nombre, respectivamente.
Constructor & Getters/Setters: Facilitan la creación de objetos y el acceso a las propiedades.


Creando el Repositorio y Servicio Authority
Para interactuar con la entidad Authority, necesitamos crear una capa de repository y service.
Authority Repository




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;

public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
			
				
					
				
					1
2
3
4
5
6
7
				
						package org.studyeasy.SpringBlog.repositories;
 
import org.springframework.data.jpa.repository.JpaRepository;
import org.studyeasy.SpringBlog.models.Authority;
 
public interface AuthorityRepository extends JpaRepository<Authority, Long> {
}
					
				
			
		


Authority Service




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;

@Service
public class AuthorityService {

    @Autowired
    private AuthorityRepository authorityRepository;

    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						package org.studyeasy.SpringBlog.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.repositories.AuthorityRepository;
 
@Service
public class AuthorityService {
 
    @Autowired
    private AuthorityRepository authorityRepository;
 
    public Authority save(Authority authority) {
        return authorityRepository.save(authority);
    }
}
					
				
			
		


Explicación

AuthorityRepository: Extiende JpaRepository para proporcionar operaciones CRUD para la entidad Authority.
AuthorityService: Utiliza AuthorityRepository para gestionar authorities, encapsulando la lógica de negocio.


Definiendo Privilegios con Enums
Los Enums son una forma eficiente de definir un conjunto fijo de constantes, como privilegios de usuarios.
Creando el Enum Privileges




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.util.constants;

public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");

    private Long id;
    private String name;

    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						package org.studyeasy.SpringBlog.util.constants;
 
public enum Privileges {
    RESET_PASSWORD(1L, "RESET_PASSWORD"),
    ACCESS_ADMIN_PANEL(2L, "ACCESS_ADMIN_PANEL");
 
    private Long id;
    private String name;
 
    Privileges(Long id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
}
					
				
			
		


Explicación

Enum Constants: RESET_PASSWORD y ACCESS_ADMIN_PANEL representan privilegios distintos.
Fields: Cada constante enum tiene un id y un name.
Constructor & Getters: Facilitan la creación y recuperación de las propiedades del privilegio.


Población de Datos Iniciales
Los datos iniciales inicializan la base de datos con authorities predeterminadas, asegurando que los roles esenciales estén disponibles al inicio de la aplicación.
Implementando Datos Iniciales




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;

@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AuthorityService authorityService;

    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
			
				
					
				
					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
				
						package org.studyeasy.SpringBlog.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.studyeasy.SpringBlog.models.Authority;
import org.studyeasy.SpringBlog.services.AuthorityService;
import org.studyeasy.SpringBlog.util.constants.Privileges;
 
@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AuthorityService authorityService;
 
    @Override
    public void run(String... args) throws Exception {
        for (Privileges privilege : Privileges.values()) {
            Authority authority = new Authority();
            authority.setId(privilege.getId());
            authority.setName(privilege.getName());
            authorityService.save(authority);
        }
    }
}
					
				
			
		


Explicación

@Component: Registra la clase como un bean de Spring.
CommandLineRunner: Ejecuta el método run después de que la aplicación arranca.
Looping Through Privileges: Itera sobre todos los valores del enum para crear y guardar las authorities correspondientes.
Error Handling: Problemas menores, como incompatibilidades de tipo, se resuelven asegurando tipos de datos consistentes (Long vs. int).

Salida de la Ejecución de Datos Iniciales
Al ejecutar la aplicación, la tabla Authority se llena con los privilegios definidos:


ID
Name


1
RESET_PASSWORD


2
ACCESS_ADMIN_PANEL



Estableciendo Relaciones Muchos-a-Muchos
Para asociar usuarios con múltiples authorities y viceversa, se establece una many-to-many relationship entre las entidades Account y Authority.
Actualizando el Modelo Account




		
		
			
			
Java
			
			package org.studyeasy.SpringBlog.models;

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

@Entity
public class Account {

    @Id
    private Long id;
    private String username;
    private String password;

    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();

    // 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 org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
 
@Entity
public class Account {
 
    @Id
    private Long id;
    private String username;
    private String password;
 
    @ManyToMany
    @JoinTable(
        name = "account_authority",
        joinColumns = @JoinColumn(name = "account_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id")
    )
    private Set<Authority> authorities = new HashSet<>();
 
    // Constructors, Getters, and Setters
}
					
				
			
		


Explicación

@ManyToMany: Define una relación muchos-a-muchos entre Account y Authority.
@JoinTable: Especifica la tabla de unión account_authority que facilita la relación.

joinColumns: Refleja la entidad Account.
inverseJoinColumns: Refleja la entidad Authority.


Set<Authority>: Utiliza un Set para prevenir authorities duplicados para una cuenta.

Creando la Tabla de Unión
La tabla de unión account_authority se crea automáticamente basado en las anotaciones, con la siguiente estructura:


Nombre de la Columna
Tipo de Datos
Restricciones


account_id
Long
Foreign Key a Account.id


authority_id
Long
Foreign Key a Authority.id


Beneficios de las Relaciones Muchos-a-Muchos

Flexibility: Permite múltiples authorities por usuario y viceversa.
Data Integrity: Asegura datos consistentes y no redundantes a través de la tabla de unión.


Conclusión
Implementar tablas de authority en una aplicación Spring Boot es fundamental para una robusta user management y authorization. Esta guía integral cubrió los pasos esenciales:

Setting Up the Authority Entity: Estableciendo una entidad fundamental para representar roles de usuarios.
Creating the Authority Repository and Service: Facilitando el acceso a datos y la lógica de negocio.
Defining Privileges with Enums: Enumerando privilegios de usuarios distintos para claridad y consistencia.
Populating Seed Data: Asegurando que roles esenciales sean inicializados al inicio de la aplicación.
Establishing Many-to-Many Relationships: Habilitando asociaciones flexibles entre usuarios y sus authorities.

Siguiendo estos pasos, los desarrolladores pueden crear un sistema de gestión de authority seguro y escalable dentro de sus aplicaciones Spring Boot.
SEO Optimized Keywords
Spring Boot authority tables, user management Spring Boot, Spring Boot authorization, many-to-many Spring Boot, Spring Boot security, defining privileges Spring Boot, Spring Boot seed data, Authority entity Spring Boot, Spring Boot user roles, Spring Boot application security
Note: This article is AI generated.