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

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

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

 

给TA打赏
共{{data.count}}人
人已打赏
安全技术

C/C++内存泄漏及检测

2022-1-11 12:36:11

安全资讯

做技术合作:本田宣布与谷歌无人车公司正式谈判

2016-12-24 0:20:40

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索