spring security

Spring Security

一、 Spring Security 简介

1 概括

　　Spring Security 是一个高度自定义的安全框架。利用 Spring IoC/DI

和 AOP 功能，为系统提供了声明式安全访问控制功能，减少了为系

统安全而编写大量重复代码的工作。

　　使用 Spring Secruity 的原因有很多，但大部分都是发现了 javaEE

的 Servlet 规范或 EJB 规范中的安全功能缺乏典型企业应用场景。同

时认识到他们在 WAR 或 EAR 级别无法移植。因此如果你更换服务器

环境，还有大量工作去重新配置你的应用程序。使用 Spring Security

解决了这些问题，也为你提供许多其他有用的、可定制的安全功能。

正如你可能知道的两个应用程序的两个主要区域是“认证”和“授

权”（或者访问控制）。这两点也是 Spring Security 重要核心功能。“认

证”，是建立一个他声明的主体的过程（一个“主体”一般是指用户，

　　设备或一些可以在你的应用程序中执行动作的其他系统），通俗点说

就是系统认为用户是否能登录。“授权”指确定一个主体是否允许在你

的应用程序执行一个动作的过程。通俗点讲就是系统判断用户是否有

权限去做某些事情。

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 月发布了 acegi 1.0.0 版本。2007 年底 acegi 更名为

Spring Security。

二、第一个 Spring Security 项目

1 导入依赖

　　Spring Security 已经被 Spring boot 进行集成，使用时直接引入启

动器即可。

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>

2 访问页面

　　导入 spring-boot-starter-security 启动器后，Spring Security 已经生效，默认拦截全部请求，如果用户没有登录，跳转到内置登录页面。

在项目中新建 login.html 页面后

在浏览器输入：http://localhost:8080/login.html 后会显示下面页面

默认的 username 为 user，password 打印在控制台中。当然了，

同学们显示的肯定和我的不一样。

在浏览器中输入账号和密码后会显示 login.html 页面内容。

三、 UserDetailsService 详解

　　当什么也没有配置的时候，账号和密码是由 Spring Security 定义

生成的。而在实际项目中账号和密码都是从数据库中查询出来的。所

以我们要通过自定义逻辑控制认证逻辑。

如果需要自定义逻辑时，只需要实现 UserDetailsService 接口即

可。接口定义如下：

1 返回值

返回值 UserDetails 是一个接口，定义如下

　　要想返回 UserDetails 的实例就只能返回接口的实现类。Spring

Security 中提供了如下的实例。对于我们只需要使用里面的 User 类即

可。注意 User 的全限定路径是：

org.springframework.security.core.userdetails.User

此处经常和系统中自己开发的 User 类弄混。

　　其中构造方法有两个，调用其中任何一个都可以实例化

UserDetails 实现类 User 类的实例。而三个参数的构造方法实际上也

是调用 7 个参数的构造方法。

username:用户名

password:密码

authorities：用户具有的权限。此处不允许为 null

　　此处的用户名应该是客户端传递过来的用户名。而密码应该是从

数据库中查询出来的密码。Spring Security 会根据 User 中的 password

和客户端传递过来的 password 进行比较。如果相同则表示认证通过，

如果不相同表示认证失败。

　　authorities 里面的权限对于后面学习授权是很有必要的，包含的

所有内容为此用户具有的权限，如有里面没有包含某个权限，而在做

某个事情时必须包含某个权限则会出现 403。通常都是通过

AuthorityUtils.commaSeparatedStringToAuthorityList(“”) 来创建

authorities 集合对象的。参数时一个字符串，多个权限使用逗号分隔。

2 方法参数

方法参数表示用户名。此值是客户端表单传递过来的数据。默认

情况下必须叫 username，否则无法接收。

3 异常

UsernameNotFoundException 用户名没有发现异常。在

loadUserByUsername 中是需要通过自己的逻辑从数据库中取值的。如

果通过用户名没有查询到对应的数据，应该抛出

UsernameNotFoundException，系统就知道用户名没有查询到。

四、 PasswordEncoder 密码解析器详解

Spring Security 要求容器中必须有 PasswordEncoder 实例。所以当

自定义登录逻辑时要求必须给容器注入 PaswordEncoder 的 bean 对象

1 接口介绍

　　encode():把参数按照特定的解析规则进行解析。

　　matches()验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回 true；如果不匹配，则返回 false。

　　第一个参数表示需要被解析的密码。第二个参数表示存储的密码。

upgradeEncoding()：如果解析的密码能够再次进行解析且达到更

安全的结果则返回 true，否则返回 false。默认返回 false。

3 BCryptPasswordEncoder 简介

BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析

器，平时多使用这个解析器。

BCryptPasswordEncoder 是对 bcrypt 强散列方法的具体实现。是

基于 Hash 算法实现的单向加密。可以通过 strength 控制加密强度，

默认 10.

4 代码演示

在项目 src/test/java 下新建 com.bjsxt.MyTest 测试BCryptPasswordEncoder 用法。

@SpringBootTest
@RunWith(SpringRunner.class)
public class MyTest {
@Test
public void test(){
//创建解析器
PasswordEncoder encoder = new BCryptPasswordEncoder();
//对密码进行加密
String password = encoder.encode("123");
System.out.println("------------"+password);
//判断原字符加密后和内容是否匹配
boolean result = encoder.matches("123",password);
System.out.println("============="+result);
}
}

五、自定义登录逻辑

当进行自定义登录逻辑时需要用到之前讲解的

UserDetailsService 和 PasswordEncoder。但是 Spring Security 要求：当

进行自定义登录逻辑时容器内必须有 PasswordEncoder 实例。所以不

能直接 new 对象。

1 编写配置类

新建类 com.bjsxt.config.SecurityConfig 编写下面内容

@Configuration
public class SecurityConfig {
@Bean
public PasswordEncoder getPwdEncoder(){
return new BCryptPasswordEncoder();
}
}

2 自定义逻辑

在 Spring Security 中实现 UserDetailService 就表示为用户详情服

务。在这个类中编写用户认证逻辑。

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private PasswordEncoder encoder;
@Override
public UserDetails loadUserByUsername(String username) throws
UsernameNotFoundException {
//1. 查询数据库判断用户名是否存在，如果不存在抛出
UsernameNotFoundException
if(!username.equals("admin")){
throw new UsernameNotFoundException("用户名不存在");
}
//把查询出来的密码进行解析,或直接把 password 放到构造方法中。
//理解:password 就是数据库中查询出来的密码，查询出来的内容不是 123
String password = encoder.encode("123");
return new User(username,password,
AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
}
}

3 查看效果

重启项目后，在浏览器中输入账号：admin，密码：123。后可以正确进入到 login.html 页面。

六、自定义登录页面

