SpringBoot java SpringSecurity框架【详解】

SpringSecurity

来源视频

文章目录

SpringSecurity1、概述2、Spring Security、Apache Shiro 选择问题2.1、Shiro2.1.1、shiro的优点2.1.2、shiro的缺点

2.2、Spring Security2.2.1、spring-security的优点

3、快速入门3.1、装备工作

4、认证4.1、登录流程校验4.2、入门案例的原理4.3、正式开始4.3.1 准备工作4.3.2、实现4.3.3、核心代码实现4.3.3.1、密码加密存储4.3.3.2、登陆接口4.3.3.3、认证过滤器4.3.3.4、退出登陆

5、授权5.1、权限的作用5.2、授权基本流程5.3、授权实现5.3.1、限制访问资源所需权限5.3.2、封装权限信息5.3.3 从数据库查询权限信息5.3.3.1 RBAC权限模型5.3.3.2 准备工作5.3.3.3、代码实现

6、自定义失败处理6.1、自定义实现类6.2、配置给SpringSecurity

7、 跨域8、自定义权限校验方法9、CSRF10、认证处理器10.1、认证成功处理器10.2、认证失败处理器10.3、注销成功处理器

彩蛋：

1、概述

​ Spring Security是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富；

​ Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的实际标准；

​ Spring Security是一个框架，致力于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring Security的真正强大之处在于可以轻松扩展以满足自定义要求。

​ 在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。

我们先来学习下 Spring Security 。其官方对自己介绍如下：

Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications.

​ Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是保护基于Spring的应用程序的事实标准。

Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Like all Spring projects, the real power of Spring Security is found in how easily it can be extended to meet custom requirementsSpring

​

​ Security是一个专注于为Java应用程序提供身份验证和授权的框架。与所有Spring项目一样，Spring Security的真正威力在于它可以多么容易地扩展以满足定制需求

一般Web应用的需要进行认证和授权。

​ 认证（Authentication）：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户

​ 授权（Authorization）：经过认证后判断当前用户是否有权限进行某个操作

​ 而认证和授权就是SpringSecurity作为安全框架的核心功能。

2、Spring Security、Apache Shiro 选择问题

2.1、Shiro

​ 首先Shiro较之 Spring Security，Shiro在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势。

Shiro是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点：

易于理解的 Java Security API； 简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）； 对角色的简单的签权（访问控制），支持细粒度的签权； 支持一级缓存，以提升应用程序的性能； 内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境； 异构客户端会话访问； 非常简单的加密 API； 不跟任何的框架或者容器捆绑，可以独立运行。 Shiro四大核心功能:Authentication,Authorization,Cryptography,Session Management

四大核心功能介绍：

Authentication：身份认证/登录，验证用户是不是拥有相应的身份；Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Shiro架构

Shiro三个核心组件：Subject, SecurityManager 和 Realms.

Subject：主体，可以看到主体可以是任何可以与应用交互的 用户；SecurityManager：相当于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的 FilterDispatcher；是 Shiro 的心脏；所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

2.1.1、shiro的优点

shiro的代码更易于阅读，且使用更加简单；shiro可以用于非web环境，不跟任何框架或容器绑定，独立运行；

2.1.2、shiro的缺点

授权第三方登录需要手动实现；

2.2、Spring Security

​ 除了不能脱离Spring，shiro的功能它都有。而且Spring Security对Oauth、OpenID也有支持,Shiro则需要自己手动实现。Spring Security的权限细粒度更高,毕竟Spring Security是Spring家族的。

Spring Security一般流程为：

当用户登录时，前端将用户输入的用户名、密码信息传输到后台，后台用一个类对象将其封装起来，通常使用的是UsernamePasswordAuthenticationToken这个类。程序负责验证这个类对象。验证方法是调用Service根据username从数据库中取用户信息到实体类的实例中，比较两者的密码，如果密码正确就成功登陆，同时把包含着用户的用户名、密码、所具有的权限等信息的类对象放到SecurityContextHolder（安全上下文容器，类似Session）中去。用户访问一个资源的时候，首先判断是否是受限资源。如果是的话还要判断当前是否未登录，没有的话就跳到登录页面。如果用户已经登录，访问一个受限资源的时候，程序要根据url去数据库中取出该资源所对应的所有可以访问的角色，然后拿着当前用户的所有角色一一对比，判断用户是否可以访问（这里就是和权限相关）。

2.2.1、spring-security的优点

