devbox
算法编织者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

微服务统一认证中心_微服务认证中心

作者：算法编织者 | 2024-02-03 18:59:36

赞

踩

微服务认证中心

       在微服务架构中，由于不同的业务会拆分成不同的微服务，传统的单体项目一般是通过过滤器进行拦截校验，而微服务显然不可能分发到各个服务进行用户认证，这就需要由一个统一的地方来管理所有服务的认证信息，实现只登录一次，即可在各个服务的授权范围内进行操作；本文采用springcloud-oauth2来实现多个微服务的统一认证，废话不多说，先来个架构图：

OAuth 2 有四种授权模式:

什么情况下需要用 OAuth2

        首先大家最熟悉的就是几乎每个人都用过的，比如用微信登录、用 QQ 登录、用微博登录、用 Google 账号登录、用 github 授权登录等等，这些都是典型的 OAuth2 使用场景。假设我们做了一个自己的服务平台，如果不使用 OAuth2 登录方式，那么我们需要用户先完成注册，然后用注册号的账号密码或者用手机验证码登录。而使用了 OAuth2 之后，相信很多人使用过、甚至开发过公众号网页服务、小程序，当我们进入网页、小程序界面，第一次使用就无需注册，直接使用微信授权登录即可，大大提高了使用效率。因为每个人都有微信号，有了微信就可以马上使用第三方服务，这体验不要太好了。而对于我们的服务来说，我们也不需要存储用户的密码，只要存储认证平台返回的唯一ID 和用户信息即可。 
        以上是使用了 OAuth2 的授权码模式，利用第三方的权威平台实现用户身份的认证。当然了，如果你的公司内部有很多个服务，可以专门提取出一个认证中心，这个认证中心就充当上面所说的权威认证平台的角色，所有的服务都要到这个认证中心做认证

这样一说，发现没，这其实就是个单点登录的功能。这就是另外一种使用场景，对于多服务的平台，可以使用 OAuth2 实现服务的单点登录，只做一次登录，就可以在多个服务中自由穿行，当然仅限于授权范围内的服务和接口。


        OAuth2 其实是一个关于授权的网络标准，它制定了设计思路和运行流程，利用这个标准我们其实是可以自己实现 OAuth2 的认证过程的。今天要介绍的 spring-cloud-starter-oauth2 ，其实是 Spring Cloud 按照 OAuth2 的标准并结合 spring-security 封装好的一个具体实现。接下来看一下系统架构说明：

【登录时序图】

【接口调用时序图】

 

认证服务：OAuth2 主要实现端，Token 的生成、刷新、验证都在认证中心完成。

后台服务： 接收到请求后会到认证中心验证（微服务入口一般是网关）

前端：认证服务、后台服务之间的联调

        上图描述了使用了 前端与OAuth2 认证服务、微服务间的请求过程。大致的过程就是前端用用户名和密码到后台服务登录，成功后后台服务到认证服务端换取 token，返回给前端，前端拿着 token 去各个微服务请求数据接口，一般这个 token 是放到 header 中的。当微服务接到请求后，先要拿着 token 去认证服务端检查 token 的合法性，如果合法，再根据用户所属的角色及具有的权限动态的返回数据。

        接下来，正式进入实战阶段 ！~

1. 搭建认证中心auth-center

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-oauth2</artifactId>
  4.     <version>2.2.2.RELEASE</version>
  5. </dependency>

