SpringSecurity 应用

简介

Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。

快速入门实践

创建项目

创建security项目，其pom.xml文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.3.2.RELEASE</version>
    </parent>
    <groupId>com.cy</groupId>
    <artifactId>05-security</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
</project>

添加项目依赖

第一步：创建项目，其pom.xml文件核心依赖如下：

<dependencies>

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

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

第二步：启动服务(依赖添加以后会默认添加一个tomcat，端口8080)
服务启动之后,你会发现,控制台会出现一个随机的密码，用于访问当前系统，默认用户名是user,密码就是控制台上的密码，如图所示：

在这里插入图片描述

启动服务访问测试

服务启动后，打开浏览器进行访问，如图所示：
在这里插入图片描述

输入账号（默认用户名为user）和密码登陆成功默认为如下页面.

在这里插入图片描述
其中，出现这个页面表示还没有配置登陆成功页面，这个资源页面现在还不存在，可以在项目的resources目录下创建static目录（假如没有此目录），然后在此目录下创建index.html页面，内容如下：

 <!DOCTYPE html>
  <html lang="en">
  <head>
    <meta charset="UTF-8">
    <title>Title</title> 
  </head>
  <body>
     <div>
       <h1>The Index Page</h1>
     </div> 
   </body> 
 </html>

此时，再次启动服务进行登陆，呈现登陆成功的效果，如图所示：

在这里插入图片描述

自定义认证逻辑

认证流程分析

在这里插入图片描述

定义security配置类

定义配置类，基于此类配置认证和授权逻辑，例如：

package com.cy.security.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 认证授权管理器对用户输入的密码与数据库中存储的密码进行比对时，
     * 需要对这个密码加密，加密算法需要我们自己指定
     * @return
     */
    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //super.configure(http);
        //关闭跨域攻击
        http.csrf().disable();
        //自定义登陆表单
        http.formLogin().loginPage("/login.html").loginProcessingUrl("/login");
        //请求资源的认证配置
        http.authorizeRequests()
                .antMatchers("/login","/login.html")
                .permitAll()
                .anyRequest().authenticated();
    }
}

定义数据访问层对象

定义数据访问层对象，基于此对象实现用户及用户权限信息的获取，例如：

package com.cy.security.dao;
import com.cy.security.domain.SysUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;

@Mapper
public interface UserMapper {
     /**
     * 基于用户名获取用户信息
     * @param username
     * @return
     */
    @Select("select id,username,password,status " +
            "from tb_users " +
            "where username=#{username}")
     SysUser selectUserByUsername(String username);

    /**
     * 基于用户id查询用户权限
     * @param userId 用户id
     * @return 用户的权限
     * 涉及到的表:tb_user_roles,tb_role_menus,tb_menus
     */
    @Select("select distinct m.permission " +
            "from tb_user_roles ur join tb_role_menus rm on ur.role_id=rm.role_id" +
            "     join tb_menus m on rm.menu_id=m.id " +
            "where ur.user_id=#{userId} and m.permission is not null")
    List<String> selectUserPermissions(Long userId);
}

定义UserDetailService接口实现类

Spring Security 提供了一个UserDetailService接口，我们可以基于此接口实现类，实现用户信息的获取和封装，例如：