spring-security对spring整合较好，使用起来更加方便；有更强大的spring社区进行支持；支持第三方的 oauth 授权，官方网站：spring-security-oauth

3、快速入门

3.1、装备工作

​ 我们先创建一个空项目

在项目中创建一个普通的maven项目

将该普通的maven改为SpringBoot工程

1、添加依赖

org.springframework.boot

spring-boot-starter-parent

2.6.4

org.springframework.boot

spring-boot-starter-web

org.projectlombok

lombok

2、创建启动类

@SpringBootApplication

public class IntroductionSpringSecurity {

public static void main(String[] args) {

SpringApplication.run(IntroductionSpringSecurity.class,args);

}

}

3、创建Controller

@RestController

public class HelloController {

@RequestMapping("/hello")

public String hello(){

return "World Hello";

}

}

测试访问：

4、导入SpringSecurity依赖

org.springframework.boot

spring-boot-starter-security

重新启动测试：

这时我们可以看到当我们访问我们的接口的时候，就会自动跳转到一个SpringSecurity的默认登陆页面

这时候需要我们登录才可以进行访问，我们可以看到控制台有一串字符串，其实那就是SpringSecurity初始化生成给我的密码

默认用户名：user

输入用户名和密码，再次登录

成功。

4、认证

4.1、登录流程校验

4.2、入门案例的原理

前后端认证流程：

UsernamePasswordAuthenticationFilter：是我们最常用的用户名和密码认证方式的主要处理类,构造了一个UsernamePasswordAuthenticationToken对象实现类，将用请求信息封装为Authentication Authentication接口: 封装了用户相关信息。 AuthenticationManager接口：定义了认证Authentication的方法，是认证相关的核心接口，也是发起认证的出发点，因为在实际需求中，我们可能会允许用户使用用户名+密码登录，同时允许用户使用邮箱+密码，手机号码+密码登录，甚至，可能允许用户使用指纹登录（还有这样的操作？没想到吧），所以说AuthenticationManager一般不直接认证，AuthenticationManager接口的常用实现类ProviderManager 内部会维护一个List列表，存放多种认证方式，实际上这是委托者模式的应用（Delegate）。也就是说，核心的认证入口始终只有一个：AuthenticationManager AuthenticationManager，ProviderManager ，AuthenticationProvider… 用户名+密码（UsernamePasswordAuthenticationToken），邮箱+密码，手机号码+密码登录则对应了三个AuthenticationProvider DaoAuthenticationProvider:用于解析并认证 UsernamePasswordAuthenticationToken 的这样一个认证服务提供者,对应以上的几种登录方式。 UserDetailsService接口：Spring Security 会将前端填写的username 传给 UserDetailService.loadByUserName方法。我们只需要从数据库中根据用户名查找到用户信息然后封装为UserDetails的实现类返回给SpringSecurity 即可，自己不需要进行密码的比对工作，密码比对交由SpringSecurity处理。 UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。

UsernamePasswordAuthenticationFilter：是我们最常用的用户名和密码认证方式的主要处理类,构造了一个UsernamePasswordAuthenticationToken对象实现类，将用请求信息封装为Authentication

BasicAuthenticationFilter...:将UsernamePasswordAuthenticationFilter的实现类UsernamePasswordAuthenticationToken封装成的 Authentication进行登录逻辑处理

AuthenticationManager

AuthenticationProvider

…

UsernamePasswordAuthenticationToken（Authentication的一个实现）对象,其实就是一个Authentication的实现，他封装了我们需要的认证信息。之后会调用AuthenticationManager。这个类其实并不会去验证我们的信息，信息验证的逻辑都是在AuthenticationProvider里面，而Manager的作用则是去管理Provider，管理的方式是通过for循环去遍历（因为不同的登录逻辑是不一样的，比如表单登录、第三方登录（qq登录，邮箱登录…）。换句话说 不同的Provider支持的是不同的Authentication）。在AuthenticationManager调用DaoAuthenticationProvider。而DaoAuthenticationProvider继承了AbstractUserDetailsAuthenticationProvider ，从而也就获得了其中的authenticate方法去进行验证。

[]: https://zhuanlan.zhihu.com/p/201029977

ExceptionTranslationFilter：主要用于处理AuthenticationException（认证）和AccessDeniedException（授权）的异常

FilterSecurityInterceptor:获取当前 request 对应的权限配置**，**调用访问控制器进行鉴权操作

4.3、正式开始

登录：

​ 1.自定义登录接口

​ 调用ProviderManager的方法进行认证 如果认证通过生成jwt

