Spring Security 使用總結

時間 2019-11-10

原文原文鏈接

暑假的時候在學習了 Spring Security 併成功運用到了項目中。在實踐中摸索出了一套結合 json + jwt(json web token) + Spring Boot + Spring Security 技術的權限方案趁着國慶假期記錄一下。前端

如下全部步驟的源碼能夠從個人 github 上取得。若是要了解，請閱讀 readme.md。java

各個技術的簡要介紹

json : 與前端交互的數據交換格式

我的理解上，它的特色是能夠促進 web 先後端解耦，提高團隊的工做效率。同時也是跟安卓端和 iOS 端交互的工具，目前是沒想出除了 json 和 XML 以外的交流形式誒（或許等之後有空閒時間會看看）。 git

它的另外一個特色是輕量級，簡潔和清晰的層次能夠方便咱們閱讀和編寫，而且減小服務器帶寬佔用。github

jwt (json web token)

用人話講就是將用戶的身份信息（帳號名字）、其餘信息（不固定，根據須要增長）在用戶登錄時提取出來，而且經過加密手段加工成一串密文，在用戶登錄成功時帶在返回結果發送給用戶。之後用戶每次請求時均帶上這串密文，服務器根據解析這段密文判斷用戶是否有權限訪問相關資源，並返回相應結果。 web

從網上摘錄了一些優勢，關於 jwt 的更多資料感興趣的讀者能夠自行谷歌：spring

相比於session，它無需保存在服務器，不佔用服務器內存開銷。
無狀態、可拓展性強：好比有3臺機器（A、B、C）組成服務器集羣，若session存在機器A上，session只能保存在其中一臺服務器，此時你便不能訪問機器B、C，由於B、C上沒有存放該Session，而使用token就可以驗證用戶請求合法性，而且我再加幾臺機器也沒事，因此可拓展性好就是這個意思。
由 2 知，這樣作可就支持了跨域訪問。

Spring Boot

Spring Boot 是一個用來簡化 Spring 應用的搭建以及開發過程的框架。用完後會讓你大呼 : "wocao! 怎麼有這麼方便的東西! mama 不再用擔憂我不會配置 xml 配置文件了!"。數據庫

Spring Security

這是 Spring Security 提供的一個安全權限控制框架，能夠根據使用者的須要定製相關的角色身份和身份所具備的權限，完成黑名單操做、攔截無權限的操做。配合 Spring Boot 能夠快速開發出一套完善的權限系統。json

本次技術方案中 Spring Security 執行流程

從圖中能夠看出本次執行流程圍繞着的就是 token。後端

用戶經過登錄操做得到咱們返回的 token 並保存在本地。在之後每次請求都在請求頭中帶上 token ，服務器在收到客戶端傳來的請求時會判斷是否有 token ，如有，解析 token 並寫入權限到本次會話，若無直接跳過解析 token 的步驟，而後判斷本次訪問的接口是否須要認證，是否須要相應的權限，並根據本次會話中的認證狀況作出反應。跨域

動手實現這個安全框架

步驟一：創建項目，配置好數據源

使用 Itellij Idea 創建一個 Spring Boot 項目

選擇 Web 、Security 、 Mybatis 和 JDBC 四個組件。

在數據庫中創建所需的數據庫 spring_security

在 spring boot 配置文件 application.properties 中配置好數據源

啓動項目查看 Spring Boot 是否替咱們配置好 Spring Security 了。

如果正確啓動了，能夠看到 Spring Security 生成了一段默認密碼。

咱們訪問 localhost:8080 會彈出一個 basic 認證框

輸入用戶名 user 密碼 前面自動生成的密碼 即可獲得經過的返回消息（返回 404，由於咱們還未創建任何頁面）
輸入錯誤的用戶名或者密碼會返回 401 ，提示未認證

若是你走到了這一步，意味着你已經配置好了所須要的環境，接下來就跟着進入下一步吧！

步驟二：生成咱們的 jwt

在這一步咱們將學習如何根據咱們的須要生成咱們定製的 token ！