启动类开启feign和服务发现注解：

  1. @MapperScan("com.example.dao")
  2. @SpringBootApplication
  3. @EnableFeignClients
  4. @EnableDiscoveryClient
  5. public class AppAuthCenter {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(AppAuthCenter.class, args);
  8.     }
  9.  
  10. }
  1. server:
  2.   port: 8080
  3.  
  4. spring:
  5.   application:
  6.     name: auth-center
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         server-addr: 127.0.0.1:8848
  11.   redis:
  12.     database: 2
  13.     host: 127.0.0.1
  14.     port: 6379
  15.     password: 123456
  16.   datasource:
  17.     type: com.zaxxer.hikari.HikariDataSource
  18.     driver-class-name: "com.mysql.cj.jdbc.Driver"
  19.     url: jdbc:mysql://127.0.0.1:3306/security?characterEncoding=utf8&characterSetResults=utf8&autoReconnect=true&failOverReadOnly=false
  20.     username: root
  21.     password: 123456
  22.     hikari:
  23.       minimum-idle: "0"
  24.       auto-commit: "true" # 此属性控制从池返回的连接的默认自动提交行为,默认值：true
  25.       pool-name: "springcloud-security-oauth2-jwt" # 连接池名称
  26.       max-lifetime: "1800000" # 此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
  27.       connection-timeout: "30000" # 数据库连接超时时间,默认30秒，即30000
  28.       connection-test-query: "SELECT 1"
  29.  
  30. mybatis-plus:
  31.   enabled: true #mybatis plus开启 如果没有此配置那么com.cnnho.redfish.common.config.MybatisPlusConfig 配置不起作用
  32.   mapper-locations: classpath:mapper/*Mapper.xml
  33.   global-config:
  34.     db-config:
  35.       field-strategy: not-empty #字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
  36.       id-type: auto
  37.       db-type: mysql
  38.       refresh-mapper: "true"
  39.   configuration:
  40.     cache-enabled: true
  41.     map-underscore-to-camel-case: true
  42.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  43.     auto-mapping-unknown-column-behavior: none

1.1 spring security 基础配置：

  1. package com.example.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.security.authentication.AuthenticationManager;
  5. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  6. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  7. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  8. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  9. import org.springframework.security.crypto.password.PasswordEncoder;
  10.  
  11. /**
  12.  * @author: joybinny
  13.  */
  14. @EnableWebSecurity
  15. public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  16.  
  17.     @Bean
  18.     public PasswordEncoder passwordEncoder() {
  19.         return new BCryptPasswordEncoder();
  20.     }
  21.  
  22.     @Bean
  23.     @Override
  24.     public AuthenticationManager authenticationManagerBean() throws Exception {
  25.         return super.authenticationManagerBean();
  26.     }
  27.  
  28.     /**
  29.      * 允许匿名访问所有接口 主要是 oauth 接口
  30.      * @param http
  31.      * @throws Exception
  32.      */
  33.     @Override
  34.     protected void configure(HttpSecurity http) throws Exception {
  35.         http.authorizeRequests()
  36.                 .antMatchers("/**").permitAll();
  37.     }
  38. }

使用 @EnableWebSecurity 注解修饰，并继承自 WebSecurityConfigurerAdapter 类。 这个类的重点就是声明 PasswordEncoder 和 AuthenticationManager两个 Bean。稍后会用到。其中 BCryptPasswordEncoder是一个密码加密工具类，它可以实现不可逆的加密，AuthenticationManager是为了实现 OAuth2 的 password 模式必须要指定的授权管理 Bean。

1.2 实现 UserDetailsService

如果你之前用过 Security 的话，那肯定对这个类很熟悉，它是实现用户身份验证的一种方式，也是最简单方便的一种。另外还有结合 AuthenticationProvider的方式，有机会讲 Security 的时候再展开来讲吧。 UserDetailsService的核心就是 loadUserByUsername方法，它要接收一个字符串参数，也就是传过来的用户名，返回一个 UserDetails对象。

  1. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  2. import com.example.dao.UserDao;
  3. import com.example.entity.UserPo;
  4. import io.micrometer.core.instrument.util.StringUtils;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.security.core.userdetails.UserDetails;
  7. import org.springframework.security.core.userdetails.UserDetailsService;
  8. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import java.util.ArrayList;
  12.  
  13. @Component(value = "kiteUserDetailsService")
  14. public class KiteUserDetailsService implements UserDetailsService {
  15.  
  16.     @Autowired
  17.     private UserDao userDao;
  18.  
  19.     /**
  20.      * Security的登录，User赋予权限
  21.      *
  22.      * @param username
  23.      * @return
  24.      * @throws UsernameNotFoundException
  25.      */
  26.     @Override
  27.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  28.         if (StringUtils.isBlank(username)) {
  29.             throw new UsernameNotFoundException("Username is not null");
  30.         }
  31.         QueryWrapper queryWrapper = new QueryWrapper();
  32.         queryWrapper.eq("user_name", username);
  33.         /** 只做认证，不做鉴权（如做鉴权，参考下面注释的代码..） */
  34.         UserPo user = userDao.selectOne(queryWrapper);
  35.         if (null == user) { //校验用户是否存在
  36.             throw new UsernameNotFoundException("User is not exist");
  37.         }
  38.         return new org.springframework.security.core.userdetails.User(username, user.getOauthPassword(), new ArrayList<>());//返回null访问/oauth/token会报错Unauthorized
  39.  
  40.  
  41.         /* 认证 + 鉴权
  42.         String role = user.getRole();
  43.         List<SimpleGrantedAuthority> authorities = new ArrayList<>();
  44.         authorities.add(new SimpleGrantedAuthority(role));
  45.         return new org.springframework.security.core.userdetails.User(username, user.getOauthPassword(), authorities);*/
  46.  
  47.     }
  48. }

