Spring Security 實戰乾貨：玩轉自定義登陸

時間 2019-11-06

標籤 spring security 實戰乾貨自定義登陸欄目 Spring 简体版

原文原文鏈接

1. 前言

前面的關於 Spring Security 相關的文章只是一個預熱。爲了接下來更好的實戰，若是你錯過了請從 Spring Security 實戰系列開始。安全訪問的第一步就是認證（Authentication），認證的第一步就是登陸。今天咱們要經過對 Spring Security 的自定義，來設計一個可擴展，可伸縮的 form 登陸功能。html

2. form 登陸的流程

下面是 form 登陸的基本流程：前端

只要是 form 登陸基本都能轉化爲上面的流程。接下來咱們看看 Spring Security 是如何處理的。java

3. Spring Security 中的登陸

昨天 Spring Security 實戰乾貨：自定義配置類入口WebSecurityConfigurerAdapter 中已經講到了咱們一般的自定義訪問控制主要是經過 HttpSecurity 來構建的。默認它提供了三種登陸方式：web

formLogin() 普通表單登陸
oauth2Login() 基於 OAuth2.0 認證/受權協議
openidLogin() 基於 OpenID 身份認證規範

以上三種方式通通是 AbstractAuthenticationFilterConfigurer 實現的，spring

4. HttpSecurity 中的 form 表單登陸

啓用表單登陸經過兩種方式一種是經過 HttpSecurity 的 apply(C configurer) 方法本身構造一個 AbstractAuthenticationFilterConfigurer 的實現，這種是比較高級的玩法。另外一種是咱們常見的使用 HttpSecurity 的 formLogin() 方法來自定義 FormLoginConfigurer 。咱們先搞一下比較常規的第二種。數據庫

4.1 FormLoginConfigurer

該類是 form 表單登陸的配置類。它提供了一些咱們經常使用的配置方法：json

loginPage(String loginPage) : 登陸頁面而並非接口，對於先後分離模式須要咱們進行改造默認爲 /login。
loginProcessingUrl(String loginProcessingUrl) 實際表單向後臺提交用戶信息的 Action，再由過濾器UsernamePasswordAuthenticationFilter 攔截處理，該 Action 其實不會處理任何邏輯。
usernameParameter(String usernameParameter) 用來自定義用戶參數名，默認 username 。
passwordParameter(String passwordParameter) 用來自定義用戶密碼名，默認 password
failureUrl(String authenticationFailureUrl) 登陸失敗後會重定向到此路徑，通常先後分離不會使用它。
failureForwardUrl(String forwardUrl) 登陸失敗會轉發到此，通常先後分離用到它。可定義一個 Controller （控制器）來處理返回值,可是要注意 RequestMethod。
defaultSuccessUrl(String defaultSuccessUrl, boolean alwaysUse) 默認登錄成功後跳轉到此，若是 alwaysUse 爲 true 只要進行認證流程並且成功，會一直跳轉到此。通常推薦默認值 false
successForwardUrl(String forwardUrl) 效果等同於上面 defaultSuccessUrl 的 alwaysUse 爲 true 可是要注意 RequestMethod。
successHandler(AuthenticationSuccessHandler successHandler) 自定義認證成功處理器，可替代上面全部的 success 方式
failureHandler(AuthenticationFailureHandler authenticationFailureHandler) 自定義失敗成功處理器，可替代上面全部的 failure 方式
permitAll(boolean permitAll) form 表單登陸是否放開

知道了這些咱們就能來搞個定製化的登陸了。安全

5. Spring Security 聚合登陸實戰

接下來是咱們最激動人心的實戰登陸操做。有疑問的可認真閱讀 Spring 實戰的一系列預熱文章。app

5.1 簡單需求

咱們的接口訪問都要經過認證，登錄錯誤後返回錯誤信息（json），成功後前臺能夠獲取到對應數據庫用戶信息（json）（實戰中記得脫敏）。cors

咱們定義處理成功失敗的控制器：

