AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2018-07-04 4236
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 链接网址：https://www.jianshu.com/p/6307c89fe3fa/链接网址2：https://blog.csdn.net/linzhiqiang0316/article/details/78358907jwt介绍：        JWT是一种用于双方之间传递安全信息的简洁的、URL安全的表述性声明规范。

链接网址：https://www.jianshu.com/p/6307c89fe3fa/

链接网址2：https://blog.csdn.net/linzhiqiang0316/article/details/78358907

jwt介绍：

        JWT是一种用于双方之间传递安全信息的简洁的、URL安全的表述性声明规范。JWT作为一个开放的标准（ RFC 7519 ），定义了一种简洁的，自包含的方法用于通信双方之间以Json对象的形式安全的传递信息。

jwt认证流程介绍： 

1. 用户使用账号和面发出post请求； 
2. 服务器使用私钥创建一个jwt； 
3. 服务器返回这个jwt给浏览器； 
4. 浏览器将该jwt串在请求头中像服务器发送请求； 
5. 服务器验证该jwt； 
6. 返回响应的资源给浏览器。


一：开发一个简单的API

在IDEA开发工具中新建一个maven工程，添加对应的依赖如下：
  1. <dependency>
  2. <groupId>org.springframework.boot </groupId>
  3. <artifactId>spring-boot-starter </artifactId>
  4. </dependency>
  6. <dependency>
  7. <groupId>org.springframework.boot </groupId>
  8. <artifactId>spring-boot-starter-test </artifactId>
  9. <scope>test </scope>
  10. </dependency>
  12. <dependency>
  13. <groupId>org.springframework.boot </groupId>
  14. <artifactId>spring-boot-starter-web </artifactId>
  15. </dependency>
  18. <dependency>
  19. <groupId>org.springframework.boot </groupId>
  20. <artifactId>spring-boot-starter-data-jpa </artifactId>
  21. </dependency>
  24. <dependency>
  25. <groupId>mysql </groupId>
  26. <artifactId>mysql-connector-java </artifactId>
  27. <version>5.1.30 </version>
  28. </dependency>
  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>

新建一个UserController.java文件，在里面在中增加一个hello方法：

  1. @RequestMapping( "/hello")
  2. @ResponseBody
  3. public String hello(){
  4. return "hello";
  5. }

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

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

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












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

二：增加用户注册功能

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

  1. package boss.portal.entity;
  3. import javax.persistence.*;
  5. /**
  6. * @author zhaoxinguo on 2017/9/13.
  7. */
  8. @Entity
  9. @Table(name = "tb_user")
  10. public class User {
  12. @Id
  13. @GeneratedValue
  14. private long id;
  15. private String username;
  16. private String password;
  18. public long getId() {
  19. return id;
  20. }
  22. public String getUsername() {
  23. return username;
  24. }
  26. public void setUsername(String username) {
  27. this.username = username;
  28. }
  30. public String getPassword() {
  31. return password;
  32. }
  34. public void setPassword(String password) {
  35. this.password = password;
  36. }
  37. }

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

  1. package boss.portal.repository;
  3. import boss.portal.entity.User;
  4. import org.springframework.data.jpa.repository.JpaRepository;
  6. /**
  7. * @author zhaoxinguo on 2017/9/13.
  8. */
  9. public interface UserRepository extends JpaRepository<User, Long> {
  11. User findByUsername(String username);
  13. }
在UserController类中增加注册方法，实现用户注册的接口：

  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. }

其中的@PostMapping("/signup")

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

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

  1. package boss.portal;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  8. @SpringBootApplication
  9. public class JwtauthApplication {
  11. @Bean
  12. public BCryptPasswordEncoder bCryptPasswordEncoder() {
  13. return new BCryptPasswordEncoder();
  14. }
  16. public static void main(String[] args) {
  17. SpringApplication.run(JwtauthApplication.class, args);
  18. }
  19. }

三：增加JWT认证功能

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

  1. 内容是一个正确的JWT格式

  2. 检查签名

  3. 检查claims

  4. 检查权限

处理登录

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

  1. package boss.portal.web.filter;
  3. import boss.portal.entity.User;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import io.jsonwebtoken.Jwts;
  6. import io.jsonwebtoken.SignatureAlgorithm;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  9. import org.springframework.security.core.Authentication;
  10. import org.springframework.security.core.AuthenticationException;
  11. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  13. import javax.servlet.FilterChain;
  14. import javax.servlet.ServletException;
  15. import javax.servlet.http.HttpServletRequest;
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.io.IOException;
  18. import java.util.ArrayList;
  19. import java.util.Date;
  21. /**
  22. * 验证用户名密码正确后，生成一个token，并将token返回给客户端
  23. * 该类继承自UsernamePasswordAuthenticationFilter，重写了其中的2个方法
  24. * attemptAuthentication ：接收并解析用户凭证。
  25. * successfulAuthentication ：用户成功登录后，这个方法会被调用，我们在这个方法里生成token。
  26. * @author zhaoxinguo on 2017/9/12.
  27. */
  28. public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter {
  30. private AuthenticationManager authenticationManager;
  32. public JWTLoginFilter(AuthenticationManager authenticationManager) {
  33. this.authenticationManager = authenticationManager;
  34. }
  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);
  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. }
  55. // 用户成功登录后，这个方法会被调用，我们在这个方法里生成token
  56. @Override
  57. protected void successfulAuthentication(HttpServletRequest req,
  58. HttpServletResponse res,
  59. FilterChain chain,
  60. Authentication auth) throws IOException, ServletException {
  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. }
  70. }

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

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

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

