一、SpringSecurity 简介

1.1 SpringSecurity 简介

SpringSecurity是基于Spring框架，提供了一套Web应用安全性的完整解决方案，核心功能就是用户认证（Authentication）和用户授权（Authorization）。
用户认证：通俗的说就是系统认为用户是否登录。
用户授权：通俗的说就是系统判断用户是否有权限去做某些事情。

1.2 SpringSecurity 与 Shiro

SSM配置SpringSecurity会很麻烦，而配置Shiro则简单很多，因此在SSM时使用Shiro很多；而使用SpringBoot使用SpringSecurity则会很简单，因此使用SpringBoot创建的项目使用SpringSecurity比较多。

SpringSecurity 优点

  • 和 Spring 无缝整合；
  • 全面的权限控制；
  • 专门为 Web 开发而设计。旧版本不能脱离 Web 环境使用；新版本对真个框架进行了分层抽取，分成了核心模块和 Web 模块。单独引入核心模块就可以脱离 Web 环境。
  • 重量级框架。

Shiro 优点

  • Apache 旗下轻量级权限控制框架；
  • 可以脱离 Web 环境使用；在 Web 环境下一些特定的需求需要手动编写代码定制。

1.3 SpringSecutiry 入门案例

引入依赖

  1. <!-- SpringBoot依赖 -->
  2. <dependency>
  3.       <groupId>org.springframework.boot</groupId>
  4.       <artifactId>spring-boot-starter</artifactId>
  5. </dependency>
  7. <!-- web 环境依赖 -->
  8. <dependency>
  9.     <groupId>org.springframework.boot</groupId>
  10.     <artifactId>spring-boot-starter-web</artifactId>
  11. </dependency>
  13. <!-- Spring Security 依赖 -->
  14. <dependency>
  15.     <groupId>org.springframework.boot</groupId>
  16.     <artifactId>spring-boot-starter-security</artifactId>
  17. </dependency>

编写控制器

  1. @RestController
  2. @RequestMapping("/test")
  3. public class MainController {
  5.     @GetMapping("hello")
  6.     public String hello() {
  7.         return "Hello Security";
  8.     }
  9. }

访问控制器

访问http://127.0.0.1:8080/test/hello页面会重定向到登录页面，如下图：
QQ截图20220302140023.png

  • 默认用户名：user
  • 默认密码：在控制台中打印，如下图：

QQ截图20220302140202.png

1.4 SpringSecutiry 基本原理

在 SpringBoot 中，我们只需要引入 SpringSecurity 依赖，就可以使用 SpringSecurity 的功能，这是因为 SpringBoot 为我们自动化配置，因此不需要我们手动配置。SpringSecurity 本质上就是过滤器链，由一个个过滤器组成。在程序运行后，可以控制台看到如下代码，这里所展示的过滤器就是组成 SpringSecutiry 的所有过滤器。

  1. # 下面所有类省略 org.springframework.security.web 前缀包名
  3. .context.request.async.WebAsyncManagerIntegrationFilter
  4. .context.SecurityContextPersistenceFilter
  5. .header.HeaderWriterFilter
  6. .csrf.CsrfFilter
  7. .authentication.logout.LogoutFilter
  9. # 对/login的 POST 请求做拦截，校验表单中的用户名、密码
  10. .authentication.UsernamePasswordAuthenticationFilter
  11. .authentication.ui.DefaultLoginPageGeneratingFilter
  12. .authentication.ui.DefaultLogoutPageGeneratingFilter
  13. .authentication.www.BasicAuthenticationFilter
  14. .savedrequest.RequestCacheAwareFilter
  15. .servletapi.SecurityContextHolderAwareRequestFilter
  16. .authentication.AnonymousAuthenticationFilter 
  17. .session.SessionManagementFilter
  19. # 异常过滤器，用来处理在认证授权过程中抛出的异常
  20. .access.ExceptionTranslationFilter
  22. # 方法级的权限过滤器，位于过滤链的最底部
  23. .access.intercept.FilterSecurityInterceptor

运行代码时会执行到FilterSecurityInterceptor的如下方法中：
QQ截图20220302141436.png
super.beforeInvocation(filterIncocation)表示查看之前的 filter 是否通过。
fi.getChain().doFilter(fi.getRequest(), fi.getResponse())真正的调用后台任务。