關閉 Spring Boot 替咱們配置好的 Spring Security。（由於默認配置好的 Spring Security 會攔截掉咱們定製的登錄接口）

建立 Spring Security 配置類 WebSecurityConfig.java

@Configuration      // 聲明爲配置類
@EnableWebSecurity      // 啓用 Spring Security web 安全的功能
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().permitAll()       // 容許全部請求經過
                .and()
                .csrf()
                .disable()                      // 禁用 Spring Security 自帶的跨域處理
                .sessionManagement()                        // 定製咱們本身的 session 策略
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 調整爲讓 Spring Security 不建立和使用 session
    }
}

在數據庫中創建相應的用戶和角色。

建立用戶表 user

其中各個屬性和做用以下:

username : 用戶名
password : 密碼
role_id : 用戶所屬角色編號
last_password_change : 最後一次密碼修改時間
enable : 是否啓用該帳號，能夠用來作黑名單

建立角色表 role

其中各個屬性做用以下:

role_id : 角色相應 id
role_name : 角色的名稱
auth : 角色所擁有的權限

編寫相應的登錄密碼判斷邏輯

由於登錄功能很容易實現，這裏就不寫出來佔地方了哎。

編寫 token 操做類（生成 token 部分）

由於網上有造好的輪子，咱們能夠直接拿來作些修改就可使用了。

使用 maven 導入網上造好的 jwt 輪子

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

創建咱們本身的 token 操做類 TokenUtils.java

public class TokenUtils {

    private final Logger logger = Logger.getLogger(this.getClass());

    @Value("${token.secret}")
    private String secret;

    @Value("${token.expiration}")
    private Long expiration;

    /**
     * 根據 TokenDetail 生成 Token
     *
     * @param tokenDetail
     * @return
     */
    public String generateToken(TokenDetail tokenDetail) {
        Map<String, Object> claims = new HashMap<String, Object>();
        claims.put("sub", tokenDetail.getUsername());
        claims.put("created", this.generateCurrentDate());
        return this.generateToken(claims);
    }

    /**
     * 根據 claims 生成 Token
     *
     * @param claims
     * @return
     */
    private String generateToken(Map<String, Object> claims) {
        try {
            return Jwts.builder()
                    .setClaims(claims)
                    .setExpiration(this.generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, this.secret.getBytes("UTF-8"))
                    .compact();
        } catch (UnsupportedEncodingException ex) {
            //didn't want to have this method throw the exception, would rather log it and sign the token like it was before
            logger.warn(ex.getMessage());
            return Jwts.builder()
                    .setClaims(claims)
                    .setExpiration(this.generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, this.secret)
                    .compact();
        }
    }

    /**
     * token 過時時間
     *
     * @return
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + this.expiration * 1000);
    }

    /**
     * 得到當前時間
     *
     * @return
     */
    private Date generateCurrentDate() {
        return new Date(System.currentTimeMillis());
    }

}

這個工具類的目前作的事情是 :

把用戶名封裝進下載的輪子的 token 的主體 claims 中，並在裏面封裝了當前時間（方便後面判斷 token 是否在修改密碼以前生成的）
再計算 token 過時的時間寫入到輪子的 token 中
對輪子的 token 進行撒鹽加密，生成一串字符串，即咱們定製的 token

生成定製 token 的方法的入參 TokenDetail 的定義以下

public interface TokenDetail {

    //TODO: 這裏封裝了一層，不直接使用 username 作參數的緣由是能夠方便將來增長其餘要封裝到 token 中的信息

    String getUsername();
}

public class TokenDetailImpl implements TokenDetail {

    private final String username;

    public TokenDetailImpl(String username) {
        this.username = username;
    }

    @Override
    public String getUsername() {
        return this.username;
    }
}

同時這個工具類把加密 token 撒鹽的字符串和 token 的過時時間提取到了 application.properties 中

# token 加密密鑰
token.secret=secret
# token 過時時間，以秒爲單位，604800 是 一星期
token.expiration=604800

至此，咱們生成 token 的教程已經完成，至於登錄接口，判斷帳號密碼是否正確的操做就留給讀者去實現，讀者只需在登錄成功時在結果中返回生成好的 token 給用戶便可。