@RestController
 @RequestMapping("/login")
 public class LoginController {
     @Resource
     private SysUserService sysUserService;
 
     /** * 登陸失敗返回 401 以及提示信息. * * @return the rest */
     @PostMapping("/failure")
     public Rest loginFailure() {
 
         return RestBody.failure(HttpStatus.UNAUTHORIZED.value(), "登陸失敗了，老哥");
     }
 
     /** * 登陸成功後拿到我的信息. * * @return the rest */
     @PostMapping("/success")
     public Rest loginSuccess() {
           // 登陸成功後用戶的認證信息 UserDetails會存在 安全上下文寄存器 SecurityContextHolder 中
         User principal = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
         String username = principal.getUsername();
         SysUser sysUser = sysUserService.queryByUsername(username);
         // 脫敏
         sysUser.setEncodePassword("[PROTECT]");
         return RestBody.okData(sysUser,"登陸成功");
     }
 }
複製代碼

而後咱們自定義配置覆寫 void configure(HttpSecurity http) 方法進行以下配置（這裏須要禁用crsf）：

@Configuration
 @ConditionalOnClass(WebSecurityConfigurerAdapter.class)
 @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
 public class CustomSpringBootWebSecurityConfiguration {
 
     @Configuration
     @Order(SecurityProperties.BASIC_AUTH_ORDER)
     static class DefaultConfigurerAdapter extends WebSecurityConfigurerAdapter {
         @Override
         protected void configure(AuthenticationManagerBuilder auth) throws Exception {
             super.configure(auth);
         }
 
         @Override
         public void configure(WebSecurity web) throws Exception {
             super.configure(web);
         }
 
         @Override
         protected void configure(HttpSecurity http) throws Exception {
             http.csrf().disable()
                     .cors()
                     .and()
                     .authorizeRequests().anyRequest().authenticated()
                     .and()
                     .formLogin()
                     .loginProcessingUrl("/process")
                     .successForwardUrl("/login/success").
                     failureForwardUrl("/login/failure");
 
         }
     }
 }
複製代碼

使用 Postman 或者其它工具進行 Post 方式的表單提交 http://localhost:8080/process?username=Felordcn&password=12345 會返回用戶信息：

{
     "httpStatus": 200,
     "data": {
         "userId": 1,
         "username": "Felordcn",
         "encodePassword": "[PROTECT]",
         "age": 18
     },
     "msg": "登陸成功",
     "identifier": ""
 }
複製代碼

把密碼修改成其它值再次請求認證失敗後：

{
      "httpStatus": 401,
      "data": null,
      "msg": "登陸失敗了，老哥",
      "identifier": "-9999"
  }
複製代碼

6. 多種登陸方式的簡單實現

就這麼完了了麼？如今登陸的花樣繁多。常規的就有短信、郵箱、掃碼，第三方是之後我要講的不在今天範圍以內。如何應對想法多的產品經理？咱們來搞一個可擴展各類姿式的登陸方式。咱們在上面 2. form 登陸的流程 中的用戶和斷定之間增長一個適配器來適配便可。咱們知道這個所謂的斷定就是 UsernamePasswordAuthenticationFilter 。

咱們只須要保證 uri 爲上面配置的/process 而且可以經過 getParameter(String name) 獲取用戶名和密碼便可 。

我忽然以爲能夠模仿 DelegatingPasswordEncoder 的搞法，維護一個註冊表執行不一樣的處理策略。固然咱們要實現一個 GenericFilterBean 在 UsernamePasswordAuthenticationFilter 以前執行。同時制定登陸的策略。

6.1 登陸方式定義

定義登陸方式枚舉 ``。

public enum LoginTypeEnum {
  
      /** * 原始登陸方式. */
      FORM,
      /** * Json 提交. */
      JSON,
      /** * 驗證碼. */
      CAPTCHA
  
  }
複製代碼

6.2 定義前置處理器接口

定義前置處理器接口用來處理接收的各類特點的登陸參數並處理具體的邏輯。這個藉口其實有點隨意，重要的是你要學會思路。我實現了一個默認的 form' 表單登陸和經過RequestBody放入json` 的兩種方式，篇幅限制這裏就不展現了。具體的 DEMO 參見底部。

public interface LoginPostProcessor {
   
   
   
