Spring Security如何为用户示例添加角色详解

在这个 Spring Security 教程中，我很乐意与您分享如何通过在 Java Web 应用程序中为用户添加角色来实现授权——从数据库设计到实体类；从单元测试到在用户注册中添加默认角色；以 Web 形式更新用户的角色。

技术：Spring Web MVC、Spring Data JPA、Hibernate 框架、Spring Security、Spring Boot Test、JUnit 5、AssertJ、Thymeleaf 和 MySQL 数据库。

基本上，我们需要在数据库中有 3 个表，如下所示：

一个用户可以有一个或多个角色，一个角色可以分配给一个或多个用户，因此用户和角色表之间的实体关系是多对多的。users_roles是实现这种关系的中间表。

1. 用户和角色实体类和存储库的代码

将User实体类编码如下：

1. package net.codejava; 
2.   
3. import java.util.HashSet; 
4. import java.util.Set; 
5.   
6. import javax.persistence.*; 
7.   
8. @Entity 
9. @Table(name = "users") 
10. public class User { 
11.      
12.     @Id 
13.     @GeneratedValue(strategy = GenerationType.IDENTITY) 
14.     private Long id; 
15.      
16.     @Column(nullable = false, unique = true, length = 45) 
17.     private String email; 
18.      
19.     @Column(nullable = false, length = 64) 
20.     private String password; 
21.      
22.     @Column(name = "first_name", nullable = false, length = 20) 
23.     private String firstName; 
24.      
25.     @Column(name = "last_name", nullable = false, length = 20) 
26.     private String lastName; 
27.      
28.     @ManyToMany(fetch = FetchType.EAGER) 
29.     @JoinTable( 
30.             name = "users_roles", 
31.             joinColumns = @JoinColumn(name = "user_id"), 
32.             inverseJoinColumns = @JoinColumn(name = "role_id") 
33.     ) 
34.     private Set<Role> roles = new HashSet<>(); 
35.   
36.     public void addRole(Role role) { 
37.         this.roles.add(role); 
38. } 
39.   
40.     // getters and setters are not shown for brevity 
41. } 

并像这样对Role实体类进行编码：

1. package net.codejava; 
2.   
3. import javax.persistence.*; 
4.   
5. @Entity 
6. @Table(name = "roles") 
7. public class Role { 
8. @Id 
9. @GeneratedValue(strategy = GenerationType.IDENTITY) 
10. private Integer id; 
11.   
12. @Column(nullable = false, length = 45) 
13. private String name; 
14.   
15. public Role() { } 
16.   
17. public Role(String name) { 
18. this.name = name; 
19. } 
20.   
21. public Role(Integer id, String name) { 
22. this.id = id; 
23. this.name = name; 
24. } 
25.   
26. public Role(Integer id) { 
27. this.id = id; 
28. } 
29.   
30.   
31. @Override 
32. public String toString() { 
33. return this.name; 
34. } 
35.   
36. // getters and setters are not shown for brevity    
37. } 

如您所见，User类有一组角色，但Role类没有任何对 User 的引用。默认情况下， @ManyToMany关系上没有级联操作——这意味着更新User对象不会更改关联的Role对象。

2. 单元测试——创建角色

接下来，让我们编写以下测试类，用于将一些Role对象持久化到数据库中：

1. package net.codejava; 
2.   
3. import static org.assertj.core.api.Assertions.assertThat; 
4.   
5. import java.util.List; 
6.   
7. import org.junit.jupiter.api.Test; 
8. import org.springframework.beans.factory.annotation.Autowired; 
9. import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; 
10. import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace; 
11. import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; 
12. import org.springframework.test.annotation.Rollback; 
13.   
14. @DataJpaTest 
15. @AutoConfigureTestDatabase(replace = Replace.NONE) 
16. @Rollback(false) 
17. public class RoleRepositoryTests { 
18.   
19. @Autowired private RoleRepository repo; 
20.   
21. @Test 
22. public void testCreateRoles() { 
23. Role user = new Role("User"); 
24. Role admin = new Role("Admin"); 
25. Role customer = new Role("Customer"); 
26.   
27. repo.saveAll(List.of(user, admin, customer)); 
28.   
29. List<Role> listRoles = repo.findAll(); 
30.   
31. assertThat(listRoles.size()).isEqualTo(3); 
32. } 
33.   
34. } 

运行testCreateRoles()方法，我们最终将根据 3 个角色将 3 个新行插入到角色表中：用户、管理员和客户。

3. 单元测试——给用户添加角色

要测试向用户添加角色，请使用以下初始代码创建UserRepositoryTests类：