​ 把用户信息存入redis中

​ 2.自定义UserDetailsService

​ 在这个实现类中去查询数据库

校验：

​ 1.定义Jwt认证过滤器

​ 获取token

​ 解析token获取其中的userid

​ 从redis中获取用户信息

​ 存入SecurityContextHolder

4.3.1 准备工作

重新建立一个新的普通maven项目

1.添加依赖

org.springframework.boot

spring-boot-starter-parent

2.6.4

org.springframework.boot

spring-boot-starter-data-redis

com.alibaba

fastjson

1.2.79

io.jsonwebtoken

jjwt

0.9.1

mysql

mysql-connector-java

org.springframework.boot

spring-boot-starter-web

org.projectlombok

lombok

org.springframework.boot

spring-boot-starter-security

com.baomidou

mybatis-plus-boot-starter

3.4.3

org.springframework.boot

spring-boot-starter-test

2.在主启动类同级目录下建立utils包

添加Redis相关配置

FastJsonRedisSerializer

package com.qx.utils;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.serializer.SerializerFeature;

import com.fasterxml.jackson.databind.JavaType;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.type.TypeFactory;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.SerializationException;

import com.alibaba.fastjson.parser.ParserConfig;

import org.springframework.util.Assert;

import java.nio.charset.Charset;

/**

* Redis使用FastJson序列化

*/

public class FastJsonRedisSerializer implements RedisSerializer

{

public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

private Class clazz;

static

{

ParserConfig.getGlobalInstance().setAutoTypeSupport(true);

}

public FastJsonRedisSerializer(Class 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);

}

}

3.在主启动类同级目录下建立config包

RedisConfig

package com.qx.config;

import com.qx.utils.FastJsonRedisSerializer;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration

public class RedisConfig {

@Bean

@SuppressWarnings(value = { "unchecked", "rawtypes" })

public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory)

{

RedisTemplate 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;

}

}

4.在主启动类同级目录下建立controller包

响应类ResponseResult

package com.qx.domain;

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)

public class ResponseResult {

/**

* 状态码

*/

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 Integer getCode() {

return code;

}

public void setCode(Integer code) {

this.code = code;

}

public String getMsg() {

return msg;

}

public void setMsg(String msg) {

this.msg = msg;

}

public T getData() {

return data;

}

public void setData(T data) {

this.data = data;

}

public ResponseResult(Integer code, String msg, T data) {

this.code = code;

this.msg = msg;

this.data = data;

}

}

5.将工具类置于utils包

JwtUtil

package com.qx.utils;

import io.jsonwebtoken.Claims;

import io.jsonwebtoken.JwtBuilder;

import io.jsonwebtoken.Jwts;

import io.jsonwebtoken.SignatureAlgorithm;

import javax.crypto.SecretKey;

import javax.crypto.spec.SecretKeySpec;

import java.util.Base64;

import java.util.Date;

import java.util.UUID;

/**

* JWT工具类

*/

public class JwtUtil {

//有效期为

public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000 一个小时

//设置秘钥明文

public static final String JWT_KEY = "qx";

public static String getUUID(){

String token = UUID.randomUUID().toString().replaceAll("-", "");

return token;

}

/**

* 生成jtw jwt加密

* @param subject token中要存放的数据（json格式）

* @return

*/

public static String createJWT(String subject) {

JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间

return builder.compact();

}

/**

* 生成jtw jwt加密

* @param subject token中要存放的数据（json格式）

* @param ttlMillis token超时时间

* @return

*/

public static String createJWT(String subject, Long ttlMillis) {

JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间

return builder.compact();

}

/**

* 创建token jwt加密

* @param id

* @param subject

* @param ttlMillis

* @return

*/

public static String createJWT(String id, String subject, Long ttlMillis) {

JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间

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;

}

long expMillis = nowMillis + ttlMillis;

Date expDate = new Date(expMillis);

return Jwts.builder()

.setId(uuid) //唯一的ID

.setSubject(subject) // 主题 可以是JSON数据

.setIssuer("sg") // 签发者

.setIssuedAt(now) // 签发时间

.signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥

.setExpiration(expDate);

}

public static void main(String[] args) throws Exception {

//jwt加密

String jwt = createJWT("123456");

//jwt解密

Claims claims = parseJWT(jwt);

String subject = claims.getSubject();

System.out.println(subject);

System.out.println(jwt);

}

/**

* 生成加密后的秘钥 secretKey

* @return

*/