虽然 Spring Security 给我们提供了登录页面，但是对于实际项目

中，大多喜欢使用自己的登录页面。所以 Spring Security 中不仅仅提供了登录页面，还支持用户自定义登录页面。实现过程也比较简单，

只需要修改配置类即可。

1 编写登录页面

　　别写登录页面，登录页面中<form>的 action 不编写对应控制器也

可以。

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>内容</title>
</head>
<body>
<form action="/login" method="post">
<input type="text" name="username"/>
<input type="password" name="password"/>
<input type="submit" value="提交"/>
</form>
</body>
</html>

2 修改配置类

　　修改配置类中主要是设置哪个页面是登录页面。配置类需要继承

WebSecurityConfigurerAdapte,并重写 configure 方法。

successForwardUrl()登录成功后跳转地址loginPage() 登录页面

loginProcessingUrl 登录页面表单提交地址，此地址可以不真实存在。

antMatchers():匹配内容

permitAll():允许@Configuration

public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
// 表单认证
http.formLogin()
.loginProcessingUrl("/login")
//当发现/login 时认为是登录，需
要执行 UserDetailsServiceImpl
.successForwardUrl("/toMain")
//此处是 post 请求
.loginPage("/login.html");
// url 拦截
http.authorizeRequests()
.antMatchers("/login.html").permitAll() //login.html 不需要被认
证
.anyRequest().authenticated();//所有的请求都必须被认证。必须登录
后才能访问。
//关闭 csrf 防护
http.csrf().disable();
}
@Bean
public PasswordEncoder getPe(){
return new BCryptPasswordEncoder();
}
}

3 编写控制器

编写控制器，当用户登录成功后跳转 toMain 控制器。编写完成

控制器后编写 main.html。页面中随意写上一句话表示 main.html 页面

内容即可。而之前的/login 控制器方法是不执行的，所以可以删除了。

@Controller
public class LoginController {
//
该方法不会被执行
//
@RequestMapping("/login")
//
public String login(){
//
System.out.println("执行了 login 方法");//
return "redirect:main.html";
//
}
@PostMapping("/toMain")
public String toMain(){
return "redirect:/main.html";
}
}

七、认证过程其他常用配置

1 失败跳转

表单处理中成功会跳转到一个地址，失败也可以跳转到一个地址

中。

1.1编写页面

在 src/main/resources/static 下新建 fail.html 并编写如下内容

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
操作失败，请重新登录. <a href="/login.html">跳转</a>
</body>
</html>

1.2修改表单配置

在配置方法中表单认证部分添加 failureForwardUrl()方法，表示登

录失败跳转的 url。此处依然是 POST 请求，所以跳转到可以接收

POST请求的控制器/fail 中。

// 表单认证http.formLogin()

.loginProcessingUrl("/login")

//当发现/login 时认为是登录，需要执行

UserDetailsServiceImpl

.successForwardUrl("/toMain")

//此处是 post 请求

.failureForwardUrl("/fail")

//登录失败跳转地址

.loginPage("/login.html");

1.3添加控制器方法

在控制器类中添加控制器方法，方法映射路径/fail。此处要注意：

由于是 POST 请求访问/fail。所以如果返回值直接转发到 fail.html 中，

及时有效果，控制台也会报警告，提示 fail.html 不支持 POST 访问方式。

@PostMapping("/fail")
public String fail(){
return "redirect:/fail.html";
}

1.4设置 fail.html 不需要认证

认证失败跳转到 fail.html 页面中，所以必须配置 fail.html 不需要

被认证。需要修改配置类中内容

// url 拦截

http.authorizeRequests()

.antMatchers("/login.html").permitAll() //login.html 不需要被认证

.antMatchers("/fail.html").permitAll()

//fail.html 不需要被认证

.anyRequest().authenticated();//所有的请求都必须被认证。必须登录后才能访问。

2 设置请求账户和密码的参数名

2.1源码简介

当进行登录时会执行 UsernamePasswordAuthenticationFilter 过滤器。

usernamePasrameter:账户参数名

passwordParameter:密码参数名

postOnly=true:默认情况下只允许 POST 请求。

2.2修改配置

// 表单认证
http.formLogin()
.loginProcessingUrl("/login")
//当发现/login 时认为是登录，需要执行
UserDetailsServiceImpl
.successForwardUrl("/toMain")
//此处是 post 请求
.failureForwardUrl("/fail")
//登录失败跳转地址
.loginPage("/login.html")
.usernameParameter("myusername")
.passwordParameter("mypassword");

2.3修改页面

修改 login.html

用户名：<input type="text" name="myusername"/><br/>

密码:<input type="password" name="mypassword"/><br/>

</form>

3 自定义登录成功处理器

3.1源码分析

使用 successForwardUrl()时表示成功后转发请求到地址。内部是

通过 successHandler（）方法进行控制成功后交给哪个类进行处理

ForwardAuthenticationSuccessHandler 内部就是最简单的请求转

发。由于是请求转发，当遇到需要跳转到站外或在前后端分离的项目

中就无法使用了。

当需要控制登录成功后去做一些事情时，可以进行自定义认证成

功控制器。

3.2代码实现

3.2.1 自定义类

新建类 com.bjsxt.handler.MyAuthenticationSuccessHandler 编写如

下：

public class MyAuthenticationSuccessHandler implements
AuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse, Authentication authentication) throws
IOException, ServletException {
//Principal 主体，存放了登录用户的信息
User user = (User)authentication.getPrincipal();
System.out.println(user.getUsername());
System.out.println(user.getPassword());//密码输出为 null
System.out.println(user.getAuthorities());
//重定向到百度。这只是一个示例，具体需要看项目业务需求
httpServletResponse.sendRedirect("http://www.baidu.com");
}
}

3.2.2 修改配置项

使用 successHandler()方法设置成功后交给哪个对象进行处理

// 表单认证

http.formLogin()
.loginProcessingUrl("/login")
//当发现/login 时认为是登录，需要执行
UserDetailsServiceImpl
.successHandler(new MyAuthenticationSuccessHandler())
//.successForwardUrl("/toMain")
//此处是 post 请求
.failureForwardUrl("/fail")
//登录失败跳转地址
.loginPage("/login.html");

4 自定义登录失败处理器

4.1源码分析

failureForwardUrl()内部调用的是 failureHandler()方法

ForwardAuthenticationFailureHandler 中也是一个请求转发，并在

request 作用域中设置 SPRING_SECURITY_LAST_EXCEPTION 的 key，内容为异常对象。

4.2代码实现

4.2.1 新建控制器

新建 com.bjsxt.handler.MyForwardAuthenticationFailureHandler 实

现 AuthenticationFailureHandler。在方法中添加重定向语句