1. package net.codejava; 
2.   
3. import static org.assertj.core.api.Assertions.assertThat; 
4.   
5. import org.junit.jupiter.api.Test; 
6. import org.springframework.beans.factory.annotation.Autowired; 
7. import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; 
8. import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace; 
9. import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; 
10. import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; 
11. import org.springframework.test.annotation.Rollback; 
12.   
13. @DataJpaTest 
14. @AutoConfigureTestDatabase(replace = Replace.NONE) 
15. @Rollback(false) 
16. public class UserRepositoryTests { 
17.   
18. @Autowired 
19. private TestEntityManager entityManager; 
20.   
21. @Autowired 
22. private UserRepository userRepo; 
23.   
24. @Autowired 
25. private RoleRepository roleRepo; 
26.   
27. // test methods go here... 
28. } 

以下是第一个测试方法的代码片段，它保留了一个没有任何角色的用户对象：

1. @Test 
2. public void testCreateUser() { 
3. User user = new User(); 
4. user.setEmail("ravikumar@gmail.com"); 
5. user.setPassword("ravi2020"); 
6. user.setFirstName("Ravi"); 
7. user.setLastName("Kumar"); 
8.   
9. User savedUser = userRepo.save(user); 
10.   
11. User existUser = entityManager.find(User.class, savedUser.getId()); 
12.   
13. assertThat(user.getEmail()).isEqualTo(existUser.getEmail()); 
14.   
15. } 

以下测试方法创建一个具有管理员角色的新用户：

1. @Test 
2. public void testAddRoleToNewUser() { 
3. Role roleAdmin = roleRepo.findByName("Admin"); 
4.   
5. User user = new User(); 
6. user.setEmail("mikes.gates@gmail.com"); 
7. user.setPassword("mike2020"); 
8. user.setFirstName("Mike"); 
9. user.setLastName("Gates"); 
10. user.addRole(roleAdmin);    
11.   
12. User savedUser = userRepo.save(user); 
13.   
14. assertThat(savedUser.getRoles().size()).isEqualTo(1); 
15. } 

以下测试将通过添加两个角色 User 和 Customer 来更新现有用户：

1. @Test 
2. public void testAddRoleToExistingUser() { 
3. User user = userRepo.findById(1L).get(); 
4. Role roleUser = roleRepo.findByName("User"); 
5. Role roleCustomer = new Role(3); 
6.   
7. user.addRole(roleUser); 
8. user.addRole(roleCustomer); 
9.   
10. User savedUser = userRepo.save(user); 
11.   
12. assertThat(savedUser.getRoles().size()).isEqualTo(2);   
13. } 

运行这些测试方法，您将看到插入到users和users_roles表中的行。角色表不受影响。

4. 为注册用户设置默认角色

用户注册中的一个常见场景是为新注册的用户设置默认角色，例如用户或客户角色。以下是服务层的示例代码片段：

1. package net.codejava; 
2.   
3. @Service 
4. public class UserService { 
5.   
6. @Autowired 
7. private UserRepository userRepo; 
8.   
9. @Autowired RoleRepository roleRepo; 
10.   
11. @Autowired PasswordEncoder passwordEncoder; 
12.   
13. public void registerDefaultUser(User user) { 
14. Role roleUser = roleRepo.findByName("User"); 
15. user.addRole(roleUser); 
16.   
17. userRepo.save(user); 
18. } 
19.   
20. } 

以及控制器层的代码：

1. package net.codejava; 
2.   
3. @Controller 
4. public class AppController { 
5.   
6. @Autowired 
7. private UserService service; 
8.   
9. @PostMapping("/register") 
10. public String processRegister(User user) { 
11. service.registerDefaultUser(user); 
12.   
13. return "register_success"; 
14. }   
15. } 

如您所见，这非常简单——感谢 Spring Data JPA 和 Hibernate 框架，极大地简化了数据访问层的编码。

5. 在 Web 表单中为用户分配角色

现在，我将向您展示如何使用 Web 用户界面编写编辑用户功能的代码，我们可以在其中更改分配给用户的角色。

首先，在UserService类中实现如下方法：

1. public List<User> listAll() { 
2. return userRepo.findAll(); 
3. } 

在控制器类中：

1. @GetMapping("/users") 
2. public String listUsers(Model model) { 
3. List<User> listUsers = service.listAll(); 
4. model.addAttribute("listUsers", listUsers); 
5.   
6. return "users"; 
7. } 

此处理程序方法将显示从数据库中检索到的用户列表。并将以下相关代码放入视图页面（HTML）：

