SpringSecurity安全性框架详解
SpringSecurity简介
Spring Security是一个高度自定义的安全框架。利用 Spring IoC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。使用 Spring Secruity 的原因有很多，但大部分都是发现了 javaEE的 Servlet 规范或 EJB 规范中的安全功能缺乏典型企业应用场景。同时认识到他们在 WAR 或 EAR 级别无法移植。因此如果你更换服务器环境，还有大量工作去重新配置你的应用程序。使用 Spring Security解决了这些问题，也为你提供许多其他有用的、可定制的安全功能。正如你可能知道的两个应用程序的两个主要区域是“认证”和“授权”（或者访问控制）。这两点也是 Spring Security 重要核心功能。“认证”，是建立一个他声明的主体的过程（一个“主体”一般是指用户，设备或一些可以在你的应用程序中执行动作的其他系统），通俗点说就是系统认为用户是否能登录。“授权”指确定一个主体是否允许在你的应用程序执行一个动作的过程。通俗点讲就是系统判断用户是否有权限去做某些事情。
快速入门
导入依赖
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.6.7version>
<relativePath/>
parent>
<groupId>com.examplegroupId>
<artifactId>demoartifactId>
<version>0.0.1-SNAPSHOTversion>
<name>demoname>
<description>Demo project for Spring Bootdescription>
<properties>
<java.version>1.8java.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-securityartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.securitygroupId>
<artifactId>spring-security-testartifactId>
<scope>testscope>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
project>
前端页面
login.html
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<form action="/login" method="post">
用户名：<input type="text" name="username" /><br/>
密码：<input type="password" name="password" /><br/>
<input type="submit" value="登录" />
form>
body>
html>
访问页面
导入spring-boot-starter-security 启动器后，Spring Security 已经生效，默认拦截全部请求，如果用户没有登录，跳转到内置登录页面
默认的 username 为 user，password 打印在控制台中
在浏览器中输入账号和密码后会显示 login.html 页面内容
UserDetailsService详解
当什么也没有配置的时候，账号和密码是由 Spring Security 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。所以我们要通过自定义逻辑控制认证逻辑。如果需要自定义逻辑时，只需要实现UserDetailsService 接口即可。接口定义如下：
返回值 UserDetails 也是一个接口，定义如下
public interface UserDetails extends Serializable {
Collection<? extends GrantedAuthority> getAuthorities();//获取所有权限
String getPassword();//获取密码
String getUsername();//获取用户名
boolean isAccountNonExpired();//是否账号过期
boolean isAccountNonLocked();//是否账号被锁定
boolean isCredentialsNonExpired();//凭证(密码)是否过期
boolean isEnabled();//是否可用
}
要想返回 UserDetails 的实例就只能返回接口的实现类。SpringSecurity 中提供了如下的实例。对于我们只需要使用里面的 User 类即可
在 User 类中提供了很多方法和属性，其中构造方法有两个，调用其中任何一个都可以实例化，三个参数的构造方法实际上也是调用 7 个参数的构造方法。
public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
this(username, password, true, true, true, true, authorities);
}
public User(String username, String password, boolean enabled, boolean accountNonExpired,
boolean credentialsNonExpired, boolean accountNonLocked,
Collection<? extends GrantedAuthority> authorities) {
Assert.isTrue(username != null && !"".equals(username) && password != null,
"Cannot pass null or empty values to constructor");
this.username = username;
this.password = password;
this.enabled = enabled;
this.accountNonExpired = accountNonExpired;
this.credentialsNonExpired = credentialsNonExpired;
this.accountNonLocked = accountNonLocked;
this.authorities = Collections.unmodifiableSet(sortAuthorities(authorities));
}
此处的用户名应该是客户端传递过来的用户名，默认情况下必须叫 username。而密码应该是从数据库中查询出来的密码。Spring Security 会根据 User 中的 password 和客户端传递过来的 password 进行比较。如果相同则表示认证通过，如果不相同表示认证失败。
authorities 里面的权限对于后面学习授权是很有必要的，包含的所有内容为此用户具有的权限，如果里面没有包含某个权限，而在做某个事情时必须包含某个权限则会出现 403。通常都是通过AuthorityUtils.commaSeparatedStringToAuthorityList(“”) 来创建authorities 集合对象的。参数是一个字符串，多个权限使用逗号分隔。
异常
UsernameNotFoundException 用户名没有发现异常。在 loadUserByUsername 中是需要通过自己的逻辑从数据库中取值的。如果通过用户名没有查询到对应的数据，应该抛出UsernameNotFoundException ，系统就知道用户名没有查询到
PasswordEncoder 密码解析器详解
Spring Security 要求容器中必须有 PasswordEncoder 实例。所以当自定义登录逻辑时要求必须给容器注入 PaswordEncoder 的bean对象。
接口介绍
- encode() ：把参数按照特定的解析规则进行解析。
- matches() ：验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回 true；如果不匹配，则返回
false。第一个参数表示需要被解析的密码。第二个参数表示存储的密码。 - upgradeEncoding() ：如果解析的密码能够再次进行解析且达到更安全的结果则返回 true，否则返回 false。默认返回
false。
内置解析器
在 Spring Security 中内置了很多解析器
BCryptPasswordEncoder 简介
BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析器，平时多使用这个解析器。
BCryptPasswordEncoder 是对 bcrypt 强散列方法的具体实现。是基于Hash算法实现的单向加密。可以通过strength控制加密强度，默认 10.
代码演示
新建测试方法BCryptPasswordEncoder 用法
@SpringBootTest
public class MyTest {
@Test
public void test(){
//创建解析器
PasswordEncoder pw = new BCryptPasswordEncoder();
//对密码加密
String encode = pw.encode("123");
System.out.println(encode);
//判断原字符和加密后内容是否匹配
boolean matches = pw.matches("1234", encode);
System.out.println("==================="+matches);
}
}
自定义登录逻辑
当 进 行 自 定 义 登 录 逻 辑 时 需 要 用 到 之 前 讲 解 的 UserDetailsService 和PasswordEncoder 。但是 Spring Security 要求：当进行自定义登录逻辑时容器内必须有PasswordEncoder 实例。所以不能直接 new 对象
编写配置类
package com.example.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
public class SecurityConfig {
@Bean
public PasswordEncoder getPW(){
return new BCryptPasswordEncoder();
}
}
自定义逻辑
在 Spring Security 中实现 UserDetailService 就表示为用户详情服务。在这个类中编写用户认证逻辑
package com.example.demo.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
@Service
public class UserServiceImpl implements UserDetailsService {
@Autowired
private PasswordEncoder pw;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//1.查询数据库判断用户名是否存在，如果不存在抛出UsernameNotFoundException异常
if (!"admin".equals(username)){
throw new UsernameNotFoundException("用户名不存在");
}
//2.把查询出来的密码（注册时已经加密过）进行解析，或直接把密码放入构造方法中
String password = pw.encode("123");
return new User(username,password,
AuthorityUtils.commaSeparatedStringToAuthorityList("admin,normal"));//角色
}
}
重启项目后，在浏览器中输入账号：admin，密码：123。后可以正确进入到 login.html 页面。
自定义登录页面
编写登录页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="/login" method="post">
用户名：<input type="text" name="username" /><br/>
密码：<input type="password" name="password" /><br/>
<input type="submit" value="登录" />
</form>
</body>
</html>
修改配置类
修改配置类中主要是设置哪个页面是登录页面。配置类需要继承WebSecurityConfigurerAdapte,并重写configure 方法
- successForwardUrl() ：登录成功后跳转地址
- loginPage() ：登录页面
- loginProcessingUrl ：登录页面表单提交地址，此地址可以不真实存在。
- antMatchers() ：匹配内容
- permitAll() ：允许访问，不需要认证
package com.example.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
//表单提交
http.formLogin()
//自定义登录页面
.loginPage("/login.html")
//当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
.loginProcessingUrl("/login")
//登录成功后跳转页面，POST请求，控制器
.successForwardUrl("/toMain");
http.authorizeRequests()
//login.html不需要被认证
.antMatchers("/login.html").permitAll()
//所有请求都必须被认证，必须登录后被访问
.anyRequest().authenticated();
//关闭csrf防护
http.csrf().disable();
}
@Bean
public PasswordEncoder getPW(){
return new BCryptPasswordEncoder();
}
}
编写控制器
package com.example.demo.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class LoginController {
// 该方法不执行
// @RequestMapping("login")
// public String login(){
// return "redirect:main.html";
// }
/**
* 成功后跳转页面
* @return
*/
@RequestMapping("/toMain")
public String toMain(){
return "redirect:/main.html";
}
}
认证过程其他常用配置
失败跳转
表单处理中成功会跳转到一个地址，失败也可以跳转到一个地址
编写页面error.html
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
操作失败，请重新登录 <a href= "/login.html">跳转a>
body>
html>
修改表单配置
在配置方法中表单认证部分添加 failureForwardUrl() 方法，表示登录失败跳转的 url。此处依然是POST 请求，所以跳转到可以接收 POST请求的控制器/error中
//表单提交
http.formLogin()
//自定义登录页面
.loginPage("/login.html")
//当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
.loginProcessingUrl("/login")
//登录成功后跳转页面，POST请求
.successForwardUrl("/toMain")
//登录失败后跳转页面，POST请求
.failureForwardUrl("/toError");
添加控制器的
在控制器类中添加控制器方法，方法映射路径/error。此处要注意：由于是 POST 请求访问/error。所以如果返回值直接转发到 error.html 中，即使有效果，控制台也会报警告，提示 error.html 不支持POST 访问方式
/**
* 失败后跳转页面
* @return
*/
@RequestMapping("/toError")
public String toError(){
return "redirect:/error.html";
}
设置error.html不需要认证
http.authorizeRequests()
//login.html不需要被认证
.antMatchers("/login.html").permitAll()
//error.html不需要被认证
.antMatchers("/error.html").permitAll()
//所有请求都必须被认证，必须登录后被访问
.anyRequest().authenticated();
设置请求账户和密码的参数名
当进行登录时会执行 UsernamePasswordAuthenticationFilter 过滤器
- usernamePasrameter ：账户参数名
- passwordParameter ：密码参数名
- postOnly=true ：默认情况下只允许POST请求
修改配置
//表单提交
http.formLogin()
//自定义登录页面
.loginPage("/login.html")
//当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
.loginProcessingUrl("/login")
//登录成功后跳转页面，POST请求
.successForwardUrl("/toMain")
//登录失败后跳转页面，POST请求
.failureForwardUrl("/toError")
.usernameParameter("myusername")
.passwordParameter("mypassword");
修改login.html
<form action="/login" method="post">
用户名：<input type="text" name="myusername" /><br/>
密码：<input type="password" name="mypassword" /><br/>
<input type="submit" value="登录" />
</form>
自定义登录成功处理器
使用successForwardUrl()时表示成功后转发请求到地址。内部是通过 successHandler() 方法进行控制成功后交给哪个类进行处理
ForwardAuthenticationSuccessHandler内部就是最简单的请求转发。由于是请求转发，当遇到需要跳转到站外或在前后端分离的项目中就无法使用了
所以当需要控制登录成功后去做一些事情时，可以进行自定义认证成功控制器
代码实现
自定义类
package com.example.demo.handle;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
private String url;
public MyAuthenticationSuccessHandler(String url) {
this.url = url;
}
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
//Principal 主体，存放了登录用户的信息
User user = (User) authentication.getPrincipal();
System.out.println(user.getUsername());
//输出null
System.out.println(user.getPassword());
System.out.println(user.getAuthorities());
response.sendRedirect(url);
}
}
修改配置项
使用 successHandler()方法设置成功后交给哪个对象进行处理
//表单提交
http.formLogin()
//自定义登录页面
.loginPage("/login.html")
//当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
.loginProcessingUrl("/login")
//登录成功后跳转页面，POST请求
// .successForwardUrl("/toMain")
//和successForwardUrl不能共存
.successHandler(new
MyAuthenticationSuccessHandler("http://www.baidu.com"))
//登录失败后跳转页面，POST请求
.failureForwardUrl("/toError")
.usernameParameter("myusername")
.passwordParameter("mypassword");
自定义登录失败处理器
failureForwardUrl()内部调用的是 failureHandler() 方法
ForwardAuthenticationFailureHandler 中也是一个请求转发，并在request 作用域中设置SPRING_SECURITY_LAST_EXCEPTION 的 key，内容为异常对象
代码实现
新建控制器
package com.example.demo.handle;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class MyForwardAuthenticationFailureHandler implements AuthenticationFailureHandler {
private String url;
public MyForwardAuthenticationFailureHandler(String url) {
this.url = url;
}
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
response.sendRedirect(url);
}
}
修改配置类
修改配置类中表单登录部分。设置失败时交给失败处理器进行操作。 failureForwardUrl 和failureHandler 不可共存
//表单提交
http.formLogin()
//自定义登录页面
.loginPage("/login.html")
//当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
.loginProcessingUrl("/login")
//登录成功后跳转页面，POST请求
// .successForwardUrl("/toMain")
//和successForwardUrl不能共存
.successHandler(new
MyAuthenticationSuccessHandler("http://www.baidu.com"))
//登录失败后跳转页面，POST请求
// .failureForwardUrl("/toError")
.failureHandler(new MyForwardAuthenticationFailureHandler("/error.html"))
.usernameParameter("myusername")
.passwordParameter("mypassword");
访问控制url匹配
在前面讲解了认证中所有常用配置，主要是对 http.formLogin() 进行操作。而在配置类中http.authorizeRequests() 主要是对url进行控制，也就是我们所说的授权（访问控制）。http.authorizeRequests() 也支持连缀写法，总体公式为：url 匹配规则.权限控制方法
anyRequest()
在之前认证过程中我们就已经使用过 anyRequest()，表示匹配所有的请求。一般情况下此方法都会使用，设置全部内容都需要进行认证
.anyRequest().authenticated();
antMatchers()
参数是不定向参数，每个参数是一个 ant 表达式，用于匹配 URL规则，规则如下：
- ? ： 匹配一个字符
- ：匹配 0 个或多个字符
- ** ：匹配 0 个或多个目录
在实际项目中经常需要放行所有静态资源，下面演示放行 js 文件夹下所有脚本文件
.antMatchers("/js/**","/css/**").permitAll()
还有一种配置方式是只要是.js 文件都放行
.antMatchers("/**/*.js").permitAll()
regexMatchers()
使用正则表达式进行匹配。和 antMatchers() 主要的区别就是参数， antMatchers() 参数是 ant 表达式， regexMatchers() 参数是正则表达式
以.js 结尾的文件都被放行
.regexMatchers( ".+[.]js").permitAll()
两个参数时使用方式
无论是 antMatchers() 还是 regexMatchers() 都具有两个参数的方法，其中第一个参数都是HttpMethod ，表示请求方式，当设置了 HttpMethod 后表示只有设定的特定的请求方式才执行对应的权限设置
mvcMatchers()
mvcMatchers()适用于配置了 servletPath 的情况
servletPath 就是所有的 URL 的统一前缀。在 SpringBoot 整合SpringMVC 的项目中可以在application.properties 中添加下面内容设置 ServletPath
spring.mvc.servlet.path=/xxxx
在 Spring Security 的配置类中配置 .servletPath() 是 mvcMatchers()返回值特有的方法，antMatchers()和 regexMatchers()没有这个方法。在 servletPath() 中配置了 servletPath 后，mvcMatchers()直接写 SpringMVC 中@RequestMapping()中设置的路径即可
.mvcMatchers("/demo").servletPath("/xxxx").permitAll()
如果不习惯使用 mvcMatchers()也可以使用 antMatchers()，下面代码和上面代码是等效
.antMatchers("/xxxx/demo").permitAll()
内置访问控制方法
Spring Security 匹配了 URL 后调用了 permitAll() 表示不需要认证，随意访问。在 Spring Security 中提供了多种内置控制
- permitAll()：表示所匹配的 URL 任何人都允许访问
- authenticated()：表示所匹配的 URL 都需要被认证才能访问
- anonymous()：表示可以匿名访问匹配的URL，和permitAll()效果类似，只是设置为 anonymous()的 url 会执行 filter 链中
- denyAll()：表示所匹配的 URL 都不允许被访问
- rememberMe() ：被“remember me”的用户允许访问
- fullyAuthenticated()：如果用户不是被 remember me 的，才可以访问
角色权限判断
除了之前讲解的内置权限控制。Spring Security 中还支持很多其他权限控制。这些方法一般都用于用户已经被认证后，判断用户是否具有特定的要求
hasAuthority(String)
判断用户是否具有特定的权限，用户的权限是在自定义登录逻辑中创建 User 对象时指定的。下图中admin和normal 就是用户的权限。admin和normal 严格区分大小写
在配置类中通过 hasAuthority(“admin”)设置具有 admin 权限时才能访问
.antMatchers("/main1.html").hasAuthority("admin")
hasAnyAuthority(String …)
如果用户具备给定权限中某一个，就允许访问
下面代码中由于大小写和用户的权限不相同，所以用户无权访问
.antMatchers("/main1.html").hasAnyAuthority("adMin","admiN")
hasRole(String)
如果用户具备给定角色就允许访问。否则出现 403；
在给用户赋予角色时角色需要以： **ROLE_**开头 ，后面添加角色名称。例如：ROLE_abc 其中 abc 是角色名，ROLE_是固定的字符开头
使用 hasRole()时参数也只写 abc 即可，否则启动报错
在配置类中直接写 abc 即可
.antMatchers("/main1.html").hasRole("abc")
hasAnyRole(String …)
如果用户具备给定角色的任意一个，就允许被访问
hasIpAddress(String)
如果请求是指定的 IP 就运行访问，可以通过 request.getRemoteAddr() 获取 ip 地址
需要注意的是在本机进行测试时 localhost 和 127.0.0.1 输出的 ip地址是不一样的
.antMatchers("/main1.html").hasIpAddress("127.0.0.1")
自定义403处理方案
新建类实现 AccessDeniedHandler
package com.example.demo.handle;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);//错误码 403
response.setHeader("Content-Type", "application/json;charset=utf-8");
PrintWriter out = response.getWriter();
out.write("{\"status\":\"error\",\"msg\":\"权限不足，请联系管理员！\"}");
out.flush();
out.close();
}
}
修改配置类
配置类中重点添加异常处理器，设置访问受限后交给哪个对象进行处理
myAccessDeniedHandler 是在配置类中进行自动注入的
//异常处理
http.exceptionHandling().accessDeniedHandler(myAccessDeniedHandler);
基于注解的访问控制
在 Spring Security 中提供了一些访问控制的注解。这些注解都是默认是都不可用的，需要通过**@EnableGlobalMethodSecurity** 进行开启后使用；如果设置的条件允许，程序正常执行。如果不允许会报 500
这些注解可以写到 Service 接口或方法上，也可以写到 Controller或 Controller 的方法上。通常情况下都是写在控制器方法上的，控制接口URL是否允许被访问
@Secured
专门用于判断是否具有角色的，能写在方法或类上。参数要以 ROLE_开头
开启注解
在 启 动 类 ( 也 可 以 在 配 置 类 等 能 够 扫 描 的 类 上 )上添加**@EnableGlobalMethodSecurity(securedEnabled = true)**
@SpringBootApplication
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SpringsecurityDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringsecurityDemoApplication.class, args);
}
}
在控制器方法上添加@Secured 注解
/**
* 成功后跳转页面
* @return
*/
@Secured("ROLE_abc")
@RequestMapping("/toMain")
public String toMain(){
return "redirect:/main.html";
}
配置类
@Override
protected void configure(HttpSecurity http) throws Exception {
//表单提交
http.formLogin()
//自定义登录页面
.loginPage("/login.html")
//当发现/login时认为是登录，必须和表单提交的地址一样。去执行UserServiceImpl
.loginProcessingUrl("/login")
//登录成功后跳转页面，POST请求
.successForwardUrl("/toMain")
//url拦截
http.authorizeRequests()
//login.html不需要被认证
.antMatchers("/login.html").permitAll()
//所有请求都必须被认证，必须登录后被访问
.anyRequest().authenticated();
//关闭csrf防护
http.csrf().disable();
}
@PreAuthorize/@PostAuthorize
@PreAuthorize/@PostAuthorize都是方法或类级别的注解
- @PreAuthorize：表示访问方法或类在执行之前先判断权限，大多情况下都是使用这个注解，注解的参数和access()方法参数取值相同，都是权限表达式
- @PostAuthorize 表示方法或类执行结束后判断权限，此注解很少被使用到
添加@PreAuthorize
在控制器方法上添加@PreAuthorize，参数可以是任何 access()支持的表达式
/**
* 成功后跳转页面
* @return
*/
@PreAuthorize("hasRole('ROLE_abc')")
@RequestMapping("/toMain")
public String toMain(){
return "redirect:/main.html";
}
RememberMe功能实现
Spring Security 中 Remember Me 为“记住我”功能，用户只需要在登录时添加 remember-me复选框，取值为true。Spring Security 会自动把用户信息存储到数据源中，以后就可以不登录进行访问
添加依赖
Spring Security 实 现 Remember Me 功 能 时 底 层 实 现 依 赖Spring-JDBC，所以需要导入 SpringJDBC。以后多使用 MyBatis 框架而很少直接导入 spring-jdbc，所以此处导入 mybatis 启动器同时还需要添加 MySQL 驱动
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.1.1version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.18version>
dependency>
配置数据源
spring.datasource.driver-class-name= com.mysql.cj.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/security?
useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username= root
spring.datasource.password= root
编写配置
package com.example.demo.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;
import javax.sql.DataSource;
@Configuration
public class RememberMeConfig {
@Autowired
private DataSource dataSource;
@Bean
public PersistentTokenRepository getPersistentTokenRepository(){
JdbcTokenRepositoryImpl jdbcTokenRepository = new
JdbcTokenRepositoryImpl();
jdbcTokenRepository.setDataSource(dataSource);
//自动建表，第一次启动时需要，第二次启动时注释掉
jdbcTokenRepository.setCreateTableOnStartup(true);
return jdbcTokenRepository;
}
}
修改SecurityConfig.java
在SecurityConfig中添加RememberMeConfig和UserDetailsService实现类对象，并自动注入
在 configure 中添加下面配置内容
http.rememberMe()
//登录逻辑交给哪个对象
.userDetailsService(userService)
// 持久层对象
.tokenRepository(persistentTokenRepository);
在客户端页面添加复选框
<form action="/login" method="post">
用户名：<input type="text" name="username" /><br/>
密码：<input type="password" name="password" /><br/>
<input type="checkbox" name="remember-me" value="true"/><br/>
<input type="submit" value="登录" />
</form>
有效时间
默认情况下重启项目后登录状态失效了。但是可以通过设置状态有效时间，即使项目重新启动下次也可以正常登录
http.rememberMe()
//失效时间，单位秒
.tokenValiditySeconds(120)
//登录逻辑交给哪个对象
.userDetailsService(userService)
// 持久层对象
.tokenRepository(persistentTokenRepository);
Thymeleaf中SpringSecurity的使用
Spring Security 可以在一些视图技术中进行控制显示效果。例如： JSP 或 Thymeleaf 。在非前后端分离且使用 Spring Boot 的项目中多使用 Thymeleaf 作为视图展示技术
Thymeleaf 对 Spring Security 的 支 持 都 放 在 thymeleaf-extras-springsecurityX 中，目前最新版本为 5。所以需要在项目中添加此 jar 包的依赖和 thymeleaf 的依赖
<!--thymeleaf springsecurity5 依赖-->
<dependency>
<groupId>org.thymeleaf.extras</groupId>
<artifactId>thymeleaf-extras-springsecurity5</artifactId>
</dependency>
<!--thymeleaf依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
在 html 页面中引入 thymeleaf 命名空间和 security 命名空间
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org"
xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
获取属性
可以在html页面中通过 sec:authentication=“” 获取UsernamePasswordAuthenticationToken 中所有 getXXX 的内容，包含父类中的 getXXX 的内容
根据源码得出下面属性：
- name ：登录账号名称
- principal ：登录主体，在自定义登录逻辑中是 UserDetails
- credentials ：凭证
- authorities ：权限和角色
- details ：实际上是 WebAuthenticationDetails 的实例。可以获取 remoteAddress (客户端
ip)和 sessionId (当前 sessionId)
新建demo.html
在项目 resources 中新建 templates 文件夹，在 templates 中新建demo.html 页面
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
登录账号:<span sec:authentication="name"></span><br/>
登录账号:<span sec:authentication="principal.username"></span><br/>
凭证：<span sec:authentication="credentials"></span><br/>
权限和角色：<span sec:authentication="authorities"></span><br/>
客户端地址：<span sec:authentication="details.remoteAddress"></span><br/>
sessionId：<span sec:authentication="details.sessionId"></span><br/>
</body>
</html>
编写Controller
thymeleaf 页面需要控制转发，在控制器类中编写下面方法
@RequestMapping("/demo")
public String demo(){
return "demo";
}
权限判断
设置用户角色和权限，设定用户具有 admin，/insert，/delete 权限 ROLE_abc 角色
return new User(username,password,
AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/insert,/dele
te"));
控制页面显示效果
在页面中根据用户权限和角色判断页面中显示的内容
通过权限判断：
<button sec:authorize="hasAuthority('/insert')">新增</button>
<button sec:authorize="hasAuthority('/delete')">删除</button>
<button sec:authorize="hasAuthority('/update')">修改</button>
<button sec:authorize="hasAuthority('/select')">查看</button>
<br/>
通过角色判断：
<button sec:authorize="hasRole('abc')">新增</button>
<button sec:authorize="hasRole('abc')">删除</button>
<button sec:authorize="hasRole('abc')">修改</button>
<button sec:authorize="hasRole('abc')">查看</button>
退出登录
用户只需要向 Spring Security 项目中发送 /logout 退出请求即可
在页面中添加 /logout 的超链接即可
<a href="/logout">退出登录a>
为了实现更好的效果，通常添加退出的配置。默认的退出 url 为 /logout ，退出成功后跳转到 /login?logout
如果不希望使用默认值，可以通过下面的方法进行修改
http.logout()
.logoutUrl("/logout")
.logoutSuccessUrl("/login.html");
SpringSecurity中的CSRF
从刚开始学习Spring Security时，在配置类中一直存在这样一行代码： http.csrf().disable(); 如果没有这行代码导致用户无法被认证。这行代码的含义是：关闭 csrf 防护
什么是CSRF
CSRF（Cross-site request forgery）跨站请求伪造，也被称为“OneClick Attack” 或者 Session
Riding。通过伪造用户请求访问受信任站点的非法请求访问。
跨域：只要网络协议，ip 地址，端口中任何一个不相同就是跨域请求。
客户端与服务进行交互时，由于 http 协议本身是无状态协议，所以引入了cookie进行记录客户端身份。在cookie中会存放session id用来识别客户端身份的。在跨域的情况下，session id 可能被第三方恶意劫持，通过这个 session id 向服务端发起请求时，服务端会认为这个请求是合法的，可能发生很多意想不到的事情。
Spring Security中的CSRF
从 Spring Security4开始CSRF防护默认开启。默认会拦截请求。进行CSRF处理。CSRF为了保证不是其他第三方网站访问，要求访问时携带参数名为 _csrf 值为token(token 在服务端产生)的内容，如果token和服务端的token匹配成功，则正常访问
编写控制器方法
编写控制器方法，跳转到 templates 中 login.html 页面
@RequestMapping("/showLogin")
public String showLogin(){
return "login";
}
新建login.html
DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org"
>
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<form action="/login" method="post">
<input type="hidden" th:value="${_csrf.token}" name="_csrf"
th:if="${_csrf}"/>
用户名：<input type="text" name="username" /><br/>
密码：<input type="password" name="password" /><br/>
<input type="submit" value="登录" />
form>
body>
html>
修改配置类
//关闭csrf防护
// http.csrf().disable();