1.5 SpringSecurity 两个重要的接口

1.5.1 UserDetailService 接口

当我们没有配置任何东西时，账号和密码是由 SpringSecurity 定义生成的。而在实际项目中，账号和密码都是从数据库中查询出来，所以我们需要自定义逻辑来控制认证逻辑。

所以当我们需要自定义逻辑时，首先需要创建一个类继承UsernamePasswordAuthenticationFilter类，并重写三个方法：

  1. public abstract Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
  3. // 认证成功回调
  4. protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult)
  6. // 认证失败回调
  7. protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed)

其次需要实现UserDetailsService接口（我们需要从数据库中查询用户名和密码，就在这个接口中进行查询）：

  1. public interface UserDetailsService {
  2.     UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
  3. }

UserDetails类就是系统默认的用户“主体”，其结构如下：

  1. public interface UserDetails extends Serializable {
  3.     // 表示获取登录用户所有权限
  4.     Collection<? extends GrantedAuthority> getAuthorities();
  6.     // 获取密码
  7.     String getPassword();
  9.     // 获取用户名
  10.     String getUsername();
  12.     // 判断账户是否过期
  13.     boolean isAccountNonExpired();
  15.     // 表示账号是否被锁定
  16.     boolean isAccountNonLocked();
  18.     // 表示密码是否过期
  19.     boolean isCredentialsNonExpired();
  21.     // 表示当前用户是否可用
  22.     boolean isEnabled();
  23. }

SpringSecurity 框架中有一个名为User的类，其实现了UserDetails接口，构造如下：

  1. public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
  2.     this(username, password, true, true, true, true, authorities);
  3. }

注意的是：方法参数username表示用户名。这个值是客户端表单传递过来的数据。默认情况下必须叫username,否则无法接收。

1.5.2 PasswordEncoder 接口

  1. public interface PasswordEncoder {
  3.     // 解析密码
  4.     String encode(CharSequence rawPassword);
  6.     // 判断密码是否匹配
  7.     // 第一个参数表示需要被解析的密码
  8.     // 第二个参数表示存储的密码
  9.     boolean matches(CharSequence rawPassword, String encodedPassword);
  11.     // 如果解析的密码能够再次进行解析且达到更安全的结果则返回true，否则返回false
  12.     default boolean upgradeEncoding(String encodedPassword) {
  13.         return false;
  14.     }
  15. }

BCryptPasswordEncoder是 Spring Security 推荐的密码解析器。它是对bcrypt强散列方法的具体实现，是基于 Hash 算法实现的单向加密。可以通过strength控制加密强度，默认为10。

使用步骤如下：

  1. public void checkPwd() {
  2.     // 创建密码解析器
  3.     BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
  4.     // 对密码进行加密
  5.     String password = encoder.encode("原始密码");
  6.     // 判断原字符加密后和加密之前是否匹配
  7.     boolean result = encoder.matches("原始密码", password);
  8. }

二、SpringSecurity Web 权限方案

2.1 设置用户名和密码

方式1：配置文件配置

  1. spring.security.user.name=xiaoxia
  2. spring.security.user.password=xiaoxia

方式2：配置类

  1. // 1.继承 WebSecurityConfigurerAdapter 类
  2. @Configuration
  3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  5.     // 2.重写 configure 方法
  6.     @Override
  7.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  8.         String username = "admin";
  9.         String password = "123";
  10.         String role = "admin";
  12.         // 对密码进行加密
  13.         BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
  14.         password = encoder.encode(password);
  16.         auth.inMemoryAuthentication() // 添加权限，从内存中获取
  17.                 .withUser(username) // 添加用户名
  18.                 .password(password) // 添加密码
  19.                 .roles(role); // 添加角色
  20.     }
  22.     // 因为configure()方法使用到了BCryptPasswordEncoder，所以需要我们进行注入，否则会报异常
  23.     @Bean
  24.     public PasswordEncoder passwordEncoder() {
  25.         return new BCryptPasswordEncoder();
  26.     }
  27. }

在上面代码中，如果没有注入PasswordEncoder则会出现下面异常：

  1. There is no PasswordEncoder mapped for the id "null"

方式3：自定义编写实现类

