重拾後端之Spring Boot（四）：使用JWT和Spring Security保護REST API

重拾後端之Spring Boot（一）：REST API的搭建可以這樣簡單
重拾後端之Spring Boot（二）：MongoDb的無縫整合
重拾後端之Spring Boot（三）：找回熟悉的Controller，Service
重拾後端之Spring Boot（四）：使用 JWT 和 Spring Security 保護 REST API

通常情況下，把API直接暴露出去是風險很大的，不說別的，直接被機器攻擊就喝一壺的。那麼一般來說，對API要劃分出一定的許可權級別，然後做一個使用者的鑑權，依據鑑權結果給予使用者開放對應的API。目前，比較主流的方案有幾種:

1. 使用者名稱和密碼鑑權，使用Session儲存使用者鑑權結果。
2. 使用OAuth進行鑑權（其實OAuth也是一種基於Token的鑑權，只是沒有規定Token的生成方式）
3. 自行採用Token進行鑑權

第一種就不介紹了，由於依賴Session來維護狀態，也不太適合移動時代，新的專案就不要採用了。第二種OAuth的方案和JWT都是基於Token的，但OAuth其實對於不做開放平臺的公司有些過於複雜。我們主要介紹第三種：JWT。

什麼是JWT？

JWT是 Json Web Token 的縮寫。它是基於 RFC 7519 標準定義的一種可以安全傳輸的 小巧 和 自包含 的JSON物件。由於資料是使用數字簽名的，所以是可信任的和安全的。JWT可以使用HMAC演算法對secret進行加密或者使用RSA的公鑰私鑰對來進行簽名。

JWT的工作流程

下面是一個JWT的工作流程圖。模擬一下實際的流程是這樣的（假設受保護的API在/protected中）

1. 使用者導航到登入頁，輸入使用者名稱、密碼，進行登入
2. 伺服器驗證登入鑑權，如果改使用者合法，根據使用者的資訊和伺服器的規則生成JWT Token
3. 伺服器將該token以json形式返回（不一定要json形式，這裡說的是一種常見的做法）
4. 使用者得到token，存在localStorage、cookie或其它資料儲存形式中。
5. 以後使用者請求/protected中的API時，在請求的header中加入 Authorization: Bearer xxxx(token)。此處注意token之前有一個7字元長度的 Bearer
6. 伺服器端對此token進行檢驗，如果合法就解析其中內容，根據其擁有的許可權和自己的業務邏輯給出對應的響應結果。
7. 使用者取得結果

為了更好的理解這個token是什麼，我們先來看一個token生成後的樣子，下面那坨亂糟糟的就是了。

eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ3YW5nIiwiY3JlYXRlZCI6MTQ4OTA3OTk4MTM5MywiZXhwIjoxNDg5Njg0NzgxfQ.RC-BYCe_UZ2URtWddUpWXIp4NMsoeq2O6UF-8tVplqXY1-CI9u1-a-9DAAJGfNWkHE81mpnR3gXzfrBAB3WUAg複製程式碼

但仔細看到的話還是可以看到這個token分成了三部分，每部分用 . 分隔，每段都是用 Base64 編碼的。如果我們用一個Base64的解碼器的話 （ www.base64decode.org/ ），可以看到第一部分 eyJhbGciOiJIUzUxMiJ9 被解析成了:

{
    "alg":"HS512"
}複製程式碼

這是告訴我們HMAC採用HS512演算法對JWT進行的簽名。

第二部分 eyJzdWIiOiJ3YW5nIiwiY3JlYXRlZCI6MTQ4OTA3OTk4MTM5MywiZXhwIjoxNDg5Njg0NzgxfQ 被解碼之後是

{
    "sub":"wang",
    "created":1489079981393,
    "exp":1489684781
}複製程式碼

這段告訴我們這個Token中含有的資料宣告（Claim），這個例子裡面有三個宣告：sub, created 和 exp。在我們這個例子中，分別代表著使用者名稱、建立時間和過期時間，當然你可以把任意資料宣告在這裡。

看到這裡，你可能會想這是個什麼鬼token，所有資訊都透明啊，安全怎麼保障？別急，我們看看token的第三段 RC-BYCe_UZ2URtWddUpWXIp4NMsoeq2O6UF-8tVplqXY1-CI9u1-a-9DAAJGfNWkHE81mpnR3gXzfrBAB3WUAg。同樣使用Base64解碼之後，咦，這是什麼東東

