代码拉取完成，页面将自动刷新
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security正是Spring家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。
正如你可能知道的关于安全方面的两个主要区域是“ 认证 ”和“ 授权 ”（或者访问控 制），一般来说，Web 应用的安全性包括 用户认证（Authentication）和用户授权 （Authorization） 两个部分，这两点也是Spring Security重要核心功能。
（ 1 ）用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问 该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认 证过程。 通俗点说就是系统认为用户是否能登录
（ 2 ）用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统中，不同用户 所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以 进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的 权限。 通俗点讲就是系统判断用户是否有权限去做某些事情。
“Spring Security开始于 2003 年年底,““spring的acegi安全系统”。 起因是Spring 开发者邮件列表中的一个问题,有人提问是否考虑提供一个基于spring的安全实现。
Spring Security 以“The Acegi Secutity System for Spring” 的名字始于 2013 年晚些 时候。一个问题提交到Spring 开发者的邮件列表，询问是否已经有考虑一个机遇Spring 的安全性社区实现。那时候Spring 的社区相对较小（相对现在）。实际上Spring自己在 2013 年只是一个存在于ScourseForge的项目，这个问题的回答是一个值得研究的领 域，虽然目前时间的缺乏组织了我们对它的探索。
考虑到这一点，一个简单的安全实现建成但是并没有发布。几周后，Spring社区的其他成 员询问了安全性，这次这个代码被发送给他们。其他几个请求也跟随而来。到 2014 年一 月大约有 20 万人使用了这个代码。这些创业者的人提出一个SourceForge项目加入是为 了，这是在 2004 三月正式成立。
和Acegi安全性。而不是专注于授权。开始的时候这很适合，但是越来越多的用户请求额 外的容器支持。容器特定的认证领域接口的基本限制变得清晰。还有一个相关的问题增加 新的容器的路径，这是最终用户的困惑和错误配置的常见问题。
Acegi安全特定的认证服务介绍。大约一年后，Acegi安全正式成为了Spring框架的子项 目。1.0.0最终版本是出版于 2006 - 在超过两年半的大量生产的软件项目和数以百计的改 进和积极利用社区的贡献。
Acegi安全 2007 年底正式成为了Spring组合项目，更名为"Spring Security"。
1.3.1 Spring Security
Spring技术栈的组成部分。
https://spring.io/projects/spring-security
SpringSecurity特点：
⚫ 和Spring无缝整合。
⚫ 全面的权限控制。
⚫ 专门为Web开发而设计。
◼ 旧版本不能脱离Web环境使用。
◼ 新版本对整个框架进行了分层抽取，分成了核心模块和Web模块。单独
引入核心模块就可以脱离Web环境。
⚫ 重量级。
1.3.2 Shiro
Apache旗下的轻量级权限控制框架。
⚫ 轻量级。Shiro主张的理念是把复杂的事情变简单。针对对性能有更高要求
的互联网应用有更好表现。
⚫ 通用性。
◼ 好处：不局限于Web环境，可以脱离Web环境使用。
◼ 缺陷：在Web环境下一些特定的需求需要手动编写代码定制。
Spring Security 是 Spring 家族中的一个安全管理框架，实际上，在 Spring Boot 出现之 前，Spring Security 就已经发展了多年了，但是使用的并不多，安全管理这个领域，一直 是 Shiro 的天下。
相对于 Shiro，在 SSM 中整合 Spring Security 都是比较麻烦的操作，所以，Spring Security 虽然功能比 Shiro 强大，但是使用反而没有 Shiro 多（Shiro 虽然功能没有 Spring Security 多，但是对于大部分项目而言，Shiro 也够用了）。
自从有了 Spring Boot 之后，Spring Boot 对于 Spring Security 提供了自动化配置方 案，可以使用更少的配置来使用 Spring Security。
因此，一般来说，常见的安全管理技术栈的组合是这样的：
@Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override protected void configure(HttpSecurity http) throws Exception { http.formLogin() // 表单登录 .and() .authorizeRequests() // 认证配置 .anyRequest() // 任何请求 .authenticated(); // 都需要身份验证 } }
访问localhost:
默认的用户名：user
密码在项目启动的时候在控制台会打印， 注意每次启动的时候密码都回发生变化！
英文单词：principal
使用系统的用户或设备或从其他系统远程登录的用户等等。简单说就是谁使用系
统谁就是主体。
2.3.2认证
英文单词：authentication
权限管理系统确认一个主体的身份，允许主体进入系统。简单说就是“主体”证
明自己是谁。
笼统的认为就是以前所做的登录操作。
2.3.3授权
英文单词：authorization
将操作系统的“权力”“授予”“主体”，这样主体就具备了操作系统中特定功
能的能力。
所以简单来说，授权就是给用户分配权限。
package com.atguigu.controller;
@Controller public class IndexController {
@GetMapping( "index" ) @ResponseBody public String index(){ return "success" ; } }
SpringSecurity 本质是一个过滤器链：
从启动是可以获取到过滤器链：
org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFil ter
org.springframework.security.web.context.SecurityContextPersistenceFilter
org.springframework.security.web.header.HeaderWriterFilter
org.springframework.security.web.csrf.CsrfFilter
org.springframework.security.web.authentication.logout.LogoutFilter
org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter
org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter
org.springframework.security.web.savedrequest.RequestCacheAwareFilter
org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter
org.springframework.security.web.authentication.AnonymousAuthenticationFilter
org.springframework.security.web.session.SessionManagementFilter
org.springframework.security.web.access.ExceptionTranslationFilter
org.springframework.security.web.access.intercept.FilterSecurityInterceptor
FilterSecurityInterceptor：是一个方法级的权限过滤器, 基本位于过滤链的最底部。
super.beforeInvocation(fi) 表示查看之前的filter 是否通过。
fi.getChain().doFilter(fi.getRequest(), fi.getResponse());表示真正的调用后台的服务。
ExceptionTranslationFilter：是个异常过滤器，用来处理在认证授权过程中抛出的异常
UsernamePasswordAuthenticationFilter ：对/login的POST请求做拦截，校验表单中用户 名，密码。
当什么也没有配置的时候，账号和密码是由Spring Security定义生成的。而在实际项目中 账号和密码都是从数据库中查询出来的。 所以我们要通过自定义逻辑控制认证逻辑。
如果需要自定义逻辑时，只需要实现UserDetailsService接口即可。接口定义如下：
⚫ 返回值UserDetails
Collection<? extends GrantedAuthority> getAuthorities();
// 表示获取密码
String getPassword();
// 表示获取用户名
String getUsername();
// 表示判断账户是否过期
boolean isAccountNonExpired();
// 表示判断账户是否被锁定
boolean isAccountNonLocked();
// 表示凭证{密码}是否过期
boolean isCredentialsNonExpired();
// 表示当前用户是否可用
boolean isEnabled();
以下是UserDetails实现类
以后我们只需要使用User 这个实体类即可！
⚫ 方法参数 username
表示用户名。此值是客户端表单传递过来的数据。默认情况下必须叫username，否则无 法接收。
String encode(CharSequence rawPassword);
// 表示验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹 配，则返回true；如果不匹配，则返回false。第一个参数表示需要被解析的密码。第二个 参数表示存储的密码。
boolean matches(CharSequence rawPassword, String encodedPassword);
// 表示如果解析的密码能够再次进行解析且达到更安全的结果则返回 true，否则返回 false。默认返回false。
default boolean upgradeEncoding(String encodedPassword) { return false ; }
BCryptPasswordEncoder是Spring Security官方推荐的密码解析器，平时多使用这个解析 器。
BCryptPasswordEncoder是对bcrypt强散列方法的具体实现。是基于Hash算法实现的单 向加密。可以通过strength控制加密强度，默认10.
@Test public void test01(){ // 创建密码解析器 BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder(); // 对密码进行加密 String atguigu = bCryptPasswordEncoder.encode( "atguigu" ); // 打印加密之后的数据 System. out .println( " 加密之后数据： \t" +atguigu);
// 判断原字符加密后和加密之前是否匹配 boolean result = bCryptPasswordEncoder.matches( "atguigu" , atguigu); // 打印比较结果 System. out .println( " 比较结果： \t" +result); }
https://docs.spring.io/spring- security/site/docs/5.3.4.RELEASE/reference/html5/#servlet-hello
方式一：在application.properties
spring.security.user.name = atguigu spring.security.user.password = atguigu
package com.atguigu.config;
@Configuration public class SecurityConfig { // 注入 PasswordEncoder 类到 spring 容器中 @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); } }
package com.atguigu.service;
@Service public class LoginService implements UserDetailsService {
@Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { // 判断用户名是否存在 if (! "admin" .equals(username)){ throw new UsernameNotFoundException( " 用户名不存在！ " );
// 从数据库中获取的密码 atguigu 的密文
String pwd = "$2a$10$2R/M6iU3mCZt3ByG7kwYTeeW0w7/UqdeXrb27zkBIizBvAven0/na" ;
// 第三个参数表示权限 return new User(username,pwd, AuthorityUtils. commaSeparatedStringToAuthorityList ( "admin," )); } }
3.2.1 准备sql
create table users(
id bigint primary key auto_increment,
username varchar(20) unique not null,
password varchar(100)
);
-- 密码atguigu
insert into users values(1,'张
san','$2a$10$2R/M6iU3mCZt3ByG7kwYTeeW0w7/UqdeXrb27zkBIizBvAven0/na');
-- 密码atguigu
insert into users values(2,'李
si','$2a$10$2R/M6iU3mCZt3ByG7kwYTeeW0w7/UqdeXrb27zkBIizBvAven0/na');
create table role(
id bigint primary key auto_increment,
name varchar(20)
);
insert into role values(1,'管理员');
insert into role values(2,'普通用户');
create table role_user(
uid bigint,
rid bigint
);
insert into role_user values(1,1);
insert into role_user values(2,2);
create table menu(
id bigint primary key auto_increment,
name varchar(20),
url varchar(100),
parentid bigint,
permission varchar(20)
);
insert into menu values(1,'系统管理','',0,'menu:system');
insert into menu values(2,'用户管理','',0,'menu:user');
create table role_menu(
mid bigint,
rid bigint
);
insert into role_menu values(1,1);
insert into role_menu values(2,1);
insert into role_menu values(2,2);
@Data public class Users {
private Integer id; private String username; private String password; }
3.2.4 整合MybatisPlus制作mapper
@Repository public interface UsersMapper extends BaseMapper { }
配置文件添加数据库配置 #mysql数据库连接 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/demo?serverTimezone=GMT%2B8 spring.datasource.username=root spring.datasource.password=root
3.2.5 制作登录实现类
@Service("userDetailsService") public class MyUserDetailsService implements UserDetailsService { @Autowired private UsersMapper usersMapper; @Override public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException { QueryWrapper wrapper = new QueryWrapper(); wrapper.eq("username",s); Users users = usersMapper.selectOne(wrapper); if(users == null) { throw new UsernameNotFoundException("用户名不存在！"); } System.out.println(users); List auths = AuthorityUtils.commaSeparatedStringToAuthorityList("role"); return new User(users.getUsername(), new BCryptPasswordEncoder().encode(users.getPassword()),auths); } }
< dependency > < groupId >org.springframework.boot</ groupId > < artifactId >spring-boot-starter-thymeleaf</ artifactId > </ dependency >
@Controller public class IndexController {
@GetMapping( "index" ) public String index(){ return "login" ; }
@GetMapping( "findAll" ) @ResponseBody public String findAll(){ return "findAll" ; }
@Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { // 注入 PasswordEncoder 类到 spring 容器中 @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); }
@Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers( "/layui/"** , "/index" ) // 表示配置请求路径 .permitAll() // 指定 URL 无需保护。 .anyRequest() // 其他请求 .authenticated(); // 需要认证 } }
访问localhost:8090/index
访问localhost:8090/findAll 会提示 403 错误 表示没有这个权限。
@Override protected void configure(HttpSecurity http) throws Exception { // 配置认证 http.formLogin() .loginPage( "/index" ) // 配置哪个 url 为登录页面 .loginProcessingUrl( "/login" ) // 设置哪个是登录的 url 。 .successForwardUrl( "/success" ) // 登录成功之后跳转到哪个 url .failureForwardUrl( "/fail" ); // 登录失败之后跳转到哪个 url
http.authorizeRequests() .antMatchers( "/layui/"** , "/index" ) // 表示配置请求路径 .permitAll() // 指定 URL 无需保护。 .anyRequest() // 其他请求 .authenticated(); // 需要认证 // 关闭 csrf http.csrf().disable(); }
@PostMapping( "/success" ) public String success(){ return "success" ; }
@PostMapping( "/fail" ) public String fail(){ return "fail" ;
< form action="/login"method="post" > 用户名:< input type="text"name="username" />< br /> 密码：< input type="password"name="password" />< br /> < input type="submit"value=" 提交 " /> </ form >
注意：页面提交方式必须为post 请求，所以上面的页面不能使用，用户名，密码必须为 username,password
原因：
在执行登录的时候会走一个过滤器 UsernamePasswordAuthenticationFilter
如果修改配置可以调用usernameParameter()和passwordParameter()方法。
< form action="/login"method="post" > 用户名:< input type="text"name="loginAcct" />< br /> 密码：< input type="password"name="userPswd" />< br /> < input type="submit"value=" 提交 " /> </ form >
3.4.1 hasAuthority 方法
如果当前的主体具有指定的权限，则返回 true,否则返回false
@GetMapping( "/find" ) @ResponseBody public String find(){ return "find" ; }
⚫ 给用户登录主体赋予权限
访问findAll 进入登录页面
3.4.2 hasAnyAuthority方法
true.
3.4.3 hasRole 方法
如果当前主体具有指定的角色，则返回true。
底层源码：
3.4.4 hasAnyRole
@Data public class Menu { private Long id ; private String name ; private String url ; private Long parentId ; private String permission ; }
@Data public class Role { private Long id ; private String name ; }
UserInfoMapper
/** * 根据用户 Id 查询用户角色 * @param userId * @return */ List selectRoleByUserId(Long userId);
/** * 根据用户 Id 查询菜单 * @param userId * @return */ List
selectMenuByUserId(Long userId);上述接口需要进行多表管理查询：
需要在resource/mapper目录下自定义UserInfoMapper.xml
_ < mapper namespace="com.atguigu.mapper.UserInfoMapper" >
< select id="selectRoleByUserId"resultType="com.atguigu.bean.Role" > SELECT r. id ,r. name FROM role r INNER JOIN role_user ru ON ru. rid =r. id where ru. uid =#{0} </ select > < select id="selectMenuByUserId"resultType="com.atguigu.bean.Menu" > SELECT m. id ,m. name ,m. url ,m. parentid ,m. permission FROM menu m INNER JOIN role_menu rm ON m. id =rm. mid INNER JOIN role r ON r. id =rm. rid INNER JOIN role_user ru ON r. id =ru. rid WHERE ru. uid =#{0} </ select > </ mapper >
UsersServiceImpl
在配置文件中application.yml添加
mybatis : mapper-locations : classpath:mapper/*.xml
http.exceptionHandling().accessDeniedPage( "/unauth" );
@GetMapping( "/unauth" ) public String accessDenyPage(){ return "unauth" ; }
unauth.html
< body > < h1 >对不起，您没有访问权限！</ h1 >
</ body >
3.7.1 @Secured
@EnableGlobalMethodSecurity(securedEnabled=true)
@SpringBootApplication @EnableGlobalMethodSecurity(securedEnabled= true ) public class DemosecurityApplication {
public static void main(String[] args) { SpringApplication. run (DemosecurityApplication. class , args); }
}
@RequestMapping( "testSecured" ) @ResponseBody @Secured({ "ROLE_normal" , "ROLE_admin" }) public String helloUser() { return "hello,user" ; }
@Secured({ "ROLE_normal" , "ROLE_ 管理员 " })
登录之后直接访问：http://localhost:8090/testSecured 控制器
将上述的角色改为 @Secured({ "ROLE_normal" , "ROLE_ 管理员 " })即可访问
3.7.2 @PreAuthorize
@EnableGlobalMethodSecurity(prePostEnabled = true )
@PreAuthorize：注解适合进入方法前的权限验证， @PreAuthorize可以将登录用 户的roles/permissions参数传到方法中。
@RequestMapping( "/preAuthorize" ) @ResponseBody //@PreAuthorize("hasRole('ROLE_ 管理员 ')") @PreAuthorize( "hasAnyAuthority('menu:system')" ) public String preAuthorize(){ System. out .println( "preAuthorize" ); return "preAuthorize" ; }
使用李四登录测试：
3.7.3 @PostAuthorize
@EnableGlobalMethodSecurity(prePostEnabled = true )
@PostAuthorize 注解使用并不多，在方法执行后再进行权限验证，适合验证带有返回值 的权限.
@RequestMapping( "/testPostAuthorize" ) @ResponseBody @PostAuthorize( "hasAnyAuthority('menu:system')" ) public String preAuthorize(){ System. out .println( "test--PostAuthorize" ); return "PostAuthorize" ; }
3.7.4 @PostFilter
@PostFilter ：权限验证之后对数据进行过滤 留下用户名是admin1的数据
表达式中的 filterObject 引用的是方法返回值List中的某一个元素
@RequestMapping( "getAll" ) @PreAuthorize( "hasRole('ROLE_ 管理员 ')" ) @PostFilter( "filterObject.username == 'admin1'" ) @ResponseBody public List getAllUser(){
ArrayList list = new ArrayList<>(); list.add( new UserInfo(1l, "admin1" , "6666" )); list.add( new UserInfo(2l, "admin2" , "888" )); return list; }
3.7.5 @PreFilter
@PreFilter: 进入控制器之前对数据进行过滤
@RequestMapping( "getTestPreFilter" ) @PreAuthorize( "hasRole('ROLE_ 管理员 ')" ) @PreFilter(value = "filterObject.id%2==0" ) @ResponseBody public List getTestPreFilter(@RequestBody List list){ list.forEach(t-> { System. out .println(t.getId()+ "\t" +t.getUsername()); }); return list; }
先登录，然后使用postman 进行测试
测试的Json 数据：
[
{
"id" : "1" ,
"username" : "admin" ,
"password" : "666"
},
{
"id" : "2" ,
"username" : "admins" ,
"password" : "888"
},
{
"id" : "3" ,
"username" : "admins11" ,
"password" : "11888"
},
{
"id" : "4" ,
"username" : "admins22" ,
"password" : "22888"
https://docs.spring.io/spring- security/site/docs/5.3.4.RELEASE/reference/html5/#el-access
CREATE TABLE persistent_logins (
username varchar(64) NOT NULL,
series varchar(64) NOT NULL,
token varchar(64) NOT NULL,
last_used timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE
CURRENT_TIMESTAMP,
PRIMARY KEY (series)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
spring : datasource : driver-class-name : com.mysql.jdbc.Driver url : jdbc:mysql://192.168.200.128:3306/test username : root password : root
@Configuration public class BrowserSecurityConfig {
@Autowired private DataSource dataSource ;
@Bean public PersistentTokenRepository persistentTokenRepository(){ JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl(); // 赋值数据源 jdbcTokenRepository.setDataSource( dataSource ); // 自动创建表 , 第一次执行会创建，以后要执行就要删除掉！ jdbcTokenRepository.setCreateTableOnStartup( true );
return jdbcTokenRepository; } }
@Autowired private UsersServiceImpl usersService ;
@Autowired private PersistentTokenRepository tokenRepository ;
http.rememberMe() .tokenRepository( tokenRepository ) .userDetailsService( usersService );
记住我：< input type="checkbox"name="remember-me"title=" 记住密码 " />< br />
此处：name 属性值必须位remember-me.不能改为其他值
3.8.6 使用张三进行登录测试
登录成功之后，关闭浏览器再次访问http://localhost:8090/find，发现依然可以使用！
success.html
< body > 登录成功< br > < a href="/logout" >退出</ a > </ body >
http.logout().logoutUrl( "/logout" ).logoutSuccessUrl( "/index" ).permitAll
跨站请求伪造（英语：Cross-site request forgery），也被称为 one-click attack 或者 session riding，通常缩写为 CSRF 或者 XSRF， 是一种挟制用户在当前已 登录的Web应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比，XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。
跨站请求攻击，简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个 自己曾经认证过的网站并运行一些操作（如发邮件，发消息，甚至财产操作如转账和购买 商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。 这利用了web中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的 浏览器，却不能保证请求本身是用户自愿发出的。
从Spring Security 4.0开始，默认情况下会启用CSRF保护，以防止CSRF攻击应用 程序，Spring Security CSRF会针对PATCH，POST，PUT和DELETE方法进行防护。
3.10.2 案例
< input type="hidden"th:if="${_csrf}!=null"th:value="${_csrf.token}"name="_csrf " />
关闭安全配置的类中的csrf
// http.csrf().disable();
3.10.3 Spring Security 实现CSRF的原理：
SaveOnAccessCsrfToken 类有个接口CsrfTokenRepository
当前接口实现类：HttpSessionCsrfTokenRepository，CookieCsrfTokenRepository
微服务最早由Martin Fowler与James Lewis于 2014 年共同提出，微服务架构风格是一种 使用一套小服务来开发单个应用的方式途径，每个服务运行在自己的进程中，并使用轻量 级机制通信，通常是HTTP API，这些服务基于业务能力构建，并能够通过自动化部署机制 来独立部署，这些服务使用不同的编程语言实现，以及不同数据存储技术，并保持最低限 度的集中式管理。
（ 2 ）微服务每个模块都可以使用不同的存储方式（比如有的用redis，有的用mysql 等），数据库也是单个模块对应自己的数据库。
（ 3 ）微服务每个模块都可以使用不同的开发技术，开发模式更灵活。
（ 1 ）如果是基于Session，那么Spring-security会对cookie里的sessionid进行解析，找 到服务器存储的session信息，然后判断当前用户是否符合请求的要求。 （ 2 ）如果是token，则是解析出token，然后将当前请求加入到Spring-security管理的权限 信息中去
如果系统的模块众多，每个模块都需要进行授权与认证，所以我们选择基于token的形式 进行授权与认证，用户根据用户名密码认证成功，然后获取当前用户角色的一系列权限 值，并以用户名为key，权限列表为value的形式存入redis缓存中，根据用户名相关信息 生成token返回，浏览器将token记录到cookie中，每次调用api接口都默认将token携带 到header请求头中，Spring-security解析header头获取token信息，解析token获取当前 用户名，根据用户名就可以从redis中获取权限列表，这样Spring-security就能够判断当前 请求是否有权限访问
"alg": "HS256",
"typ": "JWT"
}
在上面的代码中，alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）； typ属性表示令牌的类型，JWT令牌统一写为JWT。最后，使用Base64 URL算法将上述 JSON对象转换为字符串保存。
有效载荷
有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT 指定七个默认字段供选择。
iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT
除以上默认字段外，我们还可以自定义私有字段，如下例：
"sub": "1234567890",
"name": "Helen",
"admin": true
}
请注意，默认情况下JWT是未加密的，任何人都可以解读其内容，因此不要构建隐私信息 字段，存放保密信息，以防止信息泄露。
JSON对象也使用Base64 URL算法转换为字符串保存。
签名哈希
首先，需要指定一个密码（secret）。该密码仅仅为保存在服务器中，并且不能向用户公 开。然后，使用标头中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成 签名。
HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(claims), secret)
在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个 部分用"."分隔，就构成整个JWT对象。
Base64URL算法
如前所述，JWT头和有效载荷序列化的算法都用到了Base64URL。该算法和常见Base64算 法类似，稍有差别。
作为令牌的JWT可以放在URL中（例如api.example/?token=xxx）。 Base64中用的三个 字符是"+"，"/"和"="，由于在URL中有特殊含义，因此Base64URL中对他们做了替换： "="去掉，"+"用"-"替换，"/"用"_"替换，这就是Base64URL算法。
Spring Security的核心配置就是继承WebSecurityConfigurerAdapter并注解 @EnableWebSecurity的配置。这个配置指明了用户名密码的处理方式、请求路径、登录 登出控制等和安全相关的配置 @Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public class TokenWebSecurityConfig extends WebSecurityConfigurerAdapter { //自定义查询数据库用户名密码和权限信息 private UserDetailsService userDetailsService; //token管理工具类（生成token） private TokenManager tokenManager; //密码管理工具类 private DefaultPasswordEncoder defaultPasswordEncoder; //redis操作工具类 private RedisTemplate redisTemplate; @Autowired public TokenWebSecurityConfig(UserDetailsService userDetailsService, DefaultPasswordEncoder defaultPasswordEncoder, TokenManager tokenManager, RedisTemplate redisTemplate) { this.userDetailsService = userDetailsService; this.defaultPasswordEncoder = defaultPasswordEncoder; this.tokenManager = tokenManager; this.redisTemplate = redisTemplate; } /**
@Override public void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService).passwordEncoder(defaultPasswordEnc oder); } /**
（ 1 ）DefaultPasswordEncoder：密码处理的方法 @Component public class DefaultPasswordEncoder implements PasswordEncoder {
public DefaultPasswordEncoder() { this(- 1 ); } /**
public String encode(CharSequence rawPassword) { return MD5.encrypt(rawPassword.toString()); } public boolean matches(CharSequence rawPassword, String encodedPassword) { return encodedPassword.equals(MD5.encrypt(rawPassword.toString())); } }
（ 2 ）TokenManager：token操作的工具类 @Component public class TokenManager { private long tokenExpiration = 24 * 60 * 60 * 1000 ; private String tokenSignKey = "123456"; public String createToken(String username) { String token = Jwts.builder().setSubject(username) .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration)) .signWith(SignatureAlgorithm.HS512, tokenSignKey).compressWith(CompressionCodecs.GZIP).compact(); return token; } public String getUserFromToken(String token) { String user = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody().getSu bject(); return user; } public void removeToken(String token) { //jwttoken无需删除，客户端扔掉即可。 } }
（ 3 ）TokenLogoutHandler：退出实现 public class TokenLogoutHandler implements LogoutHandler { private TokenManager tokenManager; private RedisTemplate redisTemplate; public TokenLogoutHandler(TokenManager tokenManager, RedisTemplate redisTemplate) { this.tokenManager = tokenManager; this.redisTemplate = redisTemplate; } @Override public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) { String token = request.getHeader("token"); if (token != null) { tokenManager.removeToken(token); //清空当前用户缓存中的权限数据 String userName = tokenManager.getUserFromToken(token);
redisTemplate.delete(userName); } ResponseUtil.out(response, R.ok()); } }
（ 4 ）UnauthorizedEntryPoint：未授权统一处理 public class UnauthorizedEntryPoint implements AuthenticationEntryPoint { @Override public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
ResponseUtil.out(response, R.error()); } }
(1) SecutityUser
@Data @Slf4j public class SecurityUser implements UserDetails { //当前登录用户 private transient User currentUserInfo; //当前权限 private List permissionValueList; public SecurityUser() { } public SecurityUser(User user) { if (user != null) { this.currentUserInfo = user; } } @Override public Collection<? extends GrantedAuthority> getAuthorities() {
Collection authorities = new ArrayList<>(); for(String permissionValue : permissionValueList) { if(StringUtils.isEmpty(permissionValue)) continue; SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permissionValue); authorities.add(authority); } return authorities; } @Override public String getPassword() { return currentUserInfo.getPassword(); } @Override public String getUsername() { return currentUserInfo.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; } }
（ 2 ）User @Data @ApiModel(description = "用户实体类") public class User implements Serializable { private String username; private String password; private String nickName; private String salt; private String token; }
4.3.3创建认证和授权的filter
（ 1 ）TokenLoginFilter：认证的filter public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter { private AuthenticationManager authenticationManager; private TokenManager tokenManager; private RedisTemplate redisTemplate; public TokenLoginFilter(AuthenticationManager authenticationManager, TokenManager tokenManager, RedisTemplate redisTemplate) { this.authenticationManager = authenticationManager; this.tokenManager = tokenManager; this.redisTemplate = redisTemplate; this.setPostOnly(false); this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/admin/acl/login","POST")); } @Override public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res) throws AuthenticationException { try { User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword(), new ArrayList<>())); } catch (IOException e) { throw new RuntimeException(e); } }
/**
tokenManager.createToken(user.getCurrentUserInfo().getUsername());
redisTemplate.opsForValue().set(user.getCurrentUserInfo().getUsername(), user.getPermissionValueList()); ResponseUtil.out(res, R.ok().data("token", token)); } /**
（ 2 ）TokenAuthenticationFilter：授权filter public class TokenAuthenticationFilter extends BasicAuthenticationFilter { private TokenManager tokenManager; private RedisTemplate redisTemplate; public TokenAuthenticationFilter(AuthenticationManager authManager, TokenManager tokenManager,RedisTemplate redisTemplate) { super(authManager); this.tokenManager = tokenManager; this.redisTemplate = redisTemplate; } @Override protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException { logger.info("================="+req.getRequestURI()); if(req.getRequestURI().indexOf("admin") == - 1 ) { chain.doFilter(req, res); return; } UsernamePasswordAuthenticationToken authentication = null; try { authentication = getAuthentication(req); } catch (Exception e) { ResponseUtil.out(res, R.error()); } if (authentication != null) {
SecurityContextHolder.getContext().setAuthentication(authentication); } else { ResponseUtil.out(res, R.error()); }
chain.doFilter(req, res); } private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) { // token置于header里 String token = request.getHeader("token"); if (token != null && !"".equals(token.trim())) { String userName = tokenManager.getUserFromToken(token); List permissionValueList = (List) redisTemplate.opsForValue().get(userName); Collection authorities = new ArrayList<>(); for(String permissionValue : permissionValueList) { if(StringUtils.isEmpty(permissionValue)) continue; SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permissionValue); authorities.add(authority); } if (!StringUtils.isEmpty(userName)) { return new UsernamePasswordAuthenticationToken(userName, token, authorities); } return null; } return null; } }
SpringSecurity采用的是责任链的设计模式，它有一条很长的过滤器链。现在对这条过滤 器链的 15 个过滤器进行说明:
（ 1 ） WebAsyncManagerIntegrationFilter：将 Security 上下文与 Spring Web 中用于 处理异步请求映射的 WebAsyncManager 进行集成。
（ 2 ） SecurityContextPersistenceFilter：在每次请求处理之前将该请求相关的安全上 下文信息加载到 SecurityContextHolder 中，然后在该次请求处理完成之后，将 SecurityContextHolder 中关于这次请求的信息存储到一个“仓储”中，然后将 SecurityContextHolder 中的信息清除，例如在Session中维护一个用户的安全信 息就是这个过滤器处理的。
（ 3 ） HeaderWriterFilter：用于将头信息加入响应中。
（ 4 ） CsrfFilter：用于处理跨站请求伪造。
（ 5 ）LogoutFilter：用于处理退出登录。 （ 6 ）UsernamePasswordAuthenticationFilter：用于处理基于表单的登录请求，从表单中 获取用户名和密码。默认情况下处理来自 /login 的请求。从表单中获取用户名和密码 时，默认使用的表单 name 值为 username 和 password，这两个值可以通过设置这个 过滤器的usernameParameter 和 passwordParameter 两个参数的值进行修改。
（ 7 ）DefaultLoginPageGeneratingFilter：如果没有配置登录页面，那系统初始化时就会 配置这个过滤器，并且用于在需要进行登录时生成一个登录表单页面。
（ 8 ）BasicAuthenticationFilter：检测和处理 http basic 认证。
（ 9 ）RequestCacheAwareFilter：用来处理请求的缓存。
（ 10 ）SecurityContextHolderAwareRequestFilter：主要是包装请求对象request。
（ 11 ）AnonymousAuthenticationFilter：检测 SecurityContextHolder 中是否存在 Authentication 对象，如果不存在为其提供一个匿名 Authentication。
（ 12 ）SessionManagementFilter：管理 session 的过滤器
（ 13 ）ExceptionTranslationFilter：处理 AccessDeniedException 和 AuthenticationException 异常。
（ 14 ）FilterSecurityInterceptor：可以看做过滤器链的出口。
（ 15 ）RememberMeAuthenticationFilter：当用户没有登录而直接访问资源时, 从 cookie 里找出用户的信息, 如果 Spring Security 能够识别出用户提供的remember me cookie, 用户将不必填写用户名和密码, 而是直接登录进入系统，该过滤器默认不开启。
Spring Security 采取过滤链实现认证与授权，只有当前过滤器通过，才能进入下一个 过滤器：
使用Spring Security提供的认证过滤器，也可以自定义过滤器（例如：短信验证）。认 证过滤器要在configure(HttpSecurity http)方法中配置，没有配置不生效。下面会重 点介绍以下三个过滤器：
UsernamePasswordAuthenticationFilter过滤器：该过滤器会拦截前端提交的 POST 方式 的登录表单请求，并进行身份认证。
ExceptionTranslationFilter过滤器：该过滤器不需要我们配置，对于前端提交的请求会 直接放行，捕获后续抛出的异常并进行处理（例如：权限访问限制）。
FilterSecurityInterceptor过滤器：该过滤器是过滤器链的最后一个过滤器，根据资源 权限配置来判断当前请求是否有权限访问对应的资源。如果访问受限会抛出相关异常，并 由ExceptionTranslationFilter过滤器进行捕获和处理。
认证流程是在UsernamePasswordAuthenticationFilter过滤器中处理的，具体流程如下 所示：
5.3.1 UsernamePasswordAuthenticationFilter源码
证。该过滤器的 doFilter() 方法实现在其抽象父类
AbstractAuthenticationProcessingFilter 中，查看相关源码：
***** 上述的 第二 过程调用了UsernamePasswordAuthenticationFilter的 attemptAuthentication() 方法，源码如下：**
****上述的（ 3 ）过程创建的UsernamePasswordAuthenticationToken是 Authentication 接口的实现类，该类有两个构造器，一个用于封装前端请求传入的未认 证的用户信息，一个用于封装认证成功后的用户信息：
*** Authentication 接口的实现类用于存储用户认证信息，查看该接口具体定义：
5.3.2 ProviderManager 源码
上述过程中， UsernamePasswordAuthenticationFilter 过滤器的 attemptAuthentication() 方法的 （ 5 ）过程 将未认证的 Authentication 对象传入 ProviderManager 类的 authenticate() 方法进行身份认证。
ProviderManager 是 AuthenticationManager 接口的实现类，该接口是认证相关的核心接 口，也是认证的入口。在实际开发中，我们可能有多种不同的认证方式，例如：用户名+ 密码、邮箱+密码、手机号+验证码等，而这些认证方式的入口始终只有一个，那就是 AuthenticationManager。在该接口的常用实现类 ProviderManager 内部会维护一个 List 列表，存放多种认证方式，实际上这是委托者模式 （Delegate）的应用。每种认证方式对应着一个 AuthenticationProvider， AuthenticationManager 根据认证方式的不同（根据传入的 Authentication 类型判断）委托 对应的 AuthenticationProvider 进行用户认证。
上述认证成功之后的（ 6 ）过程，调用 CredentialsContainer 接口定义的 eraseCredentials() 方法去除敏感信息。查看 UsernamePasswordAuthenticationToken 实现的 eraseCredentials() 方法，该方 法实现在其父类中：
UsernamePasswordAuthenticationFilter 过滤器的 doFilter() 方法，查看认证成 功/失败的处理：
ExceptionTranslationFilter 过滤器和 FilterSecurityInterceptor 过滤器进行介绍。
5.4.1 ExceptionTranslationFilter过滤器
5.4.2 FilterSecurityInterceptor过滤器
FilterSecurityInterceptor 是过滤器链的最后一个过滤器，该过滤器是过滤器链 的最后一个过滤器，根据资源权限配置来判断当前请求是否有权限访问对应的资源。如果 访问受限会抛出相关异常，最终所抛出的异常会由前一个过滤器 ExceptionTranslationFilter 进行捕获和处理。具体源码如下：
需要注意， Spring Security 的过滤器链是配置在 SpringMVC 的核心组件 DispatcherServlet 运行之前。也就是说，请求通过 Spring Security 的所有过滤器， 不意味着能够正常访问资源，该请求还需要通过 SpringMVC 的拦截器链。
一般认证成功后的用户信息是通过 Session 在多个请求之间共享，那么 Spring Security 中是如何实现将已认证的用户信息对象 Authentication 与 Session 绑定的进行 具体分析。
⚫ 在前面讲解认证成功的处理方法 successfulAuthentication() 时，有以下代码：
⚫ 查看 SecurityContext 接 口 及 其 实 现 类 SecurityContextImpl， 该 类 其 实 就 是 对 Authentication 的封装：
⚫ 查看 SecurityContextHolder 类 ， 该 类 其 实 是 对 ThreadLocal 的 封 装 ， 存 储 SecurityContext 对象：
5.5.1 SecurityContextPersistenceFilter过滤器
前面提到过，在 UsernamePasswordAuthenticationFilter 过滤器认证成功之 后，会在认证成功的处理方法中将已认证的用户信息对象 Authentication 封装进 SecurityContext，并存入 SecurityContextHolder。
之后，响应会通过 SecurityContextPersistenceFilter 过滤器，该过滤器的位置 在所有过滤器的最前面，请求到来先进它，响应返回最后一个通过它，所以在该过滤器中 处理已认证的用户信息对象 Authentication 与 Session 绑定。
认证成功的响应通过 SecurityContextPersistenceFilter 过滤器时，会从 SecurityContextHolder 中取出封装了已认证用户信息对象 Authentication 的 SecurityContext，放进 Session 中。当请求再次到来时，请求首先经过该过滤器，该过滤 器会判断当前请求的 Session 是否存有 SecurityContext 对象，如果有则将该对象取出再次 放入 SecurityContextHolder 中，之后该请求所在的线程获得认证用户信息，后续的资源访 问不需要进行身份认证；当响应再次返回时，该过滤器同样从 SecurityContextHolder 取出 SecurityContext 对象，放入 Session 中。具体源码如下：
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手