public class MyForwardAuthenticationFailureHandler implements
AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse, AuthenticationException e) throws
IOException, ServletException {
httpServletResponse.sendRedirect("/fail.html");
}
}

4.2.2 修改配置类

修改配置类中表单登录部分。设置失败时交给失败处理器进行操

作。failureForwardUrl 和 failureHandler 不可共存。

// 表单认证
http.formLogin()
.loginProcessingUrl("/login")
//当发现/login 时认为是登录，需
要执行 UserDetailsServiceImpl
.successHandler(new MyAuthenticationSuccessHandler())
//.successForwardUrl("/toMain")
//此处是 post 请求
.failureHandler(new MyForwardAuthenticationFailureHandler())
//
.failureForwardUrl("/fail")
//登录失败跳转地址
.loginPage("/login.html");

八、访问控制 url 匹配

在前面讲解了认证中所有常用配置，主要是对 http.formLogin()

进行操作。而在配置类中 http.authorizeRequests()主要是对 url 进行控

制，也就是我们所说的授权（访问控制）。http.authorizeRequests()

也支持连缀写法，总体公式为：

url 匹配规则.权限控制方法

通过上面的公式可以有很多 url 匹配规则和很多权限控制方法。

这些内容进行各种组合就形成了 Spring Security 中的授权。

在所有匹配规则中取所有规则的交集。配置顺序影响了之后授权

效果，越是具体的应该放在前面，越是笼统的应该放到后面。

1 anyRequest()

在之前认证过程中我们就已经使用过 anyRequest()，表示匹配所

有的请求。一般情况下此方法都会使用，设置全部内容都需要进行认

证。

代码示例：

anyRequest().authenticated();

2 antMatcher()

方法定义如下：

public C antMatchers(String... antPatterns)

参数是不定向参数，每个参数是一个 ant 表达式，用于匹配 URL规则。

规则如下：

? 匹配一个字符
* 匹配 0 个或多个字符
** 匹配 0 个或多个目录

在实际项目中经常需要放行所有静态资源，下面演示放行 js 文件

夹下所有脚本文件。

.antMatchers("/js/**").permitAll()

还有一种配置方式是只要是.js 文件都放行

antMatchers("/**/*.js").permitAll()

3 regexMatchers()

3.1介绍

使用正则表达式进行匹配。和 antMatchers()主要的区别就是参

数，antMatchers()参数是 ant 表达式，regexMatchers()参数是正则表

达式。

演示所有以.js 结尾的文件都被放行。

.regexMatchers(".+[.]js").permitAll()

3.2两个参数时使用方式

无论是 antMatchers()还是 regexMatchers()都具有两个参数的方

法，其中第一个参数都是 HttpMethod，表示请求方式，当设置了

HttpMethod 后表示只有设定的特定的请求方式才执行对应的权限设置。

枚举类型 HttpMethod 内置属性如下：

4 mvcMatchers()

mvcMatchers()适用于配置了 servletPath 的情况。

servletPath 就是所有的 URL 的统一前缀。在 SpringBoot 整合

SpringMVC 的项目中可以在 application.properties 中添加下面内容设

置 ServletPath

spring.mvc.servlet.path= /bjsxt

在 Spring Security 的配置类中配置.servletPath()是 mvcMatchers()

返回值特有的方法，antMatchers()和 regexMatchers()没有这个方法。

在 servletPath()中配置了 servletPath 后，mvcMatchers()直接写 Spring

MVC 中@RequestMapping()中设置的路径即可。

.mvcMatchers("demo").servletPath("/bjsxt").permitAll()

如果不习惯使用 mvcMatchers()也可以使用 antMatchers()，下面

代码和上面代码是等效的

antMatchers("/bjsxt/demo").permitAll()九、内置访问控制方法介绍

Spring Security 匹配了 URL 后调用了 permitAll()表示不需要认证，

随意访问。在 Spring Security 中提供了多种内置控制。

1 permitAll()

permitAll()表示所匹配的 URL 任何人都允许访问。

2 authenticated()

authenticated()表示所匹配的 URL 都需要被认证才能访问。

3 anonymous()

anonymous()表示可以匿名访问匹配的 URL。和 permitAll()效果类

似，只是设置为 anonymous()的 url 会执行 filter 链中

官方源码定义如下：

4 denyAll()

denyAll()表示所匹配的 URL 都不允许被访问。

5 rememberMe()

被“remember me”的用户允许访问

6 fullyAuthenticated()

如果用户不是被 remember me 的，才可以访问。

十、角色权限判断

除了之前讲解的内置权限控制。Spring Security 中还支持很多其

他权限控制。这些方法一般都用于用户已经被认证后，判断用户是否

具有特定的要求。

1 hasAuthority(String)

判断用户是否具有特定的权限，用户的权限是在自定义登录逻辑

中创建 User 对象时指定的。

下图中 admin 就是用户的权限。admin 严格区分大小写。

在配置类中通过 hasAuthority(“admin”)设置具有 admin 权限时才

能访问。

.antMatchers("/main1.html").hasAuthority("admin")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 即可。否则启动报错。

给用户赋予角色：

可以通过 request.getRemoteAddr()获取 ip 地址。

需要注意的是在本机进行测试时 localhost 和 127.0.0.1 输出的 ip

地址是不一样的。

当浏览器中通过 localhost 进行访问时控制台打印的内容：

十一、

自定义 403 处理方案

使用 Spring Security 时经常会看见 403（无权限），默认情况下

显示的效果如下：

而在实际项目中可能都是一个异步请求，显示上述效果对于用户

就不是特别友好了。Spring Security 支持自定义权限受限。

1 新建类

新建类实现 AccessDeniedHandler

@Component

public class MyAccessDeniedHandler implements AccessDeniedHandler {

@Override

public void handle(HttpServletRequest httpServletRequest, HttpServletResponsehttpServletResponse, AccessDeniedException e) throws IOException,

ServletException {

httpServletResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);

httpServletResponse.setHeader("Content-Type","application/json;charset=utf-8")

;

PrintWriter out = httpServletResponse.getWriter();

out.write("{\"status\":\"error\",\"msg\":\"权限不足，请联系管理

员!\"}");

out.flush();

out.close();

}

2 修改配置类

配置类中重点添加异常处理器。设置访问受限后交给哪个对象进

行处理。

myAccessDeniedHandler 是在配置类中进行自动注入的。

//异常处理

http.exceptionHandling()

.accessDeniedHandler(myAccessDeniedHandler);

十二、

基于表达式的访问控制

1 access()方法使用

之前学习的登录用户权限判断实际上底层实现都是调用

access(表达式)

可以通过 access()实现和之前学习的权限控制完成相同的功能。

1.1以 hasRole 和 permitAll 举例

