Spring Boot+Spring Security+JWT 实现 RESTful Api 权限控制

摘要：
用spring-boot开发RESTful API非常的方便，在生产环境中，对发布的API增加授权保护是非常必要的。现在我们来看如何利用JWT技术为API增加授权保护，保证只有获得授权的用户才能够访问API。

一：开发一个简单的API

在IDEA开发工具中新建一个maven工程，添加对应的依赖如下：

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
1<dependency>

2            <groupId>org.springframework.boot</groupId>

3            <artifactId>spring-boot-starter</artifactId>

4        </dependency>

5

6        <dependency>

7            <groupId>org.springframework.boot</groupId>

8            <artifactId>spring-boot-starter-test</artifactId>

9            <scope>test</scope>

10        </dependency>

11

12        <dependency>

13            <groupId>org.springframework.boot</groupId>

14            <artifactId>spring-boot-starter-web</artifactId>

15        </dependency>

16

17        <!-- spring-data-jpa -->

18        <dependency>

19            <groupId>org.springframework.boot</groupId>

20            <artifactId>spring-boot-starter-data-jpa</artifactId>

21        </dependency>

22

23        <!-- mysql -->

24        <dependency>

25            <groupId>mysql</groupId>

26            <artifactId>mysql-connector-java</artifactId>

27            <version>5.1.30</version>

28        </dependency>

29

30        <!-- spring-security 和 jwt -->

31        <dependency>

32            <groupId>org.springframework.boot</groupId>

33            <artifactId>spring-boot-starter-security</artifactId>

34        </dependency>

35        <dependency>

36            <groupId>io.jsonwebtoken</groupId>

37            <artifactId>jjwt</artifactId>

38            <version>0.7.0</version>

39        </dependency>

40

1
2
1  新建一个UserController.java文件，在里面

2

在中增加一个hello方法：

1
2
3
4
5
6
1@RequestMapping("/hello")

2    @ResponseBody

3    public String hello(){

4        return "hello";

5    }

6

1
2
1   

2

这样一个简单的RESTful API就开发好了。

现在我们运行一下程序看看效果，执行JwtauthApplication.java类中的main方法：

等待程序启动完成后，可以简单的通过curl工具进行API的调用，如下图：

至此，我们的接口就开发完成了。但是这个接口没有任何授权防护，任何人都可以访问，这样是不安全的，下面我们开始加入授权机制。

二：增加用户注册功能

首先增加一个实体类User.java：

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
1package boss.portal.entity;

2

3import javax.persistence.*;

4

5/**

6 * @author zhaoxinguo on 2017/9/13.

7 */

8@Entity

9@Table(name = "tb_user")

10public class User {

11

12    @Id

13    @GeneratedValue

14    private long id;

15    private String username;

16    private String password;

17

18    public long getId() {

19        return id;

20    }

21

22    public String getUsername() {

23        return username;

24    }

25

26    public void setUsername(String username) {

27        this.username = username;

28    }

29

30    public String getPassword() {

31        return password;

32    }

33

34    public void setPassword(String password) {

35        this.password = password;

36    }

37}

38

39

  然后增加一个Repository类UserRepository，可以读取和保存用户信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1package boss.portal.repository;

2

3import boss.portal.entity.User;

4import org.springframework.data.jpa.repository.JpaRepository;

5

6/**

7 * @author zhaoxinguo on 2017/9/13.

8 */

9public interface UserRepository extends JpaRepository<User, Long> {

10

11    User findByUsername(String username);

12

13}

14

15

在UserController类中增加注册方法，实现用户注册的接口：

1
2
3
4
5
6
7
8
9
10
1/**

2     * 该方法是注册用户的方法，默认放开访问控制

3     * @param user

4     */

5    @PostMapping("/signup")

6    public void signUp(@RequestBody User user) {

7        user.setPassword(bCryptPasswordEncoder.encode(user.getPassword()));

8        applicationUserRepository.save(user);

9    }

10

 
其中的
@PostMapping
(
"/signup"
)

这个方法定义了用户注册接口，并且指定了url地址是/users/signup。由于类上加了注解 @RequestMapping(“/users”)，类中的所有方法的url地址都会有/users前缀，所以在方法上只需指定/signup子路径即可。

密码采用了BCryptPasswordEncoder进行加密，我们在Application中增加BCryptPasswordEncoder实例的定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1package boss.portal;

2

3import org.springframework.boot.SpringApplication;

4import org.springframework.boot.autoconfigure.SpringBootApplication;

5import org.springframework.context.annotation.Bean;

6import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

7

8@SpringBootApplication

9public class JwtauthApplication {

10

11  @Bean

12  public BCryptPasswordEncoder bCryptPasswordEncoder() {

13      return new BCryptPasswordEncoder();

14  }

15

16  public static void main(String[] args) {

17      SpringApplication.run(JwtauthApplication.class, args);

18  }

19}

20

21

1
2
1   

2

三：增加JWT认证功能

