Spring全家桶之SpringSecurity
SpringSecurity
- 一、Spring Security简介
- 二、第一个 SpringSecurity 项目
- 三、 UserDetailsService 详解
- 四、 PasswordEncoder 密码解析器详解
- 五、 自定义登录逻辑
- 六、 自定义登录页面
- 七、 认证过程其他常用配置
- 失败跳转
- 设置请求账户和密码的参数名
- 自定义登录成功 /失败处理器
- 源码分析
- 代码实现
- 八、访问控制url 匹配
- 九、内置访问控制方法介绍
- 1 permitAll()
- 2 denyAll()
- 3 anonymous()
- 4 authenticated()
- 5 fullyAuthenticated()
- 6 rememberMe()
- 十、角色权限判断
- 1.hasAuthority(String)
- 2 hasAnyAuthority(String ...)
- 3 hasRole(String)
- 4 hasAnyRole
- 5 hasIpAddress(String)
- 十一、自定义403 处理方案
- 功能实现步骤
- 补充 : 常见的状态码
- 十二、基于表达式的访问控制
- access()方法使用
- 使用自定义方法集合access实现权限控制
- 十三、基于注解的访问控制
- @Secured
- @PreAuthorize/@PostAuthorize
- 十四、Remember Me 功能实现
- 补充 : 配置高版本的mysql-connector
- 十五、Thymeleaf 中Spring Security 的使用
- 获取属性
- 权限判断
- 十六、退出登录
- 补充 :如何使用断点调试解读源码?
- 十七、Spring Security 中CSRF
- 1 什么是CSRF
- 2 Spring Security 中CSRF
一、Spring Security简介
1.概括
SpringSecurity 是一个高度自定义的安全框架。利用 SpringIoC/DI和 AOP 功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。使用 SpringSecruity 的原因有很多，但大部分都是发现了 javaEE的 Servlet 规范或 EJB 规范中的安全功能缺乏典型企业应用场景。同时认识到他们在 WAR 或 EAR 级别无法移植。因此如果你更换服务器环境，还需要大量工作去重新配置你的应用程序。使用 SpringSecurity解决了这些问题，也为你提供许多其他有用的、可定制的安全功能。
正如你可能知道的两个应用程序的两个主要区域是“认证”和“授权”（或者访问控制）。这两点也是 SpringSecurity 重要核心功能。“认证”，是建立一个他声明的主体的过程（一个“主体”一般是指用户，设备或一些可以在你的应用程序中执行动作的其他系统），通俗点说就是系统认为用户是否能登录。“授权”指确定一个主体是否允许在你的应用程序执行一个动作的过程。通俗点讲就是系统判断用户是否有权限去做某些事情。
2.历史
Spring Security 以“The Acegi Secutity System for Spring” 的名字始于 2003 年年底。其前身为 acegi 项目。起因是 Spring 开发者邮件列表中一个问题，有人提问是否考虑提供一个基于 Spring 的安全实现。限制于时间问题，开发出了一个简单的安全实现，但是并没有深入研究。几周后，Spring 社区中其他成员同样询问了安全问题，代码提供给了这些人。2004 年 1 月份已经有 20 人左右使用这个项目。随着更多人的加入，在 2004 年 3 月左右在 sourceforge 中建立了一个项目。在最开始并没有认证模块，所有的认证功能都是依赖容器完成的，而 acegi 则注重授权。但是随着更多人的使用，基于容器的认证就显现出了不足。 acegi 中也加入了认证功能。 大约 1 年后 acegi 成为 Spring子项目。 在 2006 年 5 月发布了 acegi1.0.0 版本。2007 年底 acegi 更名为SpringSecurity。
二、第一个 SpringSecurity 项目
-
使用spring 官网快速床架一个sprigboot项目，并导入security、web启动器(会自动生成启动类)。
点击进入快速构建SpringBoot项目页面快速构建好的项目的pom文件
<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.1.8.RELEASEversion> <relativePath/> parent> <groupId>ah.szxy.springsecuritygroupId> <artifactId>01-SpringSecurity-DemoartifactId> <version>0.0.1-SNAPSHOTversion> <name>01-SpringSecurity-Demoname> <description>Demo project for Spring Bootdescription> <properties> <java.version>1.8java.version> <spring-cloud.version>Greenwich.SR3spring-cloud.version> <maven-jar-plugin.version>2.6maven-jar-plugin.version> properties> <dependencies> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-webartifactId> dependency> <dependency> <groupId>org.springframework.cloudgroupId> <artifactId>spring-cloud-starter-securityartifactId> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-testartifactId> <scope>testscope> dependency> dependencies> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloudgroupId> <artifactId>spring-cloud-dependenciesartifactId> <version>${spring-cloud.version}version> <type>pomtype> <scope>importscope> dependency> dependencies> dependencyManagement> <build> <plugins> <plugin> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-maven-pluginartifactId> plugin> plugins> build> project>注意:本项目使用的是SpringBoot 2.1.8版本
-
创建一个简单的登录界面(login.html)和主页面(main.html)，以及登录控制器
controller
@Controller public class LoginController { @RequestMapping("login") public String Login() { System.out.println("执行了登陆的方法"); return "redirect:main.html"; } }login.html
<html> <head> <meta charset="UTF-8"> <title>登陆结果页面title> head> <body> <form action="/login" method="post"> 姓名:<input type="text" name="username" ><br> 密码:<input type="password" name="password"><br> <button>登陆button> form> body> html>main.html
<html> <head> <meta charset="UTF-8"> <title>登陆结果界面title> head> <body> <h1>登陆成功h1> body> html> -
测试结果
在项目中新建login.html 页面后
在浏览器输入：http://localhost:8080/login.html 后会显示下面页面
上面这个界面就是SpringSecurity 为我们生成的认证界面
默认的username 为user，password 打印在控制台中 ,而且每次启动项目时生成的密码都不同(如下图)
在认证成功后 ,我们就可以访问我们自己写好的登陆界面
需要注意的是 ,默认的密码只能使用一次 ,列如我们访问到 login.html页面后 ,在此退回到登陆页面,然后再用刚才的方式重新登陆 ,结果出现如下页面 ,需要我们重启项目即可
三、 UserDetailsService 详解
当什么也没有配置的时候，账号和密码是由 SpringSecurity 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。所以我们要通过自定义逻辑控制认证逻辑。如果需要自定义逻辑时，只需要实现 UserDetailsService 接口即可。接口定义如下：
UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}
1.返回值
返回值 UserDetails 是一个接口，定义如下方法 ,要想返回 UserDetails 的实例就只能返回接口的实现类。而User就是UserDatails 的具体实现类.
User做为UserDatails 的具体实现类。注意 User 的全限定路径是：org.springframework.security.core.userdetails.User , 此处经常和系统中自己开发的 User 类弄混
在 User 类中提供了很多方法和属性。其中构造方法有两个，调用其中任何一个都可以实例化UserDetails 实现类 User 类的实例。而3个参数的构造方法实际上也是调用 7 个参数的构造方法。
username //用户名
password //密码
authorities //用户具有的权限。此处不允许为 null
此处的用户名应该是客户端传递过来的用户名。而密码应该是从数据库中查询出来的密码。SpringSecurity 会根据 User 中的 password和客户端传递过来的 password 进行比较。如果相同则表示认证通过，如果不相同表示认证失败。
authorities 里面的权限对于后面学习授权是很有必要的，包含的所有内容为此用户具有的权限，如有里面没有包含某个权限，而在做某个事情时必须包含某个权限则会出现 403。通常都是通过AuthorityUtils.commaSeparatedStringToAuthorityList(“”) 来创建authorities 集合对象的。参数是一个字符串，多个权限使用逗号分隔。
2.方法参数
方法参数表示用户名。此值是客户端表单传递过来的数据。默认情况下必须叫 username，否则无法接收。
3. 异常
UsernameNotFoundException 用户名没有发现异常。 在loadUserByUsername 中是需要通过自己的逻辑从数据库中取值的。如果通过用户名没有查询到对应的数据，应该抛出UsernameNotFoundException，系统就知道用户名没有查询到。
四、 PasswordEncoder 密码解析器详解
SpringSecurity 要求容器中必须有 PasswordEncoder 实例。
所以当自定义登录逻辑时要求必须给容器注入PaswordEncoder的bean对象
1. 接口介绍
encode() : 把参数按照特定的解析规则进行解析。
matches() : 验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回 true；如果不匹配，则返回 false。第一个参数表示需要被解析的密码。第二个参数表示存储的密码。
upgradeEncoding() ：如果解析的密码能够再次进行解析且达到更安全的结果则返回 true，否则返回 false。默认返回 false。
2. 内置解析器介绍
在 SpringSecurity 中内置了很多解析器。在这里主要讲解BCryptPasswordEncoder
3. BCryptPasswordEncoder 的讲解
BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析器，平时多使用这个解析器。
BCryptPasswordEncoder 是对 bcrypt 强散列方法的具体实现, 是基于 Hash 算法实现的单向加密。可以通过 strength 控制加密强度，默认 10.
4. 代码演示
在项目创建测试类测试BCryptPasswordEncoder 用法。
@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {
@Test
public void contextLoads() {
PasswordEncoder encoder=new BCryptPasswordEncoder();
String encode = encoder.encode("123");
System.out.println("---------"+encode);
//$2a$10$2dJQEvpeaBXQ8WGf.CXmq.Qil9R5JFvgMY9HTCXSO2r7YzhwvYCRm
boolean matches = encoder.matches("123", encode);
System.out.println("++++++++++"+matches);//true
/**
*如果需要重新解析密码以提高安全性，则返回true ,否则返回false。默认实现总是返回false。
* @param encodedPassword要检查的编码密码
* @return 如果需要重新解析密码以获得更好的安全性返回true，否则false。
*/
boolean upgradeEncoding = encoder.upgradeEncoding(encode);
System.out.println("解析的密码能够再次进行解析且达到更安全的结果 : "+upgradeEncoding);//false
}
}
五、 自定义登录逻辑
当进行自定义登录逻辑时需要用到之前讲解的UserDetailsService 和 PasswordEncoder。
但是 SpringSecurity 要求：当进行自定义登录逻辑时容器内必须有 PasswordEncoder 实例。
所以不能直接 new 对象。通过配置了创建PasswordEncoder对象
案例实现
-
创建配置类
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; /** * 实例化密码解析器 * 方便实现类通过@Autowired注入 * @author chy * */ @Configuration public class SecurityConfig { @Bean public PasswordEncoder getPwdEncoder() { return new BCryptPasswordEncoder(); } } -
编写具体的业务逻辑
注意: 需要实现 UserDetailsService ,并且注入PasswordEncoder
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; import org.springframework.stereotype.Service; /** * 在Spring Security 中实现UserDetailService 表示为用户详情服务。 在这个类中编写用户认证逻辑。 * * @author chy * */ @Service public class LoginServiceImpl implements UserDetailsService { @Autowired private PasswordEncoder encoder; @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { // 1. 查询数据库判断用户名是否存在，如果不存在抛出UsernameNotFoundException if (!username.equals("admin")) { // 设置了这个条件后, 必须输入用户名 admin,密码123才能登陆 throw new UsernameNotFoundException("用户名不存在"); } // 把查询出来的密码进行解析,或直接把password 放到构造方法中。 // 理解:password 就是数据库中查询出来的密码，查询出来的内容不是123 // 之所以encode一下,是因为没连接数据库,没有获取数据库中加密后的字符串 String password = encoder.encode("123"); return new User(username, password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin")); } }
六、 自定义登录页面
虽然 SpringSecurity 给我们提供了登录页面，
但是对于实际项目中，大多喜欢使用自己的登录页面。
所以 SpringSecurity 中不仅仅提供了登录页面，还支持用户自定义登录页面。
实现过程也比较简单，只需要修改配置类即可。
-
编写登录页面
编写登录页面，登录页面中的 action 不编写对应控制器也可以。
默认情况下表单name属性必须为username和password。<html> <head> <meta charset="UTF-8"> <title>登陆结果页面title> head> <body> <form action="/login" method="post"> 姓名:<input type="text" name="username" ><br> 密码:<input type="text" name="password"><br> <button>登陆button> form> body> html> -
修改配置类
修改配置类中主要是设置哪个页面是登录页面。配置类需要继承WebSecurityConfigurerAdapte,并重写 configure 方法。
-
successForwardUrl()登录成功后跳转地址
-
loginPage() 登录页面
-
loginProcessingUrl 登录页面表单提交地址，此地址可以不真实存在。
-
antMatchers():匹配内容
-
permitAll():允许
@Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter{ /** * 必须制定一个PasswordEncoder用于密码加密 * @return */ @Bean public PasswordEncoder setEncoder() { return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception { //super.configure(http); //表单认证 http.formLogin() .loginProcessingUrl("/login") //设置登录请求ur .loginPage("/login.html") //设置自定义登录页面，使用绝对路径 .successForwardUrl("/loginSuccess"); //设置登陆成功后跳转的请求路径 //拦截: 相当于授权的过程 http.authorizeRequests() .antMatchers("/login.html").permitAll() //请求登录页面的请求不需要认证。 .anyRequest().authenticated(); //所有请求都需要认证 //关闭csrf防护，类似于防火墙，不关闭上面的设置不会真正生效。 http.csrf().disable(); } }
-
编写控制器
编写控制器，当用户登录成功后跳转 /user/loginSuccess 控制器。
编写完成控制器后编写 main.html。
页面中随意写上一句话表示 main.html 页面内容即可。
而之前的/user/login 控制器方法是不执行的，所以可以删除了。import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; @Controller public class LoginController { @RequestMapping("/loginSuccess") public String Login() { System.out.println("执行了登陆的方法"); return "redirect:/main.html"; } }注意 : 在使用SpringSecurity时 , 无论是前端页面还是Controller 最好对每个url都加上 " / "
-
测试结果
访问任意页面,跳转到自定义的SpringSecurity的登陆界面
可以看到输入上个实例中自定义的登陆逻辑中输入的用户名和密码后,跳转到登陆成功页面
七、 认证过程其他常用配置
失败跳转
表单处理中成功会跳转到一个地址，失败也可以跳转到一个地址中
-
在配置类中修改表单认证和拦截逻辑
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() .loginProcessingUrl("/login") //当发现/login 时认为是登录，需要执行UserDetailsServiceImpl .loginPage("/login.html") .failureForwardUrl("/loginFalse") //认证失败后跳转的url .successForwardUrl("/loginSuccess"); //认证成功后跳转的url //拦截: 相当于授权的过程 http.authorizeRequests() .antMatchers("/login.html").permitAll() //login.html 不需要被认证 .antMatchers("/error.html").permitAll() .anyRequest().authenticated(); //所有的请求都必须被认证。必须登录后才能访问。 //关闭csrf防护 http.csrf().disable(); } //必须制定一个PasswordEncoder用于密码加密 @Bean public PasswordEncoder getPwdEncoder() { return new BCryptPasswordEncoder(); } } -
在controller中创建认证失败跳转的方法,根据
failureForwardUrl("/loginFalse")@RequestMapping("/loginFalse") public String LoginFalse() { return "redirect:/error.html"; } -
创建前端页面
<html> <head> <meta charset="UTF-8"> <title>登陆结果页面title> head> <body> <h1>登陆失败,请重试 <a href="/login.html">跳转a>h1> body> html> -
测试效果
认证通过时
认证失败时
设置请求账户和密码的参数名
源码简介
当进行登录时会执行 UsernamePasswordAuthenticationFilter 过滤器。
相关参数
usernamePasrameter:账户参数名
passwordParameter:密码参数名
postOnly=true:默认情况下只允许 POST 请求。
发现源码中默认情况下，只能以post方式登录，表单name必须为username、password。
在配置类中可以修改
案例实现
-
修改配置类
添加 usernameParameter() 和 passwordParameter()的方法
自定义设置认证表单中用户名 , 密码的name属性@Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter{ @Override protected void configure(HttpSecurity http) throws Exception { //表单认证 http.formLogin() .loginProcessingUrl("/login") //当发现/login 时认为是登录，需要执行UserDetailsServiceImpl .loginPage("/login.html") .successForwardUrl("/loginSuccess") //认证成功后跳转的url,post 请求 .failureForwardUrl("/loginFalse") //认证失败后跳转的url,post请求 .usernameParameter("uname") //自定义设置认证表单中用户名的name属性 .passwordParameter("upwd"); //自定义设置认证表单中密码的name属性 //拦截: 相当于授权的过程 http.authorizeRequests() .antMatchers("/login.html").permitAll() //登陆页面不需要被认证 .antMatchers("/error.html").permitAll() //登陆失败后的页面不需要再次被认证 .anyRequest().authenticated(); //所有的请求都必须被认证。必须登录后才能访问。 //关闭csrf防护，类似于防火墙，不关闭上面的设置不会真正生效。 http.csrf().disable(); } //必须制定一个PasswordEncoder用于密码加密 @Bean public PasswordEncoder getPwdEncoder() { return new BCryptPasswordEncoder(); } } -
根据配置类修改的属性 ,更改前端页面的属性 login.html
<form action="/login" method="post"> 姓名:<input type="text" name="uname" ><br> 密码:<input type="text" name="upwd"><br> <button>登陆</button> </form> -
测试结果同上
自定义登录成功 /失败处理器
源码分析
1.自定义登录成功处理器源码分析
使用successForwardUrl()时表示成功后转发请求到地址。
内部是通过successHandler（）方法进行控制成功后交给哪个类进行处理
/**
* Forward Authentication Success Handler
*
* @param forwardUrl the target URL in case of success
* @return the {@link FormLoginConfigurer} for additional customization
*/
public FormLoginConfigurer<H> successForwardUrl(String forwardUrl) {
successHandler(new ForwardAuthenticationSuccessHandler(forwardUrl));
return this;
}
ForwardAuthenticationSuccessHandler 内部就是最简单的请求转发。
由于是请求转发，当遇到需要跳转到站外或在前后端分离的项目中就无法使用了。
public class ForwardAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
private final String forwardUrl;
/**
* @param forwardUrl
*/
public ForwardAuthenticationSuccessHandler(String forwardUrl) {
Assert.isTrue(UrlUtils.isValidRedirectUrl(forwardUrl),
() -> "'" + forwardUrl + "' is not a valid forward URL");
this.forwardUrl = forwardUrl;
}
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
request.getRequestDispatcher(forwardUrl).forward(request, response);
}
}
当需要控制登录成功后去做一些事情时，可以进行自定义认证成功控制器。
2.自定义登录成功处理器源码分析
failureForwardUrl()内部调用的是failureHandler()方法
/**
* Forward Authentication Failure Handler
*
* @param forwardUrl the target URL in case of failure
* @return the {@link FormLoginConfigurer} for additional customization
*/
public FormLoginConfigurer<H> failureForwardUrl(String forwardUrl) {
failureHandler(new ForwardAuthenticationFailureHandler(forwardUrl));
return this;
}
ForwardAuthenticationFailureHandler 中也是一个请求转发，
并在request 作用域中设置SPRING_SECURITY_LAST_EXCEPTION 的key，内容为异常对象。
/**
*
* Forward Authentication Failure Handler
*
*
* @author Shazin Sadakath
* @since 4.1
*/
public class ForwardAuthenticationFailureHandler implements AuthenticationFailureHandler {
private final String forwardUrl;
/**
* @param forwardUrl
*/
public ForwardAuthenticationFailureHandler(String forwardUrl) {
Assert.isTrue(UrlUtils.isValidRedirectUrl(forwardUrl),
() -> "'" + forwardUrl + "' is not a valid forward URL");
this.forwardUrl = forwardUrl;
}
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
request.setAttribute(WebAttributes.AUTHENTICATION_EXCEPTION, exception);
request.getRequestDispatcher(forwardUrl).forward(request, response);
}
}
代码实现
新建一个处理器的类 , 编写代码如下
1.自定义登陆成功的处理器
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
/**
* 自定义成功处理器
* @author chy
*
*/
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
Authentication authentication) throws IOException, ServletException {
//Principal 主体，存放了登录用户的信息
User user = (User)authentication.getPrincipal();
System.out.println(user.getUsername());//admin
System.out.println(user.getPassword());//密码输出为null
System.out.println(user.getAuthorities());//
//重定向到百度。这只是一个示例，具体需要看项目业务需求
response.sendRedirect("http://www.baidu.com");//[admin]
}
}
2.自定义登陆失败的处理器
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
/**
* 自定义失败处理器
* @author chy
*
*/
public class FailHandler implements AuthenticationFailureHandler {
private String url;
public FailHandler(String url) {
super();
this.url = url;
}
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
AuthenticationException exception) throws IOException, ServletException {
System.out.println(exception);
response.sendRedirect(url);
}
}
3.修改配置类中页面跳转的方法
将登陆成功/ 失败跳转到对应的 url 的方法修改成登陆成功/ 失败后跳转到对应的 处理器类 的方法
页面跳转有两种方式,
一种是直接通过重新接口方法的response参数进行重定向
一种是定义一个String类型的url ,创建一个带参的构造方法, 在创建页面跳转的处理器时直接指定url
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;
/**
* 页面跳转有两种方式,
* 一种是直接通过重新接口方法的response参数进行重定向
*一种是定义一个String类型的url ,创建一个带参的构造方法, 在创建页面跳转的处理器时直接指定url
*
* @author chy
*
*/
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{
@Override
protected void configure(HttpSecurity http) throws Exception {
//表单认证
http.formLogin()
.loginProcessingUrl("/login") //当发现/login 时认为是登录，需要执行UserDetailsServiceImpl
.loginPage("/login.html")
//.successForwardUrl("/loginSuccess") //认证成功后跳转的url,post 请求
.successHandler(new MyAuthenticationSuccessHandler())
//.failureForwardUrl("/loginFalse") //认证失败后跳转的url,post请求
.failureHandler(new FailHandler("/error.html"))
.usernameParameter("uname") //自定义设置认证表单中用户名的name属性
.passwordParameter("upwd"); //自定义设置认证表单中密码的name属性
//拦截: 相当于授权的过程
http.authorizeRequests()
.antMatchers("/login.html").permitAll() //登陆页面不需要被认证
.antMatchers("/error.html").permitAll() //登陆失败后的页面不需要再次被认证
.anyRequest().authenticated(); //所有的请求都必须被认证。必须登录后才能访问。
//关闭csrf防护，类似于防火墙，不关闭上面的设置不会真正生效。
http.csrf().disable();
}
//必须制定一个PasswordEncoder用于密码加密
@Bean
public PasswordEncoder getPwdEncoder() {
return new BCryptPasswordEncoder();
}
}
3.测试结果
使用自定义成功处理器后,登陆成功后会跳转到指定的url(百度首页)
使用自定义失败处理器后,登陆失败后会跳转到指定的url(error.html)
八、访问控制url 匹配
在前面讲解了认证中所有常用配置，主要是对http.formLogin()进行操作。
而在配置类中http.authorizeRequests()主要是对url 进行控制，也就是我们所说的授权（访问控制）。http.authorizeRequests()也支持连缀写法，总体公式为：url 匹配规则.权限控制方法
//拦截: 相当于授权的过程
http.authorizeRequests()
.antMatchers("/login.html").permitAll() //登陆页面不需要被认证
.antMatchers("/error.html").permitAll() //登陆失败后的页面不需要再次被认证
//.antMatchers("/css/**","/js/**","/images/**").permitAll() //放行静态资源,/**表示当前目录以及子目录
.antMatchers("/**/*.png").permitAll() //放行所有为png格式的图片
.anyRequest().authenticated(); //其他所有的请求都必须被认证。必须登录后才能访问。
通过上面的公式可以有很多url 匹配规则和很多权限控制方法。
这些内容进行各种组合就形成了Spring Security 中的授权。
在所有匹配规则中取所有规则的交集。配置顺序影响了之后授权效果，
越是具体的应该放在前面，越是笼统的应该放到后面。
1 anyRequest()
在之前认证过程中我们就已经使用过anyRequest()，表示匹配所有的请求。
一般情况下此方法都会使用，设置全部内容都需要进行认证。.anyRequest().authenticated();
2 antMatcher()
方法定义如下：public C antMatchers(String... antPatterns)
参数是不定向参数，每个参数是一个ant 表达式，用于匹配URL规则。
规则如下：
? 匹配一个字符
* 匹配0 个或多个字符
** 匹配0 个或多个目录
a.在实际项目中经常需要放行所有静态资源，下面演示放行images文件夹下所有脚本文件。
.antMatchers("/css/**","/js/**","/images/**").permitAll()
测试效果,创建静态资源文件夹
通过浏览器直接访问a.png,b.jpg ,发现都可以访问
b.还有一种配置方式是只要是.png文件都放行
.antMatchers("/**/*.png").permitAll()
测试效果,创建静态资源文件夹
通过浏览器直接访问a.png,发现可以访问
直接访问 b.jpg ,发现跳回用户登陆界面,因为 .jpg格式的没有被拦截
3.1 regexMatchers()
使用正则表达式进行匹配。和antMatchers()主要的区别就是参数，这里附上一些常见的正则表达式
antMatchers()参数是ant 表达式，regexMatchers()参数是正则表达式。
演示所有以 .jpg 结尾的文件都被放行。
.regexMatchers(".+[.]jpg").permitAll()
测试效果,创建静态资源文件夹
通过浏览器直接访问a.png,被重定向到了用户登陆的界面
直接访问 b.jpg ,发现可以被访问
3.2 两个参数时使用方式
无论是antMatchers()还是regexMatchers()都具有两个参数的方法，
其中第一个参数都是HttpMethod，表示请求方式,
当设置了HttpMethod 后表示只有设定的特定的请求方式才执行对应的权限设置。
演示指定请求必须是post请求
.regexMatchers(HttpMethod.POST,"/controller的方法").permitAll()
枚举类型HttpMethod 内置属性如下：
4 mvcMatchers()
mvcMatchers()适用于配置了servletPath 的情况。
servletPath 就是所有的URL 的统一前缀。
在SpringBoot 整合SpringMVC 的项目中可以在全局配置文件application.properties 中添加下面内容设置ServletPath
spring.mvc.servlet.path=/chy #自定义的前缀名
在Spring Security 的配置类中配置.servletPath()是mvcMatchers()返回值特有的方法，antMatchers()和regexMatchers()没有这个方法。
在servletPath()中配置了servletPath 后，mvcMatchers()直接写SpringMVC 中@RequestMapping()中设置的路径即可。
.mvcMatchers("/demo").servletPath("/chy").permitAll()
如果不习惯使用mvcMatchers()也可以使用antMatchers()，下面代码和上面代码是等效的
.antMatchers("/chy/demo").permitAll()
测试,访问Controller中的demo
如果使用 http://localhost:8080/chy/demo 则访问成功
如果使用 http://localhost:8080/demo 则会跳转到如下页面
因为加上servletPath ,所以即使访问html资源也需要加上 /chy,
所有我们还需要对 /chy 的url结构的资源进行放行,如下图,
跳转到失败页面也需要进行第二步修改
步骤介绍:
第一步 : 在mvcMatchers()中的servletPath()方法指定前缀
第二步: 在用户登陆中添加前缀
第三不: 放行静态资源
九、内置访问控制方法介绍
Spring Security 匹配了URL 后调用了permitAll()表示不需要认证，随意访问。
在Spring Security 中提供了多种内置控制。
在定义permitAll()方法的类中,一共定义了6种访问控制方法
1 permitAll()
permitAll()表示所匹配的URL 任何人都允许访问。
/**
* Specify that URLs are allowed by anyone.
*
* @return the {@link ExpressionUrlAuthorizationConfigurer} for further
* customization
*/
public ExpressionInterceptUrlRegistry permitAll() {
return access(permitAll);
}
2 denyAll()
denyAll()表示所匹配的URL 都不允许被访问。
/**
* Specify that URLs are not allowed by anyone.
*
* @return the {@link ExpressionUrlAuthorizationConfigurer} for further
* customization
*/
public ExpressionInterceptUrlRegistry denyAll() {
return access(denyAll);
}
3 anonymous()
anonymous()表示可以匿名访问匹配的URL。和permitAll()效果类似，只是设置为anonymous()的url 会执行filter 链中
/**
* Specify that URLs are allowed by anonymous users.
*
* @return the {@link ExpressionUrlAuthorizationConfigurer} for further
* customization
*/
public ExpressionInterceptUrlRegistry anonymous() {
return access(anonymous);
}
4 authenticated()
authenticated()表示所匹配的URL 都需要被认证才能访问。
/**
* Specify that URLs are allowed by any authenticated user.
*
* @return the {@link ExpressionUrlAuthorizationConfigurer} for further
* customization
*/
public ExpressionInterceptUrlRegistry authenticated() {
return access(authenticated);
}
5 fullyAuthenticated()
如果用户不是被remember me 的，才可以访问。
/**
* Specify that URLs are allowed by users who have authenticated and were not
* "remembered".
*
* @return the {@link ExpressionUrlAuthorizationConfigurer} for further
* customization
* @see RememberMeConfigurer
*/
public ExpressionInterceptUrlRegistry fullyAuthenticated() {
return access(fullyAuthenticated);
}
6 rememberMe()
被“remember me”的用户允许访问
/**
* Specify that URLs are allowed by users that have been remembered.
*
* @return the {@link ExpressionUrlAuthorizationConfigurer} for further
* customization
* @see RememberMeConfigurer
*/
public ExpressionInterceptUrlRegistry rememberMe() {
return access(rememberMe);
}
十、角色权限判断
除了之前讲解的内置权限控制 , Spring Security 中还支持很多其他权限控制。
这些方法一般都用于用户已经被认证后，判断用户是否具有特定的要求。
1.hasAuthority(String)
判断用户是否具有特定的权限，用户的权限是在自定义登录逻辑中创建User 对象时指定的。
下图中admin 就是用户的权限。admin 严格区分大小写。
return new User(username, password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));//权限
在配置类中通过hasAuthority(“admin”)设置具有admin 权限时才能访问。
.antMatchers("/main1.html").hasAuthority("admin")
测试效果
在main.html添加一个资源跳转标签,跳转到 main1.html
访问登陆页面,正常登陆,登陆后跳转到main1.html,可以访问到这个页面
但是将配置类中将 admin写成 adMin,如下图
则会出现403,权限异常,如下下图
2 hasAnyAuthority(String …)
如果用户具备给定权限中某一个，就允许访问。
下面代码中由于大小写和用户的权限不相同，所以用户无权访问 /main1.html
.antMatchers("/main1.html").hasAnyAuthority("adMin","admiN")
3 hasRole(String)
如果用户具备给定角色就允许访问。否则出现403。
参数取值来源于自定义登录逻辑UserDetailsService 实现类中创建User 对象时给User 赋予的授权。
在给用户赋予角色时角色需要以：ROLE_ 开头，后面添加角色名称。
例如：ROLE_abc 其中abc 是角色名，ROLE_是固定的字符开头。
使用hasRole()时参数也只写abc 即可。否则启动报错。
a.给用户赋予角色(loadUserByUsername方法返回值中)：
return new User(username, password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc"));//权限
b.在配置类中直接写abc 即可。
.antMatchers("/main1.html").hasRole("abc") //判断用户是否具备给定角色,是就允许访问。
测试效果
访问用户登陆页面
登陆成功后跳转到main.html,点击main.html中的a标签
跳转到main1.html ,如下图 , 跳转成功!
4 hasAnyRole
如果用户具备给定角色的任意一个，就允许被访问
.antMatchers("/main.html").hasAnyRole("abC","abc","ABC") //判断用户是否用户具备给定角色的任意一个，是就允许被访问
5 hasIpAddress(String)
如果请求是指定的IP 就运行访问。
可以通过request.getRemoteAddr()获取ip 地址。
需要注意的是在本机进行测试时localhost 和127.0.0.1 输出的ip地址是不一样的。
当浏览器中通过localhost 进行访问时控制台打印的内容：
当浏览器中通过127.0.0.1 访问时控制台打印的内容：
当浏览器中通过具体ip 进行访问时控制台打印内容：
使用hasIpAddress进行权限判断时,如果使用的地址为127.0.0.1
.antMatchers("/main.html").hasIpAddress("127.0.0.1") //如果请求是指定的IP 就运行访问。
测试效果
访问登陆页面,在输入正确的登陆名和密码后 ,
本来应该访问到main.html ,但是却出现了下图错误
但是将url改成 127.0.0.1后,却可以访问成功,如下下图
同时也证明了"在本机进行测试时localhost 和127.0.0.1 输出的ip地址是不一样的"的结论
而在实际应用,由于url通常使用的是域名而不是本地地址,所以不需要担心出现这个问题!!!
十一、自定义403 处理方案
使用Spring Security 时经常会看见403（无权限），默认情况下显示的效果如下：
而在实际项目中可能都是一个异步请求，显示上述效果对于用户就不是特别友好了。
Spring Security 支持自定义权限受限。
功能实现思路
a.创建一个页面的处理类继承AccessDeniedHandler接口, 重写handle()方法
b.使用@Component注解,将处理类交给Spring容器管理
c.在配置类中注入,并在http.exceptionHandling().accessDeniedHandler()中使用
功能实现步骤
1.新建异常处理的处理类 ,根据状态码确定
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
/**
* 自定义403页面
* 1.继承AccessDeniedHandler接口, 重写handle()方法
* 2.添加@Component注解
* 3.在配置类中注入
* 4.使用
* @author chy
*
*/
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response,
AccessDeniedException accessDeniedException) throws IOException, ServletException {
//HttpServletResponse.SC_FORBIDDEN代表 403
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
response.setHeader("Content-Type","application/json;charset=utf-8");
PrintWriter out = response.getWriter();
out.write("{\"status\":\"error\",\"msg\":\"权限不足，请联系管理员!\"}");
out.flush();
out.close();
}
}
2.修改配置类
注入这个类
@Autowired
private MyAccessDeniedHandler myAccessDeniedHandler;
在configure()方法中,自定义异常处理页面
//自定义异常处理页面-403
http.exceptionHandling()
.accessDeniedHandler(myAccessDeniedHandler);
测试结果
使用上次的项目
访问登陆页面,在输入正确的登陆名和密码后 ,
本来应该访问到main.html ,但是却出现了下图错误(由于localhost和127.0.0.1不同导致的)
但是由于我们自定义了登陆页面,页面显示如下
补充 : 常见的状态码
1**：请求收到，继续处理
2**：操作成功收到，分析、接受
3**：完成此请求必须进一步处理
4**：请求包含一个错误语法或不能完成
5**：服务器执行一个完全有效请求失败
100——客户必须继续发出请求
101——客户要求服务器根据请求转换HTTP协议版本
200——交易成功
201——提示知道新文件的URL
202——接受和处理、但处理未完成
203——返回信息不确定或不完整
204——请求收到，但返回信息为空
205——服务器完成了请求，用户代理必须复位当前已经浏览过的文件
206——服务器已经完成了部分用户的GET请求
300——请求的资源可在多处得到
301——删除请求数据
302——在其他地址发现了请求数据
303——建议客户访问其他URL或访问方式
304——客户端已经执行了GET，但文件未变化
305——请求的资源必须从服务器指定的地址得到
306——前一版本HTTP中使用的代码，现行版本中不再使用
307——申明请求的资源临时性删除
400——错误请求，如语法错误
401——请求授权失败
402——保留有效ChargeTo头响应
403——请求不允许,没有权限
404——没有发现文件、查询或URl
405——用户在Request-Line字段定义的方法不允许
406——根据用户发送的Accept拖，请求资源不可访问
407——类似401，用户必须首先在代理服务器上得到授权
408——客户端没有在用户指定的饿时间内完成请求
409——对当前资源状态，请求不能完成
410——服务器上不再有此资源且无进一步的参考地址
411——服务器拒绝用户定义的Content-Length属性请求
412——一个或多个请求头字段在当前请求中错误
413——请求的资源大于服务器允许的大小
414——请求的资源URL长于服务器允许的长度
415——请求资源不支持请求项目格式
416——请求中包含Range请求头字段，在当前请求资源范围内没有range指示值，请求也不包含If-Range请求头字段
417——服务器不满足请求Expect头字段指定的期望值，如果是代理服务器，可能是下一级服务器不能满足请求
500——服务器产生内部错误
501——服务器不支持请求的函数
502——服务器暂时不可用，有时是为了防止发生系统过载
503——服务器过载或暂停维修
504——关口过载，服务器使用另一个关口或服务来响应用户，等待时间设定值较长
505——服务器不支持或拒绝支请求头中指定的HTTP版本
十二、基于表达式的访问控制
access()方法使用
之前学习的登录用户权限判断实际上底层实现都是调用access(表达式)
可以通过access()实现和之前学习的权限控制完成相同的功能。
举例 :
下面代码和直接使用permitAll()和hasRole()是等效的。
//.antMatchers("/login.html").permitAll() //登陆页面不需要被认证
.antMatchers("/login.html").access("permitAll") //使用access实现拦截
//.antMatchers("/main1.html").hasRole("abc") //判断用户是否具备给定角色,是就允许访问。
.antMatchers("/main1.html").access("hasRole(\"abc\")") //使用access实现角色权限验证
使用自定义方法集合access实现权限控制
虽然这里面已经包含了很多的表达式(方法)
但是在实际项目中很有可能出现需要自己自定义逻辑的情况。
判断登录用户是否具有访问当前URL 权限。
a.新建接口及实现类
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.core.Authentication;
public interface MyService {
/**
* 判断用户是否具有访问当前url的权限
* @param request
* @param authentication
* @return
*/
boolean hasPermission(HttpServletRequest request, Authentication authentication);
}
import java.util.Collection;
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
@Component
public class MyServiceImpl implements MyService {
@Override
public boolean hasPermission(HttpServletRequest request, Authentication authentication) {
Object obj = authentication.getPrincipal();
if (obj instanceof UserDetails) {
UserDetails user = (UserDetails) obj;
Collection<? extends GrantedAuthority> authorities = user.getAuthorities();
return authorities.contains(new SimpleGrantedAuthority(request.getRequestURI()));
}
return false;
}
}
b.在access 中通过@bean 的id 名.方法(参数)的形式进行调用 ,配置类中修改如下：
.anyRequest().access("@myServiceImpl.hasPermission(request,authentication)");
//ah.szxy.service.MyServiceImpl.hasPermission(HttpServletRequest, Authentication)
c.在自定义等登陆逻辑,实现类中 ,放开需要访问的html页面 .如,/main.html
return new User(username, password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/main.html"));//权限
测试
没有步骤c时 ,登陆后,跳转到自定义的错误页面
加上步骤c后,页面正常
但是跳转到main1.html会失败
如需要获取main1.html的访问权限,需要重复步骤c ,开放main1.html的访问权限 ,
其他页面的访问 , 亦是如此
十三、基于注解的访问控制
在Spring Security 中提供了一些访问控制的注解。这些注解都是默认是都不可用的，
需要通过@EnableGlobalMethodSecurity 进行开启后使用。
如果设置的条件允许，程序正常执行。如果不允许会报500
org.springframework.security.access.AccessDeniedException: 不允许访问
这些注解可以写到Service 接口或方法上 ,也可以写到Controller或Controller 的方法上。
通常情况下都是写在控制器方法上的，控制接口URL 是否允许被访问。
@Secured
@Secured 是专门用于判断是否具有角色的。能写在方法或类上。参数可以以ROLE_开头。
实现步骤
1.在启动类( 也可以在配置类等能够扫描的类上) 上添加相关注解
@EnableGlobalMethodSecurity(securedEnabled = true)
@EnableGlobalMethodSecurity(securedEnabled = true) //开启SpringSecurity访问控制的注解
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
2.在控制器方法上添加@Secured 注解
@Secured("ROLE_abc")
//@Secured("abc")
@RequestMapping("/loginSuccess")
public String LoginSuccess() {
System.out.println("执行了登陆的方法");
return "redirect:/main.html";
}
3.配置类中方法配置保留最基本的配置即可。
@Override
protected void configure(HttpSecurity http) throws Exception {
//表单认证
http.formLogin()
.loginProcessingUrl("/login") //当发现/login 时认为是登录，需要执行UserDetailsServiceImpl
.loginPage("/login.html") //自定义的登陆页面
.successForwardUrl("/loginSuccess") //认证成功后跳转的url,post 请求
.failureForwardUrl("/loginFalse") //认证失败后跳转的url,post请求
//拦截: 相当于授权的过程
http.authorizeRequests()
.antMatchers("/login.html").permitAll() //登陆页面不需要被认证
.antMatchers("/error.html").permitAll() //登陆失败后的页面不需要再次被认证
.anyRequest().authenticated(); //其他所有的请求都必须被认证。必须登录后才能访问。
//关闭csrf防护，类似于防火墙，不关闭上面的设置不会真正生效。
http.csrf().disable();
}
4.LoginServiceImpl的loadUserByUsername方法的返回值
return new User(username, password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc"));
测试
使用@Secured(“ROLE_abc”) , 访问认证成功后可以跳转到相关页面
使用@Secured(“abc”) , 访问认证成功跳转失败 ,而且控制台报500,如下图
原因是在使用注解 ,必须和loadUserByUsername方法的返回值参数一致
@PreAuthorize/@PostAuthorize
@PreAuthorize 和@PostAuthorize 都是方法或类级别注解。
@PreAuthorize 表示访问方法或类在执行之前先判断权限，大多情况下都是使用这个注解 . 该注解的参数和access()方法参数取值相同，都是权限表达式。
@PostAuthorize 表示方法或类执行结束后判断权限，此注解很少被使用到。
实现步骤
1.在启动类中开启@PreAuthorize 注解。
注意:
可以与securedEnabled 属性同时使用 ,互不影响
prePostEnabled,这个属性同时开启了上面两个注解的使用
@EnableGlobalMethodSecurity(securedEnabled = true,prePostEnabled = true) //开启SpringSecurity访问控制的注解
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
2.添加@PreAuthorize
注意:
在控制器方法上添加@PreAuthorize，参数可以是任何access()支持的表达式
而且 @PreAuthorize("hasRole('abc')") 和@PreAuthorize("hasRole('ROLE_abc')") 都可以使用,也就是说这个注解可以支持 ROLE_这个前缀的存在,但是不区分大小写
//@Secured("ROLE_abc")
//@Secured("abc")
//@PreAuthorize("hasRole('ROLE_abc')")
@PreAuthorize("hasRole('abc')")
@RequestMapping("/loginSuccess")
public String LoginSuccess() {
System.out.println("执行了登陆的方法");
return "redirect:/main.html";
}
测试结果,一切正常
十四、Remember Me 功能实现
Spring Security 中Remember Me 为“记住我”功能，
用户只需要在登录时添加remember-me 复选框，取值为true。
Spring Security 会自动把用户信息存储到数据源中，以后就可以不登录进行访问。
实现步骤
1.添加依赖
Spring Security 实现Remember Me 功能时底层实现依赖Spring-JDBC，所以需要导入Spring-JDBC。
以后多使用MyBatis 框架而很少直接导入spring-jdbc，所以导入mybatis 启动器同时还需要添加MySQL
驱动
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.1.0version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
2.在application.properties 中配置数据源。请确保数据库中已经存在名为security 数据库,没有请创建
#配置数据库连接参数
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/security
spring.datasource.username=root
spring.datasource.password=root
补充 : 配置高版本的mysql-connector
如果在pom中没有mysql-connector的版本,它会默认跟随SpringBoot父项目中定义的版本,
本人使用的是SpringBoot2.1.8版本 ,在配套的mysql-connector版本为8.0.17
在这个版本后 ,驱动类的位置和url的写法稍有区别 ,现在贴在下面
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
#配置mysql-connector 版本8以上的连接参数
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/security?useUnicode=true&characterEncoding=gbk&useJDBCCompliantTimezoneShift=true&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
3.新建 ah.szxy.config.RememberMeConfig 类并创建Bean 对象 , 也可以从SecurityConfig 类注入相关属性,然后通过@Bean注入getPersistentTokenRepository()方法
方式一
新建 RememberMeConfig 类
/**
* 自动建表，第一次启动时需要，第二次启动时注释掉
* jdbcTokenRepositoryImpl.setCreateTableOnStartup(true);
*
* @author 曹海洋
*
*/
@Configuration
public class RememberMeConfig {
@Autowired
private DataSource dataSource;
@Bean
public PersistentTokenRepository getPersistentTokenRepository() {
JdbcTokenRepositoryImpl jdbcTokenRepositoryImpl = new JdbcTokenRepositoryImpl();
jdbcTokenRepositoryImpl.setDataSource(dataSource);
// 自动建表，第一次启动时需要，第二次启动时注释掉
jdbcTokenRepositoryImpl.setCreateTableOnStartup(true);
return jdbcTokenRepositoryImpl;
}
}
方式二
注入DataSource
将getPersistentTokenRepository()方法通过@Bean放到SecurityConfig 这个配置类中
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{
@Autowired
private MyAccessDeniedHandler myAccessDeniedHandler;
@Autowired
private LoginServiceImpl loginServiceImpl;
@Autowired
private PersistentTokenRepository repository;
@Autowired
private DataSource dataSource;
@Override
protected void configure(HttpSecurity http) throws Exception {
//表单认证
http.formLogin()
.loginProcessingUrl("/login") //当发现/login 时认为是登录，需要执行UserDetailsServiceImpl
.loginPage("/login.html") //自定义的登陆页面
.successForwardUrl("/loginSuccess") //认证成功后跳转的url,post 请求
//.successHandler(new MyAuthenticationSuccessHandler()) //认证成功时,跳转到自定义的处理器
.failureForwardUrl("/loginFalse") //认证失败后跳转的url,post请求
//.failureHandler(new MyFailHandler("/error.html")) //认证失败时,跳转到自定义的处理器
.usernameParameter("uname") //自定义设置认证表单中用户名的name属性
.passwordParameter("upwd"); //自定义设置认证表单中密码的name属性
//拦截: 相当于授权的过程
http.authorizeRequests()
//.antMatchers("/login.html").access("permitAll") //使用access实现拦截
.antMatchers("/login.html").permitAll() //登陆页面不需要被认证
.antMatchers("/error.html").permitAll() //登陆失败后的页面不需要再次被认证
//.antMatchers("/css/**","/js/**","/images/**").permitAll() //放行静态资源,/**表示当前目录以及子目录
//.antMatchers("/**/*.png").permitAll() //拦截以 .png结尾的
//.regexMatchers(HttpMethod.POST,".+[.]jpg").permitAll() //拦截方法为post,且为 .jpg结尾的
//.antMatchers("/chy/**").permitAll() //拦截chy前缀下的 所有
//.mvcMatchers("/demo").servletPath("/chy").permitAll() //拦截前缀为chy,方法为demo的
//.antMatchers("/chy/demo").permitAll() //拦截路径中存在 /chy/demo的
//.antMatchers("/main1.html").hasAuthority("adMin") //如果用户具备给定权限，就允许访问
//.antMatchers("/main1.html").hasAnyAuthority("adMin","admiN") //如果用户具备给定权限中某一个，就允许访问
//.antMatchers("/main1.html").hasRole("abc") //判断用户是否具备给定角色,是就允许访问。
//.antMatchers("/main1.html").access("hasRole(\"abc\")") //使用access实现角色权限验证
//.antMatchers("/main.html").hasAnyRole("abC","abc","ABC") //判断用户是否用户具备给定角色的任意一个，是就允许被访问
//.antMatchers("/main.html").hasIpAddress("127.0.0.1") //如果请求是指定的IP 就运行访问。
.anyRequest().authenticated(); //其他所有的请求都必须被认证。必须登录后才能访问。
//.anyRequest().access("@myServiceImpl.hasPermission(request,authentication)"); //使用access方法实现访问控制
//ah.szxy.service.MyServiceImpl.hasPermission(HttpServletRequest, Authentication)
//关闭csrf防护，类似于防火墙，不关闭上面的设置不会真正生效。
http.csrf().disable();
//自定义异常处理页面-403
http.exceptionHandling()
.accessDeniedHandler(myAccessDeniedHandler);
//调用rememberMe的相关配置
http.rememberMe()
//.rememberMeParameter("rememberMe") //修改rememberMe前端复选框的name属性值, 默认为remember-me
//.tokenValiditySeconds(60) //设置tokenValiditySeconds生效时间, 默认是2周
.userDetailsService(loginServiceImpl) //登录逻辑交给哪个对象
.tokenRepository(repository); //实现PersistentTokenRepository方法后就可以持久化登陆信息到数据库
}
@Bean
public PersistentTokenRepository getPersistentTokenRepository() {
JdbcTokenRepositoryImpl jdbcTokenRepositoryImpl = new JdbcTokenRepositoryImpl();
jdbcTokenRepositoryImpl.setDataSource(dataSource);
// 自动建表，第一次启动时需要，第二次启动时注释掉
//jdbcTokenRepositoryImpl.setCreateTableOnStartup(true);
return jdbcTokenRepositoryImpl;
}
//必须制定一个PasswordEncoder用于密码加密
@Bean
public PasswordEncoder getPwdEncoder() {
return new BCryptPasswordEncoder();
}
}
4 修改SecurityConfig
在SecurityConfig 中注入RememberMeConfig 和UserDetailsService实现类对象
调用http.rememberMe()方法下的相关方法
在配置类中添加下面配置内容。
@Autowired
private LoginServiceImpl loginServiceImpl; //自定义的登陆逻辑实现类
@Autowired
private PersistentTokenRepository repository; //系统下的类
//调用rememberMe的相关配置
http.rememberMe()
//.rememberMeParameter("rememberMe") //修改rememberMe前端复选框的name属性值, 默认为remember-me
//.tokenValiditySeconds(60) //设置tokenValiditySeconds生效时,间单位s, 默认是2周
.userDetailsService(loginServiceImpl) //登录逻辑交给哪个对象
.tokenRepository(repository); //实现PersistentTokenRepository方法后就可以持久化登陆信息到数据库
注意rememberMe的另外两个方法的用法
| 方法名 | 作用 |
|---|---|
| .rememberMeParameter(“rememberMe”) | 修改rememberMe前端复选框的name属性值, 默认为remember-me |
| .tokenValiditySeconds() | 设置tokenValiditySeconds生效时间,单位秒, 默认是2周 |
5 在客户端页面中添加复选框
在客户端登录页面中添加remember-me 的复选框，只要用户勾选了复选框下次就不需要进行登录了。
<body>
<form action="/login" method="post">
姓名:<input type="text" name="uname" ><br>
密码:<input type="text" name="upwd"><br>
记住我:<input type="checkbox" name="remember-me" value="true"/> <br/>
<button>登陆button>
form>
body>
测试
访问登陆页面 ,输入正确的用户名和密码 ,跳转到http://localhost:8080/main.html
复制该url关闭浏览器 ,重新打开并访问该url ,结果如下图一
数据库中,生成如下表 ,可以看到登陆的数据已经被持久化到数据库中 ,如下下图二
图一
图二
再次注意:
在第二次登陆时,
需要将RememberMeConfig类中的getPersistentTokenRepository方法中的jdbcTokenRepositoryImpl.setCreateTableOnStartup(true);
这段代码注释掉, 否则会出现如下问题
Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'persistent_logins' already exists
因为开启这段代码后,在重启项目后自动创建名为persistent_logins的数据表
因为上次数据库表已经创建了,这次还创建当然报错啦~~~
每次修改loadUserByUsername方法的返回值(用户权限)return new User(username,password,AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/insert,/delete"));
RememberMe功能都会失效,需要重新设置 ,
不过不需要重新开启上面注意中的那段代码,
只需要清空生成的persistent_logins数据表的数据库再重启项目即可
十五、Thymeleaf 中Spring Security 的使用
Spring Security 可以在一些视图技术中进行控制显示效果。
例如：JSP 或Thymeleaf。
在非前后端分离且使用Spring Boot 的项目中多使用Thymeleaf 作为视图展示技术。
Thymeleaf 对Spring Security 的支持都放在thymeleaf-extras-springsecurityX 中.
目前最新版本为5 , 所以需要在项目中添加此jar 包的依赖和thymeleaf 的依赖。
实现步骤
1.添加依赖
<dependency>
<groupId>org.thymeleaf.extrasgroupId>
<artifactId>thymeleaf-extras-springsecurity5artifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-thymeleafartifactId>
dependency>
2.在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">
注意 :
使用thymeleaf的页面不能放到resource目录下的static目录下,而应该放到templates目录下
因为它已经不是简单的静态页面了
获取属性
可以在html 页面中通过sec:authentication="" 获取UsernamePasswordAuthenticationToken 中所有getXXX 的内容，包含父类中的getXXX 的内容。根据源码得出下面属性：
name：登录账号名称
principal：登录主体，在自定义登录逻辑中是UserDetails
credentials：凭证
authorities：权限和角色
details：实际上是WebAuthenticationDetails 的实例。可以获取remoteAddress(客户端ip)和sessionId(当前sessionId)
实现步骤:
a.在项目resources 中新建templates 文件夹，在templates 中新建thymeleafDemo.html 页面
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org"
xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
<head>
<meta charset="UTF-8">
<title>Insert title heretitle>
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>
客户端ip: <span sec:authentication="details.remoteAddress">span><br>
body>
html>
b.编写控制器中的方法
@RequestMapping("/demo")
public String demo() {
//默认开启视图解析器
return "thymeleafDemo";
}
测试 :浏览器访问该方法
权限判断
在html 页面中可以使用sec:authorize=”表达式”进行权限控制，判断是否显示某些内容。
表达式的内容和access(表达式)的用法相同。
如果用户具有指定的权限，则显示对应的内容；如果表达式不成立，则不显示对应的元素。
不同权限的用户显示不同的按钮
1. 设置用户角色和权限
设定用户具有admin，/insert，/delete 权限ROLE_abc 角色。
在loadUserByUsername的返回值中设置
@Service
public class LoginServiceImpl implements UserDetailsService {
@Autowired
private PasswordEncoder encoder;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// 1. 查询数据库判断用户名是否存在，如果不存在抛出UsernameNotFoundException
if (!username.equals("admin")) {
// 设置了这个条件后, 必须输入用户名 admin,密码123才能登陆
throw new UsernameNotFoundException("用户名不存在");
}
String password = encoder.encode("123");
AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc"));//权限
return new User(username,password,AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/insert,/delete"));
}
}
2. 控制页面显示效果
在thymeleafDemo.html 页面中根据用户权限和角色判断页面中显示的内容
通过权限判断：
<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>
测试结果
访问controller中的相关方法
十六、退出登录
用户只需要向Spring Security 项目中发送/logout 退出请求即可。
实现步骤
-
实现退出非常简单，只要在页面中添加/logout 的超链接即可。
<a href="/logout">退出登录a>点击退出后页面显示的url如下
为了实现更好的效果，通常添加退出的配置。
默认的退出url 为/logout，退出成功后跳转到/login?logout -
在配置类SecurityConfig的configure()方法中添加如下代码
http.logout() .logoutSuccessUrl("/login.html"); //用户退出成功后 ,跳转的页面 //.logoutUrl("/logout") //修改用户退出时,超链接的name属性值,一般不推荐修改点击退出后页面显示的url如下,正常啦 O(∩_∩)O哈哈~
注意: 使用退出功能后 ,
会自动清除RememberMe中在数据库中持久化的口令 ,如果需要的话需要重新登陆并勾选
补充 :如何使用断点调试解读源码?
1.点击想要跟随的源码 ,例如我想查看 logoutSuccessUrl的源码, ctr状态下+鼠标左键点击进入该方法
2. 在方法声明的地方打断点
3. 以Debug方式运行即可
十七、Spring Security 中CSRF
从刚开始学习Spring Security 时，在配置类中一直存在这样一行代码：http.csrf().disable();
如果没有这行代码导致用户无法被认证。这行代码的含义是：关闭csrf 防护。
1 什么是CSRF
CSRF（Cross-site request forgery）跨站请求伪造，也被称为“OneClick Attack”
或者Session Riding。通过伪造用户请求访问受信任站点的非法请求访问。
跨域：只要网络协议，ip 地址，端口中任何一个不相同就是跨域请求。
客户端与服务进行交互时，由于http 协议本身是无状态协议，
所以引入了cookie 进行记录客户端身份。在cookie 中会存放session id用来识别客户端身份的。
在跨域的情况下，session id 可能被第三方恶意劫持，通过这个session id 向服务端发起请求时，
服务端会认为这个请求是合法的，可能发生很多意想不到的事情。
2 Spring Security 中CSRF
从Spring Security4 开始CSRF 防护默认开启默认会拦截请求 ,进行CSRF 处理。
CSRF 为了保证不是其他第三方网站访问，要求访问时携带参数名为_csrf 值为token(token 在服务端产生)的内容，如果token 和服务端的token 匹配成功，则正常访问。
实现步骤
-
编写控制器方法，跳转到templates 中login.html 页面。
@GetMapping("/showLogin") public String showLogin() { return "login"; } -
在项目resources 下新建templates 文件夹，并在文件夹中新建login.html 页面。隐藏域部分必须存在的否则无法正常登录。
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org"> <head> <meta charset="UTF-8"> <title>Titletitle> head> <body> -
修改配置类 ,在配置类中注释掉CSRF 防护失效
//关闭csrf 防护 //http.csrf().disable();
测试结果
a.注释掉关闭csrf防护后(即开启csrf防护) ,没有在html页面,添加隐藏域的部分 ,
即使输入了正确的用户名和密码以后,也会被重定向到原来的登陆页面
b.添加了隐藏域后, 根据 ${_csrf.token}获取我们刷新页面产生的 token,如下图
然后提交给controller进行比对 ,如果和SpringSecurity内部生成的token一致,
然后我们再次访问就会跳转到相应的页面
c.如果我们开启csrf防护(配置类中没写http.csrf().disable();) ,就必须在表单提交页面添加
如果我们关闭了 csrf防护 http.csrf().disable();,什么也不用写了
链接：https://pan.baidu.com/s/1jbI1mm_t0jTmQln1XIrbvg
点赞私聊即可获取资料分享
提取码：6r5k
复制这段内容后打开百度网盘手机App，操作更方便哦