D X    DmYTeȧLUZcPZ0$gZAY_7wY@複製程式碼

最後一段其實是簽名，這個簽名必須知道祕鑰才能計算。這個也是JWT的安全保障。這裡提一點注意事項，由於資料宣告（Claim）是公開的，千萬不要把密碼等敏感欄位放進去，否則就等於是公開給別人了。

也就是說JWT是由三段組成的，按官方的叫法分別是header（頭）、payload（負載）和signature（簽名）：

header.payload.signature複製程式碼

頭中的資料通常包含兩部分：一個是我們剛剛看到的 alg，這個詞是 algorithm 的縮寫，就是指明演算法。另一個可以新增的欄位是token的型別(按RFC 7519實現的token機制不只JWT一種)，但如果我們採用的是JWT的話，指定這個就多餘了。

{
  "alg": "HS512",
  "typ": "JWT"
}複製程式碼

payload中可以放置三類資料：系統保留的、公共的和私有的：

• 系統保留的宣告（Reserved claims）：這類宣告不是必須的，但是是建議使用的，包括：iss (簽發者), exp (過期時間),
  sub (主題), aud (目標受眾)等。這裡我們發現都用的縮寫的三個字元，這是由於JWT的目標就是儘可能小巧。
• 公共宣告：這類宣告需要在 IANA JSON Web Token Registry 中定義或者提供一個URI，因為要避免重名等衝突。
• 私有宣告：這個就是你根據業務需要自己定義的資料了。

簽名的過程是這樣的：採用header中宣告的演算法，接受三個引數：base64編碼的header、base64編碼的payload和祕鑰（secret）進行運算。簽名這一部分如果你願意的話，可以採用RSASHA256的方式進行公鑰、私鑰對的方式進行，如果安全性要求的高的話。

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)複製程式碼

JWT的生成和解析

為了簡化我們的工作，這裡引入一個比較成熟的JWT類庫，叫 jjwt ( github.com/jwtk/jjwt )。這個類庫可以用於Java和Android的JWT token的生成和驗證。

JWT的生成可以使用下面這樣的程式碼完成：

String generateToken(Map<String, Object> claims) {
    return Jwts.builder()
            .setClaims(claims)
            .setExpiration(generateExpirationDate())
            .signWith(SignatureAlgorithm.HS512, secret) //採用什麼演算法是可以自己選擇的，不一定非要採用HS512
            .compact();
}複製程式碼

資料宣告（Claim）其實就是一個Map，比如我們想放入使用者名稱，可以簡單的建立一個Map然後put進去就可以了。

Map<String, Object> claims = new HashMap<>();
claims.put(CLAIM_KEY_USERNAME, username());複製程式碼

解析也很簡單，利用 jjwt 提供的parser傳入祕鑰，然後就可以解析token了。

Claims getClaimsFromToken(String token) {
    Claims claims;
    try {
        claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
    } catch (Exception e) {
        claims = null;
    }
    return claims;
}複製程式碼

JWT本身沒啥難度，但安全整體是一個比較複雜的事情，JWT只不過提供了一種基於token的請求驗證機制。但我們的使用者許可權，對於API的許可權劃分、資源的許可權劃分，使用者的驗證等等都不是JWT負責的。也就是說，請求驗證後，你是否有許可權看對應的內容是由你的使用者角色決定的。所以我們這裡要利用Spring的一個子專案Spring Security來簡化我們的工作。

Spring Security

Spring Security是一個基於Spring的通用安全框架，裡面內容太多了，本文的主要目的也不是展開講這個框架，而是如何利用Spring Security和JWT一起來完成API保護。所以關於Spring Secruity的基礎內容或展開內容，請自行去官網學習（ projects.spring.io/spring-secu… ）。

簡單的背景知識

如果你的系統有使用者的概念的話，一般來說，你應該有一個使用者表，最簡單的使用者表，應該有三列：Id，Username和Password，類似下表這種

ID	USERNAME	PASSWORD
10	wang	abcdefg

而且不是所有使用者都是一種角色，比如網站管理員、供應商、財務等等，這些角色和網站的直接使用者需要的許可權可能是不一樣的。那麼我們就需要一個角色表：

ID	ROLE
10	USER
20	ADMIN

當然我們還需要一個可以將使用者和角色關聯起來建立對映關係的表。

USER_ID	ROLE_ID
10	10
20	20