上面 2 个方案在真实项目中并不适用，因为用户名和密码都是从数据库中查找出来的，因此我们需要自定义编写实现类。

Spring Security 在认证过程中，会去先找配置文件和配置类，如果没有找到就会找到继承UserDetailsService接口的类。

  1. @Configuration
  2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  4.     // 注入UserDetailsService
  5.     @Autowired
  6.     UserDetailsService userDetailsService;
  8.     @Override
  9.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  10.         auth.userDetailsService(userDetailsService) // 设置UserDetailsService的实现类
  11.                 .passwordEncoder(passwordEncoder()); // 设置密码解析器
  12.     }
  14.     @Bean
  15.     public PasswordEncoder passwordEncoder() {
  16.         return new BCryptPasswordEncoder();
  17.     }
  18. }
  1. // 注意这里的userDetailsService一定要与SecurityConfig注入的名字保持一致
  2. // 这里测试的时候，@Service中没有内容也可以
  3. @Service("userDetailsService")
  4. public class MyUserDetailsService implements UserDetailsService {
  6.     // username:这里的username是我们从表单提交中获取到的数据
  7.     @Override
  8.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  10.         // 我们在这里查询数据库
  12.         // 创建权限角色
  13.         List<GrantedAuthority> authorities =
  14.                 AuthorityUtils.commaSeparatedStringToAuthorityList("admin");
  16.         // User：这个User实现了UserDetails接口，所以我们可以直接返回
  17.         return new User(username,
  18.                 new BCryptPasswordEncoder().encode("1234"),
  19.                 authorities);
  20.     }
  21. }

2.2 自定义用户登录页面

当我们访问链接时会跳转到Spring Security的登录页面。我们可以自定义这个登录页面。

首先需要自定义一个登录页面login.html，注意from表单的action就是我们登录的Controller路径，该Controller不需要我们来写。

注意：

  • method的属性必须是post。
  • 用户名的name属性必须是username。
  • 密码的name属性必须是password。

这是因为在Spring Security的过滤器UsernamePasswordAuthenticationFilter中定义的。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>登录</title>
  6. </head>
  7. <body>
  8. <form action="/user/login" method="post">
  9.     用户名：<input type="text" name="username"><br>
  10.     密码：<input type="password" name="password"><br>
  11.     <input type="submit" value="登录">
  12. </form>
  13. </body>
  14. </html>
  1. @Override
  2. protected void configure(HttpSecurity http) throws Exception {
  3.     http.formLogin() // 自定义自己编写登录页面
  4.         .loginPage("/login.html") // 配置哪个url为登录页面
  5.         .loginProcessingUrl("/user/login") // 登录的Controller访问路径，不需要我们写，提供路径即可
  6.         .defaultSuccessUrl("/test/index") // 登录成功默认的页面
  7.         .permitAll()
  8.         .and().authorizeRequests()
  9.         // 设置哪些页面不需要经过认证
  10.         .antMatchers("/","/test/hello","/user/login")
  11.         .permitAll() // 指定URL，无需保护
  12.         .anyRequest() // 其他请求
  13.         .authenticated() // 需要认证
  14.         .and().csrf().disable(); // 关闭csrf防护
  15. }

当然如果需要修改默认参数username和password则需要使用下面方法：

  1. http.formLogin() // 自定义自己编写登录页面
  2.                 .loginPage("/login.html") // 设置默认登录路径
  3.                 .loginProcessingUrl("/user/login") // 登录的Controller访问路径，不需要我们写，提供路径即可
  4.                 .defaultSuccessUrl("/test/index") // 登录成功默认的页面
  5.                 .successForwardUrl("") // 登录成功跳转的页面
  6.                 .failureForwardUrl("") // 登录失败跳转的页面
  7.                 .usernameParameter("name")  // 修改前端传入的默认参数 username
  8.                 .passwordParameter("pwd")   // 修改前端传入的默认参数 password

这样前端传参的时候就需要使用name和pwd的属性了。

  1. <form action="/user/login" method="post">
  2.     用户名：<input type="text" name="name"><br>
  3.     密码：<input type="password" name="pwd"><br>
  4.     <input type="submit" value="登录">
  5. </form>

2.3 权限

2.3.1 hasAuthority 和 hasAnyAuthority