用户填入用户名密码后，与数据库里存储的用户信息进行比对，如果通过，则认证成功。传统的方法是在认证通过后，创建sesstion，并给客户端返回cookie。现在我们采用JWT来处理用户名密码的认证。区别在于，认证通过后，服务器生成一个token，将token返回给客户端，客户端以后的所有请求都需要在http头中指定该token。服务器接收的请求后，会对token的合法性进行验证。验证的内容包括：

内容是一个正确的JWT格式

检查签名

检查claims

检查权限

处理登录

创建一个类JWTLoginFilter，核心功能是在验证用户名密码正确后，生成一个token，并将token返回给客户端：

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
1package boss.portal.web.filter;

2

3import boss.portal.entity.User;

4import com.fasterxml.jackson.databind.ObjectMapper;

5import io.jsonwebtoken.Jwts;

6import io.jsonwebtoken.SignatureAlgorithm;

7import org.springframework.security.authentication.AuthenticationManager;

8import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

9import org.springframework.security.core.Authentication;

10import org.springframework.security.core.AuthenticationException;

11import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

12

13import javax.servlet.FilterChain;

14import javax.servlet.ServletException;

15import javax.servlet.http.HttpServletRequest;

16import javax.servlet.http.HttpServletResponse;

17import java.io.IOException;

18import java.util.ArrayList;

19import java.util.Date;

20

21/**

22 * 验证用户名密码正确后，生成一个token，并将token返回给客户端

23 * 该类继承自UsernamePasswordAuthenticationFilter，重写了其中的2个方法

24 * attemptAuthentication ：接收并解析用户凭证。

25 * successfulAuthentication ：用户成功登录后，这个方法会被调用，我们在这个方法里生成token。

26 * @author zhaoxinguo on 2017/9/12.

27 */

28public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter {

29

30    private AuthenticationManager authenticationManager;

31

32    public JWTLoginFilter(AuthenticationManager authenticationManager) {

33        this.authenticationManager = authenticationManager;

34    }

35

36    // 接收并解析用户凭证

37    @Override

38    public Authentication attemptAuthentication(HttpServletRequest req,

39                                                HttpServletResponse res) throws AuthenticationException {

40        try {

41            User user = new ObjectMapper()

42                    .readValue(req.getInputStream(), User.class);

43

44            return authenticationManager.authenticate(

45                    new UsernamePasswordAuthenticationToken(

46                            user.getUsername(),

47                            user.getPassword(),

48                            new ArrayList<>())

49            );

50        } catch (IOException e) {

51            throw new RuntimeException(e);

52        }

53    }

54

55    // 用户成功登录后，这个方法会被调用，我们在这个方法里生成token

56    @Override

57    protected void successfulAuthentication(HttpServletRequest req,

58                                            HttpServletResponse res,

59                                            FilterChain chain,

60                                            Authentication auth) throws IOException, ServletException {

61

62        String token = Jwts.builder()

63                .setSubject(((org.springframework.security.core.userdetails.User) auth.getPrincipal()).getUsername())

64                .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 24 * 1000))

65                .signWith(SignatureAlgorithm.HS512, "MyJwtSecret")

66                .compact();

67        res.addHeader("Authorization", "Bearer " + token);

68    }

69

70}

71

72

1
2
1   

2

该类继承自UsernamePasswordAuthenticationFilter，重写了其中的2个方法：

attemptAuthentication ：接收并解析用户凭证。

successfulAuthentication ：用户成功登录后，这个方法会被调用，我们在这个方法里生成token。

授权验证

用户一旦登录成功后，会拿到token，后续的请求都会带着这个token，服务端会验证token的合法性。

创建JWTAuthenticationFilter类，我们在这个类中实现token的校验功能。

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
1package boss.portal.web.filter;

2

3import io.jsonwebtoken.Jwts;

4import org.springframework.security.authentication.AuthenticationManager;

5import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

6import org.springframework.security.core.context.SecurityContextHolder;

7import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

8

9import javax.servlet.FilterChain;

10import javax.servlet.ServletException;

11import javax.servlet.http.HttpServletRequest;

12import javax.servlet.http.HttpServletResponse;

13import java.io.IOException;

14import java.util.ArrayList;

15

16/**

17 * token的校验

18 * 该类继承自BasicAuthenticationFilter，在doFilterInternal方法中，

19 * 从http头的Authorization 项读取token数据，然后用Jwts包提供的方法校验token的合法性。

20 * 如果校验通过，就认为这是一个取得授权的合法请求

21 * @author zhaoxinguo on 2017/9/13.

22 */