下面代码和直接使用 permitAll()和 hasRole()是等效的。

2 使用自定义方法

虽然这里面已经包含了很多的表达式(方法)但是在实际项目中很

有可能出现需要自己自定义逻辑的情况。

判断登录用户是否具有访问当前 URL 权限。

2.1新建接口及实现类

新建接口 com.bjsxt.service.MyService 后新建实现类。

public interface MyService {

boolean hasPermission(HttpServletRequest request, Authentication

authentication);

}

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

}

2.2修改配置类

在 access 中通过@bean 的 id 名.方法(参数)的形式进行调用

配置类中修改如下：

// url 拦截 (授权)

http.authorizeRequests()

.antMatchers("/login.html").access("permitAll")

.antMatchers("/fail.html").permitAll()

.anyRequest().access("@myServiceImpl.hasPermission(request,authenticat

ion)");十三、

基于注解的访问控制

在 Spring Security 中提供了一些访问控制的注解。这些注解都是

默认是都不可用的，需要通过@EnableGlobalMethodSecurity 进行开启

后使用。

如果设置的条件允许，程序正常执行。如果不允许会报 500

这些注解可以写到 Service 接口或方法上上也可以写到 Controller

或 Controller 的方法上。通常情况下都是写在控制器方法上的，控制

接口 URL 是否允许被访问。

1 @Secured

@Secured 是专门用于判断是否具有角色的。能写在方法或类上。

参数要以 ROLE_开头。

1.1实现步骤

1.1.1 开启注解

在启动类 ( 也可以在配置类等能够扫描的类上 ) 上添加

@EnableGlobalMethodSecurity(securedEnabled = true)@SpringBootApplication

@EnableGlobalMethodSecurity(securedEnabled = true)

