端分离认证实践指南：Spring Security和JWT详解

简介

Spring Security 是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，他可 以实现强大的Web安全控制，对于安全控制，我们仅需要引入 spring-boot-starter-security 模块，进行少量的配置，即可实现强大的安全管理！

Spring Security的两个主要目标是 “认证” 和 “授权”（访问控制）。

认证: 验证当前访问系统的是不是本系统用户，并且要确认具体是哪个用户。

授权：也就是用户是否有权限进行某个操作

快速入门

1、创建一个springboot工程，并添加SpingSecurity相应依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-securityartifactId>
dependency>

2、编写一个控制器，尝试访问

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

运行程序进行访问，我们会发现浏览器会自动跳转到一个登陆的页面，也就是我们必须先要进行登陆

用户名默认为user,密码则在程序启动的时候打印在控制台上，复制下来即可进行登陆。登陆成功后即可成功访问。

认证

思路分析：我们登陆的账户和密码应该是从数据库进行校验，所以我们在用户进行登陆的时候，应该去数据库进行查询是否有这个用户，如果有对应用户信息，则用户登陆成功，反之登陆失败

具体实现：

1、创建用户表

CREATE TABLE `sys_user` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键',
  `userName` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  `nickName` VARCHAR(64) NOT NULL DEFAULT 'NUll' COMMENT '昵称',
  `password` VARCHAR(64) NOT NULL DEFAULT 'NUll' COMMENT '密码',
  `status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
  `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
  `phoneNumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
  `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别(0男，1女，2未知)',
  `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
  `userType` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型(0管理员,1普通用户)',
  `createBy` BIGINT DEFAULT NULL COMMENT '创建人的用户id',
  `createTime` DATETIME DEFAULT NULL COMMENT '创建时间',
  `updateBy` BIGINT DEFAULT NULL COMMENT '更新人',
  `updateTime` DATETIME DEFAULT NULL COMMENT '更新时间',
  `delFlag` INT DEFAULT '0' COMMENT '删除标志(0代表已删除，1代表未删除)',
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

2、引入mysql和mybatisPlus依赖

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.5.1version>
dependency>

3、编写yml文件

spring.datasource.url=jdbc:mysql://localhost:3306/springsecurity
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root

4、编写user实体类

/**
 * 用户表实体类
 * @author: QiJingJing
 * @create: 2022/3/29
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("sys_user")
public class User implements Serializable {
    /**
     * 主键
     */
    @TableId("id")
    private Long id;
    /**
     * 用户名
     */
    @TableField("userName")
    private String username;
    /**
     * 昵称
     */
    @TableField("nickName")
    private String nickName;
    /**
     * 密码
     */
    @TableField("password")
    private String password;
    /**
     * 账号状态（0 正常 1停用）
     */
    @TableField("status")
    private String status;
    /**
     * 邮箱
     */
    @TableField("email")
    private String email;
    /**
     * 手机号
     */
    @TableField("phoneNumber")
    private String phoneNumber;
    /**
     * 用户性别（0男，1女，2未知）
     */
    @TableField("sex")
    private String sex;
    /**
     * 头像
     */
    @TableField("avatar")
    private String avatar;
    /**
     * 用户类型（0管理员，1普通用户）
     */
    @TableField("userType")
    private String userType;
    /**
     * 创建人的用户id
     */
    @TableField("createBy")
    private Long createBy;
    /**
     * 创建时间
     */
    @TableField("createTime")
    private Date createTime;
    /**
     * 更新人
     */
    @TableField("updateBy")
    private Long updateBy;
    /**
     * 更新时间
     */
    @TableField("updateTime")
    private Date updateTime;
    /**
     * 删除标志（0代表未删除，1代表已删除）
     */
    @TableField("delFlag")
    private Integer delFlag;
}

5、编写mapper层代码

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

6、user表中随便添加一条数据，在测试类中测试是否可以正常查询

@SpringBootTest
class Springsecurity1ApplicationTests {
    @Autowired
    UserMapper userMapper;
    @Test
    void contextLoads() {
        userMapper.selectList(null).forEach(System.out::println);
    }
}

运行结果：

User(id=1, username=admin, nickName=随风, password=admin, status=0, [email protected], phoneNumber=17303773603, sex=0, avatar=null, userType=1, createBy=null, createTime=null, updateBy=null, updateTime=null, delFlag=0)

到这一步，说明我们的mysql相关代码没有错误。

7、定义一个UserDetailsServiceImpl类去实现UserDetailsService接口，这样我们自己写的类就可以从数据库中查询用户名和密码

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    UserMapper userMapper;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 查询用户信息
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUsername,username);
        User user = userMapper.selectOne(queryWrapper);
        // 如果没有用户，就抛出异常
        if(Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
        }
        // todo 查询用户对应的权限信息(等到权限部分进行补充)
        
        // 把数据封装为UserDetails返回
        return new UserDetailsImpl(user);;
    }
}

上面类需要返回一个UserDetails对象，我们可以创建一个它的实现类UserDetailsImpl，将User对象进行封装

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserDetailsImpl implements UserDetails {
    private User user;
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        // todo 这里权限部分后面进行补充，先返回null即可
        return null;
    }
    @Override
    public String getPassword() {
        return user.getPassword();
    }
    @Override
    public String getUsername() {
        return user.getUsername();
    }
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    @Override
    public boolean isEnabled() {
        return true;
    }
}

运行程序进行登陆测试,我们会发现，控制台爆出这样的错误

There is no PasswordEncoder mapped for the id “null”

这是因为默认使用PasswordEncoder要求的数据库中密码格式为{id}password,如果找不到id，就会显示null，一般不会采用这样方式，所以我们需要替换掉PasswordEncoder。可以使用SpringSecurity为我们提供的CryptPasswordEncoder

定义一个配置类继承WebSecurityConfigurerAdapter

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 创建BCryptPasswordEncoder 注入容器
     */
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
}

在测试类里获取你想设置的密码加密后的样子,比如我的密码是admin

@SpringBootTest
class Springsecurity1ApplicationTests {
    @Autowired
    PasswordEncoder passwordEncoder;
    @Test
    void contextLoads() {
        String admin = passwordEncoder.encode("admin");
        System.out.println(admin);
    }
}

打印结果：

$2a$10$pEluzoEZyQ7AH3Wzp9iLQeg7.Cm/ghFaiLc61bQJU90BvOS3pA6te

存储到对应数据库即可，再次进行登陆密码就是admin即可成功登陆。

8、当然我们也可以自定义登陆接口进行登陆，登陆成功可以利用jwt返回一个token给前端，并且把用户信息存储到redis里面

• 引入一些所需依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.80version>
dependency>

<dependency>
    <groupId>io.jsonwebtokengroupId>
    <artifactId>jjwtartifactId>
    <version>0.9.1version>
dependency>

• 导入一些所用的工具类

/**
 * Redis使用FastJson序列化
 * @author: QiJingJing
 * @create: 2022/3/29
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
    private Class<T> clazz;
    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }
    public FastJsonRedisSerializer(Class<T> clazz){
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
       return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0 ){
            return null;
        }
        String str  = new String(bytes,DEFAULT_CHARSET);
        return JSON.parseObject(str,clazz);
    }
    protected JavaType getJavaType(Class<?> clazz){
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

/**
 * Jwt工具类
 * @author: QiJingJing
 * @create: 2022/3/29
 */
public class JwtUtil {
    // 有效期为一个小时
    public static final Long JWT_TTL = 60*60*1000L;
    // 设置密钥明文
    public static final String JWT_KEY = "lili";
    public static String getUuid(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
    /**
     * 生成jwt
     * @param subject: token中要存放的数据(Json格式)
     * @return: java.lang.String
     **/
    public static String createJwt(String subject){
        // 设置过期时间
        JwtBuilder builder = getJwtBuilder(subject,null,getUuid());
        return builder.compact();
    }
    /**
     * 生成jwt
     * @param subject: token中要存放的数据（Json）格式
     * @param ttlMillis:token超时时间
     * @return: java.lang.String
     **/
    public static String createJwt(String subject,Long ttlMillis){
        // 设置过期时间
        JwtBuilder builder = getJwtBuilder(subject,ttlMillis,getUuid());
        return builder.compact();
    }
    private static JwtBuilder getJwtBuilder(String subject,Long ttlMillis,String uuid){
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        SecretKey secretKey = generalkey();
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if (ttlMillis == null) {
            ttlMillis = JwtUtil.JWT_TTL;
        }
        Date expDate = new Date(nowMillis + ttlMillis);
        return Jwts.builder()
                // 唯一Id
                .setId(uuid)
                // 主体，可以是JSON数据
                .setSubject(subject)
                // 签发者
                .setIssuer("ll")
                //签发时间
                .setIssuedAt(now)
                // 使用HS256对称加密算法签名，第二个参数为密钥
                .signWith(signatureAlgorithm,secretKey)
                .setExpiration(expDate);
    }
    /**
     *  创建token
     * @param id:
     * @param subject:
     * @param ttlMillis:
     * @return:
     **/
    public static String createJwt(String id,String subject, Long ttlMillis){

        return getJwtBuilder(subject,ttlMillis,id).compact();
    }

    public static void main(String[] args)throws Exception{
      
    }
    /**
     * 生成加密后的密钥 secretkey
     **/
    public static SecretKey generalkey(){
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        return new SecretKeySpec(encodedKey,0,encodedKey.length,"AES");
    }
    /**
     * 解析 jwt
     */
    public static Claims parseJwt(String jwt) throws Exception{
        SecretKey secretKey = generalkey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

/**
 * @author: QiJingJing
 * @create: 2022/3/29
 */
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {
    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本对象，Integer，String，实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本对象，Integer，String，实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     redis键
     * @param timeout 超时时间
     * @return true=设置成功； false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return ture=成功，false = 失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return Boolean.TRUE.equals(redisTemplate.expire(key, timeout, unit));
    }

    /**
     * 获得缓存的基本对象
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     */
    public long deleteObject(final Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }
    /**
     * 获得缓存的list对象
     * @param key 缓存的键值
     * @return: 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key){
        return redisTemplate.opsForList().range(key,0,-1);
    }
    /**
     * 缓存Set
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return: 缓存数据的对象
     */
    public <T>BoundSetOperations<String,T> setCacheSet(final String key, final Set<T> dataSet){
        BoundSetOperations<String,T> setOperations = redisTemplate.boundSetOps(key);
        for (T t : dataSet) {
            setOperations.add(t);
        }
        return setOperations;
    }
    /**
     * 获得缓存的set
     * @param key
     */
    public <T> Set<T> getCacheSet(final String key){
        return redisTemplate.opsForSet().members(key);
    }
    /**
     * 缓存Map
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key,final Map<String,T> dataMap){
        if (dataMap != null){
            redisTemplate.opsForHash().putAll(key,dataMap);
        }
    }
    /**
     * 获得缓存的Map
     * @param key
     * @return:
     */
    public <T> Map<String,T> getCacheMap(final String key){
        return redisTemplate.opsForHash().entries(key);
    }
    /**
     * 往Hash中存入数据
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key,String hKey,final T value){
       redisTemplate.opsForHash().put(key,hKey,value);
    }
    /**
     * 获取Hash中的数据
     * @param key redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key,final String hKey){
        HashOperations<String,String,T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key,hKey);
    }
    /**
     * 获取多个Hash中的数据
     * @param key Redis键集合
     * @param hKeys Hash键集合
     * @return: Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key,final Collection<Object> hKeys){
        return redisTemplate.opsForHash().multiGet(key,hKeys);
    }
    /**
     * 获得缓存的基本对象列表
     * @param pattern 字符串前缀
     * @return: 对象列表
     */
    public Collection<String> keys(final String pattern){
        return  redisTemplate.keys(pattern);
    }
}

/**
 *
 * @author: QiJingJing
 * @create: 2022/3/29
 */
@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings(value = {"unchecked","rawtypes"})
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

/**
 * 响应结果集
 * @author: QiJingJing
 * @create: 2022/3/29
 */
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult <T>{
    /**
     * 状态码
     */
    private Integer code;
    /**
     * 提示信息
     */
    private String msg;
    /**
     * 查询到的结果数据
     */
    private T data;

    public ResponseResult(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public ResponseResult(Integer code, T data) {
        this.code = code;
        this.data = data;
    }

    public ResponseResult(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

/**
 * @author: QiJingJing
 * @create: 2022/3/29
 */
public class WebUtils {
    /**
     * 将字符串渲染到客户端
     * @param response 渲染对象
     * @param string 待渲染的字符串
     */
    public static void renderString(HttpServletResponse response, String string){
     try{
        response.setStatus(200);
        response.setContentType("application/json");
        response.setCharacterEncoding("utf-8");
        response.getWriter().print(string);
     }catch (IOException e){
         e.printStackTrace();
     }
    }
}

自定义登陆接口需要对这个接口进行放行，也就是不用登陆也能访问这个接口，在接口中我们需要通过AuthenticationManager的authenticate方法来认证，所以需要在SecurityConfig中配置把AuthenticationManager注入容器，并且配置需要放行的接口(“/user/login”)，因此在SecurityConfig配置类中需要新添加的代码如下：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 把认证AuthenticationManager注入bean容器
     */
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
        @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                // 关闭csrf
                .csrf().disable()
                // 不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登陆接口 允许匿名访问(登陆后则不能访问)
                .antMatchers("/user/login").anonymous()
                // 登陆与否都可以访问
                //.antMatchers("/hello").permitAll()
                // 除了上面所有的请求全部需要鉴权认证
                .anyRequest().authenticated();
    }
}

编写登陆接口的service层以及Controller层

public interface LoginService {
    ResponseResult<Object> login(User user);
}

@Service
public class LoginServiceImpl implements LoginService {
    @Autowired
    RedisCache redisCache;
    @Autowired
    AuthenticationManager authenticationManager;

    @Override
    public ResponseResult<Object> login(User user) {
        // 获取认证
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword());
        Authentication authenticate = authenticationManager.authenticate(token);
        // 认证没通过给出提示
        if (Objects.isNull(authenticate)) {
            throw new RuntimeException("登陆失败");
        }

        //认证通过后，使用userId生成一个jwt，存入ResponseResult返回
        UserDetailsImpl userDetails = (UserDetailsImpl) authenticate.getPrincipal();
        String id = userDetails.getUser().getId().toString();
        String jwt = JwtUtil.createJwt(id);
        HashMap<String, String> map = new HashMap<>();
        map.put("token", jwt);
        // 把完整的信息存入redis，userId作为主键
        redisCache.setCacheObject("login"+id,userDetails);

        return new ResponseResult<>(200, "登陆成功", map);
    }
}

@RestController
public class LoginController {
    @Autowired
    private LoginService loginService;
    @PostMapping("/user/login")
    public ResponseResult<Object>login(@RequestBody User user){
        return loginService.login(user);
    }
}

PostMan进行登陆测试

恭喜你，登陆成功

温馨提示：记得打开redis哦，不然会报错，因为我用到了redis

8、过滤器

我们登陆成功，就可以在登陆状态随意访问其他接口了，只需要验证请求头中的token是否合法，是否在redis里面有数据即可

下面开始编写filter

/**
 * @author: QiJingJing
 * @create: 2022/4/5
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    @Autowired
    private RedisCache redisCache;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 获取token
        String token = request.getHeader("token");
        if(!StringUtils.hasText(token)){
            // 如果没有token则进行放行
            filterChain.doFilter(request,response);
            return;
        }
            // 解析token
            String userId;
            try {
                Claims claims = JwtUtil.parseJwt(token);
                userId = claims.getSubject();
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("token非法");
            }
            // 从redis中获取用户信息
        UserDetailsImpl userDetails = redisCache.getCacheObject("login" + userId);
            if(Objects.isNull(userDetails)){
                throw new RuntimeException("用户未登录");
            }
            // 存入SecurityContextHolder
            //  获取权限信息，封装到Authentication
            SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(userDetails,null,userDetails.getAuthorities()));
        // 放行
        filterChain.doFilter(request,response);
    }
}

然后把过滤器添加到配置类SecurityConfig里面，继续添加以下代码

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 添加过滤器
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

这个时候我们可以携带token信息访问hello接口，成功访问到信息

9、退出登陆（redis里面删除用户数据即可），对应的LoginController，LoginService、LoginServiceImpl中添加以下代码

@RestController
public class LoginController {
    @RequestMapping("user/logout")
    public ResponseResult logout(){
        return loginService.logout();
    }
}

public interface LoginService {
    ResponseResult logout();
}

@Service
public class LoginServiceImpl implements LoginService {
    @Override
    public ResponseResult logout() {
        // 获取SecurityContextHolder中的用户id
        UsernamePasswordAuthenticationToken authentication =(UsernamePasswordAuthenticationToken)SecurityContextHolder.getContext().getAuthentication();
        UserDetailsImpl user = (UserDetailsImpl) authentication.getPrincipal();
        Long id = user.getUser().getId();
        // 删除redis中的值
        redisCache.deleteObject("login"+id);
        return new ResponseResult<>(200,"注销成功");
    }
}

测试注销

成功注销。

授权

在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验，在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息来判断当前用户是否具有某种权限。

首先我们需要在配置类SecurityConfig上开启相关配置，添加一个注解

@EnableGlobalMethodSecurity(prePostEnabled=true)

**具体实现：**这些权限我们要从数据库里面进行获取，基于RBAC权限模型来实现。

RBAC:RBAC权限模型(Role-Based Access Control) 基于角色的权限控制。这是目前最被开发者使用也是相对易用、通用的权限模型

准备工作：创建所需的权限表、角色表、权限角色关联表、用户角色关联表

sql代码如下:

CREATE TABLE `sys_menu` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `menuName` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
  `path` varchar(200) DEFAULT NULL COMMENT '路由地址',
  `component` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '组件路径',
  `visible` char(1) DEFAULT '0' COMMENT '菜单状态(0显示1隐藏)',
  `status` char(1) DEFAULT '0' COMMENT '菜单状态(0正常 1停用)',
  `perms` varchar(100) DEFAULT NULL COMMENT '权限标识',
  `icon` varchar(100) DEFAULT '#' COMMENT '菜单图标',
  `createBy` bigint DEFAULT NULL,
  `createTime` datetime DEFAULT NULL,
  `updateBy` bigint DEFAULT NULL,
  `updateTime` datetime DEFAULT NULL,
  `delFalg` int DEFAULT '0' COMMENT '是否删除(0未删除,1已删除)',
  `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='权限表';