這是典型的一個關係型資料庫的使用者角色的設計，由於我們要使用的MongoDB是一個文件型資料庫，所以讓我們重新審視一下這個結構。

這個資料結構的優點在於它避免了資料的冗餘，每個表負責自己的資料，通過關聯表進行關係的描述，同時也保證的資料的完整性：比如當你修改角色名稱後，沒有髒資料的產生。

但是這種事情在使用者許可權這個領域發生的頻率到底有多少呢？有多少人每天不停的改的角色名稱？當然如果你的業務場景確實是需要保證資料完整性，你還是應該使用關係型資料庫。但如果沒有高頻的對於角色表的改動，其實我們是不需要這樣的一個設計的。在MongoDB中我們可以將其簡化為

{
  _id: <id_generated>
  username: 'user',
  password: 'pass',
  roles: ['USER', 'ADMIN']
}複製程式碼

基於以上考慮，我們重構一下 User 類，

@Data
public class User {
    @Id
    private String id;

    @Indexed(unique=true, direction= IndexDirection.DESCENDING, dropDups=true)
    private String username;

    private String password;
    private String email;
    private Date lastPasswordResetDate;
    private List<String> roles;
}複製程式碼

當然你可能發現這個類有點怪，只有一些field，這個簡化的能力是一個叫lombok類庫提供的 ，這個很多開發過Android的童鞋應該熟悉，是用來簡化POJO的建立的一個類庫。簡單說一下，採用 lombok 提供的 @Data 修飾符後可以簡寫成，原來的一坨getter和setter以及constructor等都不需要寫了。類似的 Todo 可以改寫成：

@Data
public class Todo {
    @Id private String id;
    private String desc;
    private boolean completed;
    private User user;
}複製程式碼

增加這個類庫只需在 build.gradle 中增加下面這行

dependencies {
    // 省略其它依賴
    compile("org.projectlombok:lombok:${lombokVersion}")
}複製程式碼

引入Spring Security

要在Spring Boot中引入Spring Security非常簡單，修改 build.gradle，增加一個引用 org.springframework.boot:spring-boot-starter-security：

dependencies {
    compile("org.springframework.boot:spring-boot-starter-data-rest")
    compile("org.springframework.boot:spring-boot-starter-data-mongodb")
    compile("org.springframework.boot:spring-boot-starter-security")
    compile("io.jsonwebtoken:jjwt:${jjwtVersion}")
    compile("org.projectlombok:lombok:${lombokVersion}")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}複製程式碼

你可能發現了，我們不只增加了對Spring Security的編譯依賴，還增加 jjwt 的依賴。

Spring Security需要我們實現幾個東西，第一個是UserDetails：這個介面中規定了使用者的幾個必須要有的方法，所以我們建立一個JwtUser類來實現這個介面。為什麼不直接使用User類？因為這個UserDetails完全是為了安全服務的，它和我們的領域類可能有部分屬性重疊，但很多的介面其實是安全定製的，所以最好新建一個類：

public class JwtUser implements UserDetails {
    private final String id;
    private final String username;
    private final String password;
    private final String email;
    private final Collection<? extends GrantedAuthority> authorities;
    private final Date lastPasswordResetDate;

    public JwtUser(
            String id,
            String username,
            String password,
            String email,
            Collection<? extends GrantedAuthority> authorities,
            Date lastPasswordResetDate) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.email = email;
        this.authorities = authorities;
        this.lastPasswordResetDate = lastPasswordResetDate;
    }
    //返回分配給使用者的角色列表
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    @JsonIgnore
    public String getId() {
        return id;
    }

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

    @Override
    public String getUsername() {
        return username;
    }
    // 賬戶是否未過期
    @JsonIgnore
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    // 賬戶是否未鎖定
    @JsonIgnore
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    // 密碼是否未過期
    @JsonIgnore
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    // 賬戶是否啟用
    @JsonIgnore
    @Override
    public boolean isEnabled() {
        return true;
    }
    // 這個是自定義的，返回上次密碼重置日期
    @JsonIgnore
    public Date getLastPasswordResetDate() {
        return lastPasswordResetDate;
    }
}複製程式碼

這個介面中規定的很多方法我們都簡單粗暴的設成直接返回某個值了，這是為了簡單起見，你在實際開發環境中還是要根據具體業務調整。當然由於兩個類還是有一定關係的，為了寫起來簡單，我們寫一個工廠類來由領域物件建立 JwtUser，這個工廠就叫 JwtUserFactory 吧：

