• JustAuth扩展：支持自动获得回调域名、使用redission作为Cache

    当前使用的版本：
     

    just_auth_version = '1.16.6'
just_auth_starter_version = '1.4.0'

    "me.zhyd.oauth:JustAuth:${just_auth_version}", //多渠道登录
"com.xkcoding.justauth:justauth-spring-boot-starter:${just_auth_starter_version}" //启动器

    在JustAuth整合过程中，遇到两个功能扩展：
    1）JustAuth默认使用sping-data-redis作为缓存接口，当前系统没有使用该redis驱动，由于已经使用了redission，不希望引入更多的架构。故需要扩展JustAuthCache接口
    2）JustAuth配置的登录回调地址必须写完整的域名。本着从哪里来，回哪里去的原则，回调的域名地址，95%需求都会跟请求的域名地址一致。这样只需要在请求时获得请求的域名地址即可，不用在配置文件里额外配置。让配置文件的redirect-uri真正成为URI而不是URL

    自定义缓存

    自定义缓存按照文档的扩展即可，项目使用redission，如下定义一个CacheBean

    1. package org.ccframe.commons.auth;
    2.  
    3. import me.zhyd.oauth.cache.AuthStateCache;
    4. import org.ccframe.config.GlobalEx;
    5. import org.redisson.api.RBucket;
    6. import org.redisson.api.RedissonClient;
    7. import org.redisson.client.codec.StringCodec;
    8.  
    9. import java.util.concurrent.TimeUnit;
    10.  
    11. /**
    12.  * JustAuth三方登录缓存管理.
    13.  * @author Jim 2024/03/08
    14.  */
    15. public class CcAuthStateCache implements AuthStateCache {
    16.  
    17.     private RedissonClient redissonClient;
    18.  
    19.     public CcAuthStateCache(RedissonClient redissonClient){
    20.         this.redissonClient = redissonClient;
    21.     }
    22.  
    23.     /**
    24.      * 存入缓存
    25.      *
    26.      * @param key   缓存key
    27.      * @param value 缓存内容
    28.      */
    29.     @Override
    30.     public void cache(String key, String value) {
    31.         RBucket bucket = redissonClient.getBucket(GlobalEx.CACHEREGION_THIRD_AUTH + key);
    32.         bucket.set(value, 10, TimeUnit.MINUTES); // 10分钟还无法三方绑定的登录，则无法进行绑定
    33.     }
    34.  
    35.     /**
    36.      * 存入缓存
    37.      *
    38.      * @param key     缓存key
    39.      * @param value   缓存内容
    40.      * @param timeout 指定缓存过期时间（毫秒）
    41.      */
    42.     @Override
    43.     public void cache(String key, String value, long timeout) {
    44.         RBucket bucket = redissonClient.getBucket(GlobalEx.CACHEREGION_THIRD_AUTH + key, StringCodec.INSTANCE);
    45.         bucket.set(value, timeout, TimeUnit.MILLISECONDS);
    46.     }
    47.  
    48.     /**
    49.      * 获取缓存内容
    50.      *
    51.      * @param key 缓存key
    52.      * @return 缓存内容
    53.      */
    54.     @Override
    55.     public String get(String key) {
    56.         RBucket bucket = redissonClient.getBucket(GlobalEx.CACHEREGION_THIRD_AUTH + key, StringCodec.INSTANCE);
    57.         return bucket.get();
    58.     }
    59.  
    60.     /**
    61.      * 是否存在key，如果对应key的value值已过期，也返回false
    62.      *
    63.      * @param key 缓存key
    64.      * @return true：存在key，并且value没过期；false：key不存在或者已过期
    65.      */
    66.     @Override
    67.     public boolean containsKey(String key) {
    68.         return redissonClient.getBucket(GlobalEx.CACHEREGION_THIRD_AUTH + key).isExists();
    69.     }
    70. }

    实现真正的REDIRECT URI

    先看看实现后的效果，整合后，CcFrame的公共配置只需要如下配置：
     

    1. justauth:
    2.   enabled: false #原来的关闭掉，因为自己写了个新的CcAuthRequestFactory,使用下面的开关
    3.   cc-enabled: true
    4.   cache:
    5.     type: custom
    6.   type:
    7.     QQ: #前台登录
    8.       client-id: ${app.third-oauth.QQ.client-id:}
    9.       client-secret: ${app.third-oauth.QQ.client-secret:}
    10.       redirect-uri: /api/common/thirdOauthCallback/qq
    11.       union-id: false
    12.     GITEE: #后台登录
    13.       client-id: ${app.third-oauth.GITEE.client-id:}
    14.       client-secret: ${app.third-oauth.GITEE.client-secret:}
    15.       redirect-uri: /admin/common/thirdOauthCallback/gitee
    16.     DINGTALK: #后台登录
    17.       client-id: ${app.third-oauth.DINGTALK.client-id:}
    18.       client-secret: ${app.third-oauth.DINGTALK.client-secret:}
    19.       redirect-uri: /admin/common/thirdOauthCallback/dingtalk

    redirect-uri不关心回调地址从哪里来，这样便省去了不同项目域名地址之间差异，我只关心URI

    而项目里的配置则更简单：

    1. app:
    2.   third-oauth:
    3.     GITEE:
    4.       client-id: ??
    5.       client-secret: ??

    即可针对不同的项目及环境实现接入。

    扩展点如下：
    针对不支持URI的问题，本打算extend AuthRequestFactory的，结果发现大部分方法都private了，不方便扩展。再检查下用法发现引入的地方是在用户代码部分，因此索性复制了重写了

    1. /*
    2.  * Copyright (c) 2019-2029, xkcoding & Yangkai.Shen & 沈扬凯 (237497819@qq.com & xkcoding.com).
    3.  * 
    4.  * Licensed under the GNU LESSER GENERAL PUBLIC LICENSE 3.0;
    5.  * you may not use this file except in compliance with the License.
    6.  * You may obtain a copy of the License at
    7.  * 
    8.  * http://www.gnu.org/licenses/lgpl.html
    9.  * 
    10.  * Unless required by applicable law or agreed to in writing, software
    11.  * distributed under the License is distributed on an "AS IS" BASIS,
    12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13.  * See the License for the specific language governing permissions and
    14.  * limitations under the License.
    15.  *
    16.  */
    17.  
    18. package org.ccframe.commons.auth;
    19.  
    20. import cn.hutool.core.collection.CollUtil;
    21. import cn.hutool.core.util.EnumUtil;
    22. import cn.hutool.core.util.ReflectUtil;
    23. import cn.hutool.core.util.StrUtil;
    24. import com.xkcoding.http.config.HttpConfig;
    25. import com.xkcoding.justauth.autoconfigure.ExtendProperties;
    26. import com.xkcoding.justauth.autoconfigure.JustAuthProperties;
    27. import lombok.RequiredArgsConstructor;
    28. import lombok.extern.slf4j.Slf4j;
    29. import me.zhyd.oauth.cache.AuthStateCache;
    30. import me.zhyd.oauth.config.AuthConfig;
    31. import me.zhyd.oauth.config.AuthDefaultSource;
    32. import me.zhyd.oauth.config.AuthSource;
    33. import me.zhyd.oauth.enums.AuthResponseStatus;
    34. import me.zhyd.oauth.exception.AuthException;
    35. import me.zhyd.oauth.request.*;
    36. import org.springframework.beans.BeanUtils;
    37. import org.springframework.util.CollectionUtils;
    38.  
    39. import java.net.InetSocketAddress;
    40. import java.net.Proxy;
    41. import java.util.ArrayList;
    42. import java.util.HashMap;
    43. import java.util.List;
    44. import java.util.Map;
    45. import java.util.stream.Collectors;
    46.  
    47. /**
    48.  * private引入太多，直接复制了改了.
    49.  *
    50.  * 
    51.  * AuthRequest工厂类
    52.  * 
    53.  *
    54.  * @author yangkai.shen
    55.  * @date Created in 2019-07-22 14:21
    56.  */
    57. @Slf4j
    58. @RequiredArgsConstructor
    59. public class CcAuthRequestFactory {
    60.     private final JustAuthProperties properties;
    61.     private final AuthStateCache authStateCache;
    62.  
    63.     /**
    64.      * 返回当前Oauth列表
    65.      *
    66.      * @return Oauth列表
    67.      */
    68.     @SuppressWarnings({"unchecked", "rawtypes"})
    69.     public List oauthList() {
    70.         // 默认列表
    71.         List defaultList = new ArrayList<>(properties.getType().keySet());
    72.         // 扩展列表
    73.         List extendList = new ArrayList<>();
    74.         ExtendProperties extend = properties.getExtend();
    75.         if (null != extend) {
    76.             Class enumClass = extend.getEnumClass();
    77.             List names = EnumUtil.getNames(enumClass);
    78.             // 扩展列表
    79.             extendList = extend.getConfig()
    80.                     .keySet()
    81.                     .stream()
    82.                     .filter(x -> names.contains(x.toUpperCase()))
    83.                     .map(String::toUpperCase)
    84.                     .collect(Collectors.toList());
    85.         }
    86.  
    87.         // 合并
    88.         return (List) CollUtil.addAll(defaultList, extendList);
    89.     }
    90.  
    91.     /**
    92.      * 返回AuthRequest对象
    93.      *
    94.      * @param source {@link AuthSource}
    95.      * @param requestBaseUrl redirectUri 请求URI的前缀，这样配置里只需要写URI了
    96.      * @return {@link AuthRequest}
    97.      */
    98.     public AuthRequest get(String source, String requestBaseUrl) {
    99.         if (StrUtil.isBlank(source)) {
    100.             throw new AuthException(AuthResponseStatus.NO_AUTH_SOURCE);
    101.         }
    102.  
    103.         // 获取 JustAuth 中已存在的
    104.         AuthRequest authRequest = getDefaultRequest(source, requestBaseUrl);
    105.  
    106.         // 如果获取不到则尝试取自定义的
    107.         if (authRequest == null) {
    108.             authRequest = getExtendRequest(properties.getExtend().getEnumClass(), source);
    109.         }
    110.  
    111.         if (authRequest == null) {
    112.             throw new AuthException(AuthResponseStatus.UNSUPPORTED);
    113.         }
    114.  
    115.         return authRequest;
    116.     }
    117.  
    118.     /**
    119.      * 获取自定义的 request
    120.      *
    121.      * @param clazz  枚举类 {@link AuthSource}
    122.      * @param source {@link AuthSource}
    123.      * @return {@link AuthRequest}
    124.      */
    125.     @SuppressWarnings({"unchecked", "rawtypes"})
    126.     private AuthRequest getExtendRequest(Class clazz, String source) {
    127.         String upperSource = source.toUpperCase();
    128.         try {
    129.             EnumUtil.fromString(clazz, upperSource);
    130.         } catch (IllegalArgumentException e) {
    131.             // 无自定义匹配
    132.             return null;
    133.         }
    134.  
    135.         Map extendConfig = properties.getExtend().getConfig();
    136.  
    137.         // key 转大写
    138.         Map upperConfig = new HashMap<>(6);
    139.         extendConfig.forEach((k, v) -> upperConfig.put(k.toUpperCase(), v));
    140.  
    141.         ExtendProperties.ExtendRequestConfig extendRequestConfig = upperConfig.get(upperSource);
    142.         if (extendRequestConfig != null) {
    143.  
    144.             // 配置 http config
    145.             configureHttpConfig(upperSource, extendRequestConfig, properties.getHttpConfig());
    146.  
    147.             Classextends AuthRequest> requestClass = extendRequestConfig.getRequestClass();
    148.  
    149.             if (requestClass != null) {
    150.                 // 反射获取 Request 对象，所以必须实现 2 个参数的构造方法
    151.                 return ReflectUtil.newInstance(requestClass, (AuthConfig) extendRequestConfig, authStateCache);
    152.             }
    153.         }
    154.  
    155.         return null;
    156.     }
    157.  
    158.  
    159.     /**
    160.      * 获取默认的 Request
    161.      *
    162.      * @param source {@link AuthSource}
    163.      * @return {@link AuthRequest}
    164.      */
    165.     private AuthRequest getDefaultRequest(String source, String requestBaseUrl) {
    166.         AuthDefaultSource authDefaultSource;
    167.  
    168.         try {
    169.             authDefaultSource = EnumUtil.fromString(AuthDefaultSource.class, source.toUpperCase());
    170.         } catch (IllegalArgumentException e) {
    171.             // 无自定义匹配
    172.             return null;
    173.         }
    174.  
    175.         AuthConfig config = properties.getType().get(authDefaultSource.name());
    176.         // 找不到对应关系，直接返回空
    177.         if (config == null) {
    178.             return null;
    179.         }
    180.         if(!config.getRedirectUri().startsWith("http")){ // 克隆并修改回调地址
    181.             AuthConfig newConfig = new AuthConfig();
    182.             BeanUtils.copyProperties(config, newConfig);
    183.             newConfig.setRedirectUri(requestBaseUrl + newConfig.getRedirectUri());
    184.             config = newConfig;
    185.         }
    186.  
    187.         // 配置 http config
    188.         configureHttpConfig(authDefaultSource.name(), config, properties.getHttpConfig());
    189.  
    190.         switch (authDefaultSource) {
    191.             case GITHUB:
    192.                 return new AuthGithubRequest(config, authStateCache);
    193.             case WEIBO:
    194.                 return new AuthWeiboRequest(config, authStateCache);
    195.             case GITEE:
    196.                 return new AuthGiteeRequest(config, authStateCache);
    197.             case DINGTALK:
    198.                 return new AuthDingTalkRequest(config, authStateCache);
    199.             case DINGTALK_ACCOUNT:
    200.                 return new AuthDingTalkAccountRequest(config, authStateCache);
    201.             case BAIDU:
    202.                 return new AuthBaiduRequest(config, authStateCache);
    203.             case CSDN:
    204.                 return new AuthCsdnRequest(config, authStateCache);
    205.             case CODING:
    206.                 return new AuthCodingRequest(config, authStateCache);
    207.             case OSCHINA:
    208.                 return new AuthOschinaRequest(config, authStateCache);
    209.             case ALIPAY:
    210.                 return new AuthAlipayRequest(config, authStateCache);
    211.             case QQ:
    212.                 return new AuthQqRequest(config, authStateCache);
    213.             case WECHAT_OPEN:
    214.                 return new AuthWeChatOpenRequest(config, authStateCache);
    215.             case WECHAT_MP:
    216.                 return new AuthWeChatMpRequest(config, authStateCache);
    217.             case WECHAT_ENTERPRISE:
    218.                 return new AuthWeChatEnterpriseQrcodeRequest(config, authStateCache);
    219.             case WECHAT_ENTERPRISE_WEB:
    220.                 return new AuthWeChatEnterpriseWebRequest(config, authStateCache);
    221.             case TAOBAO:
    222.                 return new AuthTaobaoRequest(config, authStateCache);
    223.             case GOOGLE:
    224.                 return new AuthGoogleRequest(config, authStateCache);
    225.             case FACEBOOK:
    226.                 return new AuthFacebookRequest(config, authStateCache);
    227.             case DOUYIN:
    228.                 return new AuthDouyinRequest(config, authStateCache);
    229.             case LINKEDIN:
    230.                 return new AuthLinkedinRequest(config, authStateCache);
    231.             case MICROSOFT:
    232.                 return new AuthMicrosoftRequest(config, authStateCache);
    233.             case MI:
    234.                 return new AuthMiRequest(config, authStateCache);
    235.             case TOUTIAO:
    236.                 return new AuthToutiaoRequest(config, authStateCache);
    237.             case TEAMBITION:
    238.                 return new AuthTeambitionRequest(config, authStateCache);
    239.             case RENREN:
    240.                 return new AuthRenrenRequest(config, authStateCache);
    241.             case PINTEREST:
    242.                 return new AuthPinterestRequest(config, authStateCache);
    243.             case STACK_OVERFLOW:
    244.                 return new AuthStackOverflowRequest(config, authStateCache);
    245.             case HUAWEI:
    246.                 return new AuthHuaweiRequest(config, authStateCache);
    247.             case GITLAB:
    248.                 return new AuthGitlabRequest(config, authStateCache);
    249.             case KUJIALE:
    250.                 return new AuthKujialeRequest(config, authStateCache);
    251.             case ELEME:
    252.                 return new AuthElemeRequest(config, authStateCache);
    253.             case MEITUAN:
    254.                 return new AuthMeituanRequest(config, authStateCache);
    255.             case TWITTER:
    256.                 return new AuthTwitterRequest(config, authStateCache);
    257.             case FEISHU:
    258.                 return new AuthFeishuRequest(config, authStateCache);
    259.             case JD:
    260.                 return new AuthJdRequest(config, authStateCache);
    261.             case ALIYUN:
    262.                 return new AuthAliyunRequest(config, authStateCache);
    263.             case XMLY:
    264.                 return new AuthXmlyRequest(config, authStateCache);
    265.             case AMAZON:
    266.                 return new AuthAmazonRequest(config, authStateCache);
    267.             case SLACK:
    268.                 return new AuthSlackRequest(config, authStateCache);
    269.             case LINE:
    270.                 return new AuthLineRequest(config, authStateCache);
    271.             case OKTA:
    272.                 return new AuthOktaRequest(config, authStateCache);
    273.             default:
    274.                 return null;
    275.         }
    276.     }
    277.  
    278.     /**
    279.      * 配置 http 相关的配置
    280.      *
    281.      * @param authSource {@link AuthSource}
    282.      * @param authConfig {@link AuthConfig}
    283.      */
    284.     private void configureHttpConfig(String authSource, AuthConfig authConfig, JustAuthProperties.JustAuthHttpConfig httpConfig) {
    285.         if (null == httpConfig) {
    286.             return;
    287.         }
    288.         Map proxyConfigMap = httpConfig.getProxy();
    289.         if (CollectionUtils.isEmpty(proxyConfigMap)) {
    290.             return;
    291.         }
    292.         JustAuthProperties.JustAuthProxyConfig proxyConfig = proxyConfigMap.get(authSource);
    293.  
    294.         if (null == proxyConfig) {
    295.             return;
    296.         }
    297.  
    298.         authConfig.setHttpConfig(HttpConfig.builder()
    299.                 .timeout(httpConfig.getTimeout())
    300.                 .proxy(new Proxy(Proxy.Type.valueOf(proxyConfig.getType()), new InetSocketAddress(proxyConfig.getHostname(), proxyConfig.getPort())))
    301.                 .build());
    302.     }
    303. }

    这样一来，实际调用的时候，Autowire CcAuthRequestFactory而不是AuthRequestFactory。而在get方法的时候，增加了requestBaseUrl调用用来自动添加前缀地址。requestBaseUrl则是从Controller请求自动从前端请求抓取而来：
     

    1.     @Autowired
    2.     private CcAuthRequestFactory factory;
    3.  
    4.  
    5.     @GetMapping(value = "thirdOauth")
    6.     @ApiOperation(value = "三方登录并跳转")
    7.     @SneakyThrows
    8.     public void thirdOauth(String type,@ApiIgnore RequestSite adminSite, HttpServletResponse response){ //跳转三方登录，换取code等
    9.         AuthRequest authRequest = factory.get(type, adminSite.getRequestBaseUrl());
    10.         response.setStatus(302); //支持HTTP重定向到HTTPS
    11.         response.sendRedirect(authRequest.authorize(AuthStateUtils.createState()));
    12.     }

    BTW.三方登录的请求开关也被改了，使用cc-enabled而不是enabled，避免将原来的RequestFactory也自动初始化

    至于RequestSite adminSite如何自动注入的请看我的另一篇文章，你注入ServletHttpRequest去实现一样。

    这样便支持了前面配置文件里的直接书写URI，URL则是调用Controller的请求域名及IP：
    redirect-uri: /api/common/thirdOauthCallback/qq

    配置省事了，省一点算一点，优秀的系统必须是一点点简化而来的

  • 相关阅读:
    【康耐视国产案例】智能AI相机机器视觉精准快速实现包裹标签的智能粘贴
    vue-自适应布局-postcss-pxtorem
    【Webpack】CSS 处理
    ChatGPT 最近一年的发展情况回顾、以及我们关心的数据安全问题
    【Python机器学习】零基础掌握ShrunkCovariance协方差估计
    C++ getline()：从文件中读取一行字符串
    Upstream Consistent Hash
    驱动开发：内核封装WSK网络通信接口
    Maven：一个下载jar依赖失败的问题解决方案
    Vue中实现div的任意移动
  • 原文地址：https://blog.csdn.net/applebomb/article/details/136599256