23public class JWTAuthenticationFilter extends BasicAuthenticationFilter {

24

25    public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {

26        super(authenticationManager);

27    }

28

29    @Override

30    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {

31        String header = request.getHeader("Authorization");

32

33        if (header == null || !header.startsWith("Bearer ")) {

34            chain.doFilter(request, response);

35            return;

36        }

37

38        UsernamePasswordAuthenticationToken authentication = getAuthentication(request);

39

40        SecurityContextHolder.getContext().setAuthentication(authentication);

41        chain.doFilter(request, response);

42

43    }

44

45    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {

46        String token = request.getHeader("Authorization");

47        if (token != null) {

48            // parse the token.

49            String user = Jwts.parser()

50                    .setSigningKey("MyJwtSecret")

51                    .parseClaimsJws(token.replace("Bearer ", ""))

52                    .getBody()

53                    .getSubject();

54

55            if (user != null) {

56                return new UsernamePasswordAuthenticationToken(user, null, new ArrayList<>());

57            }

58            return null;

59        }

60        return null;

61    }

62

63}

64

65

1
2
1   

2

该类继承自BasicAuthenticationFilter，在doFilterInternal方法中，从http头的Authorization 项读取token数据，然后用Jwts包提供的方法校验token的合法性。如果校验通过，就认为这是一个取得授权的合法请求。

SpringSecurity配置

通过SpringSecurity的配置，将上面的方法组合在一起。

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
1package boss.portal.security;

2

3import boss.portal.web.filter.JWTLoginFilter;

4import boss.portal.web.filter.JWTAuthenticationFilter;

5import org.springframework.boot.autoconfigure.security.SecurityProperties;

6import org.springframework.context.annotation.Configuration;

7import org.springframework.core.annotation.Order;

8import org.springframework.http.HttpMethod;

9import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;

10import org.springframework.security.config.annotation.web.builders.HttpSecurity;

11import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

12import org.springframework.security.core.userdetails.UserDetailsService;

13import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

14

15/**

16 * SpringSecurity的配置

17 * 通过SpringSecurity的配置，将JWTLoginFilter，JWTAuthenticationFilter组合在一起

18 * @author zhaoxinguo on 2017/9/13.

19 */

20@Configuration

21@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)

22public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

23

24    private UserDetailsService userDetailsService;

25

26    private BCryptPasswordEncoder bCryptPasswordEncoder;

27

28    public WebSecurityConfig(UserDetailsService userDetailsService, BCryptPasswordEncoder bCryptPasswordEncoder) {

29        this.userDetailsService = userDetailsService;

30        this.bCryptPasswordEncoder = bCryptPasswordEncoder;

31    }

32

33    @Override

34    protected void configure(HttpSecurity http) throws Exception {

35        http.cors().and().csrf().disable().authorizeRequests()

36                .antMatchers(HttpMethod.POST, "/users/signup").permitAll()

37                .anyRequest().authenticated()

38                .and()

39                .addFilter(new JWTLoginFilter(authenticationManager()))

40                .addFilter(new JWTAuthenticationFilter(authenticationManager()));

41    }

42

43    @Override

44    public void configure(AuthenticationManagerBuilder auth) throws Exception {

45        auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);

46    }

47

48}

49

50

这是标准的SpringSecurity配置内容，就不在详细说明。注意其中的

.addFilter(new JWTLoginFilter(authenticationManager())) 
.addFilter(new JwtAuthenticationFilter(authenticationManager())) 

这两行，将我们定义的JWT方法加入SpringSecurity的处理流程中。

下面对我们的程序进行简单的验证：

# 请求hello接口，会收到403错误，如下图：

curl http:
//localhost:8080/hello

# 注册一个新用户
curl -H
"Content-Type: application/json"
-X POST -d '{
"username"
:
"admin"
,
"password"
:
"password"
}' http:
//localhost:8080/users/signup

如下图：

# 登录，会返回token，在http header中，Authorization: Bearer 后面的部分就是token
curl -i -H
"Content-Type: application/json"
-X POST -d '{
"username"
:
"admin"
,
"password"
:
"password"
}' http:
//localhost:8080/login

如下图：

# 用登录成功后拿到的token再次请求hello接口
# 将请求中的XXXXXX替换成拿到的token
# 这次可以成功调用接口了
curl -H
"Content-Type: application/json"
-H
"Authorization: Bearer XXXXXX"

"http://localhost:8080/users/hello"

如下图：

五：总结

至此，给SpringBoot的接口加上JWT认证的功能就实现了，过程并不复杂，主要是开发两个SpringSecurity的filter，来生成和校验JWT token。

JWT作为一个无状态的授权校验技术，非常适合于分布式系统架构，因为服务端不需要保存用户状态，因此就无需采用redis等技术，在各个服务节点之间共享session数据。

六：源码下载地址：
地址：https://gitee.com/micai/springboot-springsecurity-jwt-demo

七：建议及改进：
若您有任何建议，可以通过1）加入qq群715224124向群主提出，或2）发送邮件至827358369@qq.com向我反馈。本人承诺，任何建议都将会被认真考虑，优秀的建议将会被采用，但不保证一定会在当前版本中实现。

八：鸣谢地址：

http://blog.csdn.net/haiyan_qi/article/details/77373900

https://segmentfault.com/a/1190000009231329

http://www.jianshu.com/p/6307c89fe3fa

http://www.cnblogs.com/grissom007/p/6294746.html

九：如有问题请扫描下面的微笑二扫码联系，楼主会尽力帮大家解决遇到的问题！

标题