1.3 Oauth2配置文件

  1. package com.example.config;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.security.authentication.AuthenticationManager;
  6. import org.springframework.security.core.userdetails.UserDetailsService;
  7. import org.springframework.security.crypto.password.PasswordEncoder;
  8. import org.springframework.security.oauth2.config.annotation.builders.JdbcClientDetailsServiceBuilder;
  9. import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
  10. import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
  11. import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
  12. import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
  13. import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
  14. import org.springframework.security.oauth2.provider.token.TokenEnhancer;
  15. import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
  16. import org.springframework.security.oauth2.provider.token.TokenStore;
  17. import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
  18.  
  19. import javax.sql.DataSource;
  20. import java.util.ArrayList;
  21. import java.util.List;
  22.  
  23. @Configuration
  24. @EnableAuthorizationServer
  25. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  26.  
  27.     /**
  28.      * 指定密码的加密方式
  29.      */
  30.     @Autowired
  31.     public PasswordEncoder passwordEncoder;
  32.  
  33.     /**
  34.      * 该对象为刷新token提供支持
  35.      */
  36.     @Autowired
  37.     public UserDetailsService kiteUserDetailsService;
  38.  
  39.     /**
  40.      * 该对象用来支持password模式
  41.      */
  42.     @Autowired
  43.     private AuthenticationManager authenticationManager;
  44.  
  45.     @Autowired
  46.     private TokenStore jwtTokenStore;
  47.     @Autowired
  48.     private JwtAccessTokenConverter jwtAccessTokenConverter;
  49.     @Autowired
  50.     private TokenEnhancer jwtTokenEnhancer;
  51.     @Autowired
  52.     private DataSource dataSource;
  53.  
  54.  
  55.     /**
  56.      * 密码模式下配置认证管理器 AuthenticationManager,并且设置 AccessToken的存储介质tokenStore,如        果不设置，则会默认使用内存当做存储介质。
  57.      * 而该AuthenticationManager将会注入 2个Bean对象用以检查(认证)
  58.      * 1、ClientDetailsService的实现类 JdbcClientDetailsService (检查 ClientDetails 对象)
  59.      * 2、UserDetailsService的实现类 KiteUserDetailsService (检查 UserDetails 对象)
  60.      */
  61.     @Override
  62.     public void configure(final AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
  63.         /** jwt 增强模式 */
  64.         TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
  65.         List<TokenEnhancer> enhancerList = new ArrayList<>();
  66.         enhancerList.add(jwtTokenEnhancer);
  67.         enhancerList.add(jwtAccessTokenConverter);
  68.         enhancerChain.setTokenEnhancers(enhancerList);
  69.         endpoints.tokenStore(jwtTokenStore)
  70.                 .userDetailsService(kiteUserDetailsService)
  71.                 // 支持 password 模式
  72.                 .authenticationManager(authenticationManager)
  73.                 .tokenEnhancer(enhancerChain)
  74.                 .accessTokenConverter(jwtAccessTokenConverter);
  75.     }
  76.  
  77.     /**
  78.      * 配置 oauth_client_details【client_id和client_secret等】信息的认证【检查ClientDetails的合        法性】服务
  79.      * 设置 认证信息的来源：数据库 (可选项：数据库和内存,使用内存一般用来作测试)
  80.      * 自动注入：ClientDetailsService的实现类 JdbcClientDetailsService (检查 ClientDetails 对        象)
  81.      * 1.inMemory 方式存储的，将配置保存到内存中，相当于硬编码了。正式环境下的做法是持久化到数据库中，比如        mysql 中。
  82.      * 2. secret加密是client_id:secret 然后通过base64编码后的字符串
  83.      */
  84.     @Override
  85.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  86.         JdbcClientDetailsServiceBuilder jcsb = clients.jdbc(dataSource);
  87.         jcsb.passwordEncoder(passwordEncoder);
  88.     }
  89. //    @Override
  90. //    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  91. //        //添加客户端信息
  92. //        //使用内存存储OAuth客服端信息
  93. //        clients.inMemory()
  94. //                // client_id 客户单ID
  95. //                .withClient("order_client")
  96. //                // client_secret 客户单秘钥
  97. //                .secret(passwordEncoder.encode("order6666"))
  98. //                // 该客户端允许的授权类型，不同的类型，则获取token的方式不一样
  99. //                .authorizedGrantTypes("refresh_token", "authorization_code", "password")
  100. //                // token 有效期
  101. //                .accessTokenValiditySeconds(EXPIRE_TIME)
  102. //                // 允许的授权范围
  103. //                .scopes("all")
  104. //                .and()
  105. //                .withClient("user_client")
  106. //                .secret(passwordEncoder.encode("user8888"))
  107. //                .authorizedGrantTypes("refresh_token", "authorization_code", "password")
  108. //                .accessTokenValiditySeconds(EXPIRE_TIME)
  109. //                .scopes("all");
  110. //    }
  111.  
  112.  
  113.     /**
  114.      * 配置：安全检查流程
  115.      * 默认过滤器：BasicAuthenticationFilter
  116.      * 1、oauth_client_details表中clientSecret字段加密【ClientDetails属性secret】
  117.      * 2、CheckEndpoint类的接口 oauth/check_token 无需经过过滤器过滤，默认值：denyAll()
  118.      */
  119.     @Override
  120.     public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
  121.         ///允许客户表单认证
  122.         security.allowFormAuthenticationForClients();
  123.         //对于CheckEndpoint控制器[框架自带的校验]的/oauth/check端点允许所有客户端发送器请求而不会被  Spring-security拦截
  124.         security.checkTokenAccess("permitAll()");
  125.         security.tokenKeyAccess("permitAll()");
  126.  
  127.     }
  128.  
  129.  
  130. }