public class MyApp {

public static void main(String [] args){

SpringApplication.run(MyApp.class,args);

}

1.1.2 在控制器方法上添加@Secured 注解

在 LoginController 中方法上添加注解

@Secured("abc")

@RequestMapping("/toMain")

public String toMain(){

return "redirect:/main.html";

}

1.1.3 配置类

配置类中方法配置保留最基本的配置即可。

protected void configure(HttpSecurity http) throws Exception {

// 表单认证

http.formLogin()

.loginProcessingUrl("/login")

//当发现/login 时认为是登录，需要执

行 UserDetailsServiceImpl

.successForwardUrl("/toMain")

//此处是 post 请求

.loginPage("/login.html");

// url 拦截

http.authorizeRequests()

.antMatchers("/login.html").permitAll() //login.html 不需要被认证

.anyRequest().authenticated();//所有的请求都必须被认证。必须登录后才

能访问。

//关闭 csrf 防护

http.csrf().disable();

}

2 @PreAuthorize/@PostAuthorize

@PreAuthorize 和@PostAuthorize 都是方法或类级别注解。

@PreAuthorize 表示访问方法或类在执行之前先判断权限，大多

情况下都是使用这个注解，注解的参数和 access()方法参数取值相同，

都是权限表达式。

@PostAuthorize 表示方法或类执行结束后判断权限，此注解很少

被使用到。

2.1实现步骤

2.1.1 开启注解

在启动类中开启@PreAuthorize 注解。

@SpringBootApplication

@EnableGlobalMethodSecurity(prePostEnabled = true)

public class MyApp {

public static void main(String [] args){

SpringApplication.run(MyApp.class,args);

}

2.1.2 添加@PreAuthorize

在控制器方法上添加@PreAuthorize，参数可以是任何 access()支

持的表达式

@PreAuthorize("hasRole('abc')")

@RequestMapping("/toMain")

public String toMain(){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 驱动

<groupId>org.mybatis.spring.boot</groupId>

<artifactId>mybatis-spring-boot-starter</artifactId>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</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=rootspring.datasource.password=root

3 编写配置

新建 com.bjsxt.config.RememberMeConfig 类，并创建 Bean 对象

@Configuration

public class RememberMeConfig {

@Autowired

private DataSource dataSource;

@Bean

public PersistentTokenRepository getPersistentTokenRepository() {

JdbcTokenRepositoryImpl jdbcTokenRepositoryImpl=new

JdbcTokenRepositoryImpl();

jdbcTokenRepositoryImpl.setDataSource(dataSource);

//自动建表，第一次启动时需要，第二次启动时注释掉

jdbcTokenRepositoryImpl.setCreateTableOnStartup(true);

return jdbcTokenRepositoryImpl;

}

4 修改 SecurityConfig

在 SecurityConfig 中添加 RememberMeConfig 和 UserDetailsService

实现类对象，并自动注入。

在 configure 中添加下面配置内容。

http.rememberMe()

.userDetailsService(userDetailsService) //登录逻辑交给哪个对象

.tokenRepository(repository);

//持久层对象

5 在客户端页面中添加复选框

在客户端登录页面中添加 remember-me 的复选框，只要用户勾

选了复选框下次就不需要进行登录了。

密码:<input type="text" name="password"/><br/>

</form>

6 有效时间

默认情况下重启项目后登录状态失效了。但是可以通过设置状态

有效时间，即使项目重新启动下次也可以正常登录。

//remember Me

http.rememberMe()

.tokenValiditySeconds(120)//单位：秒

.tokenRepository(repository)

.userDetailsService(userDetailsServiceImpl);

十五、

Thymeleaf 中 Spring Security 的使用

Spring Security 可以在一些视图技术中进行控制显示效果。例如：

JSP 或 Thymeleaf。在非前后端分离且使用 Spring Boot 的项目中多使

用 Thymeleaf 作为视图展示技术。

Thymeleaf

对

Spring

Security

的

支

持

都

放

在

thymeleaf-extras-springsecurityX 中，目前最新版本为 5。所以需要在

项目中添加此 jar 包的依赖和 thymeleaf 的依赖。

<groupId>org.thymeleaf.extras</groupId>

<artifactId>thymeleaf-extras-springsecurity5</artifactId>

</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-spri

ngsecurity5">

1 获取属性

可以在 html 页面中通过

sec:authentication="" 获取

UsernamePasswordAuthenticationToken 中所有 getXXX 的内容，包含父

类中的 getXXX 的内容。

根据源码得出下面属性：

 name：登录账号名称

 principal：登录主体，在自定义登录逻辑中是 UserDetails

 credentials：凭证

 authorities：权限和角色

 details：实际上是 WebAuthenticationDetails 的实例。可以获取

remoteAddress(客户端 ip)和 sessionId(当前 sessionId)

1.1实现步骤：

1.1.1 新建 demo.html

在项目 resources 中新建 templates 文件夹，在 templates 中新建

demo.html 页面

1.1.2 编写 demo.html

在 demo.html 中编写下面内容，测试获取到的值

<!DOCTYPE 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>

<title>Title</title>

</head>

<body>

登录账号:<span sec:authentication="name">123</span><br/>

登录账号:<span sec:authentication="principal.username">456</span><br/>

凭证：<span sec:authentication="credentials">456</span><br/>

权限和角色：<span sec:authentication="authorities">456</span><br/>

客户端地址：<span sec:authentication="details.remoteAddress">456</span><br/>

sessionId：<span sec:authentication="details.sessionId">456</span><br/>

</body>

</html>

1.1.3 编写控制器

thymeleaf 页面需要控制转发，在控制器类中编写下面方法

@RequestMapping("/demo")

public String demo(){

return "demo";

}

2 权限判断

在 html 页面中可以使用 sec:authorize=”表达式”进行权限控制，

判断是否显示某些内容。表达式的内容和 access(表达式)的用法相同。如果用户具有指定的权限，则显示对应的内容；如果表达式不成立，

则不显示对应的元素。

2.1不同权限的用户显示不同的按钮

2.1.1 设置用户角色和权限

设定用户具有 admin，/insert，/delete 权限 ROLE_abc 角色。

return new User(username,password,

AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/insert,/de

lete"));

2.1.2 控制页面显示效果

在页面中根据用户权限和角色判断页面中显示的内容

通过权限判断：

<br/>

通过角色判断：

十六、

退出登录

用户只需要向 Spring Security 项目中发送/logout 退出请求即可。

1 退出实现

实现退出非常简单，只要在页面中添加/logout 的超链接即可。

<a href="/logout">退出登录</a>为了实现更好的效果，通常添加退出的配置。默认的退出 url 为

/logout，退出成功后跳转到/login?logout

如果不希望使用默认值，可以通过下面的方法进行修改。

http.logout()

.logoutUrl("/logout")

.logoutSuccessUrl("/login.html");

2 logout 其他常用配置源码解读

2.1addLogoutHandler(LogoutHandler)

默认是 contextLogoutHandler

2.2clearAuthentication(boolean)

是否清除认证状态，默认为 true

2.3invalidateHttpSession(boolean)

也可以自己进行定义退出成功处理器。只要实现了

LogoutSuccessHandler 接口。与之前讲解的登录成功处理器和登录失

败处理器极其类似。

十七、

Spring Security 中 CSRF

从刚开始学习 Spring Security 时，在配置类中一直存在这样一行

代码：http.csrf().disable();如果没有这行代码导致用户无法被认证。这

行代码的含义是：关闭 csrf 防护。

1 什么是 CSRF

CSRF（Cross-site request forgery）跨站请求伪造，也被称为“One

Click 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 匹配成功，则正常访问。

2.1实现步骤

2.1.1 编写控制器方法

编写控制器方法，跳转到 templates 中 login.html 页面。

@GetMapping("/showLogin")

public String showLogin() {

return "login";}

2.1.2 新建 login.html

在项目 resources 下新建 templates 文件夹，并在文件夹中新建

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml"

xmlns:th="http://www.thymeleaf.org">

<head>

<title>Title</title>

</head>

<body>

<input type="hidden" th:value="${_csrf.token}" name="_csrf"

th:if="${_csrf}"/>

用户名：<input type="text" name="username"/><br/>

密码:<input type="password" name="password"/><br/>

</form>

</body>

</html>

2.1.3 修改配置类

在配置类中注释掉 CSRF 防护失效

//关闭 csrf 防护

//http.csrf().disable();

3 anonymous()

anonymous()表示可以匿名访问匹配的 URL。和 permitAll()效果类

似，只是设置为 anonymous()的 url 会执行 filter 链中

官方源码定义如下：4 denyAll()

springboot整合 springSecurity

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hainei</groupId>
    <artifactId>samp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>samp</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>



        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>


        <!--swagger-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.4.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.4.0</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.11</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>


        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <!-- 通用mapper逆向工具 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

        <!-- 对象转json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.persistence/javax.persistence-api -->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
        </dependency>


        <!--阿里云上传视频-->
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-core</artifactId>
            <version>3.7.1</version>
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-vod</artifactId>
            <version>2.11.6</version>
        </dependency>
        <!--pagehelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--redis 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.1.0.M2</version>
        </dependency>

        <dependency>
            <groupId>org.activiti.dependencies</groupId>
            <artifactId>activiti-dependencies</artifactId>
            <version>7.1.0.M2</version>
            <type>pom</type>
        </dependency>

        <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

View Code

LoginFailureHandler

package com.hainei.samp.security;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hainei.samp.common.utils.DataResult;
import com.hainei.samp.common.utils.SnowflakeIdWorker;
import com.hainei.samp.dao.mapper.base.BaseUserlogintimesMapper;
import com.hainei.samp.pojo.model.base.BaseUserlogintimes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.security.authentication.*;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
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.util.Date;

@Component("loginFailureHandler")
public class LoginFailureHandler implements AuthenticationFailureHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private BaseUserlogintimesMapper baseUserlogintimesMapper;


    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        logger.info("登录失败");
        httpServletResponse.setStatus(HttpStatus.OK.value());
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        String mes = "登录失败";
        if(e instanceof LockedException){
            mes = "账户被锁定，请联系管理员！";
            httpServletResponse.getWriter().write(new DataResult(402,mes,"").toString());
        }else if(e instanceof CredentialsExpiredException){
            mes = "密码过期，请联系管理员！";
            httpServletResponse.getWriter().write(new DataResult(400,mes,"").toString());
        }else if(e instanceof AccountExpiredException){
            mes = "账户过期，请联系管理员！";
            httpServletResponse.getWriter().write(new DataResult(402,mes,"").toString());
        }else if(e instanceof DisabledException){
            mes = "账户被禁用，请联系管理员！";
            httpServletResponse.getWriter().write(new DataResult(402,mes,"").toString());
        }else if(e instanceof BadCredentialsException){
            String userName = (String)httpServletRequest.getSession().getAttribute("username");
            String userIpAddr = httpServletRequest.getRemoteAddr();
            BaseUserlogintimes baseUserlogintimes = baseUserlogintimesMapper.selectByIpUserName(userIpAddr, userName, 10);
            if(baseUserlogintimes!=null){
                baseUserlogintimes.setNum(baseUserlogintimes.getNum()+1);
                baseUserlogintimes.setGmtUpdatedOn(new Date());
                baseUserlogintimesMapper.updateByPrimaryKeySelective(baseUserlogintimes);
            }else{
                BaseUserlogintimes bu = new BaseUserlogintimes();
                bu.setId(String.valueOf(new SnowflakeIdWorker(0, 0).nextId()));
                bu.setIp(userIpAddr);
                bu.setUserName(userName);
                bu.setNum(1);
                bu.setVersion(1);
                bu.setGmtUpdatedOn(new Date());
                baseUserlogintimesMapper.insertSelective(bu);
            }


            mes = "用户名或者密码输入错误，请重新输入！";
            httpServletResponse.getWriter().write(new DataResult(400,mes,"").toString());
        }



    }
}

View Code

LoginSuccessHandler.java

package com.hainei.samp.security;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.hainei.samp.common.utils.DataResultToJson;
import com.hainei.samp.dao.mapper.base.BaseAccessFeatureMapper;
import com.hainei.samp.dao.mapper.base.BaseRoleMapper;
import com.hainei.samp.dao.mapper.base.BaseUserlogintimesMapper;
import com.hainei.samp.pojo.model.base.BaseRole;
import com.hainei.samp.pojo.model.base.BaseUser;
import com.hainei.samp.service.base.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Component("loginSuccessHandler")
public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private BaseUserlogintimesMapper baseUserlogintimesMapper;
    @Autowired
    private BaseRoleMapper baseRoleMapper;
    @Autowired
    private RedisService redisService;
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException, ServletException {
        logger.info("登录成功");

    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        logger.info("登录成功");
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        //删除登陆次数
        String userIpAddr = httpServletRequest.getRemoteAddr();
        baseUserlogintimesMapper.deleteByIp(userIpAddr);

        BaseUser baseUser = (BaseUser) authentication.getPrincipal();
        List<BaseRole> baseRoles = baseRoleMapper.selectByUid(baseUser.getId());
        baseUser.setBaseRoleList(baseRoles);


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

        baseUser.setToken(token);
        redisService.set(token,baseUser.getId(),1800,TimeUnit.SECONDS);



        httpServletResponse.getWriter().write(JSON.toJSONString(DataResultToJson.getResult(0,"登陆成功",baseUser)));

    }

}

View Code

LogoutSuccess

package com.hainei.samp.security;

import com.hainei.samp.common.utils.DataResult;
import com.hainei.samp.pojo.model.base.BaseUserlogintimes;
import com.hainei.samp.service.base.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component("logoutSuccess")
public class LogoutSuccess implements LogoutSuccessHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RedisService redisService;