1. <table class="table table-striped table-bordered"> 
2. <thead class="thead-dark"> 
3. <tr> 
4. <th>User ID</th> 
5. <th>E-mail</th> 
6. <th>First Name</th> 
7. <th>Last Name</th> 
8. <th>Roles</th> 
9. <th></th> 
10. </tr> 
11. </thead> 
12. <tbody> 
13. <tr th:each="user: ${listUsers}"> 
14. <td th:text="${user.id}">User ID</td> 
15. <td th:text="${user.email}">E-mail</td> 
16. <td th:text="${user.firstName}">First Name</td> 
17. <td th:text="${user.lastName}">Last Name</td> 
18. <td th:text="${user.roles}">Roles</td> 
19. <td><a th:href="/@{'/users/edit/' + ${user.id}}">Edit</a></td> 
20. </tr> 
21. </tbody> 
22. </table> 

它将在 URL http://localhost.../users 处显示用户列表，如下所示：

在此用户列表页面上，我们可以单击编辑超链接来编辑用户。所以像这样编写处理程序方法：

1. @GetMapping("/users/edit/{id}") 
2. public String editUser(@PathVariable("id") Long id, Model model) { 
3. User user = service.get(id); 
4. List<Role> listRoles = service.listRoles(); 
5. model.addAttribute("user", user); 
6. model.addAttribute("listRoles", listRoles); 
7. return "user_form"; 
8. } 

并在服务类中实现以下两个方法：

1. public User get(Long id) { 
2. return userRepo.findById(id).get(); 
3. } 
4.   
5. public List<Role> listRoles() { 
6. return roleRepo.findAll(); 
7. } 

在视图层，为编辑用户表单编写如下代码：

1. <form th:action="@{/users/save}" th:object="${user}" 
2. method="post" style="max-width: 600px; margin: 0 auto;"> 
3. <input type="hidden" th:field="*{id}" /> 
4. <div class="m-3"> 
5. <div class="form-group row"> 
6. <label class="col-4 col-form-label">E-mail: </label> 
7. <div class="col-8"> 
8. <input type="email" th:field="*{email}" class="form-control" required /> 
9. </div> 
10. </div> 
11.   
12. <div class="form-group row"> 
13. <label class="col-4 col-form-label">Password: </label> 
14. <div class="col-8"> 
15. <input type="password" th:field="*{password}" class="form-control" 
16. required minlength="6" maxlength="10"/> 
17. </div> 
18. </div> 
19.   
20. <div class="form-group row"> 
21. <label class="col-4 col-form-label">First Name: </label> 
22. <div class="col-8"> 
23. <input type="text" th:field="*{firstName}" class="form-control" 
24. required minlength="2" maxlength="20"/> 
25. </div> 
26. </div> 
27.   
28. <div class="form-group row"> 
29. <label class="col-4 col-form-label">Last Name: </label> 
30. <div class="col-8"> 
31. <input type="text" th:field="*{lastName}" class="form-control" 
32. required minlength="2" maxlength="20" /> 
33. </div> 
34. </div> 
35.   
36. <div class="form-group row"> 
37. <label class="col-4 col-form-label">Roles: </label> 
38. <div class="col-8"> 
39. <th:block th:each="role: ${listRoles}"> 
40. <input type="checkbox" th:field="*{roles}" 
41. th:text="${role.name}" th:value="${role.id}" class="m-2" /> 
42. </th:block> 
43. </div> 
44. </div>    
45.   
46. <div> 
47. <button type="submit" class="btn btn-primary">Update</button> 
48. </div> 
49. </div> 
50. </form> 

此页面中最重要的是显示角色列表并检查分配给当前用户的角色的代码：

1. <th:block th:each="role: ${listRoles}"> 
2. <input type="checkbox" th:field="*{roles}" 
3. th:text="${role.name}" th:value="${role.id}" class="m-2" /> 
4. </th:block> 

然后编辑用户表单将如下所示：

这里很酷的是，Thymeleaf 会根据分配给用户的角色自动显示选择的角色。此外，您可以在此处简单地选中/取消选中角色来更新用户的角色。

并编写处理表单提交的处理程序方法，如下所示：

1. @PostMapping("/users/save") 
2. public String saveUser(User user) { 
3. service.save(user); 
4.   
5. return "redirect:/users"; 
6. } 

以及服务层的相关代码：

1. public void save(User user) { 
2. userRepo.save(user); 
3. } 

这是一些关于在 Spring Boot Web 应用程序中向用户添加角色的代码示例。我希望您发现这个书面教程对您有所帮助。