CREATE TABLE `sys_role` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(128) DEFAULT NULL,
  `roleKey` varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
  `status` char(1) DEFAULT '0' COMMENT '角色状态(0正常，1停用)',
  `createBy` bigint DEFAULT NULL,
  `createTime` datetime DEFAULT NULL,
  `updateBy` bigint DEFAULT NULL,
  `updateTime` datetime DEFAULT NULL,
  `delFalg` int DEFAULT '0' COMMENT '是否删除(0未删除,1已删除)',
  `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色表';

CREATE TABLE `sys_role_menu` (
  `roleId` bigint NOT NULL AUTO_INCREMENT COMMENT '角色ID',
  `menuId` bigint NOT NULL DEFAULT '0' COMMENT '菜单id',
  PRIMARY KEY (`roleId`,`menuId`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色菜单关联表';

CREATE TABLE `sys_user_role` (
  `userId` bigint NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `roleId` bigint NOT NULL DEFAULT '0' COMMENT '角色id',
  PRIMARY KEY (`userId`,`roleId`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='用户角色关联表';

表中自行添加数据信息：

我们的perms字段就是存储的权限信息字符串,只需要根据用户id把perms查询出来就可以。

编写Menu实体类:

@AllArgsConstructor
@NoArgsConstructor
@Data
@TableName("sys_menu")
public class Menu {
    @TableId
    private Long id;
    @TableField("menuName")
    private String menuName;
    @TableField("path")
    private String path;
    @TableField("component")
    private String component;
    @TableField("visible")
    private String visible;
    @TableField("status")
    private String status;
    @TableField("icon")
    private String icon;
    @TableField("createBy")
    private Long createBy;
    @TableField("createTime")
    private Date createTime;
    @TableField("updateBy")
    private Long updateBy;
    @TableField("updateTime")
    private Date updateTime;
    @TableField("delFlg")
    private int delFlg;
    @TableField("remark")
    private String remark;
}

编写MenuMapper

@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
    List<String> selectPermsByUserId(@Param("userId") Long userId);
}

编写MenuMapper.xml文件(resources/mapper/)目录下面

DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.lili.mapper.MenuMapper">
    <select id="selectPermsByUserId" resultType="String">
        SELECT DISTINCT sm.`perms`
        FROM sys_user_role sur
                 LEFT JOIN `sys_role` sr
                           ON sur.`roleId` = sr.`id`
                 LEFT JOIN `sys_role_menu` srm
                           ON srm.`roleId` = sr.`id`
                 LEFT JOIN `sys_menu` sm
                           ON sm.`id` = srm.`menuId`
        WHERE userId = #{userId}
          AND sr.`status` = 0
          AND sm.`status` = 0

    select>
mapper>

先在测试类测试是否可以正确查询到权限

@SpringBootTest
class Springsecurity1ApplicationTests {
    @Autowired
    MenuMapper menuMapper;
    @Test
    void contextLoads() {
        menuMapper.selectPermsByUserId(1L).forEach(System.out::println);
    }
}

结果：

system:dept:list
system:text:list

到这一步，我们的sql代码就编写完成了，继续其他工作。

在UserDetailsServiceImpl代码里面完成我们前面没有完成的查询用户权限的代码,补充之后完整代码如下：

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    UserMapper userMapper;
    @Autowired
    MenuMapper menuMapper;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 查询用户信息
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUsername,username);
        User user = userMapper.selectOne(queryWrapper);
        // 如果没有用户，就抛出异常
        if(Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
        }
        // 查询用户对应的权限信息

        List<String> permissions = menuMapper.selectPermsByUserId(user.getId());
        // 把数据封装为UserDetails返回
        return new UserDetailsImpl(user,permissions);
    }
}

并且要把权限信息封装到UserDetailsImpl对象中，所以完整UserDetailImpl代码如下

@Data
@NoArgsConstructor
public class UserDetailsImpl implements UserDetails {
    private User user;
    private List<String> permissions;
    /**
     * 不进行序列化
     */
    @JSONField(serialize = false)
    private List<GrantedAuthority> authorities;
    public UserDetailsImpl(User user,List<String> permissions){
        this.user = user;
        this.permissions = permissions;
    }
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if(authorities != null){
            return authorities;
        }
        return permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUsername();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

给我们需要的接口信息加上对应需要的权限

@RestController
public class HelloController {
   @PreAuthorize("hasAuthority('system:dept:list')")
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

运行测试：首先正常登陆用户，然后携带token去访问/hello接口

如果登陆成功，会将用户认证和权限信息存入redis，我们在获取redis里面数据的地方打个断点(JwtAuthenticationTokenFilter类里面)，看是否可以获取到权限信息

首先进行登陆

然后携带这个token，去访问hello接口

我们可以看到，reids里面有这个权限信息。放行即可

成功访问以上接口，我们可以继续测试一个没有对应权限的，比如id为2的用户，首先进行登陆

携带token进行访问：

可以看到这个用户的权限只有system:text:list,没有system:dept:list自然不能成功访问，我们放行即可

自然也就访问不了对应的数据了。

统一异常处理

在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到，在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。

如果是认证过程中出现的异常会被封装成AuthenticationException调用AuthenticationEntryPoint对象的方法去进行异常处理。

如果是授权过程出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法进行异常处理。

所以如果我们需要自定义异常处理，我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity即可

认证异常实现类

@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(),"用户认证失败,请重新登陆");
        String s = JSON.toJSONString(result);
        // 处理异常
        WebUtils.renderString(response,s);
    }
}

授权异常实现类

@Component
public class AccessDeniedHandlerImpl implements org.springframework.security.web.access.AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "你的权限不足");
        String s = JSON.toJSONString(result);
        WebUtils.renderString(response,s);
    }
}

配置给SpringSecurity配置类,原有代码进行添加以下代码

@EnableGlobalMethodSecurity(prePostEnabled=true)
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    AccessDeniedHandlerImpl accessDeniedHandler;
    @Autowired
    AuthenticationEntryPointImpl authenticationEntryPoint;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 配置异常处理器
        http.exceptionHandling()
                //认证失败过滤器
                .authenticationEntryPoint(authenticationEntryPoint).accessDeniedHandler(accessDeniedHandler);
    }
}

测试登陆失败

测试授权失败（例如id为2没有访问hello接口的权限）

跨域

浏览器出于安全考虑，使用XMLHttpRequest对象发起HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的，同源策略要求源相同才能正常通信，即协议、域名、端口号都完全一致。

前后端分离项目肯定会存在跨域请求的问题。所以需要进行配置处理

编写一个配置类

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        // 设置允许跨域的路径
        registry.addMapping("/**")
                // 设置允许跨域请求的域名
                .allowedOriginPatterns("*")
                // 是否允许cookie
                .allowCredentials(true)
                // 摄制允许的请求方式
                .allowedMethods("GET","POST","DELETE","PUT")
                // 设置允许的header属性
                .allowedHeaders("*")
                // 跨域访问时间
                .maxAge(3600);
    }
}

在SpringSecurity配置类开启跨域访问

原有代码继续添加以下配置

@EnableGlobalMethodSecurity(prePostEnabled=true)
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 允许跨域
        http.cors();
    }
}