步驟三 : 實現驗證 token 是否有效，並根據 token 得到帳號詳細信息（權限，是否處於封號狀態）的功能

分析實現的過程

在步驟二中，咱們把用戶的的 username 、 token 建立的時間、 token 過時的時間封裝到了加密事後的 token 字符串中，就是爲了服務此時咱們驗證用戶權限的目的。

假設咱們此時拿到了用戶傳遞過來的一串 token，而且要根據這串 token 得到用戶的詳情能夠這樣作：

A. 嘗試解析這串 token ，若成功解析出來，進入下一步，不然終止解析過程
B. 根據解析出來的 username 從數據庫中查找用戶的帳號，最後一次密碼修改的時間，權限，是否封號等用戶詳情信息，把這些信息封裝到一個實體類中（userDetail類)。若查找不到該用戶，終止解析進程
C. 檢查 userDetail 中記錄的封號狀態，如果帳號已被封號，返回封號結果，終止請求
D. 根據 userDtail 比較 token 是否處於有效期內，若不處於有效期內，終止解析過程，不然繼續
E. 將 userDetail 中記錄的用戶權限寫入本次請求會話中，解析完成。

可參考下圖理解：

下面開始動手實現

嘗試解析 token 得到 username

/**
     * 從 token 中拿到 username
     *
     * @param token
     * @return
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 解析 token 的主體 Claims
     *
     * @param token
     * @return
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(this.secret.getBytes("UTF-8"))
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }

在這段代碼中，咱們先對 token 進行解密，得到 token 中封裝好的主體部分 claims (前面第二部引入的別人造好的輪子)，而後嘗試得到裏面封裝的 username 字符串。

從數據庫中得到用戶詳情 userDetail

這裏咱們將實現 Spring Security 的一個 UserDetailService 接口，這個接口只有一個方法, loadUserByUsername。流程圖以下

代碼以下:

public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 獲取 userDetail
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User user = this.userMapper.getUserFromDatabase(username);

        if (user == null) {
            throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username));
        } else {
            return SecurityModelFactory.create(user);
        }
    }
}

public class User implements LoginDetail, TokenDetail {

    private String username;
    private String password;
    private String authorities;
    private Long lastPasswordChange;
    private char enable;

    // 省略構造器和 getter setter 方法
}

public class SecurityModelFactory {

    public static UserDetailImpl create(User user) {
        Collection<? extends GrantedAuthority> authorities;
        try {
            authorities = AuthorityUtils.commaSeparatedStringToAuthorityList(user.getAuthorities());
        } catch (Exception e) {
            authorities = null;
        }

        Date lastPasswordReset = new Date();
        lastPasswordReset.setTime(user.getLastPasswordChange());
        return new UserDetailImpl(
                user.getUsername(),
                user.getUsername(),
                user.getPassword(),
                lastPasswordReset,
                authorities,
                user.enable()
        );
    }

}

其中得到未處理過的用戶詳細信息 User 類的 mapper 類定義以下:

public interface UserMapper {


    User getUserFromDatabase(@Param("username") String username);

}

相應的 xml 文件爲 :

<select id="getUserFromDatabase"  resultMap="getUserFromDatabaseMap">
        SELECT
        `user`.username,
        `user`.`password`,
        `user`.role_id,
        `user`.enable,
        `user`.last_password_change,
        `user`.enable,
        role.auth
        FROM
        `user` ,
        role
        WHERE
        `user`.role_id = role.role_id AND
        `user`.username = #{username}
    </select>

    <resultMap id="getUserFromDatabaseMap" type="cn.ssd.wean2016.springsecurity.model.domain.User">
        <id column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="last_password_change" property="lastPasswordChange"/>
        <result column="auth" property="authorities"/>
        <result column="enable" property="enable"/>
    </resultMap>

至此，咱們已經完成獲取用戶詳細信息的的功能了。接下來只要限制接口的訪問權限，並要求用戶訪問接口時帶上 token 便可實現對權限的控制。

步驟四 : 定義解析 token 的攔截器

老規矩，上流程圖:

下面定義這個攔截器

public class AuthenticationTokenFilter extends UsernamePasswordAuthenticationFilter {

    /**
     * json web token 在請求頭的名字
     */
    @Value("${token.header}")
    private String tokenHeader;

    /**
     * 輔助操做 token 的工具類
     */
    @Autowired
    private TokenUtils tokenUtils;

    /**
     * Spring Security 的核心操做服務類
     * 在當前類中將使用 UserDetailsService 來獲取 userDetails 對象
     */
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 將 ServletRequest 轉換爲 HttpServletRequest 才能拿到請求頭中的 token
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 嘗試獲取請求頭的 token
        String authToken = httpRequest.getHeader(this.tokenHeader);
        // 嘗試拿 token 中的 username
        // 如果沒有 token 或者拿 username 時出現異常，那麼 username 爲 null
        String username = this.tokenUtils.getUsernameFromToken(authToken);

        // 若是上面解析 token 成功而且拿到了 username 而且本次會話的權限還未被寫入
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 用 UserDetailsService 從數據庫中拿到用戶的 UserDetails 類
            // UserDetails 類是 Spring Security 用於保存用戶權限的實體類
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            // 檢查用戶帶來的 token 是否有效
            // 包括 token 和 userDetails 中用戶名是否同樣， token 是否過時， token 生成時間是否在最後一次密碼修改時間以前
            // 如果檢查經過
            if (this.tokenUtils.validateToken(authToken, userDetails)) {
                // 生成經過認證
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpRequest));
                // 將權限寫入本次會話
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            if (!userDetails.isEnabled()){
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().print("{\"code\":\"452\",\"data\":\"\",\"message\":\"帳號處於黑名單\"}");
                return;
            }
        }
        chain.doFilter(request, response);
    }

}