    @Override
    public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        httpServletResponse.setStatus(HttpStatus.OK.value());
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        String mes = "注销成功！！";
        String token = httpServletRequest.getHeader("token");//获取header中的验证信息
        redisService.delete(token);
        httpServletResponse.getWriter().write(new DataResult(0,mes,"").toString());
    }
}

View Code

SecurityConfig

package com.hainei.samp.security;

import org.springframework.beans.factory.annotation.Autowired;
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.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.web.cors.CorsUtils;


@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private LoginSuccessHandler loginSuccessHandler;

    @Autowired
    private LoginFailureHandler loginFailureHandler;

    @Autowired
    private LogoutSuccess logoutSuccess;
    @Autowired
    private AuthenticationTokenFilter authenticationTokenFilter; // token 拦截器

    @Override
    protected void configure(HttpSecurity http) throws Exception {

//让Spring security放行所有preflight request

        //----------------自定义方法登录----------------------
      http      .addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class)
              .cors()
                .and()
                //登陆跳转接口
                .formLogin()
                .loginPage("/login")
                .loginProcessingUrl("/login")
                //登陆成功访问接口
                .successHandler(loginSuccessHandler)
                //登陆失败访问接口
                .failureHandler(loginFailureHandler)
                .and()
                .authorizeRequests()
                .requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
                //需要放开的接口
                .antMatchers("/login","/BaseUserlogintimesController/select"
                                ,"/BaseUserSecurity/getSecurity","/BaseUserSecurity/judgeSecurity","/BaseUser/register","/BaseUser/updateByAccount"
                                ,"/BaseUser/selectByAccountToBaseUser","/BaseUser/selectByUserName",
                                "/swagger/**","/doc.html","/v2/api-docs","/swagger-ui.html","/swagger-resources/**","/webjars/**"
                                ,"/druid/**","/favicon.ico","/captcha.jpg","/","/csrf","/configuration/ui"
                                , "/BaseNavigationController/getNavigation","/file/upload")
                .permitAll()
                .anyRequest().authenticated()
                //支持注销
                .and().logout().logoutSuccessHandler(logoutSuccess)
                //关闭csrf验证
                .and().csrf().disable()
                .headers().frameOptions().disable();//全部页面不验证



    }

//    public void coonfigure(WebSecurity web) throws  Exception{
//        web.ignoring().antMatchers("/BaseUserController/test","");
//    }

}

View Code

MyUserDetailsService

package com.hainei.samp.security;




import com.hainei.samp.dao.mapper.base.BaseUserMapper;
import com.hainei.samp.dao.mapper.base.BaseUserlogintimesMapper;
import com.hainei.samp.pojo.model.base.BaseUser;
import com.hainei.samp.pojo.model.base.BaseUserlogintimes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
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.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;


@Component
public class MyUserDetailsService implements UserDetailsService {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private BaseUserMapper baseUserMapper;
    @Autowired
    private BaseUserlogintimesMapper baseUserlogintimesMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        session.setAttribute("username",username);
        String userIpAddr = request.getRemoteAddr();
//-------------------------读取数据库判断登录-----------------------
/*        SysUser sysUser = sysUserService.queryByUsername(username);

        if (Objects.nonNull(sysUser)) {
            return User.withUsername(username).password(sysUser.getEncodePassword())
                    .authorities(AuthorityUtils.NO_AUTHORITIES)
                    .build();
        }
        throw new UsernameNotFoundException("username: " + username + " notfound");*/



//------------------------根据code写死用户登录--------------------------
        /*
        //-----------------------正常的代码-----------------
        logger.info("登录用户名：" + username);
        String passWord=passwordEncoder().encode("111");
        logger.info("密码：" + passWord);
        return new User(username,passWord, AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_ACTIVITI_USER"));
        //-----------------------正常的代码-----------------
*/
        //页面默认会对密码加密，数据库里如果在用户注册时，用的是加密过的密码，则直接读取比较即可
        //return new User(username,"$2a$10$YFZDTqyBqwHkV/vTxKrhtuyIQCMD/joeIylCs8wbvXnhOYRgD/kDq", AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));

        //-------------------根据自定义用户属性登录-----------------------------

        BaseUser baseUser = baseUserMapper.selectByAccount(username);



        if(baseUser!=null){
            baseUser.setAccountNonExpired(true);
            //查询已经登入次数
            BaseUserlogintimes baseUserlogintimes = baseUserlogintimesMapper.selectByIpUserName(userIpAddr, username, 10);
            //判断账号是否锁定
            if(baseUserlogintimes!=null && baseUserlogintimes.getNum()>=6){
                baseUser.setAccountNonLocked(false);
            }else{

                baseUser.setAccountNonLocked(true);
            }
        }else{
            throw new UsernameNotFoundException("数据库中无此用户！");
        }