@Service
public class UserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;
    /**
     * 客户端点击登陆时,添加些用户信息会传给此方法
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //1.基于用户名查询用户信息
        SysUser user=userMapper.selectUserByUsername(username);
        //...判断自己写...
        System.out.println(user);
        //2.查询用户登陆用户权限
        List<String> permissions=userMapper.selectUserPermissions(user.getId());
        System.out.println(permissions);
        //3.封装用户信息并返回，将用户信息交给认证管理器，认证授权管理器负责对用户输入的信息进行认证和授权
        List<GrantedAuthority> authorityList =
                AuthorityUtils.createAuthorityList(permissions.toArray(new String[]{}));
        return new User(username, user.getPassword(),authorityList);
    }
}

自定义登陆页面

在resources的static目录下创建login.html页面，例如：

<!doctype html>
<html lang="en">
<head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" 
          integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
    <title>login</title>
</head>
<body>
<div class="container"id="app">
    <h3>Please Login</h3>
    <form>
        <div class="mb-3">
            <label for="usernameId" class="form-label">Username</label>
            <input type="text" v-model="username" class="form-control" id="usernameId" aria-describedby="emailHelp">
        </div>
        <div class="mb-3">
            <label for="passwordId" class="form-label">Password</label>
            <input type="password" v-model="password" class="form-control" id="passwordId">
        </div>
        <button type="button" @click="doLogin()" class="btn btn-primary">Submit</button>
    </form>
</div>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

<script>
    var vm=new Vue({
        el:"#app",//定义监控点，vue底层会基于此监控点在内存中构建dom树
        data:{ //此对象中定义页面上要操作的数据
            username:"",
            password:""
        },
        methods: {//此位置定义所有业务事件处理函数
            doLogin() {
                //1.定义url
                let url = "http://localhost:8080/login"
                //2.定义参数
                let params = new URLSearchParams()
                params.append('username',this.username);
                params.append('password',this.password);
                debugger
                //3.发送异步请求
                axios.post(url, params).then((response) => {
                        alert("login ok");
                        location.href="/index.html"
                })
            }
        }
    });
</script>
</body>
</html>

启动服务进行访问测试

在这里插入图片描述

授权逻辑设计及实现

修改授权配置类

在权限配置类上添加启用全局方法访问控制注解，例如

package com.cy.auth.config;

//这个配置类是配置Spring-Security的,
//prePostEnabled= true表示启动权限管理功能
@EnableGlobalMethodSecurity(prePostEnabled = true)
@Configuration
public class SpringSecurityConfigurer extends WebSecurityConfigurerAdapter {

    ……
}

定义资源访问对象

package com.cy.res.controller;

@RequestMapping("/res")
@RestController
public class ResourceController {
    @PreAuthorize("hasAuthority('sys:res:view')")
    @RequestMapping("/retrieve")
    public String doRetrieve(){
        return "select resource ok";
    }
    @PreAuthorize("hasAuthority('sys:res:create')")
    @RequestMapping("/create")
    public String doCreate(){
        return "create resource";
    }
}

其中，@PreAuthorize注解描述方法时，用于告诉系统访问此方法时需要进行权限检测。需要具备指定权限才可以访问。例如：

启动服务实现访问测试

打开浏览器分别输入http://localhost:8080/res/create和http://localhost:8080/res/select进行测试分析。

总结（Summary）

本章节主要是对spring security 在springboot平台下是如何使用的。

Spring Boot Security

1. 关于Spring Boot Security

Spring Boot Security是在Spring Boot中使用的，基于Spring Security的依赖项，其本质就是Spring Security框架加上了应用于Spring Boot工程的自动配置。

Spring Security是一款主要解决了认证和授权相关处理的安全框架。

认证：验证用户的身份，例如在登录过程中验证用户名与密码是否匹配。

授权：使得用户允许访问服务器端的某些资源，或禁止访问某些资源，例如管理员可以执行一些数据删除操作，而普通用户则不可以删除关键数据。

2. 添加依赖项

提示：关于此框架的案例仍使用boot-demo。

在项目的pom.xml需要添加的依赖代码为：

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

当添加此依赖后，启动项目，在访问所有资源时，都是要求先登录的（未退出之前只需要登录1次）。

默认的用户名是user，会在启动日志中看到默认的密码，例如：

Using generated security password: 276ff4c1-32da-4e23-adad-c926f33e37c6

当登录成功后，会返回此前尝试访问的页面。

也可以在application.properties中定义用户名和密码：

spring.security.user.name=admin
spring.security.user.password=1234

当通过以上方式自定义用户名和密码后，启动项目时将不再生成临时密码，原user用户也不可用。

3. 使用数据库中的用户名和密码

3.1. 关于Bcrypt算法

Spring Security推荐使用Bcrypt算法来实现对密码原文的加密处理，在框架中有BcryptPasswordEncoder类，此类可以实现加密、判断密码是否匹配等功能。

在密码加密器（PasswordEncoder）中需要关注的方法有：

// 使用原文作为参数，将返回密文
public String encode(CharSequence rawPassword);

// 使用原文作为第1个参数，使用密文作为第2个参数，将返回是否匹配
public boolean matches(CharSequence rawPassword, String encodedPassword)

提示：Bcrypt算法对于同一个原文反复做加密处理时，每次得到的密文都是不同的，是因为在加密处理过程中使用了随机盐，所以可以得到不同的密文，同时，由于盐值被保存在密文中了，所以也是可以正常验证的。

简单的使用示例：

package cn.tedu.boot.demo;

import org.junit.jupiter.api.Test;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class BcryptTests {

    @Test
    public void testEncode() {
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String rawPassword = "1234";
        for (int i = 0; i < 10; i++) {
            String encodedPassword = passwordEncoder.encode(rawPassword);
            System.out.println("原密码=" + rawPassword + "，密文=" + encodedPassword);
        }
    }

// 原密码=1234，密文=$2a$10$lQ/BuRDZG6h1GGZLWv/Rx.TjXEJer/668SKVeoFxNs65DMKxeVAmO
// 原密码=1234，密文=$2a$10$jqB0o3.bTzdPLuWVxgfIweZKFXC9qDU15Hzf6vpUSaPifmvdQr4je
// 原密码=1234，密文=$2a$10$NJlBJLl9lp0hAA.UfsvwheborCArK58iJF96te83jbL7J4wq079H6
// 原密码=1234，密文=$2a$10$Jm6fOxg4g4mH.FZ8xXO2OOeTqHAVe6fN/6IATox0NXO1wcW3wq.Q6
// 原密码=1234，密文=$2a$10$uzmvN3IU0yx4cVSBU49jEe2de217l7u2I84NIqiSpMCF2kQefmCZe
// 原密码=1234，密文=$2a$10$EbSsOZUg7F3EMEbgXTHXxuRSbjSxOker.aTjdI1h/zz4SCRNVuDvm
// 原密码=1234，密文=$2a$10$577X/D13svsDuT9cKNSjs.M2JUeqxF7ok9uHqCBYgdqv7pqvlOEM6
// 原密码=1234，密文=$2a$10$WeuikNbKuRCkqr8JrpC75uIa6lYhJ5fuBtWGnGMpJK7MQ8EKLaICa
// 原密码=1234，密文=$2a$10$b25uEZlqDB.koP2iY.RaKueImhdVS9Aeu5fgZmDJglqtpjIXd3UN.
// 原密码=1234，密文=$2a$10$rjTE6LmSC8Z5FBm1TQpmE.OVErbLy1xpkYPlO6pP2T2BoMclr3bTu

    @Test
    public void testMatch() {
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String rawPassword = "1234";
        String[] encodedPasswords = {
                "$2a$10$WeuikNbKuRCkqr8JrpC75uIa6lYhJ5fuBtWGnGMpJK7MQ8EKLaICa",
                "$2a$10$Jm6fOxg4g4mH.FZ8xXO2OOeTqHAVe6fN/6IATox0NXO1wcW3wq.Q6",
                "$2a$10$EbSsOZUg7F3EMEbgXTHXxuRSbjSxOker.aTjdI1h/zz4SCRNVuDvm"
        };
        for (int i = 0; i < encodedPasswords.length; i++) {
            boolean result = passwordEncoder.matches(rawPassword, encodedPasswords[i]);
            System.out.println("原密码=" + rawPassword + "，密文=" + encodedPasswords[i] + "，验证结果=" + result);
        }
    }


}

为了便于后续的操作都使用了统一的密码处理机制，先在cn.tedu.boot.demo.config下创建SecurityConfiguration类，并在此类中使用@Bean方法返回BcryptPasswordEncoder对象：

@Configuration
public class SecurityConfiguration {

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

}

接下来，调整GlobalPasswordEncoder，使得该类是通过自动装配的PasswordEncoder处理加密的：

@Component
public class GlobalPasswordEncoder {

    @Autowired
    private PasswordEncoder passwordEncoder;

    /**
     * 执行加密
     *
     * @param rawPassword 明文密码（原文）
     * @return 密文密码（加密后的结果）
     */
    public String encode(String rawPassword) {
        return passwordEncoder.encode(rawPassword);
    }

}