认证信息的来源采用数据库的方式，放弃内存模式；这就需要我们提前在数据库生成一张固定模板的表结构：

  1. CREATE TABLE `oauth_client_details`  (
  2.   `client_id` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
  3.   `resource_ids` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  4.   `client_secret` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  5.   `scope` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  6.   `authorized_grant_types` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  7.   `web_server_redirect_uri` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  8.   `authorities` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  9.   `access_token_validity` int(11) NULL DEFAULT NULL,
  10.   `refresh_token_validity` int(11) NULL DEFAULT NULL,
  11.   `additional_information` varchar(4096) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  12.   `autoapprove` varchar(256) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  13.   PRIMARY KEY (`client_id`) USING BTREE
  14. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci COMMENT = 'https://blog.csdn.net/wangxuelei036/article/details/109491215' ROW_FORMAT = Dynamic;
  15.  
  16. -- ----------------------------
  17. -- Records of oauth_client_details
  18. -- ----------------------------
  19. INSERT INTO `oauth_client_details` VALUES ('order-client', NULL, '$2a$10$lU.YisICL1MQORkGMX6OUuggYZVj2PKZetd8j7PfJgEnQJXZzw9dS', 'all', 'authorization_code,refresh_token,password', NULL, NULL, 60, 36000, NULL, '1');
  20. INSERT INTO `oauth_client_details` VALUES ('user-client', NULL, '$2a$10$ZgTwua6DPOhnI6Q1519AP.YkZsDZThST5qlqu5Wa1kJ7biXzXERvO', 'all', 'authorization_code,refresh_token,password', NULL, NULL, 120, 36000, NULL, '1');

其中密码是用 PasswordEncoder 加密生成，关于该表的详细说明可参考该文章：https://blog.csdn.net/wangxuelei036/article/details/109491215

配置jwt增强器，通过 oAuth2Authentication 可以拿到用户名等信息，通过这些我们可以在这里查询数据库或者缓存获取更多的信息，而这些信息都可以作为 JWT 扩展信息加入其中。

  1. package com.example.config.jwt;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.example.dao.UserDao;
  5. import com.example.entity.UserPo;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.security.core.userdetails.User;
  8. import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
  9. import org.springframework.security.oauth2.common.OAuth2AccessToken;
  10. import org.springframework.security.oauth2.provider.OAuth2Authentication;
  11. import org.springframework.security.oauth2.provider.token.TokenEnhancer;
  12.  
  13. import java.util.HashMap;
  14. import java.util.Map;
  15.  
  16. public class JWTokenEnhancer implements TokenEnhancer {
  17.  
  18.     @Autowired
  19.     private UserDao userDao;
  20.  
  21.     /**
  22.      *
  23.      * @param oAuth2AccessToken
  24.      * @param oAuth2Authentication 根据它获取用户token
  25.      * @return
  26.      */
  27.     @Override
  28.     public OAuth2AccessToken enhance(OAuth2AccessToken oAuth2AccessToken, OAuth2Authentication oAuth2Authentication) {
  29.         Map<String, Object> info = new HashMap<>();
  30.         info.put("jwt-ext", "JWT 扩展信息");
  31.         User user = (User) oAuth2Authentication.getPrincipal();
  32.         if(user != null){
  33.             QueryWrapper queryWrapper = new QueryWrapper();
  34.             queryWrapper.eq("user_name", user.getUsername());
  35.             /** 只做认证，不做鉴权 */
  36.             UserPo userEntity = userDao.selectOne(queryWrapper);
  37.             info.put("userPo", userEntity); //也可以只把userId放在附加信息里面
  38.         }
  39.         ((DefaultOAuth2AccessToken) oAuth2AccessToken).setAdditionalInformation(info);
  40.         return oAuth2AccessToken;
  41.     }
  42.  
  43. }

添加JwtConfig配置类

  1. package com.example.config.jwt;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.security.oauth2.provider.token.TokenStore;
  6. import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
  7. import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
  8.  
  9. @Configuration
  10. public class JwtTokenConfig {
  11.  
  12.     @Bean
  13.     public TokenStore jwtTokenStore() {
  14.         return new JwtTokenStore(jwtAccessTokenConverter());
  15.     }
  16.  
  17.     @Bean
  18.     public JwtAccessTokenConverter jwtAccessTokenConverter() {
  19.         JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter();
  20.         accessTokenConverter.setSigningKey("mysecret"); //签名秘钥
  21.         return accessTokenConverter;
  22.     }
  23.  
  24. }

JwtAccessTokenConverter 是为了做 JWT 数据转换，这样做是因为 JWT 有自身独特的数据格式。如果没有了解过 JWT ，可以参考本人之前博客：https://blog.csdn.net/AkiraNicky/article/details/99307713

1.4 其它配置

配置全局统一异常处理：

  1. @RestControllerAdvice
  2. public class MyExceptionHandler {
  3.  
  4.     @ExceptionHandler(value = InvalidGrantException.class)
  5.     public Result exceptionHandler(InvalidGrantException e) {
  6.         return Result.error("用户名密码错误");
  7.     }
  8.  
  9. }

重写check_token：

  1. package com.example.controller;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.security.oauth2.common.exceptions.InvalidTokenException;
  7. import org.springframework.security.oauth2.provider.endpoint.CheckTokenEndpoint;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RequestParam;
  10. import org.springframework.web.bind.annotation.RestController;
  11.  
  12. import java.util.Map;
  13.  
  14. /**
  15.  * 重写check_token接口
  16.  */
  17. @RestController
  18. @RequestMapping("/oauth")
  19. public class TokenEndpointController {
  20.  
  21.     @Autowired
  22.     private CheckTokenEndpoint checkTokenEndpoint;
  23.  
  24.  
  25.     @RequestMapping("/check_token")
  26.     public String checkToken(@RequestParam("token") String token) {
  27.         Map<String, ?> stringMap;
  28.         try {
  29.             stringMap = checkTokenEndpoint.checkToken(token);
  30.         } catch (InvalidTokenException e) {
  31.             JSONObject err = new JSONObject();
  32.             err.put("error", "invalid_token");
  33.             err.put("error_description", "Token has expired");
  34.             return JSON.toJSONString(err);
  35.         }
  36.         return JSON.toJSONString(stringMap);
  37.     }
  38.  
  39. }

添加切面，/oauth/token端点请求的结果进行拦截封装处理：

  1. package com.example.aspect;
  2.  
  3. import com.example.entity.Result;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.springframework.http.HttpStatus;
  8. import org.springframework.http.ResponseEntity;
  9. import org.springframework.security.authentication.InsufficientAuthenticationException;
  10. import org.springframework.security.core.Authentication;
  11. import org.springframework.security.oauth2.common.OAuth2AccessToken;
  12. import org.springframework.security.oauth2.common.util.OAuth2Utils;
  13. import org.springframework.stereotype.Component;
  14.  
  15. import java.security.Principal;
  16. import java.util.Map;
  17.  
  18. /**
  19.  * 原理就是通过切面编程实现对/oauth/token端点请求的结果进行拦截封装处理，由于/oauth/token是Spring Cloud OAuth2的内部端点，因此需要对相关的Spring源码进行分析。最终定位到
  20.  *     org.springframework.security.oauth2.provider.endpoint.TokenEndpoint.postAccessToken（）
  21.  */
  22. @Component
  23. @Aspect
  24. public class AccessTokenAspect {
  25.  
  26.     @Around("execution(* org.springframework.security.oauth2.provider.endpoint.TokenEndpoint.postAccessToken(..))")
  27.     public Object handleControllerMethod(ProceedingJoinPoint joinPoint) throws Throwable {
  28.         Object[] args = joinPoint.getArgs();
  29.         Principal principal = (Principal) args[0];
  30.         if (!(principal instanceof Authentication)) {
  31.             throw new InsufficientAuthenticationException("There is no client authentication. Try adding an appropriate authentication filter.");
  32.         }
  33.         Map<String, String> parameters = (Map<String, String>) args[1];
  34.         String grantType = parameters.get(OAuth2Utils.GRANT_TYPE);
  35.         Object proceed = joinPoint.proceed();
  36.         if ("authorization_code".equals(grantType)) {
  37.             //如果使用 @EnableOAuth2Sso 注解不能修改返回格式，否则授权码模式可以统一改
  38.             return proceed;
  39.         } else {
  40.             ResponseEntity<OAuth2AccessToken> responseEntity = (ResponseEntity<OAuth2AccessToken>) proceed;
  41.             OAuth2AccessToken body = responseEntity.getBody();
  42.             return ResponseEntity.status(HttpStatus.OK).body(Result.success(body));
  43.         }
  44.     }
  45.  
  46. }

2. 搭建网关Gateway

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-gateway</artifactId>
  4.     <version>2.2.8.RELEASE</version>
  5. </dependency>
  6.        
  7. <dependency>
  8.     <groupId>org.springframework.cloud</groupId>
  9.     <artifactId>spring-cloud-starter-openfeign</artifactId>
  10.     <version>2.2.2.RELEASE</version>
  11. </dependency>
  1. server:
  2.   port: 8090
  3.  
  4. spring:
  5.   application:
  6.     name: gateway
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         server-addr: 127.0.0.1:8848
  11.     gateway:
  12.       discovery:
  13.         locator:
  14.           enabled: true
  15.           lower-case-service-id: true
  16.       routes:
  17.         - id: auth
  18.           uri: lb://auth-center
  19.           predicates:
  20.             - Path=/auth/**
  21.           filters:
  22.             - StripPrefix=1
  23.         - id: order
  24.           uri: lb://service-order
  25.           predicates:
  26.             - Path=/order/**
  27.           filters:
  28.             - StripPrefix=1
  29. whitelist:
  30.   token: "/auth/oauth/token,/user/user/getAuthentication,/order/order/testOrderWithoutToken,/auth/oauth/check_token"
  31.   param-sign: ""
  32. blacklist:
  33.   token: ""
  34.   param-sign: ""
  1. package com.example.config;
  2.  
  3.  
  4. import org.springframework.beans.factory.ObjectProvider;
  5. import org.springframework.boot.SpringBootConfiguration;
  6. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  7. import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.http.converter.HttpMessageConverter;
  10.  
  11. import java.util.stream.Collectors;
  12.  
  13. /**
  14.  * feign response 返回数据解析配置
  15.  */
  16. @SpringBootConfiguration
  17. public class FeignMessageConfig {
  18.  
  19.     @Bean
  20.     @ConditionalOnMissingBean
  21.     public HttpMessageConverters messageConverters(ObjectProvider<HttpMessageConverter<?>> converters) {
  22.         return new HttpMessageConverters(converters.orderedStream().collect(Collectors.toList()));
  23.     }
  24.  
  25. }
  1. @FeignClient(value = "auth-center")
  2. @Component
  3. public interface VerifyTokenFeign {
  4.  
  5.     @RequestMapping(value = "/oauth/check_token", method = RequestMethod.POST)
  6.     String verifyToken(@RequestParam(value="token") String token);
  7.  
  8. }
  1. package com.example.filter;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.example.feign.VerifyTokenFeign;
  6. import io.netty.buffer.UnpooledByteBufAllocator;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
  11. import org.springframework.cloud.gateway.filter.GlobalFilter;
  12. import org.springframework.core.Ordered;
  13. import org.springframework.core.io.buffer.NettyDataBufferFactory;
  14. import org.springframework.http.HttpHeaders;
  15. import org.springframework.http.HttpStatus;
  16. import org.springframework.http.server.reactive.ServerHttpRequest;
  17. import org.springframework.http.server.reactive.ServerHttpResponse;
  18. import org.springframework.stereotype.Component;
  19. import org.springframework.util.AntPathMatcher;
  20. import org.springframework.web.server.ServerWebExchange;
  21. import reactor.core.publisher.Flux;
  22. import reactor.core.publisher.Mono;
  23.  
  24. import java.nio.charset.StandardCharsets;
  25.  
  26. /**
  27.  *  请求token全局过滤
  28.  */
  29. @Component
  30. public class GlobalTokenFilter implements GlobalFilter, Ordered {
  31.  
  32.     private AntPathMatcher antPathMatcher = new AntPathMatcher();
  33.  
  34.     @Autowired
  35.     private VerifyTokenFeign verifyTokenFeign;
  36.  
  37.     // 白名单
  38.     @Value(value = "${whitelist.token}")
  39.     private String whitelist;
  40.  
  41.     @Override
  42.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  43.         ServerHttpRequest request = exchange.getRequest();
  44.         String urlPath = request.getPath().toString();
  45.         boolean action = false;
  46.         String[] whitelistArray = whitelist.split(",");
  47.         for (String url : whitelistArray) {
  48.             if (antPathMatcher.match(url, urlPath)) {
  49.                 action = true;
  50.                 break;
  51.             }
  52.         }
  53.         if (action) return chain.filter(exchange); //白名单，放行
  54.  
  55.         String token = request.getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
  56.         if (StringUtils.isNotBlank(token)) {
  57. //            token = token.substring(7);
  58.             String verifyToken = verifyTokenFeign.verifyToken(token);
  59.             if (StringUtils.isNotBlank(verifyToken)) {
  60.                 JSONObject verifyTokenJson = JSON.parseObject(verifyToken);
  61.                 if (verifyTokenJson.containsKey("active") && verifyTokenJson.getBoolean("active")) { //JWT验证Token固定格式
  62.                     return chain.filter(exchange);
  63.                 }
  64.             }
  65.         }
  66.         return unAuthorized(exchange);
  67.     }
  68.  
  69.     /**
  70.      * 认证未通过
  71.      */
  72.     public Mono<Void> unAuthorized(ServerWebExchange exchange) {
  73.         ServerHttpResponse response = exchange.getResponse();
  74.         response.setStatusCode(HttpStatus.OK);
  75.         response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
  76.         JSONObject message = new JSONObject();
  77.         message.put("code", "-2");
  78.         message.put("msg", "登录失效，请重新登录");
  79.         return response.writeWith(Flux.create(sink -> {
  80.             sink.next(new NettyDataBufferFactory(new UnpooledByteBufAllocator(false)).wrap(message.toJSONString().getBytes(StandardCharsets.UTF_8)));
  81.             sink.complete();
  82.         }));
  83.     }
  84.  
  85.     @Override
  86.     public int getOrder() {
  87.         return 0;
  88.     }
  89. }

