Spring Security学习笔记 学习时间：2024年7月17日
1 入门项目
1 2 3 4 <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter-security</artifactId > </dependency >
1 2 3 4 5 6 7 8 9 @RestController public class HelloController { @GetMapping("/hello") public String hello () { return "Hello, 来跟 学习 Spring Security吧!" ; } }
把项目启动起来后，在浏览器中对Web接口进行访问，会发现接口是无法直接访问的。在访问接口之前会自动跳转到/login地址，进入到一个登录界面。这是因为Spring Boot中”约定大约配置”的规则，只要添加了Spring Security的依赖包，就会自动开启安全限制，在访问Web接口之前会进行安全拦截。只有输入了用户名和密码，才能访问项目中的Web接口。
默认用户名为user，密码为随机uuid：
1 2 3 4 5 6 7 8 9 10 11 public class ReactiveUserDetailsServiceAutoConfiguration { private String getOrDeducePassword (User user, PasswordEncoder encoder) { String password = user.getPassword(); if (user.isPasswordGenerated()) { logger.info(String.format("%n%nUsing generated security password: %s%n" , user.getPassword())); } return encoder == null && !PASSWORD_ALGORITHM_PATTERN.matcher(password).matches() ? "{noop}" + password : password; } }
密码生成机制：
1 2 3 4 5 6 7 8 9 10 11 public class SecurityProperties { public static class User { private String name = "user" ; private String password = UUID.randomUUID().toString(); private List<String> roles = new ArrayList (); private boolean passwordGenerated = true ; } }
1 2 3 4 5 spring: security: user: name: zym password: zym123
2 认证 认证: 所谓的认证，就是用来判断系统中是否存在某用户，并判断该用户的身份是否合法的过程，解决的其实是用户登录的问题。认证的存在，是为了保护系统中的隐私数据与资源，只有合法的用户才可以访问系统中的资源。
在Spring Security中，常见的认证方式可以分为HTTP层面和表单层面，常见的认证方式如下:
HTTP基本认证；
Form表单认证
HTTP摘要认证；
2.1 HTTP基本认证 2.1.1 概述 在Spring Security 4.x版本中，默认采用的登录方式是Http基本认证（或者Basic认证） ，该方式会弹出一个对话框，要求用户输入用户名和密码。在每次进行基本认证请求时，都会在Authorization请求头中利用Base64 对 用户:密码 字符串进行编码。这种方式并不安全，并不适合在Web项目中使用，但它是一些现代主流认证的基础，而且在Spring Security的OAuth中，内部认证的默认方式就是用的Http基本认证。
客户端首先发起一个未携带认证信息的请求；
然后服务器端返回一个401 Unauthorized的响应信息，并在WWW-Authentication头部中说明认证形式：当进行HTTP基本认证时，WWW-Authentication会被设置为Basic realm=“被保护的页面”；
接下来客户端会收到这个401 Unauthorized响应信息，并弹出一个对话框，询问用户名和密码。当用户输入后，客户端会将用户名和密码使用冒号进行拼接并用Base64编码，然后将其放入到请求的Authorization头部并发送给服务器；
最后服务器端对客户端发来的信息进行解码得到用户名和密码，并对该信息进行校验判断是否正确，最终给客户端返回响应内容。
HTTP基本认证是一种无状态的认证方式，与表单认证相比，HTTP基本认证是一种基于HTTP层面的认证方式，无法携带Session信息，也就无法实现Remember-Me功能。另外，用户名和密码在传递时仅做了一次简单的Base64编码，几乎等同于以明文传输，极易被进行密码窃听和重放攻击。所以在实际开发中，很少会使用这种认证方式来进行安全校验。
2.1.2 代码实现 新建配置类SecurityConfig：
1 2 3 4 5 6 7 8 9 10 11 12 13 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .httpBasic(); } }
在SecurityConfig类上添加@EnableWebSecurity注解后，会自动被Spring发现并注册。
注：http.authorizeRequests()首先对url进行匹配，然后进行权限控制。支持链式调用。
url匹配规则
anyRequest()：表示匹配所有的url请求
1 2 3 http.authorizeRequests() .anyRequest().authenticated();
antMatcher()：传递一个ant表达式参数，表示匹配所有满足ant表达式的请求。
?：匹配一个字符*：匹配0个或多个字符**：匹配0个或多个目录
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 http.authorizeRequests() .antMatchers("/showLogin" , "/errPage" ) .anonymous() .antMatchers( "/css/**" , "/js/**" , "/images/**" , "/fonts/**" , "/favicon.ico" ) .anonymous() .anyRequest() .authenticated();
权限控制方法
permitAll()：表示所匹配的URL任何人都允许访问anonymous()：表示可以匿名访问匹配的URL。denyAll()：表示所匹配的URL都不允许被访问。authenticated()：表示所匹配的URL都需要被认证才能访问rememberMe()：允许通过remember-me登录的用户访问hasRole()：如果有参数，参数表示角色，则其角色可以访问
2.1.3 认证流程 当第一次调用接口时，查看响应头，可以看到WWW-Authenticate认证信息:
1 WWW-Authenticate：Basic realm="Realm"
其中：
WWW-Authenticate: 表示服务器告知浏览器进行代理认证工作。
Basic: 表示认证类型为Basic认证。
realm=”Realm”: 表示认证域名为Realm域。
根据401和以上响应头信息，浏览器会弹出一个对话框，要求输入用户名/密码，Basic认证会将其拼接成 “用户名:密码” 格式，中间是一个冒号，并利用Base64编码成加密字符串xxx；然后在请求头中附加Authorization: Basic xxx，发送给后台认证；后台需要利用Base64来进行解码xxx，得到用户名和密码，再校验 用户名:密码 信息。
如果认证错误，浏览器会保持弹框；
如果认证成功，浏览器会缓存有效的Base64编码，在之后的请求中，浏览器都会在请求头中添加该有效编码。
2.1.4 认证的销毁 在成功认证之后，Basic认证会把Authorization认证信息缓存在浏览器 中一段时间，之后每次请求接口时都会自动带上，所以直到 用户关闭浏览器才会销毁认证信息 ，也就是说我们无法在服务端进行有效的注销。
2.2.1 默认配置 在之前的章节中，创建的第一个Spring Security项目中实现的效果，其实就是表单认证。每次在访问某个Web接口之前，都会重定向到一个Security自带的login登录页面上，这个登录页面，就是表单认证的效果。
下图显示，hello请求被重定向到login：
在默认的表单认证配置中，自动配置了一些url和页面:
/login(get) : get请求时会跳转到这个页面，只要我们访问任意一个需要认证的请求时，都会跳转到这个登录界面。/login(post) : post请求时会触发这个接口，在登录页面点击登录时，默认的登录页面表单中的action就是关联这个login接口。/login?error : 当用户名或密码错误时，会跳转到该页面。/: 登录成功后，默认跳转到该页面，如果配置了index.html页面，则 ”/“ 会重定向到index.html页面，当然这个页面要由我们自己实现。/logout: 注销页面。/login?logout: 注销成功后跳转到的页面。
2.2.2 自定义配置
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override public void configure (WebSecurity web) throws Exception { web.ignoring() .antMatchers("/js/**" , "/css/**" , "/images/**" ); } @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .formLogin() .loginPage("/myLogin.html" ) .permitAll() .and() .csrf() .disable(); } }
myLogin.html页面，注意form表单中action的值，请暂时先写成”/myLogin.html“。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 <!DOCTYPE html > <html lang ="en" > <body > <div class ="login" > <h2 > Access Form</h2 > <div class ="login-top" > <h1 > 登录验证</h1 > <form action ="/myLogin.html" method ="post" > <input type ="text" name ="username" placeholder ="username" /> <input type ="password" name ="password" placeholder ="password" /> <div class ="forgot" > <a href ="#" > 忘记密码</a > <input type ="submit" value ="登录" > </div > </form > </div > <div class ="login-bottom" > <h3 > 新用户 <a href ="#" > 注 册</a > </h3 > </div > </div > </body > </html >
访问接口，被重定向到/myLogin.html：
2.2.3 细化配置 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override public void configure (WebSecurity web) throws Exception { web.ignoring() .antMatchers("/js/**" , "/css/**" , "/images/**" ); } @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .formLogin() .loginPage("/myLogin.html" ) .permitAll() .defaultSuccessUrl("/index.html" ,true ) .loginProcessingUrl("/login" ) .failureUrl("/error.html" ) .usernameParameter("zym" ) .passwordParameter("zym123" ) .and() .logout() .logoutUrl("/logout" ) .logoutSuccessUrl("/myLogin.html" ) .permitAll() .deleteCookies("myCookie" ) .and() .csrf() .disable(); } }
2.3 HTTP摘要认证 暂略
2.4 前后端分离方案 2.4.1 概述 在之前的章节讲解表单认证时，处理登录成功时，跳转到某个页面的API是如下两个方法：
defaultSuccessUrl
successForwardUrl
处理登录失败时，跳转页面的API是如下两个方法：
failureUrl()
failureForwardUrl()
上面的方法，无论是认证成功还是认证失败，都是在前后端不分离时的处理方案，直接从Java后端跳转到某个页面上。在前后端分离模式下，既然后端没有页面，页面都在前端，那就可以考虑使用JSON来进行信息交互了，我们把认证成功或认证失败的信息，以JSON的格式传递给前端，由前端来决定到底该往哪个页面跳转就好了。
2.4.2 认证成功 ① API
successHandler()：successHandler方法的参数是一个 AuthenticationSuccessHandler 对象，这个对象中我们要实现的方法是 onAuthenticationSuccess。onAuthenticationSuccess()：方法中有三个参数，分别是：
HttpServletRequest: 利用该参数我们可以实现服务端的跳转;HttpServletResponse: 利用该参数我们可以做客户端的跳转，也可以返回 JSON 数据;Authentication: 这个参数则保存了我们刚刚登录成功的用户信息。
② 实现
定义SecurityAuthenticationSuccessHandler类：该类需要实现SavedRequestAwareAuthenticationSuccessHandler接口。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class SecurityAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler { @Override public void onAuthenticationSuccess (HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws ServletException, IOException { Object principal = authentication.getPrincipal(); response.setContentType("application/json;charset=utf-8" ); PrintWriter out = response.getWriter(); out.write(new ObjectMapper ().writeValueAsString(principal)); out.flush(); out.close(); } }
配置类：在SecurityConfig配置类中，调用successHandler()方法，把前面定义的SecurityAuthenticationSuccessHandler类关联进来。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .successHandler(new SecurityAuthenticationSuccessHandler ()) .and() .csrf() .disable(); } }
登录成功后，后端向前端发送json：
2.4.3 认证失败
定义类SecurityAuthenticationFailureHandler，实现ExceptionMappingAuthenticationFailureHandler接口，来专门处理认证失败时的返回结果。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class SecurityAuthenticationFailureHandler extends ExceptionMappingAuthenticationFailureHandler { @Override public void onAuthenticationFailure (HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException { response.setContentType("application/json;charset=utf-8" ); PrintWriter out = response.getWriter(); out.write(exception.getMessage()); out.flush(); out.close(); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .successHandler(new SecurityAuthenticationSuccessHandler ()) .failureHandler(new SecurityAuthenticationFailureHandler ()) .and() .csrf() .disable(); } }
登录失败：
2.4.4 退出登录
定义一个SecurityLogoutSuccessHandler类，实现LogoutSuccessHandler接口，在这里负责输出退出登录时的JSON结果。
1 2 3 4 5 6 7 8 9 10 public class SecurityLogoutSuccessHandler implements LogoutSuccessHandler { @Override public void onLogoutSuccess (HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException { response.setContentType("application/json;charset=utf-8" ); PrintWriter out = response.getWriter(); out.write("注销成功" ); out.flush(); out.close(); } }
配置类：调用logoutSuccessHandler()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .successHandler(new SecurityAuthenticationSuccessHandler ()) .failureHandler(new SecurityAuthenticationFailureHandler ()) .and() .logout() .logoutSuccessHandler(new SecurityLogoutSuccessHandler ()) .and() .csrf() .disable(); }
2.4.5 未认证 如果用户没有登录，就访问一个需要认证后才能访问的页面。这个时候，我们不应该让用户重定向到登录页面，而是给用户一个尚未登录的提示，前端收到提示之后，再自行决定页面跳转。因为在前后端分离时，后端没有页面，未认证时也没办法直接重定向到登录页面。
定义一个SecurityAuthenticationEntryPoint类，实现AuthenticationEntryPoint接口，在这里负责输出未认证时的JSON结果。
1 2 3 4 5 6 7 8 9 10 public class SecurityAuthenticationEntryPoint implements AuthenticationEntryPoint { @Override public void commence (HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException { response.setContentType("application/json;charset=utf-8" ); PrintWriter out = response.getWriter(); out.write("尚未登录，请先登录" ); out.flush(); out.close(); } }
配置类：调用authenticationEntryPoint()方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .successHandler(new SecurityAuthenticationSuccessHandler ()) .failureHandler(new SecurityAuthenticationFailureHandler ()) .and() .logout() .logoutSuccessHandler(new SecurityLogoutSuccessHandler ()) .and() .csrf() .disable() .exceptionHandling() .authenticationEntryPoint(new SecurityAuthenticationEntryPoint ()); }
3 授权 所谓授权，比如说某个用户想要访问某个资源(接口、页面、功能等)，我们应该先去检查该用户是否具备对应的权限，如果具备就允许访问，如果不具备，则不允许访问。
在Spring Security中，授权粒度有如下几种：
支持基于 URL 的请求授权 基于方法访问的授权 基于对象访问的授权
授权实现方式：
基于内存模型实现授权
基于默认数据库模型实现授权 基于自定义数据库模型实现授权
3.1 基于内存模型 略
3.2 基于默认数据库模型 略
3.3 基于自定义数据库模型 3.3.1 接口 Spring Security 支持MySQL、Oracle等多种不同的数据源，这些不同的数据源最终都由 UserDetailsService这个接口的子类来负责进行操作。
Spring Security还提供了另一个UserDetailsService的实现子类，也就是JdbcUserDetailsManager。利用JdbcUserDetailsManager可以帮助我们以JDBC的方式对接数据库进行增删改查等操作。它内部设定了一个默认的数据库模型，只要遵从这个模型，我们就可以很方便的实现在数据库中创建用户名和密码、角色等信息，但是灵活性不足。
1 2 3 public interface UserDetailsService { UserDetails loadUserByUsername (String username) throws UsernameNotFoundException; }
从源码中可以看出，可以利用loadUserByUsername()方法，根据用户名查询出对应的UserDetails信息。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public interface UserDetails extends Serializable { Collection<? extends GrantedAuthority > getAuthorities(); String getPassword () ; String getUsername () ; boolean isAccountNonExpired () ; boolean isAccountNonLocked () ; boolean isCredentialsNonExpired () ; boolean isEnabled () ; }
从UserDetails的源码中我们了解到，UserDetails其实就是一个包含了User信息的类，其中包含了用户名、密码、角色及账号状态等信息。
3.3.2 代码实现 ① 测试接口 1 2 3 4 5 6 7 8 @RestController @RequestMapping("/admin") public class AdminController { @GetMapping("/hello") public String hello () { return "hello, admin" ; } }
1 2 3 4 5 6 7 8 @RestController @RequestMapping("/user") public class UserController { @GetMapping("/hello") public String hello () { return "hello, user" ; } }
1 2 3 4 5 6 7 8 @RestController @RequestMapping("/visitor") public class VisitorController { @GetMapping("/hello") public String hello () { return "hello, visitor" ; } }
授权规则：
/visitor/hello 任何人都可以访问；
/admin/hello 具有 admin 角色的人才能访问；
/user/hello 具有 user 角色的人才能访问；
所有 user 角色能够访问的接口资源，admin 角色也都能够访问。
② 准备数据库 1 2 3 4 5 6 7 8 CREATE TABLE users (id bigint(20) NOT NULL AUTO_INCREMENT, username varchar(50) NOT NULL, password varchar(60) NOT NULL, enable tinyint(4) NOT NULL DEFAULT 1, roles text character set utf8, PRIMARY KEY (id), KEY username (username) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
③ User实体类 创建一个User实体类，这个用户实体类需要实现 UserDetails 接口，并实现接口中的方法。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 @Data public class User implements UserDetails { private Long id; private String username; private String password; private String roles; private boolean enable; private List<GrantedAuthority> authorities; @Override public Collection<? extends GrantedAuthority > getAuthorities() { return this .authorities; } @Override public String getPassword () { return this .password; } @Override public String getUsername () { return this .username; } @Override public boolean isAccountNonExpired () { return true ; } @Override public boolean isAccountNonLocked () { return true ; } @Override public boolean isCredentialsNonExpired () { return true ; } @Override public boolean isEnabled () { return true ; } }
accountNonExpired、accountNonLocked、credentialsNonExpired、enabled 这四个属性分别用来描述用户的状态，表示账户是否没有过期、账户是否没有被锁定、密码是否没有过期、以及账户是否可用；
roles 属性表示用户的角色；
getAuthorities 方法返回用户的角色信息，一个用户可能会有多个角色，所以这里返回值是一个集合类型，我们在这个方法中把自己的 Role 角色稍微转化一下即可。
④ Mapper接口 1 2 3 4 5 @Repository public interface UserMapper { @Select("SELECT * FROM users WHERE username=#{username}") User findByUserName (@Param("username") String username) ; }
⑤ 实现UserDetailsService接口 在service层，定义一个UserDetailsService子类，实现UserDetailsService接口，然后实现该接口中的loadUserByUsername()方法。这个方法的参数是用户在登录的时候传入的用户名，然后根据用户名去查询用户信息(查出来之后，系统会自动进行密码比对)。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 @Service public class MyUserDetailsService implements UserDetailsService { @Resource private UserMapper userMapper; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { User user = userMapper.findByUserName(username); if (user == null ) { throw new UsernameNotFoundException ("用户不存在" ); } user.setAuthorities(AuthorityUtils.commaSeparatedStringToAuthorityList(user.getRoles())); return user; } }
⑥ 配置类 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Resource private MyUserDetailsService userDetailsService; @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/admin/**" ) .hasRole("ADMIN" ) .antMatchers("/user/**" ) .hasRole("USER" ) .antMatchers("/visitor/**" ) .permitAll() .anyRequest() .authenticated() .and() .formLogin() .permitAll(); } @Override protected void configure (AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService) .passwordEncoder(NoOpPasswordEncoder.getInstance()); } }
4 验证码 暂略
5 自动登录和注销 5.1 实现方案 自动登录是将用户的登录信息保存在用户浏览器的cookie中，当用户下次访问时，自动实现校验并建立登录状态的一种机制 。
所以基于上面的原理，Spring Security 就为我们提供了两种比较好的实现自动登录的方案：
基于散列加密算法机制 ：加密用户必要的登录信息，并生成令牌来实现自动登录，利用TokenBasedRememberMeServices 类来实现。基于数据库等持久化数据存储机制 ：生成持久化令牌来实现自动登录，利用PersistentTokenBasedRememberMeServices 来实现。
5.2 基于散列加密算法 5.2.1 代码实现 ① 配置加密令牌key 创建一个application.yml文件，在其中添加数据库配置，以及一个用来加密令牌的key字符串，字符串的值随便自定义就行 。
1 2 3 4 5 6 7 8 spring: datasource: url: jdbc:mysql://localhost:3306/db-security?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT username: XXX password: XXX security: remember-me: key: zym
② 配置类 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Value("${spring.security.remember-me.key}") private String rememberKey; @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/admin/**" ) .hasRole("ADMIN" ) .antMatchers("/user/**" ) .hasRole("USER" ) .antMatchers("/visitor/**" ) .permitAll() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .successHandler(new SecurityAuthenticationSuccessHandler ()) .failureHandler(new SecurityAuthenticationFailureHandler ()) .and() .rememberMe() .userDetailsService(userDetailsService) .key(rememberKey) .and() .csrf() .disable(); } @Resource private MyUserDetailsService userDetailsService; @Override protected void configure (AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService) .passwordEncoder(NoOpPasswordEncoder.getInstance()); } }
请求结果：
5.2.2 cookies加密原理 首次登录时：
1 2 hashInfo=md5Hex(username +":" +expirationTime +":" password+":" +key)
将该hashInfo作为cookies存储在浏览器。
再次登录时：
1 2 rememberCookie=base64(username+":" +expirationrime+":" +hashInfo)
步骤：
首先后端根据登陆成功的用户的用户名，密码和过期时间等信息散列生成cookie，发回并保存在浏览器中；
在浏览器关闭并重新打开之后，用户再去访问 /user/hello 接口时，此时浏览器就会携带remember-me这个cookie到服务端；
服务器端拿到cookie之后，利用Base64进行解码，计算出用户名和过期时间，再根据用户名查询到用户密码；
最后还要通过 MD5 散列函数计算出散列值，并将计算出的散列值和浏览器传递来的散列值进行对比，以此确认这个令牌是否有效。
5.2.3 自动登录原理 ① 令牌生成 令牌生成的核心处理方法定义在：TokenBasedRememberMeServices#onLoginSuccess。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 @Override public void onLoginSuccess (HttpServletRequest request, HttpServletResponse response, Authentication successfulAuthentication) { String username = retrieveUserName(successfulAuthentication); String password = retrievePassword(successfulAuthentication); ...... if (!StringUtils.hasLength(password)) { UserDetails user = getUserDetailsService().loadUserByUsername(username); password = user.getPassword(); } int tokenLifetime = calculateLoginLifetime(request, successfulAuthentication); long expiryTime = System.currentTimeMillis(); expiryTime += 1000L * (tokenLifetime < 0 ? TWO_WEEKS_S : tokenLifetime); String signatureValue = makeTokenSignature(expiryTime, username, password); setCookie(new String [] { username, Long.toString(expiryTime), signatureValue }, tokenLifetime, request, response); } protected String makeTokenSignature (long tokenExpiryTime, String username, String password) { String data = username + ":" + tokenExpiryTime + ":" + password + ":" + getKey(); MessageDigest digest; digest = MessageDigest.getInstance("MD5" ); return new String (Hex.encode(digest.digest(data.getBytes()))); }
首先从登录成功的 Authentication 对象中提取出用户名/密码；
由于登录成功之后，密码可能被擦除了，所以如果一开始没有拿到密码，就再从 UserDetailsService 中重新加载用户并重新获取密码；
接下来获取令牌的有效期，令牌有效期默认是两周；
再接下来调用 makeTokenSignature()方法 去计算散列值，实际上就是根据 username、令牌有效期以及 password、key 一起计算一个散列值。如果我们没有自己去设置这个 key，默认是在 RememberMeConfigurer#getKey 方法中进行设置的，它的值是一个 UUID 字符串。但是如果服务端重启，这个默认的 key 是会变的，这样就导致之前派发出去的所有 remember-me 自动登录令牌失效，所以我们可以指定这个 key。
最后，将用户名、令牌有效期以及计算得到的散列值放入 Cookie 中并随response返回。
② 令牌解析 核心流程就是首先获取用户名和过期时间，再根据用户名查询到用户密码，然后通过 MD5 散列函数计算出散列值。最后再将拿到的散列值和浏览器传递来的散列值进行对比，就能确认这个令牌是否有效，进而确认登录是否有效。
5.3 基于持久化令牌 在持久化令牌方案中，最核心的是series和token两个值，这两个值都是用MD5散列计算生成的随机字符串。不同的是，series仅在用户使用密码重新登录时更新，而 token 会在每一个新的session会话中都重新生成 。
持久化令牌方案 避免了散列加密方案中，一个令牌可以同时在多端登录的问题 ，这是因为每个session会话都会引发token的更新，即每个token仅支持单实例登录 。
5.3.1 代码实现 ① 数据表 创建一张persistent_logins表，用来存储我们自动登录时生成的持久化令牌信息，该表SQL脚本如下：
1 create table persistent_logins (username varchar(64) not null, series varchar(64) primary key, token varchar(64) not null, last_used timestamp not null)
在该表中，series是主键，可以根据series进行令牌信息的查询等操作。
② 配置类 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Value("${spring.security.remember-me.key}") private String rememberKey; @Autowired private DataSource dataSource; @Override protected void configure (HttpSecurity http) throws Exception { JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl (); tokenRepository.setDataSource(dataSource); http.authorizeRequests() .antMatchers("/admin/**" ) .hasRole("ADMIN" ) .antMatchers("/user/**" ) .hasRole("USER" ) .antMatchers("/visitor/**" ) .permitAll() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .and() .rememberMe() .userDetailsService(userDetailsService) .key(rememberKey) .tokenRepository(tokenRepository) .tokenValiditySeconds(60 * 60 * 24 * 7 ) .and() .csrf() .disable(); } @Resource private MyUserDetailsService userDetailsService; @Override protected void configure (AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService) .passwordEncoder(NoOpPasswordEncoder.getInstance()); } }
这时候，我们只需要在登录页面中输入 用户名和密码，勾选“记住我”功能之后，Spring Security就会生成一个持久化令牌，在这个令牌中就保存了当前登陆的用户信息，该令牌信息会被自动持久化存储到persistent_logins表中。
5.3.2 两种方式的对比 散列加密方案和持久化令牌方案，这两种方案都是把信息存储在cookie中，所以都有被盗取用户身份信息的可能性，当然持久化令牌方案的安全性更高一些 。但是如果要你追求最安全的方式，那就尽量不要实现自动登录功能，所以我们要在用户体验和提高安全性之间选择平衡点。
如果我们一定要实现自动登录功能，*可以限制以cookie身份登录时的部分执行权限 ***，比如在修改密码、修改邮箱(防止找回密码)、查看隐私信息(如完整的手机号码、银行卡号等)时，我们可以进一步校验用户的登录密码，或者设置独立密码来做二次校验，以提高安全性。
5.4 注销
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 http.authorizeRequests() .antMatchers("/admin/**" ) .hasRole("ADMIN" ) .antMatchers("/user/**" ) .hasRole("USER" ) .antMatchers("/app/**" ) .permitAll() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .and() .rememberMe() .userDetailsService(userDetailsService) .key(rememberKey) .tokenRepository(tokenRepository) .tokenValiditySeconds(60 * 60 * 24 * 7 ) .and() .logout() .logoutUrl("/user/logout" ) .logoutSuccessUrl("/login" ) .invalidateHttpSession(true ) .clearAuthentication(true ) .deleteCookies("cookie01" ,"cookie02" ) .and() .csrf() .disable();
如果我们想自己编写退出登录时的业务逻辑，也可以在UserController中定义一个“/logout”接口，处理退出登录功能。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 @RestController @RequestMapping("/user") public class UserController { @GetMapping("hello") public String hello () { return "hello, user" ; } @RequestMapping("/logout") public void logout (HttpSession session) { session.invalidate(); System.out.println("logout执行了..." ); } }
6 密码加密 6.1 简介 在一般的项目里，常用的就是信息摘要算法，也可以被称为散列加密函数，或者称为散列算法、哈希函数 。这是一种可以从任何数据中创建数字“指纹”的方法，常用的散列函数有 MD5 消息摘要算法、安全散列算法(Secure Hash Algorithm)等 。
Spring Security提供了多种密码加密算法，但官方推荐使用的是BCryptPasswordEncoder 方案。
6.2 代码实现
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 @RestController @RequestMapping("/user") public class UserController { @Resource private PasswordEncoder passwordEncoder; @Resource private UserService userService; @GetMapping("/hello") public String hello () { return "hello, user" ; } @GetMapping("/register") public User registerUser (@RequestBody User user) { user.setEnable(true ); user.setRoles("USER" ); user.setPassword(passwordEncoder.encode(user.getPassword())); userService.save(user); return user; } }
配置类：放行/user/register接口，注入PasswordEncoder
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Value("${spring.security.remember-me.key}") private String rememberKey; @Autowired private DataSource dataSource; @Override protected void configure (HttpSecurity http) throws Exception { JdbcTokenRepositoryImpl tokenRepository = new JdbcTokenRepositoryImpl (); tokenRepository.setDataSource(dataSource); http.authorizeRequests() .antMatchers("/admin/**" ) .hasRole("ADMIN" ) .antMatchers("/user/register" ) .permitAll() .antMatchers("/user/**" ) .hasRole("USER" ) .antMatchers("/visitor/**" ) .permitAll() .anyRequest() .authenticated() .and() .formLogin() .permitAll() .and() .rememberMe() .userDetailsService(userDetailsService) .key(rememberKey) .tokenRepository(tokenRepository) .tokenValiditySeconds(60 * 60 * 24 * 7 ) .and() .csrf() .disable(); } @Resource private MyUserDetailsService userDetailsService; @Bean public PasswordEncoder passwordEncoder () { return new BCryptPasswordEncoder (); } @Override protected void configure (AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder()); } }
测试接口：
7 权限控制 在Spring Security 中，对接口的拦截或放行，有四种常见的权限控制方式：
利用Ant表达式实现权限控制；（已学）
利用授权注解结合SpEl表达式实现权限控制；
利用过滤器注解实现权限控制；
利用动态权限实现权限控制。
7.1 授权注解结合SpEl表达式 常用的授权注解有3个：
@PreAuthorize：方法执行前进行权限检查；@PostAuthorize：方法执行后进行权限检查；@Secured：类似于 @PreAuthorize。
代码实现
首先需要利用@EnableGlobalMethodSecurity注解开启授权注解功能 ，代码如下：
1 2 3 4 5 @EnableGlobalMethodSecurity(prePostEnabled = true,securedEnabled = true) public class SecurityConfig extends WebSecurityConfigurerAdapter { }
然后在具体的接口方法上利用授权注解进行权限控制，代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 @RestController public class UserController { @Secured({"ROLE_USER"}) @GetMapping("/user/hello") public String helloUser () { return "hello, user" ; } @PreAuthorize("hasRole('ADMIN')") @GetMapping("/admin/hello") public String helloAdmin () { return "hello, admin" ; } @PreAuthorize("#age>100") @GetMapping("/age") public String getAge (@RequestParam("age") Integer age) { return String.valueOf(age); } @GetMapping("/visitor/hello") public String helloVisitor () { return "hello, visitor" ; } }
7.2 过滤器注解 在Spring Security中还提供了另外的两个注解，即**@PreFilter和@PostFilter， 这两个注解可以对集合类型的参数或返回值进行过滤**。使用@PreFilter和@PostFilter时，Spring Security将移除对应表达式结果为false的元素。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 @Slf4j @RestController public class FilterController { @PostFilter("filterObject.id%2==0") @GetMapping("/users") public List<User> getAllUser () { List<User> users = new ArrayList <>(); for (int i = 0 ; i < 10 ; i++) { users.add(new User (i, "zym-" + i)); } return users; } }
其余略
8 跨域问题 8.1 简介 在同源策略中，域名、协议、端口都要相同。
在前后端分离的项目中，需要解决跨域问题，常用的手段：
Java后端进行跨域解决CORS
使用AJAX的JSONP
使用jQuery的JSONP插件
document.domain + iframe 跨域解决方案
window.name + iframe 跨域解决方案
location.hash + iframe 跨域解决方案
postMessage跨域解决方案
WebSocket协议跨域解决方案
node代理跨域解决方案
nginx代理跨域解决方案
8.2 代码实现 8.2.1 未引入ss的跨域解决方案 在SpringBoot环境中，创建一个端口号为8080的web项目，注意这个web项目没有引入Spring Security的依赖包。然后在其中创建一个IndexController，定义两个测试接口以便被ajax进行跨域访问。
1 2 3 4 5 6 7 8 9 10 11 12 13 @RestController public class IndexController { @GetMapping("/hello") public String hello () { return "get hello" ; } @PostMapping("/hello") public String hello2 () { return "post hello" ; } }
定义一个index.html页面，利用axios跨域访问8080项目中的web接口。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 <!DOCTYPE html > <html lang ="en" > <head > <meta charset ="UTF-8" > <meta name ="viewport" content ="width=device-width, initial-scale=1.0" > <title > Document</title > <script src ="https://cdn.bootcdn.net/ajax/libs/axios/0.26.0/axios.js" > </script > <link href ="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/4.6.1/css/bootstrap.min.css" rel ="stylesheet" > </head > <body > <div class ="container" > <button class ="btn btn-primary" > 发送GET请求</button > <button class ="btn btn-warning" > 发送POST请求</button > </div > <script > const btns = document .querySelectorAll ("button" ); btns[0 ].onclick = function ( axios ({ method : "GET" , url : "http://localhost:8080/hello" }).then (response => console .log (response); }); }; btns[1 ].onclick = function ( axios ({ method : "POST" , url : "http://localhost:8080/hello" }).then (response => console .log (response); }); }; </script > </body > </html >
然后分别执行get与post请求，这时候就可以在浏览器的控制台上看到产生了CORS跨域问题，出现了CORS error状态，在请求头中出现了Referer Policy: strict-origin-when-cross-origin。
解决
方式1：在接口方法上利用@CrossOrigin注解解决跨域问题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 @RestController public class IndexController { @CrossOrigin(value = "http://127.0.0.1:5500/") @GetMapping("/hello") public String hello () { return "get hello" ; } @CrossOrigin(value = "http://127.0.0.1:5500/") @PostMapping("/hello") public String hello2 () { return "post hello" ; } }
方式2：通过实现WebMvcConfigurer接口来解决跨域问题
1 2 3 4 5 6 7 8 9 10 11 12 @Configuration public class WebMvcConfig implements WebMvcConfigurer { @Override public void addCorsMappings (CorsRegistry registry) { registry.addMapping("/**" ) .allowedOrigins("http://127.0.0.1:5500/" ) .allowedMethods("*" ) .allowedHeaders("*" ); } }
然后成功请求：
8.2.2 引入ss的跨域解决方案 为了提高网站的安全性，在上面Spring Boot项目的基础之上，添加Spring Security的依赖包，但是暂时不进行任何别的操作。
接着重启8080这个Spring Boot项目，然后在前端中再次进行跨域请求，我们会发现在引入Spring Security后，再次产生了跨域问题。
通过实验可知，如果使用了 Spring Security，上面的跨域配置会失效，因为请求会被 Spring Security 拦截。那么在Spring Security环境中，如何解决跨域问题呢？这里我们有3种方式可以开启 Spring Security 对跨域的支持。
① 开启cors方法 在配置类中开启cors方法：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .permitAll() .and() .formLogin() .permitAll() .and() .httpBasic() .and() .cors() .and() .csrf() .disable(); } }
② 进行全局配置 第二种方式是去除上面的跨域配置，直接在 Spring Security 中做全局配置，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure (HttpSecurity http) throws Exception { http.authorizeRequests() .anyRequest() .permitAll() .and() .formLogin() .permitAll() .and() .httpBasic() .and() .cors() .configurationSource(corsConfigurationSource()) .and() .csrf() .disable(); } @Bean public CorsConfigurationSource corsConfigurationSource () { UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource (); CorsConfiguration configuration = new CorsConfiguration (); configuration.setAllowCredentials(true ); configuration.addAllowedOriginPattern("*" ); configuration.setAllowedMethods(Collections.singletonList("*" )); configuration.setAllowedHeaders(Collections.singletonList("*" )); configuration.setMaxAge(Duration.ofHours(1 )); source.registerCorsConfiguration("/**" , configuration); return source; } }
9 源码分析 9.1 整体流程 用户提交用户名和密码后：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 sequenceDiagram participant UPAF as UsernamePassword<br/>AuthenticationFilter participant AM as Authentication<br/>Manager participant DAP as DaoAuthentication<br/>Provider participant UDS as UserDetails<br/>Service participant SCH as SecurityContext<br/>Holder UPAF->>UPAF: 1.将请求信息封装为Authentication，<br/>实现类为UsernamePasswordAuthenticationToken UPAF->>AM: 2.认证authenticate() AM->>DAP: 3.委托认证authenticate() DAP->>UDS: 4.获取用户信息<br/>loadUserByUsername() UDS->>DAP: 5.返回UserDetails DAP->>DAP: 6.通过passwordEncoder对比UserDetails中的密码与Authentication<br/>中的密码一致 DAP->>DAP: 7.填充Authentication，如权限信息 DAP->>UPAF: 8.返回Authentication UPAF->>SCH: 9.通过SecurityContextHolder.getContext().setAuthentication()方法将Authentication保存至安全上下文
9.2 基础API Authentication，SecurityContext，SecurityContextHolder。三者关系：
SecurityContextHolder 用来保存 SecurityContext，利用SecurityContextHolder的getContext()方法可以得到SecurityContext对象；然后再通过调用 SecurityContext 对象中的getAuthentication()方法，就可以获取 Authentication 对象；最后我们利用Authentication对象，可以进一步获取已认证用户的详细信息。
9.2.1 Authentication接口 Authentication 是 spring-security-core 核心包中的接口，直接继承自 Principal 接口 ，而 Principal 是位于 java.security 包中，由此可知 Authentication 是 Spring Security 中的核心接口。Authentication接口中封装了用户信息，它有个很重要的子类UsernamePasswordAuthenticationToken 。
1 2 3 4 5 6 7 8 9 10 11 12 13 public interface Authentication extends Principal , Serializable { Collection<? extends GrantedAuthority > getAuthorities(); Object getCredentials () ; Object getDetails () ; Object getPrincipal () ; boolean isAuthenticated () ; void setAuthenticated (boolean isAuthenticated) throws IllegalArgumentException; }
作用：在用户登录认证之前，用户名密码等信息 会被封装为一个 Authentication 的具体实现类对象。在登录认证成功之后又会生成一个信息更全面的Authentication对象，从该对象中可以得到用户的权限信息列表、密码、用户细节信息、用户身份信息、认证信息等 。这个 Authentication对象会被保存在 SecurityContextHolder 所持有的 SecurityContext 中 ，供后续的程序进行调用，如访问权限的鉴定等。
9.2.2 SecurityContext接口 安全上下文，该类用于存储认证授权的相关信息，实际上就是存储 “当前用户 “ 的账号信息和相关权限，即代表当前用户信息的 Authentication 对象会被 SecurityContext 所持有(引用)，SecurityContext上下文对象则被SecurityContextHolder 所持有(引用)。
1 2 3 4 5 public interface SecurityContext extends Serializable { Authentication getAuthentication () ; void setAuthentication (Authentication authentication) ; }
9.2.3 SecurityContextHolder类 ① 线程安全性 由于一个请求从开始到结束都由一个线程处理，这个线程中途不会去处理其他的请求，所以在这段时间内，这个线程就相当于跟当前用户是一一对应的。SecurityContextHolder类就是用于把SecurityContext存储在当前线程中。
在Web环境下，SecurityContextHolder是利用ThreadLocal 来存储SecurityContext对象的。所以SecurityContextHolder可以用来设置和获取SecurityContext对象，该类主要是给框架内部使用，我们可以利用它获取当前用户的SecurityContext对象，进而进行请求检查，和访问控制等。
因为Sevlet中的线程都是被池化复用的，一旦处理完当前的请求，这个线程可能马上就会被分配去处理其他的请求，而且也不能保证用户下次的请求会被分配到与上次相同的线程。因此在每一次请求结束后都会自动清除当前线程的ThreadLocal对象。
② 存储策略 SecurityContextHolder可以通过设置来调整3种存储策略，三种策略详情如下:
MODE_THREADLOCAL ：表示将 SecurityContext对象 存储在当前线程中，（默认）；MODE_INHERITABLETHREADLOCAL ：表示将 SecurityContext对象 存储在线程中，但子线程可以获取到父线程中的 SecurityContext；MODE_GLOBAL ：表示 SecurityContext对象内容 在所有线程中都相同。
9.3 Filter API 9.3.1 内置过滤器 Spring Security内置的过滤器：
默认加载Filter
过滤器作用
WebAsyncManagerIntegrationFilter将 WebAsyncManager 与SpringSecurity上下文集成
SecurityContextPersistenceFilter在处理请求之前，将安全信息加载到SecurityContextHolder中
HeaderWriterFilter处理头信息加入响应中
CsrfFilter处理CSRF攻击
LogoutFilter处理注销登录
UsernamePasswordAuthenticationFilter处理表单认证
DefaultLoginPageGeneratingFilter配置默认登录页面
DefaultLogoutPageGeneratingFilter配置默认注销页面
BasicAuthenticationFilter处理 HttpBasic 登录
RequestCacheAwareFilter处理请求缓存
SecurityContextHolderAwareRequestFilter包装原始请求
AnoymousAuthenticationFilter配置匿名认证
SessionManagementFilter处理Session并发问题
ExceptionTraslationFilter处理认证/授权中的异常
9.3.2 自定义过滤器 添加过滤器的方法（都是HttpSecurity中的），第一个参数都是要加入的过滤器，第二个参数是针对已存在过滤器的Class对象：
addFilterAt(filter,atFilter)：这个相当于线性表的插入操作，把 filter 插入在 atFilter 的位置上。addFilterBefore(filter,atFilter)：这个是在 atFilter 前插入一个 filter 过滤器；addFilterAfter(filter,atFilter)：这个顾名思义是在 atFilter 后插入一个 filter 过滤器；
可以继承Spring Security中内置的过滤器以进行重写逻辑，另一方面可以继承Spring框架的过滤器。
例如：OncePerRequestFilter是Spring框架提供的一个过滤器，确保在一次HTTP请求期间只执行一次特定的过滤器逻辑。它继承了GenericFilterBean类，并实现了javax.servlet.Filter接口。
1 2 3 4 5 6 7 8 9 10 11 12 13 @Component public class MyFilter extends OncePerRequestFilter { @Override protected void doFilterInternal (HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException { System.out.println("执行过滤逻辑" ); filterChain.doFilter(httpServletRequest, httpServletResponse); } }
注册：
1 2 3 4 5 6 7 8 9 10 11 12 13 @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) public class SecurityConfig extends WebSecurityConfigurerAdapter { @Resource private MyFilter myFilter; @Override protected void configure (HttpSecurity httpSecurity) throws Exception { httpSecurity.addFilterBefore(myFilter, UsernamePasswordAuthenticationFilter.class); } }
9.4 认证管理API 9.4.1 AuthenticationManager接口 AuthenticationManager的作用是校验Authentication，如果验证失败会抛出AuthenticationException异常 。
1 2 3 public interface AuthenticationManager { Authentication authenticate (Authentication authentication) throws AuthenticationException; }
9.4.2 ProviderManager类 Spring Security 中 AuthenticationManager 接口的默认实现类 是 ProviderManager，但它本身并不直接处理身份认证请求，它会委托给内部配置的 AuthenticationProvider （一个接口）列表providers。该列表会进行循环遍历，依次对比匹配以查看它是否可以执行身份验证，每个 Provider 验证程序在验证后，将会抛出异常或返回一个完全填充的 Authentication 对象。源码如下所示：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 public class ProviderManager implements AuthenticationManager , MessageSourceAware,InitializingBean { private List<AuthenticationProvider> providers = Collections.emptyList(); public Authentication authenticate (Authentication authentication) throws AuthenticationException { Class<? extends Authentication > toTest = authentication.getClass(); AuthenticationException lastException = null ; AuthenticationException parentException = null ; Authentication result = null ; Authentication parentResult = null ; boolean debug = logger.isDebugEnabled(); for (AuthenticationProvider provider : getProviders()) { if (!provider.supports(toTest)) { continue ; } try { result = provider.authenticate(authentication); if (result != null ) { copyDetails(authentication, result); break ; } } catch (AccountStatusException | InternalAuthenticationServiceException e) { prepareException(e, authentication); throw e; } catch (AuthenticationException e) { lastException = e; } } if (result == null && parent != null ) { try { result = parentResult = parent.authenticate(authentication); } catch (ProviderNotFoundException e) { } catch (AuthenticationException e) { lastException = parentException = e; } } if (result != null ) { if (eraseCredentialsAfterAuthentication && (result instanceof CredentialsContainer)) { ((CredentialsContainer) result).eraseCredentials(); } if (parentResult == null ) { eventPublisher.publishAuthenticationSuccess(result); } return result; } if (lastException == null ) { lastException = new ProviderNotFoundException (messages.getMessage( "ProviderManager.providerNotFound" , new Object [] { toTest.getName() }, "No AuthenticationProvider found for {0}" )); } if (parentException == null ) { prepareException(lastException, authentication); } throw lastException; } }
9.5 认证实现API 9.5.1 AuthenticationProvider接口 AuthenticationManager负责管理协调认证工作的，但并不负责认证功能的真正实现，认证功能的真正实现是由 AuthenticationManager 中引用的 AuthenticationProvider 类来完成的，通过源码我们可以看到AuthenticationManager 中引用了一个providers列表。
1 2 private List<AuthenticationProvider> providers = Collections.emptyList();
AuthenticationProvider接口有多个实现子类。
9.5.2 DaoAuthenticationProvider类 DaoAuthenticationProvider是AuthenticationProvider接口的实现类，Spring Security中默认就是使用DaoAuthenticationProvider来实现基于数据库模型认证授权工作。
DaoAuthenticationProvider 在进行认证的时候，需要调用 UserDetailsService 对象的loadUserByUsername() 方法来获取用户信息 UserDetails，其中包括用户名、密码和所拥有的权限等。
authenticate()认证方法源码剖析
在AuthenticationProvider接口中有个authenticate()方法，但是该方法并没有默认实现。
1 2 3 4 5 public interface AuthenticationProvider { Authentication authenticate (Authentication authentication) throws AuthenticationException; boolean supports (Class<?> authentication) ; }
这个方法是在AuthenticationProvider的子类AbstractUserDetailsAuthenticationProvider中实现的，实现源码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 protected abstract UserDetails retrieveUser (String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException;public Authentication authenticate (Authentication authentication) throws AuthenticationException { Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication, () -> messages.getMessage( "AbstractUserDetailsAuthenticationProvider.onlySupports" , "Only UsernamePasswordAuthenticationToken is supported" )); String username = (authentication.getPrincipal() == null ) ? "NONE_PROVIDED" : authentication.getName(); boolean cacheWasUsed = true ; UserDetails user = this .userCache.getUserFromCache(username); if (user == null ) { cacheWasUsed = false ; try { user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication); } catch (UsernameNotFoundException notFound) { logger.debug("User '" + username + "' not found" ); if (hideUserNotFoundExceptions) { throw new BadCredentialsException (messages.getMessage( "AbstractUserDetailsAuthenticationProvider.badCredentials" , "Bad credentials" )); } else { throw notFound; } } Assert.notNull(user, "retrieveUser returned null - a violation of the interface contract" ); } try { preAuthenticationChecks.check(user); additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication); } catch (AuthenticationException exception) { if (cacheWasUsed) { cacheWasUsed = false ; user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication); preAuthenticationChecks.check(user); additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication); } else { throw exception; } } postAuthenticationChecks.check(user); if (!cacheWasUsed) { this .userCache.putUserInCache(user); } Object principalToReturn = user; if (forcePrincipalAsString) { principalToReturn = user.getUsername(); } return createSuccessAuthentication(principalToReturn, authentication, user); }
retrieveUser抽象方法由DaoAuthenticationProvider来具体实现：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 protected final UserDetails retrieveUser (String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException { prepareTimingAttackProtection(); try { UserDetails loadedUser = this .getUserDetailsService().loadUserByUsername(username); if (loadedUser == null ) { throw new InternalAuthenticationServiceException ( "UserDetailsService returned null, which is an interface contract violation" ); } return loadedUser; }catch (UsernameNotFoundException ex) { mitigateAgainstTimingAttack(authentication); throw ex; }catch (InternalAuthenticationServiceException ex) { throw ex; }catch (Exception ex) { throw new InternalAuthenticationServiceException (ex.getMessage(), ex); } }
9.5.3 authenticate流程
在ProviderManager类中遍历List<AuthenticationProvider> providers集合，判断AuthenticationProvider类是否支持对当前对象进行认证；
如果支持，则调用AuthenticationProvider接口对象的authenticate(authentication)方法进行认证；
结合当前具体的认证实现模型，如果是基于数据库模型来进行表单认证，则执行AbstractUserDetailsAuthenticationProvider类中的authenticate(authentication)方法具体进行认证；
AbstractUserDetailsAuthenticationProvider类中的authenticate(authentication)方法内部会调用retrieveUser()抽象方法加载对象；
在DaoAuthenticationProvider类中具体执行retrieveUser()方法，在该方法中调用UserDetailsService对象的loadUserByUsername(username)方法，从而实现根据用户名从数据库中查询用户信息；
9.6 实体接口API 9.6.1 UserDetails接口 UserDetails 是 Spring Security 中的核心接口，它表示用户的详细信息，这个接口涵盖了一些必要的用户信息字段。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public interface UserDetails extends Serializable { Collection<? extends GrantedAuthority > getAuthorities(); String getPassword () ; String getUsername () ; boolean isAccountNonExpired () ; boolean isAccountNonLocked () ; boolean isCredentialsNonExpired () ; boolean isEnabled () ; }
可以实现这个接口，然后自定义其他的属性。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 @Data @TableName("users") public class User implements UserDetails { @TableId(value = "id", type = IdType.AUTO) private Long id; @TableField("username") private String username; @TableField("password") private String password; @TableField("roles") private String roles; @TableField("enable") private boolean enable; private List<GrantedAuthority> authorities; @Override public Collection<? extends GrantedAuthority > getAuthorities() { return this .authorities; } @Override public String getPassword () { return this .password; } @Override public String getUsername () { return this .username; } @Override public boolean isAccountNonExpired () { return true ; } @Override public boolean isAccountNonLocked () { return true ; } @Override public boolean isCredentialsNonExpired () { return true ; } @Override public boolean isEnabled () { return true ; } }
9.6.2 UserDetailsService接口 UserDetailsService也是一个接口，该接口中只有一个方法loadUserByUsername()，该方法可以用来获取UserDetails对象，源码如下：
1 2 3 public interface UserDetailsService { UserDetails loadUserByUsername (String username) throws UsernameNotFoundException; }
同样可以实现接口，定义自己的业务逻辑：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 @Service public class MyUserDetailsService implements UserDetailsService { @Resource private UserService userService; @Override public UserDetails loadUserByUsername (String username) throws UsernameNotFoundException { QueryWrapper<User> queryWrapper = new QueryWrapper <>(); queryWrapper.eq("username" , username); User user = userService.getOne(queryWrapper); if (user == null ) { throw new UsernameNotFoundException ("用户不存在" ); } user.setAuthorities(AuthorityUtils.commaSeparatedStringToAuthorityList(user.getRoles())); return user; } }