接下来，应该在AdminServiceImpl中自动装配以上GlobalPasswordEncoder的对象，并在原加密的代码处调整为使用装配的对象来调用方法进行加密处理！最后，执行测试，并在数据表中保留至少1个有效管理员信息。

3.2. 实现：根据用户名查询管理员登录时所需的详情

为了保证在处理登录认证时能获取到必要的管理员，且不包含非必要信息，应该先梳理所需要信息，并将它们封装在自定义类，此类将作为查询的返回结果类型！

则在cn.tedu.boot.demo.vo包中先创建PermissionSimpleVO类，声明查询时涉及的权限信息中的属性：

@Data
public class PermissionSimpleVO implements Serializable {
    private Long id;
    private String name;
    private String value;
}

然后，再创建AdminLoginVO类，在类中声明必要属性：

@Data
public class AdminLoginVO implements Serializable {
    private Long id;
    private String username;
    private String password;
    private Integer isEnable;
    private List<PermissionSimpleVO> permissions;
}

在编写代码之前，仍应分析需要执行的SQL语句：

select id, username, password, is_enable from ams_admin where username=?

然后，在AdminMapper接口中添加抽象方法：

AdminLoginVO getLoginInfoByUsername(String username);

并在AdminMapper.xml中配置以上抽象方法映射的SQL语句：