       /** * 獲取 登陸類型 * * @return the type */
       LoginTypeEnum getLoginTypeEnum();
   
       /** * 獲取用戶名 * * @param request the request * @return the string */
       String obtainUsername(ServletRequest request);
   
       /** * 獲取密碼 * * @param request the request * @return the string */
       String obtainPassword(ServletRequest request);
   
   }
複製代碼

6.3 實現登陸前置處理過濾器

該過濾器維護了 LoginPostProcessor 映射表。經過前端來斷定登陸方式進行策略上的預處理，最終仍是會交給 UsernamePasswordAuthenticationFilter 。經過 HttpSecurity 的 addFilterBefore(preLoginFilter, UsernamePasswordAuthenticationFilter.class)方法進行前置。

package cn.felord.spring.security.filter;
 
 import cn.felord.spring.security.enumation.LoginTypeEnum;
 import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
 import org.springframework.security.web.util.matcher.RequestMatcher;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.filter.GenericFilterBean;
 
 import javax.servlet.FilterChain;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
 import static org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter.SPRING_SECURITY_FORM_PASSWORD_KEY;
 import static org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter.SPRING_SECURITY_FORM_USERNAME_KEY;
 
 /** * 預登陸控制器 * * @author Felordcn * @since 16 :21 2019/10/17 */
 public class PreLoginFilter extends GenericFilterBean {
 
 
     private static final String LOGIN_TYPE_KEY = "login_type";
 
 
     private RequestMatcher requiresAuthenticationRequestMatcher;
     private Map<LoginTypeEnum, LoginPostProcessor> processors = new HashMap<>();
 
 
     public PreLoginFilter(String loginProcessingUrl, Collection<LoginPostProcessor> loginPostProcessors) {
         Assert.notNull(loginProcessingUrl, "loginProcessingUrl must not be null");
         requiresAuthenticationRequestMatcher = new AntPathRequestMatcher(loginProcessingUrl, "POST");
         LoginPostProcessor loginPostProcessor = defaultLoginPostProcessor();
         processors.put(loginPostProcessor.getLoginTypeEnum(), loginPostProcessor);
 
         if (!CollectionUtils.isEmpty(loginPostProcessors)) {
             loginPostProcessors.forEach(element -> processors.put(element.getLoginTypeEnum(), element));
         }
 
     }
 
 
     private LoginTypeEnum getTypeFromReq(ServletRequest request) {
         String parameter = request.getParameter(LOGIN_TYPE_KEY);
 
         int i = Integer.parseInt(parameter);
         LoginTypeEnum[] values = LoginTypeEnum.values();
         return values[i];
     }
 
 
     /** * 默認仍是Form . * * @return the login post processor */
     private LoginPostProcessor defaultLoginPostProcessor() {
         return new LoginPostProcessor() {
 
 
             @Override
             public LoginTypeEnum getLoginTypeEnum() {
 
                 return LoginTypeEnum.FORM;
             }
 
             @Override
             public String obtainUsername(ServletRequest request) {
                 return request.getParameter(SPRING_SECURITY_FORM_USERNAME_KEY);
             }
 
             @Override
             public String obtainPassword(ServletRequest request) {
                 return request.getParameter(SPRING_SECURITY_FORM_PASSWORD_KEY);
             }
         };
     }
 
 
     @Override
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         ParameterRequestWrapper parameterRequestWrapper = new ParameterRequestWrapper((HttpServletRequest) request);
         if (requiresAuthenticationRequestMatcher.matches((HttpServletRequest) request)) {
 
             LoginTypeEnum typeFromReq = getTypeFromReq(request);
 
             LoginPostProcessor loginPostProcessor = processors.get(typeFromReq);
 
 
             String username = loginPostProcessor.obtainUsername(request);
 
             String password = loginPostProcessor.obtainPassword(request);
 
 
             parameterRequestWrapper.setAttribute(SPRING_SECURITY_FORM_USERNAME_KEY, username);
             parameterRequestWrapper.setAttribute(SPRING_SECURITY_FORM_PASSWORD_KEY, password);
 
         }
 
         chain.doFilter(parameterRequestWrapper, response);
 
 
     }
 }
複製代碼