3. 测试

新开个order服务，写个测试接口 ：

  1. package com.example.controller;
  2.  
  3. import com.example.entity.Result;
  4. import io.swagger.annotations.Api;
  5. import io.swagger.annotations.ApiOperation;
  6. import org.springframework.web.bind.annotation.PostMapping;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  9.  
  10.  
  11. @Api(tags = "订单模块")
  12. @RestController
  13. @RequestMapping("/order/")
  14. public class OrderController {
  15.  
  16.     @ApiOperation("测试订单-验证token")
  17.     @PostMapping("testOrder")
  18.     public Result testOrder(){
  19.         return Result.success("testOrder");
  20.     }
  21.  
  22.  
  23.     @ApiOperation("测试订单-不验证token")
  24.     @PostMapping("testOrderWithoutToken")
  25.     public Result testOrderWithoutToken(){
  26.         return Result.success("testOrderWithoutToken");
  27.     }
  28.  
  29. }

 由于我在数据库设置的order-client过期时间为一分钟，所以一分钟之内携带token是可以随意请求testOrder的，但是token一旦失效则返回“登录失效，请重新登录”。而testOrderWithoutToken接口在白名单中，gateway过滤器不会校验token，所以不需要token也可以访问：

关于用户无感知刷新token

        用户登录，后端验证用户成功之后生成两个token，这两个token分别是access_token（访问接口使用的token）、refresh_token（access_token过期后用于刷续期的token，注意设置refresh_token的过期时间需比access_token的过期时间长），后端将用户信息和这两个token存放到redis中并返回给前端并存储。