<select id="getLoginInfoByUsername" resultMap="LoginResultMap">
    select 
        ams_admin.id,
        ams_admin.username,
        ams_admin.password,
        ams_admin.is_enable,

        ams_permission.id AS permission_id,
        ams_permission.name AS permission_name,
        ams_permission.value AS permission_value
    from 
        ams_admin
    left join ams_admin_role 
        on ams_admin.id=ams_admin_role.admin_id
    left join ams_role_permission 
        on ams_admin_role.role_id=ams_role_permission.role_id
    left join ams_permission 
        on ams_role_permission.permission_id=ams_permission.id
    where 
        username=#{username}
</select>

<resultMap id="LoginResultMap" type="cn.tedu.boot.demo.vo.AdminLoginVO">
    <id column="id" property="id" />
    <result column="username" property="username" />
    <result column="password" property="password" />
    <result column="is_enable" property="isEnable" />
    <collection property="permissions" ofType="cn.tedu.boot.demo.vo.PermissionSimpleVO">
        <id column="permission_id" property="id" />
        <result column="permission_name" property="name" />
        <result column="permission_value" property="value" />
    </collection>
</resultMap>

完成后，在AdminMapperTests中进行测试：

@Test
// 脚本：清空，插入
// 脚本（测试之后）：清空
public void testGetLoginInfoByUsernameSuccessfully() {
    // 测试数据
    String username = "admin001";
    // 执行测试
    AdminLoginVO admin = mapper.getLoginInfoByUsername(username);
    // 断言查询结果不为null
    Assertions.assertNotNull(admin);
}

@Test
// 脚本：清空
public void testGetLoginInfoByUsernameFailBecauseNotExist() {
    // 测试数据
    String username = "admin001";
    // 执行测试
    AdminLoginVO admin = mapper.getLoginInfoByUsername(username);
    // 断言查询结果为null
    Assertions.assertNull(admin);
}

当测试获取数据成功时，应该可以获取以下数据：

AdminLoginVO(
	id=1, 
	username=admin001, 
	password=123456, 
	isEnable=0, 
	permissions=[
		PermissionSimpleVO(id=1, name=商品-商品管理-读取, value=/pms/product/read), 
		PermissionSimpleVO(id=2, name=商品-商品管理-编辑, value=/pms/product/update), 
		PermissionSimpleVO(id=3, name=商品-商品管理-删除, value=/pms/product/delete), 
		PermissionSimpleVO(id=4, name=后台管理-管理员-读取, value=/ams/admin/read), 
		PermissionSimpleVO(id=5, name=后台管理-管理员-编辑, value=/ams/admin/update), 
		PermissionSimpleVO(id=6, name=后台管理-管理员-删除, value=/ams/admin/delete)
	])

管理员管理员与角色角色角色与权限权限

truncate ams_admin;
truncate ams_role;
truncate ams_permission;
truncate ams_admin_role;
truncate ams_role_permission;
insert into ams_admin (username, password) values ('user001', '1234');
insert into ams_role (name) values ('商品管理员'), ('积分管理员');
insert into ams_admin_role (admin_id, role_id) values (1, 1), (1, 2);
insert into ams_permission (name, value) values ('创建商品', '/product/create'), ('删除商品', '/product/delete'), ('修改库存', '/product/stock/update'), ('查看积分', '/reward-point/show'), ('扣减积分', '/reward-point/reduce'), ('查看订单', '/order/show');
insert into ams_role_permission (role_id, permission_id) values (1, 1), (1, 2), (1, 3), (2, 4), (2, 5), (1, 6), (2, 6);

