首先需要搭建好一個Spring Boot + Swagger2的專案
因為之前有寫過 Swagger2 點我 所以這裡就不再重複一遍了。該文章將會在之前專案的基礎上繼續新增整合Jwt。

首先放下搭建完畢的專案目錄結構

pom.xml
在之前的基礎上新增Jwt依賴即可

<!--jwt-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.7.0</version
 
>
</dependency>

新增JwtAuthenticationFilter.java檔案
如名字，這是一個攔截器，當用戶訪問介面時將會被該攔截器攔截，我們可以通過修改isProtectedUrl函式中的範圍來確定需要攔截的範圍。
然後因為Jwt預設是用儲存在header中的驗證碼來驗證身份的，這對於Swagger2來說很難進行測試，需要對Swagger2進行修改，比較麻煩，所以這裡我直接修改成了從Body中取，當然同理也可以替換成cookie，session中，都行。

package com.my.swagger2.filter;

import org.springframework.util.AntPathMatcher;
import
 
 org.springframework.util.PathMatcher;
import org.springframework.web.filter.OncePerRequestFilter;

import com.my.swagger2.util.JwtUtil;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import
 
 java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private static final PathMatcher pathMatcher = new AntPathMatcher();

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //解決跨域問題
        response.setHeader("Access-Control-Allow-Origin", "*");
        try {
            if(isProtectedUrl(request)) {
                //因為jwt用來驗證身份的驗證碼是儲存在header中的，而用swagger2時header中的值不好設定，需要進行修改，因此這裡改成了從body中獲取
                //String token = request.getHeader("Authorization");
                String token = request.getParameter("Authorization");
                //檢查jwt令牌, 如果令牌不合法或者過期, 裡面會直接丟擲異常, 下面的catch部分會直接返回
                JwtUtil.validateToken(token);
            }
        } catch (Exception e) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, e.getMessage());
            return;
        }
        //如果jwt令牌通過了檢測, 那麼就把request傳遞給後面的RESTful api
        filterChain.doFilter(request, response);
    }


    //我們只對地址 /api 開頭的api檢查jwt. 不然的話登入/login也需要jwt
    private boolean isProtectedUrl(HttpServletRequest request) {
        return pathMatcher.match("/api/**", request.getServletPath());
    }

}

新增Jwt配置檔案
JwtUtil.java
這裡定義了Jwt驗證碼的格式，用到的引數等等，還有有效時間，為了測試方便，這裡定的是1000小時。

package com.my.swagger2.util;

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JwtUtil {
    static final String SECRET = "ThisIsASecret";

    public static String generateToken(String username) {
        HashMap<String, Object> map = new HashMap<>();
        //you can put any data in the map
        map.put("username", username);
        String jwt = Jwts.builder()
                .setClaims(map)
                .setExpiration(new Date(System.currentTimeMillis() + 3600_000_000L))// 1000 hour
                .signWith(SignatureAlgorithm.HS512, SECRET)
                .compact();
        return "Bearer "+jwt; //jwt前面一般都會加Bearer
    }

    public static void validateToken(String token) {
        try {
            // parse the token.
            Map<String, Object> body = Jwts.parser()
                    .setSigningKey(SECRET)
                    .parseClaimsJws(token.replace("Bearer ",""))
                    .getBody();
        }catch (Exception e){
            throw new IllegalStateException("Invalid Token. "+e.getMessage());
        }
    }
}

然後新增登入介面
loginController.java
因為這只是個測試用例，所以也沒連資料庫，使用者密碼檢測就意思一下。

package com.my.swagger2.controller;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.my.swagger2.filter.JwtAuthenticationFilter;
import com.my.swagger2.util.JwtUtil;

import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;

@RestController
@RequestMapping(value="/login")
public class loginController {

    @RequestMapping(value="check", method=RequestMethod.POST)
    @ApiOperation(value="登入身份驗證（JWT驗證）", notes="登入")
    @ApiImplicitParams({
        @ApiImplicitParam(name = "username",value = "使用者名稱稱",required = true,paramType = "form",dataType = "string"),
        @ApiImplicitParam(name = "password",value = "密碼",required = true,paramType = "form",dataType = "string")
    })
    public Object getLoginInfo(HttpServletResponse response,HttpServletRequest request) {
        Account account = new Account();
        account.setUsername(request.getParameter("username").toString());
        account.setPassword(request.getParameter("password").toString());
        if(isValidPassword(account)) {
            String jwt = JwtUtil.generateToken(account.username);
            return new HashMap<String,String>(){{
                put("token", jwt);
            }};
        }else {
            return new ResponseEntity(HttpStatus.UNAUTHORIZED);
        }
    }

    @Bean
    public FilterRegistrationBean jwtFilter() {
        final FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        JwtAuthenticationFilter filter = new JwtAuthenticationFilter();
        registrationBean.setFilter(filter);
        return registrationBean;
    }

    //密碼是否正確
    private boolean isValidPassword(Account ac) {
        Map<String,Object> param = new HashMap<String,Object>();
        param.put("userName", ac.getUsername());
        param.put("password", ac.getPassword());

        return ("test".equals(param.get("userName")))&&("[email protected]".equals(param.get("password")));
    }


    public static class Account {
        private String username;
        private String password;
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
    }   
}

然後修改下之前專案中的
myTestController.java
新增一個驗證碼參@ApiImplicitParam(name = "Authorization",value = "驗證資訊",required = true,paramType = "form",dataType = "string")

@ApiOperation(value="測試資料", notes="獲取字串1+字串2")
    @ApiImplicitParams({
      @ApiImplicitParam(name = "s1", value = "字串1", paramType = "form", dataType = "String"),
      @ApiImplicitParam(name = "s2", value = "字串2", paramType = "form",required = true, dataType = "String"),
      @ApiImplicitParam(name = "Authorization",value = "驗證資訊",required = true,paramType = "form",dataType = "string")
    })
    @RequestMapping(value="/get/info", method=RequestMethod.POST)
    public String getInfo(HttpServletResponse response,HttpServletRequest request) {
        String s1 = request.getParameter("s1");
        String s2 = request.getParameter("s2");

        String result = s1+s2;
        return result;
    }

然後啟動專案測試下
可以看到一個登入介面和一個應用介面

嘗試下直接使用應用介面（因為驗證碼設了必填，所以隨便填一個值，當然，也可以設定成非必填，然後不填值，反正最後結果都是一樣的）

點選查詢，可以看到報錯，unauthorized，被Jwt攔截下來了。

然後嘗試下登入介面，填入剛才在程式碼中設定的使用者密碼，點選查詢

可以看到返回了驗證碼，複製驗證碼，填到應用接口裡，嘗試下查詢

引數如上，點選查詢

成功查詢到資訊了

實際使用中直接去request body中取驗證碼會相對不安全，也挺麻煩，可以減少驗證碼有效時間，然後將驗證碼存入session，cookie，或者header中，前兩種可以在驗證登入時在後臺填入，然後攔截器就從session，cookie中去獲取驗證碼，這樣前臺也能不傳驗證碼了，相對也會安全點，畢竟資料傳輸這一環是最危險的，當然cookie在使用者本地，也會相對不安全點，怎麼取捨就要看自己的專案了。