public static SecretKey generalKey() {

byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);

SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");

return key;

}

/**

* jwt解密

*

* @param jwt

* @return

* @throws Exception

*/

public static Claims parseJWT(String jwt) throws Exception {

SecretKey secretKey = generalKey();

return Jwts.parser()

.setSigningKey(secretKey)

.parseClaimsJws(jwt)

.getBody();

}

}

RedisCache

package com.qx.utils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.BoundSetOperations;

import org.springframework.data.redis.core.HashOperations;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.ValueOperations;

import org.springframework.stereotype.Component;

import java.util.*;

import java.util.concurrent.TimeUnit;

@SuppressWarnings(value = { "unchecked", "rawtypes" })

@Component

public class RedisCache

{

@Autowired

public RedisTemplate redisTemplate;

/**

* 缓存基本的对象，Integer、String、实体类等

*

* @param key 缓存的键值

* @param value 缓存的值

*/

public void setCacheObject(final String key, final T value)

{

redisTemplate.opsForValue().set(key, value);

}

/**

* 缓存基本的对象，Integer、String、实体类等

*

* @param key 缓存的键值

* @param value 缓存的值

* @param timeout 时间

* @param timeUnit 时间颗粒度

*/

public 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 true=设置成功；false=设置失败

*/

public boolean expire(final String key, final long timeout, final TimeUnit unit)

{

return redisTemplate.expire(key, timeout, unit);

}

/**

* 获得缓存的基本对象。

*

* @param key 缓存键值

* @return 缓存键值对应的数据

*/

public T getCacheObject(final String key)

{

ValueOperations operation = redisTemplate.opsForValue();

return operation.get(key);

}

/**

* 删除单个对象

*

* @param key

*/

public boolean deleteObject(final String key)

{

return redisTemplate.delete(key);

}

/**

* 删除集合对象

*

* @param collection 多个对象

* @return

*/

public long deleteObject(final Collection collection)

{

return redisTemplate.delete(collection);

}

/**

* 缓存List数据

*

* @param key 缓存的键值

* @param dataList 待缓存的List数据

* @return 缓存的对象

*/

public long setCacheList(final String key, final List dataList)

{

Long count = redisTemplate.opsForList().rightPushAll(key, dataList);

return count == null ? 0 : count;

}

/**

* 获得缓存的list对象

*

* @param key 缓存的键值

* @return 缓存键值对应的数据

*/

public List getCacheList(final String key)

{

return redisTemplate.opsForList().range(key, 0, -1);

}

/**

* 缓存Set

*

* @param key 缓存键值

* @param dataSet 缓存的数据

* @return 缓存数据的对象

*/

public BoundSetOperations setCacheSet(final String key, final Set dataSet)

{

BoundSetOperations setOperation = redisTemplate.boundSetOps(key);

Iterator it = dataSet.iterator();

while (it.hasNext())

{

setOperation.add(it.next());

}

return setOperation;

}

/**

* 获得缓存的set

*

* @param key

* @return

*/

public Set getCacheSet(final String key)

{

return redisTemplate.opsForSet().members(key);

}

/**

* 缓存Map

*

* @param key

* @param dataMap

*/

public void setCacheMap(final String key, final Map dataMap)

{

if (dataMap != null) {

redisTemplate.opsForHash().putAll(key, dataMap);

}

}

/**

* 获得缓存的Map

*

* @param key

* @return

*/

public Map getCacheMap(final String key)

{

return redisTemplate.opsForHash().entries(key);

}

/**

* 往Hash中存入数据

*

* @param key Redis键

* @param hKey Hash键

* @param value 值

*/

public void setCacheMapValue(final String key, final String hKey, final T value)

{

redisTemplate.opsForHash().put(key, hKey, value);

}

/**

* 获取Hash中的数据

*

* @param key Redis键

* @param hKey Hash键

* @return Hash中的对象

*/

public T getCacheMapValue(final String key, final String hKey)

{

HashOperations opsForHash = redisTemplate.opsForHash();

return opsForHash.get(key, hKey);

}

/**

* 删除Hash中的数据

*

* @param key

* @param hkey

*/

public void delCacheMapValue(final String key, final String hkey)

{

HashOperations hashOperations = redisTemplate.opsForHash();

hashOperations.delete(key, hkey);

}

/**

* 获取多个Hash中的数据

*

* @param key Redis键

* @param hKeys Hash键集合

* @return Hash对象集合

*/

public List getMultiCacheMapValue(final String key, final Collection