授权验证

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

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

  1. package boss.portal.web.filter;
  3. import io.jsonwebtoken.Jwts;
  4. import org.springframework.security.authentication.AuthenticationManager;
  5. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  6. import org.springframework.security.core.context.SecurityContextHolder;
  7. import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
  9. import javax.servlet.FilterChain;
  10. import javax.servlet.ServletException;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.io.IOException;
  14. import java.util.ArrayList;
  16. /**
  17. * token的校验
  18. * 该类继承自BasicAuthenticationFilter，在doFilterInternal方法中，
  19. * 从http头的Authorization 项读取token数据，然后用Jwts包提供的方法校验token的合法性。
  20. * 如果校验通过，就认为这是一个取得授权的合法请求
  21. * @author zhaoxinguo on 2017/9/13.
  22. */
  23. public class JWTAuthenticationFilter extends BasicAuthenticationFilter {
  25. public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
  26. super(authenticationManager);
  27. }
  29. @Override
  30. protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
  31. String header = request.getHeader( "Authorization");
  33. if (header == null || !header.startsWith( "Bearer ")) {
  34. chain.doFilter(request, response);
  35. return;
  36. }
  38. UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
  40. SecurityContextHolder.getContext().setAuthentication(authentication);
  41. chain.doFilter(request, response);
  43. }
  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();
  55. if (user != null) {
  56. return new UsernamePasswordAuthenticationToken(user, null, new ArrayList<>());
  57. }
  58. return null;
  59. }
  60. return null;
  61. }
  63. }

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

SpringSecurity配置

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

  1. package boss.portal.security;
  3. import boss.portal.web.filter.JWTLoginFilter;
  4. import boss.portal.web.filter.JWTAuthenticationFilter;
  5. import org.springframework.boot.autoconfigure.security.SecurityProperties;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.core.annotation.Order;
  8. import org.springframework.http.HttpMethod;
  9. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  10. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  11. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  12. import org.springframework.security.core.userdetails.UserDetailsService;
  13. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  15. /**
  16. * SpringSecurity的配置
  17. * 通过SpringSecurity的配置，将JWTLoginFilter，JWTAuthenticationFilter组合在一起
  18. * @author zhaoxinguo on 2017/9/13.
  19. */
  20. @Configuration
  21. @Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)
  22. public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  24. private UserDetailsService userDetailsService;
  26. private BCryptPasswordEncoder bCryptPasswordEncoder;
  28. public WebSecurityConfig(UserDetailsService userDetailsService, BCryptPasswordEncoder bCryptPasswordEncoder) {
  29. this.userDetailsService = userDetailsService;
  30. this.bCryptPasswordEncoder = bCryptPasswordEncoder;
  31. }
  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. }
  43. @Override
  44. public void configure(AuthenticationManagerBuilder auth) throws Exception {
  45. auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);
  46. }
  48. }

这是标准的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 后面的部分就是tokencurl -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数据。


六：源码下载地址：

地址：

七：建议及改进：
若您有任何建议，可以通过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