select 
	ams_admin.id,
	ams_admin.username,
	ams_admin.password,
	ams_admin.is_enable,
	
	ams_permission.id,
	ams_permission.name,
	ams_permission.value
from 
	ams_admin
left join ams_admin_role 
	on ams_admin.id=ams_admin_role.admin_id
left join ams_role_permission 
	on ams_admin_role.role_id=ams_role_permission.role_id
left join ams_permission 
	on ams_role_permission.permission_id=ams_permission.id
where 
	username='user001';

3.3. 关于UserDetailsService

在Spring Security中，定义了UserDetailsService接口，此接口中有抽象方法：

UserDetails loadUserByUsername(String username);

Spring Security会在处理登录认证时自动根据尝试登录的用户名调用此接口实现类的此方法，并获得UserDetails对象，此对象应该包含用户的密码、权限等信息，接下来，Spring Security会自动判断密码正确，如果不正确，将返回错误信息，如果正确，会将此用户信息（包含权限）保存下来（默认保存在Session中）。

则在cn.tedu.boot.demo下创建security包，并在其下创建UserDetailsServiceImpl类，实现UserDetailsService接口：

package cn.tedu.boot.demo.security;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private AdminMapper adminMapper;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        AdminLoginVO admin = adminMapper.getLoginInfoByUsername(s);
        if (admin == null) {
            throw new BadCredentialsException("登录失败，用户名不存在！！！！！");
        }
        return User.builder()
                .username(admin.getUsername())
                .password(admin.getPassword())
                .disabled(admin.getIsEnable() == 0)
                .accountExpired(false)
                .accountLocked(false)
                .credentialsExpired(false)
                .authorities("权限待定")
                .build();
    }

}

完成后，Spring Boot Security会自动使用以上类来实验登录过程中的认证！所以，可以直接启动项目进行测试。

注意：在数据表中必须存在有效的管理员信息，且必须保证数据表中的密码是经过Bcrypt算法处理后的密文，且允许登录的账号的is_enable字段的值必须是1。

3.4. 关于授权

在处理认证过程中，需要向响应的UserDetails对象中转入权限数据！则将UserDetailsServiceImpl中的loadUserByUsername()方法内部调整为：

@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
    log.debug("尝试登录，用户名={}", s);
    AdminLoginVO admin = adminMapper.getLoginInfoByUsername(s);
    log.debug("根据用户名查询的结果为：{}", admin);
    if (admin == null) {
        log.debug("登录失败，用户名不存在！！！！！");
        throw new BadCredentialsException("登录失败，用户名不存在！！！！！");
    }

    // --------- 以下是处理授权的相关代码 ---------
    // 将用户的权限信息转换为Spring Security要求的List<GrantedAuthority>类型的数据
    // ----------------------------------------
    List<PermissionSimpleVO> permissions = admin.getPermissions();
    log.debug("此用户的权限信息为：{}", permissions);
    List<GrantedAuthority> authorities = new ArrayList<>();
    for (PermissionSimpleVO permission : permissions) {
        String permissionValue = permission.getValue();
        SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permissionValue);
        authorities.add(authority);
    }

    return User.builder()
            .username(admin.getUsername())
            .password(admin.getPassword())
            .disabled(admin.getIsEnable() == 0)
            .accountExpired(false)
            .accountLocked(false)
            .credentialsExpired(false)
            .authorities(authorities) // 将以上得到的用户权限信息封装到UserDetails对象中
            .build();
}

关于Spring Security的配置类：

package cn.tedu.boot.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true) // 添加此注解才可以在控制器方法上配置权限
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 提示：本方法中的配置可以一次性写完，每写一段都可以调用 and() 方法再拼接下一段配置

        // 关闭跨域
        http.csrf().disable();

        // authorizeRequests()：需要对请求进行认证和授权
        // antMatchers()：匹配某些路径，取值可以是字符串数组表示的URL，每个URL必须使用 / 作为第1个字符
        // permitAll()：许可所有（不需要认证授权即可访问），此方法之前必须是先匹配了路径的
        // anyRequest()：任何请求（除开以前已经配置的请求）
        // authenticated()：已经认证的（要求已经登录）
        String[] urls = {
                "/favicon.ico",
                "/doc.html",
                "/**/*.js",
                "/**/*.css",
                "/swagger-resources",
                "/v2/api-docs"
        };
        http.authorizeRequests()
                .antMatchers(urls).permitAll()
                .anyRequest().authenticated();

        // 当需要登录时，启用表单登录
        http.formLogin();
    }

}