其中檢查 token 是否有效的 tokenUtils.validateToken(authToken, userDetails) 方法定義以下:

/**
     * 檢查 token 是否處於有效期內
     * @param token
     * @param userDetails
     * @return
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        UserDetailImpl user = (UserDetailImpl) userDetails;
        final String username = this.getUsernameFromToken(token);
        final Date created = this.getCreatedDateFromToken(token);
        return (username.equals(user.getUsername()) && !(this.isTokenExpired(token)) && !(this.isCreatedBeforeLastPasswordReset(created, user.getLastPasswordReset())));
    }

    /**
     * 得到咱們封裝在 token 中的 token 建立時間
     * @param token
     * @return
     */
    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            created = new Date((Long) claims.get("created"));
        } catch (Exception e) {
            created = null;
        }
        return created;
    }

    /**
     * 得到咱們封裝在 token 中的 token 過時時間
     * @param token
     * @return
     */
    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    /**
     * 檢查當前時間是否在封裝在 token 中的過時時間以後，如果，則斷定爲 token 過時
     * @param token
     * @return
     */
    private Boolean isTokenExpired(String token) {
        final Date expiration = this.getExpirationDateFromToken(token);
        return expiration.before(this.generateCurrentDate());
    }

    /**
     * 檢查 token 是不是在最後一次修改密碼以前建立的（帳號修改密碼以後以前生成的 token 即便沒過時也判斷爲無效）
     * @param created
     * @param lastPasswordReset
     * @return
     */
    private Boolean isCreatedBeforeLastPasswordReset(Date created, Date lastPasswordReset) {
        return (lastPasswordReset != null && created.before(lastPasswordReset));
    }

步驟五 : 註冊步驟四的攔截器，使它在 Spring Security 讀取本次會話權限前將用戶所具備的權限寫入本次會話中