hasAuthority和hasAnyAuthority的区别就是前者只能设置一个角色，而后者可以设置多个角色。

使用如下：

  1. // 设置 find1 只能有admin身份访问
  2. .antMatchers("/find1").hasAuthority("admin")
  3. // 设置 find2 由 admin和manager两个身份访问
  4. .antMatchers("/find2").hasAnyAuthority("admin","manager")

添加权限如下：

  1. List<GrantedAuthority> authorities =
  2.     AuthorityUtils.commaSeparatedStringToAuthorityList("admin,manager");

hasAuthority和hasAnyAuthority的源码如下，这样就会明白hasAnyAuthority为什么会在添加权限时使用,并且是在一个参数中：

  1. // ExpressionUrlAuthorizationConfigurer.java
  3. private static String hasAuthority(String authority) {
  4.     return "hasAuthority('" + authority + "')";
  5. }
  7. private static String hasAnyAuthority(String... authorities) {
  8.     String anyAuthorities = StringUtils.arrayToDelimitedString(authorities, "','");
  9.     return "hasAnyAuthority('" + anyAuthorities + "')";
  10. }

2.3.2 hasRole 与 hasAnyRole

如果用户具备给定角色就允许访问，否则出现 403。如果当前主体具有指定的角色，则返回true。

使用如下：

  1. .antMatchers("/find3").hasRole("role")
  2. .antMatchers("/find4").hasAnyRole("role","sale")

添加权限如下：

  1. List<GrantedAuthority> authorities = AuthorityUtils.
  2.     commaSeparatedStringToAuthorityList("admin,manager,ROLE_role,ROLE_sale");

hasRole和hasAnyRole的源码如下，这样也就明白为啥会在身份之前添加ROLE_前缀：

  1. // ExpressionUrlAuthorizationConfigurer.java    
  3. // 这里可以添加 rolePrefix 前缀
  4. private static String hasAnyRole(String rolePrefix, String... authorities) {
  5.     String anyAuthorities = StringUtils.arrayToDelimitedString(authorities, "','" + rolePrefix);
  6.     return "hasAnyRole('" + rolePrefix + anyAuthorities + "')";
  7. }
  9. private static String hasRole(String rolePrefix, String role) {
  10.     Assert.notNull(role, "role cannot be null");
  11.     Assert.isTrue(rolePrefix.isEmpty() || !role.startsWith(rolePrefix), () -> "role should not start with '"
  12.             + rolePrefix + "' since it is automatically inserted. Got '" + role + "'");
  13.     return "hasRole('" + rolePrefix + role + "')";
  14. }
  1. // 如果我们不自己添加前缀，则使用默认前缀
  3. public ExpressionUrlAuthorizationConfigurer(ApplicationContext context) {
  4.     String[] grantedAuthorityDefaultsBeanNames = context.getBeanNamesForType(GrantedAuthorityDefaults.class);
  5.     if (grantedAuthorityDefaultsBeanNames.length == 1) {
  6.         GrantedAuthorityDefaults grantedAuthorityDefaults = context.getBean(grantedAuthorityDefaultsBeanNames[0],
  7.                                                                             GrantedAuthorityDefaults.class);
  8.         this.rolePrefix = grantedAuthorityDefaults.getRolePrefix();
  9.     }
  10.     else {
  11.         // 添加默认前缀
  12.         this.rolePrefix = "ROLE_";
  13.     }
  14.     this.REGISTRY = new ExpressionInterceptUrlRegistry(context);
  15. }

2.3.3 自定义 403 页面

  1. @Override
  2. protected void configure(HttpSecurity http) throws Exception {
  3.     // 自定义配置 403 页面
  4.     http.exceptionHandling().accessDeniedPage("/unauth");
  5. }

2.4 权限注解

2.4.1 @Secured

@Secured注解作用是：判断是否具有角色，需要添加前缀“ROLE_”。

步骤1：开启注解

  1. @SpringBootApplication
  2. @MapperScan("com.example.springsecuritystudy.mapper")
  3. // 开启注解
  4. @EnableGlobalMethodSecurity(securedEnabled = true)
  5. public class SpringSecurityStudyApplication {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(SpringSecurityStudyApplication.class, args);
  8.     }
  9. }