当需要控制权限时，可以在控制器类中处理请求的方法上添加注解，并配置需要哪个权限值，例如：

@GetMapping("/{id:[0-9]+}")
@PreAuthorize("hasAuthority('/ams/admin/read')") // 要求权限中具有 /ams/admin/read 这一条才允许访问此资源
public JsonResult<Admin> getById(@PathVariable Long id) {
    throw new RuntimeException("此功能尚未实现");
}

提示：以上做法可适用于通过Knife4j的调试功能发出的GET请求，如果需要测试POST请求，可能会出现403错误，则应该通过浏览器的调试面板中的“网络”来观察当前的Session ID，例如JSESSIONID=07C874111475B2CD1A41E64EA268059E，然后，在Knife4j的API文档中，在“文档管理”的“全局参数设置”中添加名为Cookie的参数，值为例如JSESSIONID=07C874111475B2CD1A41E64EA268059E，参数类型为header，则通过Knife4j进行调试时，会自动携带此信息，需要注意的是，如果重新登录、服务器端重启等原因导致Session ID发生变化，在Knife4j调试之前也应该更换Knife4j中配置的Session ID。

提示：为了保证较好的演示效果，请事先准备好数据表中的数据。

当某个已经登录的用户无权限访问资源时，将响应**403（Forbidden）**错误。

第1次响应时
Set-Cookie
JSESSIONID=FDED4F9C1FA8020FA16FF7BF4D07587B

Set-Cookie
JSESSIONID=07C874111475B2CD1A41E64EA268059E

后续请求时
Cookie
JSESSIONID=FDED4F9C1FA8020FA16FF7BF4D07587B

附：关于Session

HTTP协议是一种无状态协议，同一个用户在同一台设备上多次对同一个服务器端进行访问时，默认在服务器端并不保存此用户的相关信息，所以，无论访问多少次，服务器端都无法识别用户的身份！

为了解决此问题，最简单直接的方式是使用Session（会话），当某个客户端第1次向服务器端发送请求后，服务器端会在服务器端的内存中保存此用户的信息，并且此信息会关联到一个唯一的Session ID，当服务器端进行响应时，会将此Session ID响应到客户端，后续，客户端应该在每次请求时都携带此Session ID，则服务器可以根据后续请求头中的Session ID对应到此前保存的数据，从而识别用户的身份！

关于使用Session保存的数据，通常是：

用户身份的唯一标识，例如用户的id
高频率使用的数据，例如用户的权限
- 可能存在数据不一致的风险
不便于使用其它存储技术进行处理的数据

关于Session消失的机制：

超时，如果某客户端长时间未向服务器端发起任何请求，则在服务器端上，此客户端对应的Session数据会被清除，常见的设置值是15分钟或30分钟
更换客户端（包括更换浏览器、关开浏览器），也会无法访问此前的Session数据，并且，此前的Session数据将会根据超时机制被清理
服务器端设备关机或重启
服务器端程序调用了清除Session数据的方法，例如调用了HttpSession对象的invalidate()方法

本文由 liyunfei 创作，采用知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: Aug 8,2022

SpringSecurity入门使用

SpringSecurity 应用

简介

快速入门实践

创建项目

添加项目依赖

启动服务访问测试

自定义认证逻辑

认证流程分析

定义security配置类

定义数据访问层对象

定义UserDetailService接口实现类

自定义登陆页面

启动服务进行访问测试

授权逻辑设计及实现

修改授权配置类

定义资源访问对象

启动服务实现访问测试

总结（Summary）

Spring Boot Security

1. 关于Spring Boot Security

2. 添加依赖项

3. 使用数据库中的用户名和密码

3.1. 关于Bcrypt算法

3.2. 实现：根据用户名查询管理员登录时所需的详情

3.3. 关于UserDetailsService

3.4. 关于授权

附：关于Session