        return baseUser;
    }



    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

View Code

BaseUser

package com.hainei.samp.pojo.model.base;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.hainei.samp.service.base.RedisService;
import io.swagger.annotations.ApiModelProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import javax.persistence.Column;
import javax.persistence.Id;
import java.util.*;
import java.util.stream.Collectors;

public class BaseUser implements UserDetails {
    /**
     * 主键
     */
    @Id
    private String id;

    /**
     * 登录名
     */
    @Column(name = "account")
    @ApiModelProperty(value = "登录名",example = "登录名")
    private String account;

    /**
     * 登录密码
     */
    @Column(name = "password")
    @ApiModelProperty(value = "登录密码",example = "登录密码")
    private String password;

    /**
     * 名称
     */
    @ApiModelProperty(value = "名称",example = "名称")
    @Column(name = "user_name")
    private String userName;

    /**
     * 是否启用
     */
    @Column(name = "is_activited")
    @ApiModelProperty(value = "是否启用",example = "是否启用")
    private Boolean isActivited;

    /**
     * 手机
     */
    @Column(name = "mobile")
    @ApiModelProperty(value = "手机",example = "手机")
    private String mobile;

    /**
     * 邮箱
     */
    @Column(name = "email")
    @ApiModelProperty(value = "邮箱",example = "邮箱")
    private String email;

    /**
     * 头像
     */
    @Column(name = "head_img")
    @ApiModelProperty(value = "头像",example = "头像")
    private String headImg;

    /**
     * 性别
     */
    @Column(name = "sex")
    @ApiModelProperty(value = "性别",example = "性别")
    private Integer sex;

    /**
     * 年龄
     */
    @Column(name = "age")
    @ApiModelProperty(value = "年龄",example = "年龄")
    private Integer age;

    /**
     * 排序
     */
    @ApiModelProperty(value = "排序",example = "排序")
    @Column(name = "sort_index")
    private Integer sortIndex;

    /**
     * 是否逻辑删除
     */
    @Column(name = "is_deleted")
    @ApiModelProperty(value = "是否逻辑删除",example = "是否逻辑删除")
    private Integer isDeleted;

    /**
     * 用户来源
     */
    @Column(name = "user_from")
    @ApiModelProperty(value = "用户来源",example = "用户来源")
    private String userFrom;

    /**
     * 备注
     */
    @Column(name = "remark")
    @ApiModelProperty(value = "备注",example = "备注")
    private String remark;

    /**
     * 创建人
     */
    @Column(name = "gmt_created_by")
    @ApiModelProperty(value = "创建人",example = "创建人")
    private String gmtCreatedBy;