public final class JwtUserFactory {

    private JwtUserFactory() {
    }

    public static JwtUser create(User user) {
        return new JwtUser(
                user.getId(),
                user.getUsername(),
                user.getPassword(),
                user.getEmail(),
                mapToGrantedAuthorities(user.getRoles()),
                user.getLastPasswordResetDate()
        );
    }

    private static List<GrantedAuthority> mapToGrantedAuthorities(List<String> authorities) {
        return authorities.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }
}複製程式碼

第二個要實現的是 UserDetailsService，這個介面只定義了一個方法 loadUserByUsername，顧名思義，就是提供一種從使用者名稱可以查到使用者並返回的方法。注意，不一定是資料庫哦，文字檔案、xml檔案等等都可能成為資料來源，這也是為什麼Spring提供這樣一個介面的原因：保證你可以採用靈活的資料來源。接下來我們建立一個 JwtUserDetailsServiceImpl 來實現這個介面。

@Service
public class JwtUserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);

        if (user == null) {
            throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username));
        } else {
            return JwtUserFactory.create(user);
        }
    }
}複製程式碼

為了讓Spring可以知道我們想怎樣控制安全性，我們還需要建立一個安全配置類 WebSecurityConfig：

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{

    // Spring會自動尋找同樣型別的具體類注入，這裡就是JwtUserDetailsServiceImpl了
    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
        authenticationManagerBuilder
                // 設定UserDetailsService
                .userDetailsService(this.userDetailsService)
                // 使用BCrypt進行密碼的hash
                .passwordEncoder(passwordEncoder());
    }
    // 裝載BCrypt密碼編碼器
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                // 由於使用的是JWT，我們這裡不需要csrf
                .csrf().disable()

                // 基於token，所以不需要session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()

                .authorizeRequests()
                //.antMatchers(HttpMethod.OPTIONS, "/**").permitAll()

                // 允許對於網站靜態資源的無授權訪問
                .antMatchers(
                        HttpMethod.GET,
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js"
                ).permitAll()
                // 對於獲取token的rest api要允許匿名訪問
                .antMatchers("/auth/**").permitAll()
                // 除上面外的所有請求全部需要鑑權認證
                .anyRequest().authenticated();

        // 禁用快取
        httpSecurity.headers().cacheControl();
    }
}複製程式碼

接下來我們要規定一下哪些資源需要什麼樣的角色可以訪問了，在 UserController 加一個修飾符 @PreAuthorize("hasRole('ADMIN')") 表示這個資源只能被擁有 ADMIN 角色的使用者訪問。

/**
 * 在 @PreAuthorize 中我們可以利用內建的 SPEL 表示式：比如 'hasRole()' 來決定哪些使用者有權訪問。
 * 需注意的一點是 hasRole 表示式認為每個角色名字前都有一個字首 'ROLE_'。所以這裡的 'ADMIN' 其實在
 * 資料庫中儲存的是 'ROLE_ADMIN' 。這個 @PreAuthorize 可以修飾Controller也可修飾Controller中的方法。
 **/
@RestController
@RequestMapping("/users")
@PreAuthorize("hasRole('ADMIN')")
public class UserController {
    @Autowired
    private UserRepository repository;

    @RequestMapping(method = RequestMethod.GET)
    public List<User> getUsers() {
        return repository.findAll();
    }

    // 略去其它部分
}複製程式碼

類似的我們給 TodoController 加上 @PreAuthorize("hasRole('USER')")，標明這個資源只能被擁有 USER 角色的使用者訪問：

@RestController
@RequestMapping("/todos")
@PreAuthorize("hasRole('USER')")
public class TodoController {
    // 略去
}複製程式碼

使用application.yml配置SpringBoot應用

現在應該Spring Security可以工作了，但為了可以更清晰的看到工作日誌，我們希望配置一下，在和 src 同級建立一個config資料夾，在這個資料夾下面新建一個 application.yml。

# Server configuration
server:
  port: 8090
  contextPath:

# Spring configuration
spring:
  jackson:
    serialization:
      INDENT_OUTPUT: true
  data.mongodb:
    host: localhost
    port: 27017
    database: springboot

# Logging configuration
logging:
  level:
    org.springframework:
      data: DEBUG
      security: DEBUG複製程式碼

我們除了配置了logging的一些東東外，也順手設定了資料庫和http服務的一些配置項，現在我們的伺服器會在8090埠監聽，而spring data和security的日誌在debug模式下會輸出到console。