在 SpringSecurity 的配置類 WebSecurityConfig.java 中添加以下配置

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 註冊 token 轉換攔截器爲 bean
     * 若是客戶端傳來了 token ，那麼經過攔截器解析 token 賦予用戶權限
     *
     * @return
     * @throws Exception
     */
    @Bean
    public AuthenticationTokenFilter authenticationTokenFilterBean() throws Exception {
        AuthenticationTokenFilter authenticationTokenFilter = new AuthenticationTokenFilter();
        authenticationTokenFilter.setAuthenticationManager(authenticationManagerBean());
        return authenticationTokenFilter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/auth").authenticated()       // 需攜帶有效 token
                .antMatchers("/admin").hasAuthority("admin")   // 需擁有 admin 這個權限
                .antMatchers("/ADMIN").hasRole("ADMIN")     // 需擁有 ADMIN 這個身份
                .anyRequest().permitAll()       // 容許全部請求經過
                .and()
                .csrf()
                .disable()                      // 禁用 Spring Security 自帶的跨域處理
                .sessionManagement()                        // 定製咱們本身的 session 策略
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 調整爲讓 Spring Security 不建立和使用 session


        /**
         * 本次 json web token 權限控制的核心配置部分
         * 在 Spring Security 開始判斷本次會話是否有權限時的前一瞬間
         * 經過添加過濾器將 token 解析，將用戶全部的權限寫入本次 Spring Security 的會話
         */
        http
                .addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);
    }
}

其中咱們將步驟四中定義的攔截器註冊到 Spring 中成爲一個 bean ，並登記在 Spring Security 開始判斷本次會話是否有權限時的前一瞬間經過添加過濾器將 token 解析，將用戶全部的權限寫入本次會話。

其次，咱們添加了三個 ant 風格的地址攔截規則 :

/auth : 要求攜帶有效的 token
/admin : 要求攜帶 token 所對應的帳號具備 admin 這個權限
/ADMIN : 要求攜帶 token 對應的張帳號具備 ROLE_ADMIN 這個身份

啓動程序到 8080 端口，經過 /login 接口登錄 guest 帳號，對 /auth 接口嘗試訪問，結果以下 :

顯然，由於 token 有效，因此成功經過了攔截

接下來嘗試訪問 /admin 接口，結果以下 :

顯然，由於攜帶的 token 不具備 admin 這個權限，因此請求被攔截攔截

至此，咱們已經完成了一套權限簡單的權限規則系統，在下一步中，咱們將對無權限訪問的返回結果進行優化，並結束此次總結。

步驟六 : 完善 401 和 403 返回結果

定義 401 處理器，實現 AuthenticationEntryPoint 接口

public class EntryPointUnauthorizedHandler implements AuthenticationEntryPoint {

  /**
   * 未登陸或無權限時觸發的操做
   * 返回  {"code":401,"message":"小弟弟，你沒有攜帶 token 或者 token 無效！","data":""}
   * @param httpServletRequest
   * @param httpServletResponse
   * @param e
   * @throws IOException
   * @throws ServletException
   */
  @Override
  public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
      //返回json形式的錯誤信息
      httpServletResponse.setCharacterEncoding("UTF-8");
      httpServletResponse.setContentType("application/json");

      httpServletResponse.getWriter().println("{\"code\":401,\"message\":\"小弟弟，你沒有攜帶 token 或者 token 無效！\",\"data\":\"\"}");
      httpServletResponse.getWriter().flush();
  }

}

定義 403 處理器，實現 AccessDeniedHandler 接口

@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
        //返回json形式的錯誤信息
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");

        httpServletResponse.getWriter().println("{\"code\":403,\"message\":\"小弟弟，你沒有權限訪問呀！\",\"data\":\"\"}");
        httpServletResponse.getWriter().flush();
    }
}

將這兩個處理器配置到 SpringSecurity 的配置類中 :

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 註冊 401 處理器
     */
    @Autowired
    private EntryPointUnauthorizedHandler unauthorizedHandler;

    /**
     * 註冊 403 處理器
     */
    @Autowired
    private MyAccessDeniedHandler accessDeniedHandler;

    ...

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

                // 配置被攔截時的處理
                .exceptionHandling()
                .authenticationEntryPoint(this.unauthorizedHandler)   // 添加 token 無效或者沒有攜帶 token 時的處理
                .accessDeniedHandler(this.accessDeniedHandler)      //添加無權限時的處理

                ...
    }
}

嘗試以 guest 的身份訪問 /admin 接口，結果以下: