后端进阶之路——浅谈Spring Security用户、角色、权限和访问规则（三）

╰半夏微凉° 2023-10-14 13:46 21阅读 0赞

# 前言 #

![在这里插入图片描述][0422b4369a3549b3a39da19588ab88f4.png]  
「作者主页」：[雪碧有白泡泡][Link 1]  
「个人网站」：[雪碧的个人网站][Link 2]  
「推荐专栏」：

> ★[java一站式服务][java] ★  
> ★[前端炫酷代码分享][Link 3]  
> ★ ★ [uniapp-从构建到提升][uniapp-]★  
> ★ [从0到英雄，vue成神之路][0_vue]★  
> ★ [解决算法，一个专栏就够了][Link 4]★  
> ★ [架构咱们从0说][0]★  
> ★ [数据流通的精妙之道][Link 5]★
> 
> ★[后端进阶之路][Link 6]★

![请添加图片描述][c7f3e6b8a7624a9eabbea77dbcbca119.jpeg]

![在这里插入图片描述][54023524a97248de87c40d21e7f1b9e4.png]

### 文章目录 ###

*  前言
 *  引言
 *  1. 定义用户
 *   *  使用内存方式定义用户
     *  使用数据库方式定义用户
 *  2. 定义角色
 *   *  创建角色并将其与用户关联
     *  解释如何使用角色来组织和控制权限
 *  3. 定义权限
 *  4. 访问规则
 *   *   *  使用Ant风格的路径匹配规则
         *  使用表达式语言进行更复杂的访问规则定义
 *  小结

# 引言 #

继上篇[后端进阶之路——深入理解Spring Security配置（二）][Spring Security]  
![在这里插入图片描述][f22d526d1df540c096409160b279fb10.png]

# 1. 定义用户 #

## 使用内存方式定义用户 ##

在内存中定义用户是一种简单的方法，适用于开发和测试环境。我们可以在Spring Security的配置类中使用`InMemoryUserDetailsManager`来定义用户。下面是一个示例：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.inMemoryAuthentication()
                    .withUser("user")
                    .password("{noop}password") // 使用 "{noop}" 前缀表示密码不加密
                    .roles("USER");
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                    .anyRequest().authenticated()
                    .and()
                    .formLogin();
        }
    }

上述示例中，使用`withUser`方法定义了一个用户名为"user"，密码为"password"，角色为"USER"的用户。注意，密码的前缀"\{noop\}"表示密码不加密，这只适用于开发和测试环境。

## 使用数据库方式定义用户 ##

在实际生产环境中，通常会将用户信息存储在数据库中。使用数据库方式定义用户需要进行以下步骤：

1.  创建数据库表格来存储用户信息，例如表格名为"users"，包含列"username"、“password"和"role”。
2.  配置Spring Security以连接到数据库，并使用数据库中的用户信息进行认证和授权。

下面是一个使用数据库方式定义用户的示例：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private DataSource dataSource;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.jdbcAuthentication()
                    .dataSource(dataSource)
                    .usersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username=?")
                    .authoritiesByUsernameQuery("SELECT username, role FROM users WHERE username=?");
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                    .anyRequest().authenticated()
                    .and()
                    .formLogin();
        }
    }

上述示例中，通过`dataSource`注入了数据源，然后使用`jdbcAuthentication`配置了基于数据库的认证和授权。`.usersByUsernameQuery()`方法指定了查询用户名、密码和启用状态的SQL语句，`.authoritiesByUsernameQuery()`方法指定了查询用户名和角色的SQL语句。

# 2. 定义角色 #

> 在Spring Security中，可以使用角色来组织和控制权限。角色是一组权限的集合，可以通过将角色与用户关联来授予用户相应的权限。

**以下是在Spring Security中定义角色并将其与用户关联的示例代码：**

## 创建角色并将其与用户关联 ##

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private DataSource dataSource;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.jdbcAuthentication()
                    .dataSource(dataSource)
                    .usersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username=?")
                    .authoritiesByUsernameQuery("SELECT username, role FROM users WHERE username=?");
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                    .antMatchers("/admin/**").hasRole("ADMIN") // 需要"ADMIN"角色才能访问"/admin/**"路径
                    .anyRequest().authenticated()
                    .and()
                    .formLogin();
        }
    }