現在啟動服務後，訪問 http://localhost:8090 你可以看到根目錄還是正常顯示的

但我們試一下 http://localhost:8090/users ，觀察一下console，我們會看到如下的輸出，告訴由於使用者未鑑權，我們訪問被拒絕了。

2017-03-10 15:51:53.351 DEBUG 57599 --- [nio-8090-exec-4] o.s.s.w.a.ExceptionTranslationFilter     : Access is denied (user is anonymous); redirecting to authentication entry point

org.springframework.security.access.AccessDeniedException: Access is denied
    at org.springframework.security.access.vote.AffirmativeBased.decide(AffirmativeBased.java:84) ~[spring-security-core-4.2.1.RELEASE.jar:4.2.1.RELEASE]複製程式碼

整合JWT和Spring Security

到現在，我們還是讓JWT和Spring Security各自為戰，並沒有整合起來。要想要JWT在Spring中工作，我們應該新建一個filter，並把它配置在 WebSecurityConfig 中。

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Value("${jwt.header}")
    private String tokenHeader;

    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain chain) throws ServletException, IOException {
        String authHeader = request.getHeader(this.tokenHeader);
        if (authHeader != null && authHeader.startsWith(tokenHead)) {
            final String authToken = authHeader.substring(tokenHead.length()); // The part after "Bearer "
            String username = jwtTokenUtil.getUsernameFromToken(authToken);

            logger.info("checking authentication " + username);

            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                            userDetails, null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(
                            request));
                    logger.info("authenticated user " + username + ", setting security context");
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }

        chain.doFilter(request, response);
    }
}複製程式碼

事實上如果我們足夠相信token中的資料，也就是我們足夠相信簽名token的secret的機制足夠好，這種情況下，我們可以不用再查詢資料庫，而直接採用token中的資料。本例中，我們還是通過Spring Security的 @UserDetailsService 進行了資料查詢，但簡單驗證的話，你可以採用直接驗證token是否合法來避免昂貴的資料查詢。

接下來，我們會在 WebSecurityConfig 中注入這個filter，並且配置到 HttpSecurity 中：

public class WebSecurityConfig extends WebSecurityConfigurerAdapter{

    // 省略其它部分

    @Bean
    public JwtAuthenticationTokenFilter authenticationTokenFilterBean() throws Exception {
        return new JwtAuthenticationTokenFilter();
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        // 省略之前寫的規則部分，具體看前面的程式碼

        // 新增JWT filter
        httpSecurity
                .addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);
    }
}複製程式碼

完成鑑權（登入）、註冊和更新token的功能

到現在，我們整個API其實已經在安全的保護下了，但我們遇到一個問題：所有的API都安全了，但我們還沒有使用者啊，所以所有API都沒法訪問。因此要提供一個註冊、登入的API，這個API應該是可以匿名訪問的。給它規劃的路徑呢，我們前面其實在WebSecurityConfig中已經給出了，就是 /auth。

首先需要一個AuthService，規定一下必選動作：

public interface AuthService {
    User register(User userToAdd);
    String login(String username, String password);
    String refresh(String oldToken);
}複製程式碼

然後，實現這些必選動作，其實非常簡單：

1. 登入時要生成token，完成Spring Security認證，然後返回token給客戶端
2. 註冊時將使用者密碼用BCrypt加密，寫入使用者角色，由於是開放註冊，所以寫入角色系統控制，將其寫成 ROLE_USER
3. 提供一個可以重新整理token的介面 refresh 用於取得新的token

@Service
public class AuthServiceImpl implements AuthService {

    private AuthenticationManager authenticationManager;
    private UserDetailsService userDetailsService;
    private JwtTokenUtil jwtTokenUtil;
    private UserRepository userRepository;

    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Autowired
    public AuthServiceImpl(
            AuthenticationManager authenticationManager,
            UserDetailsService userDetailsService,
            JwtTokenUtil jwtTokenUtil,
            UserRepository userRepository) {
        this.authenticationManager = authenticationManager;
        this.userDetailsService = userDetailsService;
        this.jwtTokenUtil = jwtTokenUtil;
        this.userRepository = userRepository;
    }