版权声明：本文为博主原创文章，转载请加上原文链接，谢谢！ https://blog.csdn.net/sxdtzhaoxinguo/article/details/77965226
文章标签：
API
Spring
数据安全/隐私保护
Java
NoSQL
Redis
Maven
安全
数据格式
JSON
关键词：
API spring
Restful API
jwt spring
jwt security
Spring Security
尘光掠影
目录
相关文章
一位隐者
|
15天前
|
JSON 安全 Java
什么是JWT？如何使用Spring Boot Security实现它？
什么是JWT？如何使用Spring Boot Security实现它？
一位隐者
57 5
请看我回答~
|
13天前
|
JSON JavaScript 前端开发
深入浅出Node.js：从零开始构建RESTful API
在数字化时代的浪潮中，后端开发作为连接用户与数据的桥梁，扮演着至关重要的角色。本文将引导您步入Node.js的奇妙世界，通过实践操作，掌握如何使用这一强大的JavaScript运行时环境构建高效、可扩展的RESTful API。我们将一同探索Express框架的使用，学习如何设计API端点，处理数据请求，并实现身份验证机制，最终部署我们的成果到云服务器上。无论您是初学者还是有一定基础的开发者，这篇文章都将为您打开一扇通往后端开发深层知识的大门。
请看我回答~
29 12
游客sjjs6jgz4gp7m1
|
16天前
|
XML JSON 缓存
深入理解RESTful API设计原则与实践
在现代软件开发中，构建高效、可扩展的应用程序接口（API）是至关重要的。本文旨在探讨RESTful API的核心设计理念，包括其基于HTTP协议的特性，以及如何在实际应用中遵循这些原则来优化API设计。我们将通过具体示例和最佳实践，展示如何创建易于理解、维护且性能优良的RESTful服务，从而提升前后端分离架构下的开发效率和用户体验。
游客sjjs6jgz4gp7m1
39 9
wljslmz
|
15天前
|
负载均衡 Java 开发者
深入探索Spring Cloud与Spring Boot：构建微服务架构的实践经验
深入探索Spring Cloud与Spring Boot：构建微服务架构的实践经验
wljslmz
57 5
游客762btuqu5wybw666
|
17天前
|
JSON 缓存 测试技术
构建高效RESTful API的后端实践指南####
本文将深入探讨如何设计并实现一个高效、可扩展且易于维护的RESTful API。不同于传统的摘要概述，本节将直接以行动指南的形式，列出构建RESTful API时必须遵循的核心原则与最佳实践，旨在为开发者提供一套直接可行的实施框架，快速提升API设计与开发能力。 ####
游客762btuqu5wybw666
31 4
游客kwe6k52lwpmug
|
18天前
|
JSON API 开发者
深入理解RESTful API设计原则
在数字化时代，API已成为连接不同软件应用的桥梁。本文旨在探讨RESTful API设计的基本原则和最佳实践，帮助开发者构建高效、可扩展的网络服务接口。通过解析REST架构风格的核心概念，我们将了解如何设计易于理解和使用的API，同时保证其性能和安全性。
游客kwe6k52lwpmug
29 0
zhanbao
|
18天前
|
存储 缓存 API
深入理解RESTful API设计原则
在现代软件开发中，RESTful API已成为前后端分离架构下不可或缺的通信桥梁。本文旨在探讨RESTful API的核心设计原则，包括资源导向、无状态、统一接口、以及可缓存性等，并通过实例解析如何在实际应用中遵循这些原则来构建高效、可维护的API接口。我们将深入分析每个原则背后的设计理念，提供最佳实践指导，帮助开发者优化API设计，提升系统整体性能和用户体验。
zhanbao
16 0
zhanbao
|
18天前
|
安全 测试技术 API
构建高效RESTful API：后端开发的艺术与实践####
在现代软件开发的浩瀚星空中，RESTful API如同一座桥梁，连接着前端世界的绚丽多彩与后端逻辑的深邃复杂。本文旨在探讨如何精心打造一款既高效又易于维护的RESTful API，通过深入浅出的方式，剖析其设计原则、实现技巧及最佳实践，为后端开发者提供一份实用的指南。我们不深入晦涩的理论，只聚焦于那些能够即刻提升API品质与开发效率的关键点，让你的API在众多服务中脱颖而出。 ####
zhanbao
25 0
ritit
|
API Java Spring
kafka-Java-SpringBoot-listener API开发
listener开发过程是独立的,你也可以不开发,使用@KafkaListener注解来监听kafka的消息,我的方式是实现一个唯一方法的接口,然后在该方法里面进行消费,无需关心kafka的具体实现,只需要添加一个topics到配置值文件即可.
ritit
3976 0
蚝油菜花
|
2天前
|
人工智能 自然语言处理 API
Multimodal Live API：谷歌推出新的 AI 接口，支持多模态交互和低延迟实时互动
谷歌推出的Multimodal Live API是一个支持多模态交互、低延迟实时互动的AI接口，能够处理文本、音频和视频输入，提供自然流畅的对话体验，适用于多种应用场景。
蚝油菜花
21 3
Multimodal Live API：谷歌推出新的 AI 接口，支持多模态交互和低延迟实时互动

热门文章

最新文章

  • 1
    RESTful API 文档生成神器 Wisdom REST Client
  • 2
    Spring Boot 2.x基础教程：构建RESTful API与单元测试
  • 3
    基于RESTful标准的Web Api
  • 4
    RESTful再理解
  • 5
    SpringBoot入门到精通（二十一）如何优雅的设计 RESTful API 接口版本号，实现 API 版本控制！
  • 6
    （有数据库,rest soap 共存）restful cxf maven jdbctemplate 类似七牛 图床 设计 demo
  • 7
    SOA中springmvc中restful服务的数据权限加密方式分享
  • 8
    CI中如何保护RESTful API
  • 9
    RESTful API 设计指南
  • 10
    RESTful WebService入门
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    95
  • 2
    Spring Boot中一般如何使用线程池？
    744
  • 3
    Spring Boot 源码面试知识点
    99
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    246
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    101
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    338
  • 7
    springboot全局自定义异常
    40
  • 8
    RabbitMQ的springboot项目集成使用-01
    146
  • 9
    什么是Spring Boot 自动配置？
    57
  • 10
    Spring cloud原理详解
    77

    • 相关课程

    更多
  • SpringBoot实战教程
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Springboot项目云开发快速迁移

    • 相关电子书

    更多
  • Spring Boot2.0实战Redis分布式缓存
  • CUDA MATH API
  • API PLAYBOOK

    • 相关实验场景

    更多
  • 基于Assistant Api的旅游助手
  • 快速体验智能体API应用
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解