在上述示例中，`.antMatchers("/admin/**").hasRole("ADMIN")`指定了只有拥有"ADMIN"角色的用户才能访问"/admin/\*\*"路径。这样，我们可以根据不同的角色来限制用户对某些资源的访问权限。

## 解释如何使用角色来组织和控制权限 ##

在Spring Security中，可以使用角色来定义访问控制规则，并使用这些规则来保护应用程序的不同部分。通过为用户分配不同的角色，可以实现对不同用户的权限控制。

以下是一个使用角色进行权限控制的示例代码：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private DataSource dataSource;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.jdbcAuthentication()
                    .dataSource(dataSource)
                    .usersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username=?")
                    .authoritiesByUsernameQuery("SELECT username, role FROM users WHERE username=?");
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                    .antMatchers("/admin/**").hasRole("ADMIN") // 需要"ADMIN"角色才能访问"/admin/**"路径
                    .antMatchers("/user/**").hasRole("USER") // 需要"USER"角色才能访问"/user/**"路径
                    .anyRequest().authenticated()
                    .and()
                    .formLogin();
        }
    }

上述示例中，使用`.antMatchers("/admin/**").hasRole("ADMIN")`和`.antMatchers("/user/**").hasRole("USER")`定义了不同路径需要不同角色的访问权限。只有拥有相应角色的用户才能访问对应的路径。

# 3. 定义权限 #

> 权限是指在系统中对特定资源或操作进行访问控制的能力。它是用于确保只有经过授权的用户或角色才能执行某些敏感操作或访问某些受限资源的机制。权限的定义和管理对于确保系统的安全性和保护重要数据非常重要。

在Spring Security中，我们可以使用`@PreAuthorize`、`@PostAuthorize`和`@Secured`等注解来定义权限。这些注解可以放置在方法上，用于限制只有具有特定权限的用户才能调用该方法。

下面是一个示例，演示了如何在Spring Security中定义权限：

首先，确保你已经添加了Spring Security的依赖到你的项目中。

<dependencies>
        ...
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        ...
    </dependencies>

接下来，创建一个自定义的权限验证类。

import org.springframework.security.access.prepost.PreAuthorize;
    import org.springframework.stereotype.Component;
    
    @Component
    public class MyAuthorization {
        
    
        @PreAuthorize("hasRole('ROLE_ADMIN')")
        public void adminOnly() {
        
            // 只有具有ROLE_ADMIN角色的用户才能调用此方法
        }
    
        @PreAuthorize("hasAuthority('WRITE_PERMISSION')")
        public void writeAccess() {
        
            // 只有具有WRITE_PERMISSION权限的用户才能调用此方法
        }
    
    }

在上述代码中，`MyAuthorization`类包含了两个方法：`adminOnly()`和`writeAccess()`。这两个方法都使用了`@PreAuthorize`注解来定义权限。

`hasRole('ROLE_ADMIN')`表示只有具有`ROLE_ADMIN`角色的用户才能调用`adminOnly()`方法。

`hasAuthority('WRITE_PERMISSION')`表示只有具有`WRITE_PERMISSION`权限的用户才能调用`writeAccess()`方法。

然后，在你的业务逻辑中，可以通过依赖注入的方式使用`MyAuthorization`类，并调用相应的方法。

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class MyService {
        
    
        private final MyAuthorization myAuthorization;
    
        @Autowired
        public MyService(MyAuthorization myAuthorization) {
        
            this.myAuthorization = myAuthorization;
        }
    
        public void doSomething() {
        
            myAuthorization.adminOnly(); // 调用需要admin权限的方法
            myAuthorization.writeAccess(); // 调用需要writeAccess权限的方法
        }
    
    }

在上述代码中，`MyService`类依赖注入了`MyAuthorization`类，并在`doSomething()`方法中调用了其中的两个方法。

# 4. 访问规则 #

> 当使用Spring Security进行访问控制时，可以通过Ant风格的路径匹配规则和表达式语言来定义更复杂的访问规则。下面是一些示例代码片段，用于说明如何使用这些规则：

### 使用Ant风格的路径匹配规则 ###

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .httpBasic();
        }
    }