为什么需要刷新令牌？

        如果access token超时时间很长，比如14天，由于第三方软件获取受保护资源都要带着access token，这样access token的攻击面就比较大。如果access token超时时间很短，比如1个小时，那其超时之后就需要用户再次授权，这样的频繁授权导致用户体验不好。引入refresh token，就解决了该矛盾。

什么时候使用刷新令牌呢？

定时检测方式

        在第三方软件收到访问令牌的同时，也会收到访问令牌的过期时间expires_in。一个设计良好的第三方应用，应该将expires_in值保存下来并定时检测；如果发现expires_in即将过期，则需要利用refresh_token去重新请求授权服务，以便获取新的、有效的访问令牌。

现场发现方式

        比如第三方软件访问受保护资源的时候，突然收到一个访问令牌失效的响应，此时第三方软件立即使用refresh_token来请求一个访问令牌，以便继续代表用户使用他的数据。

由于order-client在数据库配置的access_token过期时间为60秒，refresh_token过期时间为36000秒，所以token过期后将请求不到后台资源，此时可以用refresh_token去重新获取token，客户端重新保存token即可，如果refresh_token也过期，让用户重新登录即可。

注意：如果不设置access_token_validity和refresh_token_validity，则会采用默认值：access_token_validity默认60 * 60 * 12 秒（12小时），refresh_token_validity默认默认60 *60 * 24 * 30秒 （30天）

在使用刷新令牌的时候，也是需要应用传递它的app_id和app_sercet的。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号