    /**
     * 创建时间
     */
    @Column(name = "gmt_created_on")
    @ApiModelProperty(value = "创建时间",example = "创建时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    private Date gmtCreatedOn;

    /**
     * 更新人
     */
    @Column(name = "gmt_updated_by")
    @ApiModelProperty(value = "更新人",example = "更新人")
    private String gmtUpdatedBy;

    /**
     * 更新时间
     */
    @Column(name = "gmt_updated_on")
    @ApiModelProperty(value = "更新时间",example = "更新时间")
    private Date gmtUpdatedOn;

    /**
     * 乐观锁
     */
    @Column(name = "revision")
    @ApiModelProperty(value = "乐观锁",example = "乐观锁")
    private Integer revision;

    /**
     * 账号是否被锁
     */
    @ApiModelProperty(value = "账号是否被锁",example = "账号是否被锁")
    private Boolean accountNonLocked;

    /**
     * 是否选择角色集
     */
    @ApiModelProperty(value = "是否选择角色集",example = "是否选择角色集")
    private Boolean isAccountNonExpired;

    /**
     * springSecurity 权限
     */
    private String roles;

    /**
     * springSecurity 用户角色组
     */
    private List<BaseRole> baseRoleList;


    /**
     * token
     */
    @ApiModelProperty(value = "token",example = "token")
    private String token;


    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getSortIndex() {
        return sortIndex;
    }

    public void setSortIndex(Integer sortIndex) {
        this.sortIndex = sortIndex;
    }


    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getHeadImg() {
        return headImg;
    }

    public void setHeadImg(String headImg) {
        this.headImg = headImg;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getIsDeleted() {
        return isDeleted;
    }

    public void setIsDeleted(Integer isDeleted) {
        this.isDeleted = isDeleted;
    }

    public String getUserFrom() {
        return userFrom;
    }

    public void setUserFrom(String userFrom) {
        this.userFrom = userFrom;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public Date getGmtCreatedOn() {
        return gmtCreatedOn;
    }

    public void setGmtCreatedOn(Date gmtCreatedOn) {
        this.gmtCreatedOn = gmtCreatedOn;
    }

    public String getGmtCreatedBy() {
        return gmtCreatedBy;
    }

    public void setGmtCreatedBy(String gmtCreatedBy) {
        this.gmtCreatedBy = gmtCreatedBy;
    }

    public String getGmtUpdatedBy() {
        return gmtUpdatedBy;
    }

    public void setGmtUpdatedBy(String gmtUpdatedBy) {
        this.gmtUpdatedBy = gmtUpdatedBy;
    }

    public Date getGmtUpdatedOn() {
        return gmtUpdatedOn;
    }

    public void setGmtUpdatedOn(Date gmtUpdatedOn) {
        this.gmtUpdatedOn = gmtUpdatedOn;
    }

    public Integer getRevision() {
        return revision;
    }

    public void setRevision(Integer revision) {
        this.revision = revision;
    }

    public String getRoles() {
        return roles;
    }

    public void setRoles(String roles) {
        this.roles = roles;
    }


    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {

//        String[] split = roles.split(",");
//        String[] list = new String[split.length];
//        int i = 0;
//        for (String s:split) {
//            s = "ROLE_"+s;
//            list[i] = s;
//            i = i +1;
//        }
//        System.out.println(list.toString());
        if(roles!=null){
            return Arrays.stream(roles.split(",")).map(e->new SimpleGrantedAuthority(e)).collect(Collectors.toSet());
        }
        return  new ArrayList<>();
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return account;
    }

    @Override
    public boolean isAccountNonExpired() {
        return isAccountNonExpired;
    }

    @Override
    public boolean isAccountNonLocked() {
        return accountNonLocked;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return isActivited;
    }

    public Boolean getActivited() {
        return isActivited;
    }

    public void setActivited(Boolean activited) {
        isActivited = activited;
    }


    public void setAccountNonLocked(Boolean accountNonLocked) {
        this.accountNonLocked = accountNonLocked;
    }

    public void setAccountNonExpired(Boolean accountNonExpired) {
        isAccountNonExpired = accountNonExpired;
    }


    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public List<BaseRole> getBaseRoleList() {
        return baseRoleList;
    }

    public void setBaseRoleList(List<BaseRole> baseRoleList) {
        this.baseRoleList = baseRoleList;
    }

    @Override
    public String toString() {
        return "BaseUser{" +
                "id='" + id + '\'' +
                ", account='" + account + '\'' +
                ", password='" + password + '\'' +
                ", userName='" + userName + '\'' +
                ", isActivited=" + isActivited +
                ", mobile='" + mobile + '\'' +
                ", email='" + email + '\'' +
                ", headImg='" + headImg + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                ", sortIndex=" + sortIndex +
                ", isDeleted=" + isDeleted +
                ", gmtCreatedBy='" + gmtCreatedBy + '\'' +
                ", gmtCreatedOn=" + gmtCreatedOn +
                ", gmtUpdatedBy='" + gmtUpdatedBy + '\'' +
                ", gmtUpdatedOn=" + gmtUpdatedOn +
                ", revision=" + revision +
                ", accountNonLocked=" + accountNonLocked +
                '}';
    }
}

View Code

my ceshi

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wq</groupId>
    <artifactId>test_spring_security</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test_spring_security</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

View Code

MyUserDetailsService

package com.wq.test_spring_security.config;

import com.wq.test_spring_security.mapper.BaseUserMapper;
import com.wq.test_spring_security.mapper.UserMapper;
import com.wq.test_spring_security.model.BaseUser;
import com.wq.test_spring_security.model.User;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.security.core.authority.AuthorityUtils;
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.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import tk.mybatis.mapper.common.BaseMapper;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

/**
 * Created with IntelliJ IDEA.
 * User：wq
 * Date：2021/11/29
 * Time: 11:05
 * Description: springSecurity
 */
@Component
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private BaseUserMapper userMapper;
    @Autowired
    private UserMapper userMapperTest;
    @Autowired
    private PasswordEncoder encoder;
    @Override
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
//        Example example = new Example(BaseUser.class);
//        example.createCriteria().andEqualTo("userName",userName);
//        List<BaseUser> baseUsers = userMapper.selectByExample(example);
            User user = userMapperTest.selectByUserName(userName);
//        String password = encoder.encode("123");
//        User user = new User("wjs", password, AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
        return user;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

View Code

BaseUser

package com.wq.test_spring_security.model;

import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.stream.Collectors;
import javax.persistence.*;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

/**
 *Created with IntelliJ IDEA.
 * User：wq
 * Date：2021/11/29 
 * Time: 11:23
 * Description: No Description
 */
/**
    * 系统_用户表
    */
@Data
@Table(name = "base_user")
@Component
public class BaseUser implements UserDetails {
    /**
     * id
     */
    @Id
    @Column(name = "id")
    private String id;

    /**
     * 登录账户
     */
    @Column(name = "account")
    private String account;

    /**
     * 登录密码
     */
    @Column(name = "`password`")
    private String password;

    /**
     * 名称
     */
    @Column(name = "user_name")
    private String userName;

    /**
     * 是否启用
     */
    @Column(name = "is_activited")
    private Boolean isActivited;

    /**
     * 手机
     */
    @Column(name = "mobile")
    private String mobile;

    /**
     * 邮箱
     */
    @Column(name = "email")
    private String email;

    /**
     * 头像
     */
    @Column(name = "head_img")
    private String headImg;

    /**
     * 性别
     */
    @Column(name = "sex")
    private Integer sex;

    /**
     * 排序
     */
    @Column(name = "sort_index")
    private Integer sortIndex;

    /**
     * 年龄
     */
    @Column(name = "age")
    private Integer age;

    /**
     * 是否删除
     */
    @Column(name = "is_deleted")
    private Integer isDeleted;

    /**
     * 用户来源
     */
    @Column(name = "user_from")
    private String userFrom;

    /**
     * 备注
     */
    @Column(name = "remark")
    private String remark;

    /**
     * 创建人
     */
    @Column(name = "gmt_created_by")
    private String gmtCreatedBy;

    /**
     * 创建时间
     */
    @Column(name = "gmt_created_on")
    private Date gmtCreatedOn;

    /**
     * 修改人
     */
    @Column(name = "gmt_updated_by")
    private String gmtUpdatedBy;

    /**
     * 修改时间
     */
    @Column(name = "gmt_updated_on")
    private Date gmtUpdatedOn;

    /**
     * 乐观锁
     */
    @Column(name = "revision")
    private Integer revision;

    private String roles;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        System.out.println("authorities!!!");
      //  return   AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_ACTIVITI_ADMIN");
        return   AuthorityUtils.commaSeparatedStringToAuthorityList("11");

    }

    @Override
    public String getUsername() {
        System.out.println(userName+"!!!");

        return userName;
    }

    @Override
    public boolean isAccountNonExpired() {
//        System.out.println("isAccountNonExpired");
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
//        System.out.println("isAccountNonLocked");
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
//        System.out.println("isCredentialsNonExpired");
        return true;
    }

    @Override
    public boolean isEnabled() {
//        System.out.println("isEnabled");
        return true;
    }
}

View Code

posted @ 2020-01-07 10:47 wq9 阅读(358) 评论(0) 收藏举报

刷新页面返回顶部

wq9

spring security

Spring Security

一、 Spring Security 简介

1 概括

2 历史

二、 第一个 Spring Security 项目

1 导入依赖

2 访问页面

三、 UserDetailsService 详解

1 返回值

2 方法参数

3 异常

1 接口介绍

3 BCryptPasswordEncoder 简介

4 代码演示

五、 自定义登录逻辑

1 编写配置类

2 自定义逻辑

3 查看效果

六、 自定义登录页面

1 编写登录页面

2 修改配置类

3 编写控制器

七、 认证过程其他常用配置

1 失败跳转

1.1编写页面

1.2修改表单配置

1.3添加控制器方法

1.4设置 fail.html 不需要认证

2 设置请求账户和密码的参数名

2.1源码简介

2.2修改配置

2.3修改页面

3 自定义登录成功处理器

3.1源码分析

3.2代码实现

3.2.1 自定义类

3.2.2 修改配置项

4 自定义登录失败处理器

4.2代码实现

4.2.1 新建控制器

4.2.2 修改配置类

八、 访问控制 url 匹配

3.1介绍

3.2两个参数时使用方式

4 mvcMatchers()

公告

二、第一个 Spring Security 项目

五、自定义登录逻辑

六、自定义登录页面

七、认证过程其他常用配置

八、访问控制 url 匹配