在上述代码中，我们使用`authorizeRequests()`方法来配置路径的访问规则。`.antMatchers()`方法用于指定要匹配的路径模式，并使用`hasRole()`或`hasAnyRole()`方法指定需要具有的角色。在这个例子中，如果请求的路径以"/admin/"开头，则用户需要具有"ADMIN"角色。

### 使用表达式语言进行更复杂的访问规则定义 ###

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                .expressionHandler(expressionHandler())
                .antMatchers("/admin/**").access("hasRole('ADMIN') or hasIpAddress('127.0.0.1')")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .httpBasic();
        }
    
        @Bean
        public DefaultWebSecurityExpressionHandler expressionHandler() {
        
            DefaultWebSecurityExpressionHandler expressionHandler = new DefaultWebSecurityExpressionHandler();
            expressionHandler.setRoleHierarchy(roleHierarchy());
            return expressionHandler;
        }
    
        @Bean
        public RoleHierarchy roleHierarchy() {
        
            RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
            roleHierarchy.setHierarchy("ROLE_ADMIN > ROLE_USER");
            return roleHierarchy;
        }
    }

在上述代码中，我们使用`.access()`方法来定义更复杂的访问规则。这里我们使用表达式语言，可以通过`hasRole()`和`hasIpAddress()`等方法来判断用户是否有权限访问路径。在这个例子中，如果请求的路径以"/admin/“开头，并且用户具有"ADMIN"角色或者IP地址为"127.0.0.1”，则允许访问。

另外，我们还使用`DefaultWebSecurityExpressionHandler`和`RoleHierarchyImpl`来配置角色层次关系。在这个例子中，"ROLE\_ADMIN"角色被认为是"ROLE\_USER"角色的父角色，因此具有"ROLE\_ADMIN"角色的用户也将被授予"ROLE\_USER"角色的权限。

# 小结 #

> 通过定义用户、角色、权限和访问规则  
> 可以在SpringSecurity中实现灵活的访问控制和权限管理。可以使用内存方式或数据库方式定义用户，设置用户名、密码和角色等信息。角色可以用来组织和控制权限，可以将一组权限赋予特定角色，并将角色分配给用户。权限是指用户可以执行的特定操作或访问的资源，可以细化到每个功能或数据级别。可以使用Ant风格的路径匹配规则或表达式语言编写更复杂的访问规则，以限制用户对特定路径或功能的访问权限。  
> 通过定义这些元素，可以确保系统的安全性和可靠性。

![在这里插入图片描述][2a27c18452a24ccab7c5b5f821d23873.png]

[0422b4369a3549b3a39da19588ab88f4.png]: https://img-blog.csdnimg.cn/0422b4369a3549b3a39da19588ab88f4.png
[Link 1]: https://blog.csdn.net/Why_does_it_work?spm=1011.2415.3001.5343
[Link 2]: https://sprite.inscode.cc/
[java]: https://blog.csdn.net/why_does_it_work/category_12379581.html
[Link 3]: https://blog.csdn.net/why_does_it_work/category_12378617.html
[uniapp-]: https://blog.csdn.net/why_does_it_work/category_12363697.html
[0_vue]: https://blog.csdn.net/why_does_it_work/category_12376654.html
[Link 4]: https://blog.csdn.net/why_does_it_work/category_12381051.html
[0]: https://blog.csdn.net/why_does_it_work/category_12381055.html
[Link 5]: https://blog.csdn.net/why_does_it_work/category_12381058.html
[Link 6]: https://blog.csdn.net/why_does_it_work/category_12397959.html?spm=1001.2014.3001.5482
[c7f3e6b8a7624a9eabbea77dbcbca119.jpeg]: https://img-blog.csdnimg.cn/c7f3e6b8a7624a9eabbea77dbcbca119.jpeg
[54023524a97248de87c40d21e7f1b9e4.png]: https://img-blog.csdnimg.cn/54023524a97248de87c40d21e7f1b9e4.png
[Spring Security]: http://t.csdn.cn/7mUal
[f22d526d1df540c096409160b279fb10.png]: https://img-blog.csdnimg.cn/f22d526d1df540c096409160b279fb10.png
[2a27c18452a24ccab7c5b5f821d23873.png]: https://img-blog.csdnimg.cn/2a27c18452a24ccab7c5b5f821d23873.png