步骤2：在Controller方法上添加注解

  1. @GetMapping("main")
  2. @Secured({"ROLE_role","Role_admin"})
  3. public String main() {
  4.     return "MAIN";
  5. }

2.4.2 @PreAuthorize

@Preauthorize注解作用：在进入方法前验证权限。

步骤1：开启注解

  1. @SpringBootApplication
  2. @MapperScan("com.example.springsecuritystudy.mapper")
  3. @EnableGlobalMethodSecurity(
  4.         securedEnabled = true,
  5.         prePostEnabled = true) // 开启@PreAuthorize和@PostAuthorize注解权限

步骤2：在Controller方法上添加注解

  1. @GetMapping("main")
  2. @PreAuthorize("hasAuthority('admin')")
  3. @PreAuthorize("hasAnyAuthority('admin,root')")
  4. @PreAuthorize("hasRole('ROLE_admin')")
  5. @PreAuthorize("hasAnyRole('ROLE_admin','ROLE_root')")
  6. public String main() {
  7.     return "MAIN";
  8. }

2.4.3 @PostAuthorize

@PostAuthorize和@PreAuthorize使用方式一模一样，不过@PostAuthorize的作用是在方法执行后再进行权限验证，适合验证带有返回值的权限。该注解使用不多。

2.4.4 @PostFilter

@PostFilter的作用是权限验证之后数据进行过滤。

示例如下：

  1. @GetMapping("postFilter")
  2. @Secured("ROLE_admin")
  3. @PostFilter("filterObject.password=='456'")
  4. public List<User> postFilter() {
  5.     List<User> list = new ArrayList<>();
  6.     list.add(new User(1, "admin1", "123"));
  7.     list.add(new User(2, "admin2", "456"));
  8.     return list;
  9. }

上面内容访问的结果如下：

  1. [{"id":2,"username":"admin2","password":"456"}]

这里需要注意的是：

  1. 使用@PostFilter注解后的方法返回值必须是集合或者Map类型，其他类型会报异常。
  2. filterObject代表集合中每一个类型（实体类），password代表实体类中的属性。
  3. 参数匹配注意使用==双等于符号。

2.4.5 @PreFilter

@PreFilter的作用是对入参进行过滤。

  1. @GetMapping("preFilter")
  2. @Secured("ROLE_admin")
  3. @PreFilter(value = "filterObject.id%2==0")
  4. public List<User> preFilter(@RequestBody List<User> list) {
  5.     list.forEach(item -> {
  6.         System.out.println(item.getId() + " -- "+ item.getUsername());
  7.     })
  8.     return list;
  9. }

更多权限表达式可见官网文档：https://docs.spring.io/spring-security/site/docs/5.3.4.RELEASE/reference/html5/#el-access

  1. https://docs.spring.io/spring-security/site/docs/5.3.4.RELEASE/reference/html5/#el-access

2.5 注销功能

  1. @Override
  2. protected void configure(HttpSecurity http) throws Exception {
  3.     http.logout()                    // 注销
  4.         .logoutUrl("/logout")        // 注销访问的url
  5.         .logoutSuccessUrl("/index")    // 注销成功后跳转到的页面
  6.         .permitAll()
  7.     }

2.6 自动登录功能（记住密码功能）

实现自动登录或者记住密码的功能原理如下：

  1. 客户端技术 Cookie 可以设置过期时长。
  2. 当我们在浏览器访问时，经过安全验证。
  3. 验证成功后将一段加密串设置到cookie中并设置有效时长，保存在浏览器中。
  4. 验证成功后同时也会将这一段加密串和用户信息字符串对应，并保存到数据库中。
  5. 当再次访问时，获取cookie信息，拿着cookie的信息到数据库进行比对，如果查询到对应信息，认证成功，直接登录。

Spring Security的实现流程：

  1. 浏览器请求认证，经过UsernamePasswordAuthenticationFilter过滤器。
  2. 认证成功后，调用RemeberMeService类，通过TokenRepository类包装 Token，将 Token 写入浏览器的 Cookie 中。
  3. 同时，通过JdbcTokenRepositoryImpl类将该 Token 保存到数据库中。
  4. 再次发起请求，会经过RememberMeAuthenticationFilter过滤器，读取 Cookie 中的 Token。
  5. 并从数据库中查到对应的 Token，在UserDetailsService中判断。