    @Override
    public User register(User userToAdd) {
        final String username = userToAdd.getUsername();
        if(userRepository.findByUsername(username)!=null) {
            return null;
        }
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        final String rawPassword = userToAdd.getPassword();
        userToAdd.setPassword(encoder.encode(rawPassword));
        userToAdd.setLastPasswordResetDate(new Date());
        userToAdd.setRoles(asList("ROLE_USER"));
        return userRepository.insert(userToAdd);
    }

    @Override
    public String login(String username, String password) {
        UsernamePasswordAuthenticationToken upToken = new UsernamePasswordAuthenticationToken(username, password);
        final Authentication authentication = authenticationManager.authenticate(upToken);
        SecurityContextHolder.getContext().setAuthentication(authentication);

        final UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        final String token = jwtTokenUtil.generateToken(userDetails);
        return token;
    }

    @Override
    public String refresh(String oldToken) {
        final String token = oldToken.substring(tokenHead.length());
        String username = jwtTokenUtil.getUsernameFromToken(token);
        JwtUser user = (JwtUser) userDetailsService.loadUserByUsername(username);
        if (jwtTokenUtil.canTokenBeRefreshed(token, user.getLastPasswordResetDate())){
            return jwtTokenUtil.refreshToken(token);
        }
        return null;
    }
}複製程式碼

然後建立AuthController就好，這個AuthController中我們在其中使用了表示式繫結，比如 @Value("${jwt.header}")中的 jwt.header 其實是定義在 applicaiton.yml 中的

# JWT
jwt:
  header: Authorization
  secret: mySecret
  expiration: 604800
  tokenHead: "Bearer "
  route:
    authentication:
      path: auth
      refresh: refresh
      register: "auth/register"複製程式碼

同樣的 @RequestMapping(value = "${jwt.route.authentication.path}", method = RequestMethod.POST) 中的 jwt.route.authentication.path 也是定義在上面的

@RestController
public class AuthController {
    @Value("${jwt.header}")
    private String tokenHeader;

    @Autowired
    private AuthService authService;

    @RequestMapping(value = "${jwt.route.authentication.path}", method = RequestMethod.POST)
    public ResponseEntity<?> createAuthenticationToken(
            @RequestBody JwtAuthenticationRequest authenticationRequest) throws AuthenticationException{
        final String token = authService.login(authenticationRequest.getUsername(), authenticationRequest.getPassword());

        // Return the token
        return ResponseEntity.ok(new JwtAuthenticationResponse(token));
    }

    @RequestMapping(value = "${jwt.route.authentication.refresh}", method = RequestMethod.GET)
    public ResponseEntity<?> refreshAndGetAuthenticationToken(
            HttpServletRequest request) throws AuthenticationException{
        String token = request.getHeader(tokenHeader);
        String refreshedToken = authService.refresh(token);
        if(refreshedToken == null) {
            return ResponseEntity.badRequest().body(null);
        } else {
            return ResponseEntity.ok(new JwtAuthenticationResponse(refreshedToken));
        }
    }

    @RequestMapping(value = "${jwt.route.authentication.register}", method = RequestMethod.POST)
    public User register(@RequestBody User addedUser) throws AuthenticationException{
        return authService.register(addedUser);
    }
}複製程式碼

驗證時間

接下來，我們就可以看看我們的成果了，首先註冊一個使用者 peng2，很完美的註冊成功了

然後在 /auth 中取得token，也很成功

不使用token時，訪問 /users 的結果，不出意料的失敗，提示未授權。

使用token時，訪問 /users 的結果，雖然仍是失敗，但這次提示訪問被拒絕，意思就是雖然你已經得到了授權，但由於你的會員級別還只是普卡會員，所以你的請求被拒絕。

接下來我們訪問 /users/?username=peng2，竟然可以訪問啊

這是由於我們為這個方法定義的許可權就是：擁有ADMIN角色或者是當前使用者本身。Spring Security真是很方便，很強大。

@PostAuthorize("returnObject.username == principal.username or hasRole('ROLE_ADMIN')")
    @RequestMapping(value = "/",method = RequestMethod.GET)
    public User getUserByUsername(@RequestParam(value="username") String username) {
        return repository.findByUsername(username);
    }複製程式碼

本章程式碼： github.com/wpcfan/spri…

重拾後端之Spring Boot（一）：REST API的搭建可以這樣簡單
重拾後端之Spring Boot（二）：MongoDb的無縫整合
重拾後端之Spring Boot（三）：找回熟悉的Controller，Service
重拾後端之Spring Boot（四）：使用 JWT 和 Spring Security 保護 REST API