步骤1：新建数据表（可省略）

  1. CREATE TABLE `persistent_logins` (
  2.      `username` varchar(64) NOT NULL,
  3.      `series` varchar(64) NOT NULL,
  4.      `token` varchar(64) NOT NULL,
  5.      `last_used` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE 
  6.     CURRENT_TIMESTAMP,
  7.      PRIMARY KEY (`series`)
  8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

步骤2：配置数据源

  1. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  2. spring.datasource.url=jdbc:mysql://localhost:3306/spring_security?userUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
  3. spring.datasource.username=root
  4. spring.datasource.password=123456

步骤3：创建配置类

  1. @Configuration
  2. public class BrowserSecurityConfig {
  4.     @Autowired
  5.     DataSource dataSource; // 注入数据源
  7.     @Bean
  8.     public PersistentTokenRepository persistentTokenRepository() {
  9.         JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
  10.         // Spring Security 已经为我们实现好数据库的实现，所以我们只需要提供数据源即可
  11.         jdbcTokenRepository.setDataSource(dataSource);
  12.         // 自动创建数据表，第一次执行会创建，以后要执行就要删除掉！
  13.         // 这里设置了，就可以省略掉第一步
  14.         jdbcTokenRepository.setCreateTableOnStartup(true);
  15.         return jdbcTokenRepository;
  16.     }
  17. }

步骤4：修改安全配置类

  1. @Autowired
  2. UserDetailsService userDetailsService;
  4. @Autowired
  5. PersistentTokenRepository tokenRepository;
  7. http.rememberMe()
  8.     .tokenRepository(tokenRepository)
  9.     .userDetailsService(userDetailsService)
  10.     .tokenValiditySeconds(60) // 设置有限时长

步骤5：修改前端页面

  1. 记住我：<input type="checkbox" name="remember-me" title="记住密码"/>

注意：这里name属性的值必须为remember-me，当我们访问成功后，会在浏览器的 Cookie 信息中看到名为remember-me的 Cookie。

2.7 CSRF 功能

**跨站请求伪造**：英文名Cross-site request forgery，也被称为one-click attack或者session riding，通常缩写为CSRF或者XSRF，是一种挟制用户在当前已登录的 Web 应用程序上执行非本意的操作的攻击方法。
**跨站请求伪造**和跨网站脚本（XSS）相比，XSS 利用的是用户对执行网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。
跨站请求攻击，简单来说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并运行一些操作（如发邮件、发消息、转账、购买商品等）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。这利用了 Web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。

从 SpringSecurity 4.0 开始，默认会开启 CSRF 保护，以方式 CSRF 攻击应用程序，SpringSecurity CSRF 会针对 PATCH、POST、PUT 和 DELETE 方法进行防护。也就是说这些方法只能在本站访问，而不能在其他网站访问到。

关闭 csrf 功能

  1. http.csrf().disable();

如何使用 csrf ?

只需要在表单中添加一个隐藏域。

  1. <input type="hidden" th:if="${_csrf}!=null" th:value="${_csrf.token}" name="_csrf"/>

CSRF 功能来源于CsrfFilter过滤器：

  1. @Override
  2. protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
  3.     throws ServletException, IOException {
  5.   request.setAttribute(HttpServletResponse.class.getName(), response);
  6.   CsrfToken csrfToken = this.tokenRepository.loadToken(request);
  8.   boolean missingToken = (csrfToken == null);
  9.   if (missingToken) {
  10.     csrfToken = this.tokenRepository.generateToken(request);
  11.     this.tokenRepository.saveToken(csrfToken, request, response);
  12.   }
  14.   // 获取从前端表单传入的 csrf 参数
  15.   request.setAttribute(CsrfToken.class.getName(), csrfToken);
  16.   request.setAttribute(csrfToken.getParameterName(), csrfToken);
  18.   // requireCsrfProtectionMatcher 这里会检测方法，GET等方法不需要csrf认证
  19.   if (!this.requireCsrfProtectionMatcher.matches(request)) {
  20.     filterChain.doFilter(request, response);
  21.     return;
  22.   }
  23.   filterChain.doFilter(request, response);
  24. }

三、SpringSecurity 微服务权限方案

、SpringSecurity 原理总结