Java API获取微盟token信息详解

迷南。 2022-09-02 05:20 389阅读 0赞

### Java API获取微盟token信息详解 ###

*  1. 业务概述
 *   *  1.1 业务需求
     *  1.2 实现方案
 *  2. 流程对接
 *  3. 授权实现
 *   *  3.1 IDEA HTTP Client实现
     *  3.2 代码实现

# 1. 业务概述 #

## 1.1 业务需求 ##

业务开发中需要对接微盟开放平台，同步微店商品信息，因此需要获取token信息，微盟开放平台在提供的方案是通过授权码获取token，通过刷新token获取新的token信息，但是存在一个问题就是，获取授权码没有通过API的形式，也就是说你需要不停的刷新token，来保持新的token的可用性，一旦刷新中断，需要手动获取授权码信息。  
目前市场上满足OAuth2.0协议的产品springsecurity，提供了四种获取token的方式，可以满足不同应用场景，但是微盟这种通过code授权码的方式着实不太友好，对于后端开发来说。  
详细对接文档：[https://cloud.weimob.com/saas/word/detail.html?tag=564&menuId=2][https_cloud.weimob.com_saas_word_detail.html_tag_564_menuId_2]

操作文档写的很详细，就不在赘述了。  
本篇文章是为了实现通过springboot+openfeign+redis实现。  
openFeign实现动态url调用rest接口，redis用来存储code，accessToken，refreshToken。

## 1.2 实现方案 ##

实现方案：通过微盟后台应用配置接收code的url，每次授权需要到微盟后台点击授权，会通过GET方式自动跳转到配置URL并把code与stste一同拼接到url带过去，只需要提供可访问的rest api即可，拿到code放入缓存以便获取accessToken使用，通过定时任务获取accessToken，同时将accessToken与refreshToken放入缓存，然后通过定时任务在accessToken失效时间内通过refreshToken不间断的刷新accessToken，保证accessToken可用性。  
需要注意的是，微商城的授权码与智慧酒店的授权码是互不通用的，而且不同的店铺的授权码也是不能通用，比如普通店铺与豪华版店铺是不通的，授权码只能使用一次，且有哟有效时间。

# 2. 流程对接 #

1.登录微盟后台：https://account.weimob.com/login.html  
2.进入对应的解决方案店铺-开发者中心  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70] 3.创建应用，应用名称和简介自行填写  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 1] 4.查看应用，获取CLIENT\_ID及CLIENT\_SECRET  
①应用列表中，点击“API权限”查看CLIENT\_ID及CLIENT\_SECRET（可复制出放在TXT文档中，便于后续拼接请求链接）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 2]②点击“配置”，填写应用跳转地址（填一个可以正常跳转地址，该地址用于接收平台code等），跳转地址用来接收code使用。这里可以配置一个可以使用的地址即可，但是无法通过后台自动接收code，比如通过www.baidu.com，选择店铺点击授权，会跳到百度页面并带上code，如果配置一个自定义的API，就可以实现后台自动接收code。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 3]5.获取授权码，点击授权，选择店铺  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 4]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 5]  
6.跳转地址获取授权码code=eBEOs3  
https://www.baidu.com/?code=eBEOs3&state=custom

# 3. 授权实现 #

## 3.1 IDEA HTTP Client实现 ##

idea httpclient可以，postman也行，客户端工具不同而已，直接替换对应参数即可。

### 认证授权服务
    ### 获取授权码
    POST https://dopen.weimob.com/fuwu/b/oauth2/authorize?enter=wm&view=pc&response_type=code&scope=default&client_id=4BF157FC5EE220830E81454632F75644&redirect_uri=http://www.baidu.com
    Accept：*/* Cache-Control：no-cache content-type：application/json ### 1.授权码模式，通过授权码获取token信息 POST https://dopen.weimob.com/fuwu/b/oauth2/token?code=63UBsO&grant_type=authorization_code&client_id=4BF157FC5EE220830E81454632F75644&client_secret=B1FF2DB406E79EA68995324F6C4E8586&redirect_uri=http://www.baidu.com Accept：*/*
    Cache-Control：no-cache
    
    ### 刷新token
    POST https://dopen.weimob.com/fuwu/b/oauth2/token?grant_type=refresh_token&client_id=4BF157FC5EE220830E81454632F75644&client_secret=B1FF2DB406E79EA68995324F6C4E8586&refresh_token=73c786f9-4225-4940-ae28-1cf3e5f8ffa7
    Accept：*/* Cache-Control：no-cache ### 微商城-商品列表 POST https://dopen.weimob.com/api/1_0/ec/goods/querySimpleGoodsListWithPage?accesstoken=117c0087-f70a-4287-8ea0-92c92786023d Accept：*/*
    Cache-Control：no-cache
    Connection：keep-alive
    Content-Type：application/json
    
    { 
      "pageNum": 1,
      "pageSize": 20,
      "orderBy": { 
        "field": "sortNum",
        "sort": "desc"
      },
      "queryParameter": { 
        "goodsStatus": 0,
        "goodsClassifyId": 131200,
        "search": "商品"
      }
    }
    
    ###

## 3.2 代码实现 ##

1.创建springboot项目  
2.接口实现，这里就不写controller，以及配置文件，核心实现类仅供参考。且都是以获取code为前提。  
需要注意的是，接收code的接口一定要通过controller通过出去外网可用，否则跳转后接收不到code。

公共常量：CommonConstant

/** * 公共常量 * * @author zrj * @since 2021/7/21 **/
    public class CommonConstant { 
    
        /** * 执行成功 */
        public static final String RDFA_RESULT_SUCCESS_CODE = "200";
        public static final String RDFA_RESULT_SUCCESS_MSG = "执行成功";
        /** * 执行失败 */
        public static final String RDFA_RESULT_FAIL_CODE = "500";
        public static final String RDFA_RESULT_FAIL_MSG = "执行失败";
    
        /** * 升降/降序 DESC/ASC，只能是这两个值，不区分大小写 */
        public static final String SORT_DESC = "DESC";
        public static final String SORT_ASC = "ASC";
    
        /** * 查询商品最大每页数量 */
        public static final Integer GOODS_MAX_PAGE_SIZE = 20;
        /** * 查询商品最小开始 */
        public static final Long GOODS_ID_MIN_START = 0L;
        /** * 查询商品最大每页数量 */
        public static final Integer STORE_MAX_PAGE_SIZE = 50;
    
        /** * 商品表 */
        public static final String SEARCH_GOOD = "search_goods";
        /** * 酒店表 */
        public static final String SEARCH_STORE = "search_store";
        /** * 直播表 */
        public static final String LIVE_ROOM = "live_room";
        /** * 攻略 */
        public static final String TRAVEL_GUIDE = "travel_guide";
        /** * 玩乐 */
        public static final String PLAY = "play";
        /** * 游记 */
        public static final String TRAVEL = "travel";
    
        /** * 微盟配置信息 */
        public static final String WEIMOB_PRE = "https://dopen.weimob.com/fuwu/b/oauth2/token?";
    
        public static final String GOODS_CODE = "xR6hTz";
        public static final String GOODS_CLIENT_ID = "613BE0675B1761598496A65259EEC6DA";
        public static final String GOODS_CLIENT_SECRET = "0AF68FBEB4E1D9232C1C45F629903BE5";
        public static final String GOODS_REDIRECT_URI = "http://genius.enn.cn/ennova-tour-api/app/search/getgoodscode";
    
        public static final String STORE_CODE = "FIKhbJ";
        public static final String STORE_CLIENT_ID = "86CED15582358E553B2D0E85E6DE71CE";
        public static final String STORE_CLIENT_SECRET = "CB7E35B1DBD789831D83533903C44527";
        public static final String STORE_REDIRECT_URI = "http://genius.enn.cn/ennova-tour-api/app/search/getstorecode";
    
        public static final String ACCESS_GRANT_TYPE = "authorization_code";
        public static final String REFRESH_GRANT_TYPE = "refresh_token";
    
        public static final String WEIMOB_GOODS_AUTH_CODE_KEY = "weimob_goods_auth_code";
        public static final String WEIMOB_GOODS_ACCESS_TOKEN_KEY = "weimob_goods_access_token";
        public static final String WEIMOB_GOODS_REFRESH_TOKEN_KEY = "weimob_goods_refresh_token";
    
        public static final String WEIMOB_STORE_AUTH_CODE_KEY = "weimob_store_auth_code";
        public static final String WEIMOB_STORE_ACCESS_TOKEN_KEY = "weimob_store_access_token";
        public static final String WEIMOB_STORE_REFRESH_TOKEN_KEY = "weimob_store_refresh_token";
    
        // 商品，酒店请求地址
        public static final String goodsRedictUri = "https://dopen.weimob.com/api/1_0/ec/goods/queryGoodsList?accesstoken=";
        public static final String storeRedictUri = "https://dopen.weimob.com/api/1_0/hotel/store/getStoreList?accesstoken=";
        public static final String GOODS_DETAIL_REDIRECT_URL = "https://dopen.weimob.com/api/1_0/ec/goods/queryGoodsDetail?accesstoken=";
    
        /** * 搜索平台配置信息 */
        public static final String SEARCH_INSERT_URI = "https://rdfa-gateway.dev.ennew.com/search-api/operate/insertDoc";
        public static final String SEARCH_SELECT_URI = "https://rdfa-gateway.dev.ennew.com/search-api/search/generalBasicSearch";
        public static final String SEARCH_APP_ID = "realtime";
        public static final String SEARCH_TENANT_ID = "1415914351690682370";
        public static final String SEARCH_INDEX_GROUP_ID = "10047";
        public static final String SEARCH_INDEX_GROUP_NAME = "ennova-tour-search";
    
        public static final String SEARCH_CONTENT_SQL_PRE = "SELECT * FROM tour-search where searchName=match_query('";
        public static final String SEARCH_CONTENT_SQL_SUFFIX = "') order by createTime DESC";
        public static final String WATER_FALL_SQL_PRE = "";
        public static final String WATER_FALL_SQL_SUFFIX = "";
    
    }

微盟鉴权接口：WeimobAuthorizeService

import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.stereotype.Service;
    import org.springframework.web.bind.annotation.PostMapping;
    
    import java.net.URI;
    import java.util.LinkedHashMap;
    
    /** * 微盟鉴权接口 * * @author zrj * @since 2021/7/22 **/
    @Service("WeimobAuthorizeService")
    @FeignClient(url = "https://dopen.weimob.com/fuwu/b/oauth2", name = "WeimobAuthorizeService")
    public interface WeimobAuthorizeService { 
    
        /** * 获取授权码 * 目前微盟暂不提供api方式获取授权码 */
        @PostMapping
        LinkedHashMap getAuthCode(URI uri);
    
        /** * 获取access_token */
        @PostMapping
        LinkedHashMap getAcessToken(URI uri);
    
        /** * 获取refresh_token */
        @PostMapping
        LinkedHashMap getRefreshToken(URI uri);
    
    }

微盟授权接口：WeimobTokenService

import top.rdfa.framework.biz.ro.RdfaResult;
    
    /** * 微盟获取token接口 * * @author zrj * @since 2021/7/30 **/
    public interface WeimobTokenService { 
        /** * 获取商品授权码 */
        RdfaResult getGoodsAuthCode(String code, String state);
    
        /** * 获取酒店授权码 */
        RdfaResult getStoreAuthCode(String code, String state);
    
        /** * 获取商品access_token */
        RdfaResult getGoodsAccessToken();
    
        /** * 获取商品refresh_token */
        RdfaResult getGoodsRefreshToken();
    
        /** * 获取酒店access_token */
        RdfaResult getStoreAccessToken();
    
        /** * 获取酒店refresh_token */
        RdfaResult getStoreRefreshToken();
    }

微盟授权实现类：WeimobTokenServiceImpl

import cn.hutool.core.collection.CollectionUtil;
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.json.JSONUtil;
    import com.ennova.tour.search.core.service.WeimobTokenService;
    import com.ennova.tour.search.core.service.constants.CommonConstant;
    import com.ennova.tour.search.integration.service.WeimobAuthorizeService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    import top.rdfa.framework.biz.ro.RdfaResult;
    
    import javax.annotation.Resource;
    import java.net.URI;
    import java.net.URISyntaxException;
    import java.util.LinkedHashMap;
    
    /** * 微盟授权实现类 * * @author zrj * @since 2021/7/30 **/
    @Slf4j
    @Service
    public class WeimobTokenServiceImpl implements WeimobTokenService { 
    
        @Resource
        private WeimobAuthorizeService weimobAuthorizeService;
    
        @Resource(name = "redisTemplate")
        private RedisTemplate redisTemplate;
    
        private String weimobPre;
        private String accessGrantType;
        private String refreshGrantType;
    
        private String goodsRedirectUri;
        private String goodsCode;
        private String goodsClientId;
        private String goodsClientSecret;
        private String weimobGoodsAccessTokenKey;
        private String weimobGoodsRefreshTokenKey;
        private String weimobGoodsAuthCodeKey;
    
        private String storeRedirectUri;
        private String storeCode;
        private String storeClientId;
        private String storeClientSecret;
        private String weimobStoreAccessTokenKey;
        private String weimobStoreRefreshTokenKey;
        private String weimobStoreAuthCodeKey;
    
        public WeimobTokenServiceImpl() { 
            log.info("初始化token配置信息");
            weimobPre = CommonConstant.WEIMOB_PRE;
            accessGrantType = CommonConstant.ACCESS_GRANT_TYPE;
            refreshGrantType = CommonConstant.REFRESH_GRANT_TYPE;
    
            goodsRedirectUri = CommonConstant.GOODS_REDIRECT_URI;
            goodsCode = CommonConstant.GOODS_CODE;
            goodsClientId = CommonConstant.GOODS_CLIENT_ID;
            goodsClientSecret = CommonConstant.GOODS_CLIENT_SECRET;
            weimobGoodsAccessTokenKey = CommonConstant.WEIMOB_GOODS_ACCESS_TOKEN_KEY;
            weimobGoodsRefreshTokenKey = CommonConstant.WEIMOB_GOODS_REFRESH_TOKEN_KEY;
            weimobGoodsAuthCodeKey = CommonConstant.WEIMOB_GOODS_AUTH_CODE_KEY;
    
            storeRedirectUri = CommonConstant.STORE_REDIRECT_URI;
            storeCode = CommonConstant.STORE_CODE;
            storeClientId = CommonConstant.STORE_CLIENT_ID;
            storeClientSecret = CommonConstant.STORE_CLIENT_SECRET;
            weimobStoreAccessTokenKey = CommonConstant.WEIMOB_STORE_ACCESS_TOKEN_KEY;
            weimobStoreRefreshTokenKey = CommonConstant.WEIMOB_STORE_REFRESH_TOKEN_KEY;
            weimobStoreAuthCodeKey = CommonConstant.WEIMOB_STORE_AUTH_CODE_KEY;
        }
    
        /** * 微盟获取商品授权码 */
        @Override
        public RdfaResult getGoodsAuthCode(String code, String state) { 
            log.info("微盟获取商品授权码：code=" + code);
            if (StrUtil.isEmpty(code)) { 
                return RdfaResult.fail("500", "微盟商品授权码为空，code=" + code);
            }
    
            try { 
                // 将授权码放入缓存
                redisTemplate.opsForValue().set(weimobGoodsAuthCodeKey, code);
            } catch (Exception e) { 
                return RdfaResult.fail("500", "微盟获取商品授权码失败，code=" + code);
            }
    
            return RdfaResult.success("微盟获取商品授权码成功：code=" + code);
        }
    
        /** * 微盟获取酒店授权码 */
        @Override
        public RdfaResult getStoreAuthCode(String code, String state) { 
            log.info("微盟获取酒店授权码：code=" + code);
            if (StrUtil.isEmpty(code)) { 
                return RdfaResult.fail("500", "微盟酒店授权码为空，code=" + code);
            }
    
            try { 
                // 将授权码放入缓存
                redisTemplate.opsForValue().set(weimobStoreAuthCodeKey, code);
            } catch (Exception e) { 
                return RdfaResult.fail("500", "微盟获取酒店授权码失败，code=" + code);
            }
    
            return RdfaResult.success("微盟获取酒店授权码成功：code=" + code);
        }
    
        /** * 获取商品AccessToken */
        @Override
        public RdfaResult getGoodsAccessToken() { 
            // 优先从缓存中取，默认值次之
            String goodAuthCode = (String) redisTemplate.opsForValue().get(weimobGoodsAuthCodeKey);
            log.info("获取商品AccessToken，缓存获取goodAuthCode：" + goodAuthCode);
            if (StrUtil.isNotEmpty(goodAuthCode)) { 
                goodsCode = goodAuthCode;
            }
    
            return getAccessToken(goodsCode, goodsClientId, goodsClientSecret, weimobGoodsAccessTokenKey, weimobGoodsRefreshTokenKey, goodsRedirectUri);
        }
    
        /** * 微盟刷新Token * 每小时刷新一次，获取新的access_token与refresh_token */
        @Override
        public RdfaResult getGoodsRefreshToken() { 
            // 获取商品RefreshToken
            String accessRefreshToken = (String) redisTemplate.opsForValue().get(weimobGoodsRefreshTokenKey);
            return getRefreshToken(goodsClientId, goodsClientSecret, accessRefreshToken, weimobGoodsAccessTokenKey, weimobGoodsRefreshTokenKey);
        }
    
        /** * 获取酒店Access_token */
        @Override
        public RdfaResult getStoreAccessToken() { 
            // 优先从缓存中取，默认值次之
            String storeAuthCode = (String) redisTemplate.opsForValue().get(weimobStoreAuthCodeKey);
            log.info("获取酒店Access_token，缓存获取storeAuthCode：" + storeAuthCode);
            if (StrUtil.isNotEmpty(storeAuthCode)) { 
                storeCode = storeAuthCode;
            }
            return getAccessToken(storeCode, storeClientId, storeClientSecret, weimobStoreAccessTokenKey, weimobStoreRefreshTokenKey, storeRedirectUri);
        }
    
        /** * 获取酒店refresh_token */
        @Override
        public RdfaResult getStoreRefreshToken() { 
            // 获取酒店RefreshToken
            String accessRefreshToken = (String) redisTemplate.opsForValue().get(weimobStoreRefreshTokenKey);
            return getRefreshToken(storeClientId, storeClientSecret, accessRefreshToken, weimobStoreAccessTokenKey, weimobStoreRefreshTokenKey);
        }
    
        /** * 微盟获取AccessToken */
        public RdfaResult getAccessToken(String code, String cientId, String clientSecret, String weimobAccessTokenKey, String weimobRefreshTokenKey, String redirectUri) { 
            String redirectUrl = weimobPre + "code=" + code + "&grant_type=" + accessGrantType + "&client_id=" + cientId + "&client_secret=" + clientSecret + "&redirect_uri=" + redirectUri;
            System.out.println("微盟获取AccessToken请求地址：redirectUrl=" + redirectUrl);
    
            // 获取acessToken
            LinkedHashMap accessTokenMap;
            try { 
                accessTokenMap = weimobAuthorizeService.getAcessToken(new URI(redirectUrl));
                log.info("微盟获取AccessToken结果集：acessTokenMap=" + JSONUtil.toJsonStr(accessTokenMap));
                if (CollectionUtil.isEmpty(accessTokenMap)) { 
                    log.error("微盟获取AccessToken失败，结果集为空！");
                    return RdfaResult.fail("500", "微盟获取AccessToken失败，结果集为空！");
                }
    
                String accessToken = (String) accessTokenMap.get("access_token");
                String refreshToken = (String) accessTokenMap.get("refresh_token");
                log.info("微盟获取AccessToken：accessToken=" + accessToken + "，refreshToken=" + refreshToken);
    
                // 将accessToken，refreshToken放入redis，放入job手动执行一次
                redisTemplate.opsForValue().set(weimobAccessTokenKey, accessToken);
                redisTemplate.opsForValue().set(weimobRefreshTokenKey, refreshToken);
    
            } catch (Exception e) { 
                log.error("微盟获取AccessToken异常：" + e);
                return RdfaResult.fail("500", "微盟获取AccessToken异常");
            }
    
            return RdfaResult.success("200", "微盟获取AccessToken成功", accessTokenMap);
        }
    
        /** * 微盟刷新RefreshToken */
        public RdfaResult getRefreshToken(String cientId, String clientSecret, String accessRefreshToken, String weimobAccessTokenKey, String weimobRefreshTokenKey) { 
    
            String redirectUrl = weimobPre + "grant_type=" + refreshGrantType + "&client_id=" + cientId + "&client_secret=" + clientSecret + "&refresh_token=" + accessRefreshToken;
            log.info("微盟刷新RefreshToken：redirectUrl=" + redirectUrl);
    
            LinkedHashMap refreshTokenMap = null;
            try { 
                refreshTokenMap = weimobAuthorizeService.getRefreshToken(new URI(redirectUrl));
                log.info("微盟刷新RefreshToken：refreshTokenMap：" + JSONUtil.toJsonStr(refreshTokenMap));
                if (CollectionUtil.isEmpty(refreshTokenMap)) { 
                    log.error("微盟刷新RefreshToken失败，结果集为空！");
                    return RdfaResult.fail("500", "微盟刷新RefreshToken失败，结果集为空！");
                }
    
                String accessToken = (String) refreshTokenMap.get("access_token");
                String refreshToken = (String) refreshTokenMap.get("refresh_token");
                log.info("微盟刷新RefreshToken：accessToken=" + accessToken + "，refreshToken=" + refreshToken);
    
                // 放入缓存，替换老的accessToken，与refreshToken
                redisTemplate.opsForValue().set(weimobAccessTokenKey, accessToken);
                redisTemplate.opsForValue().set(weimobRefreshTokenKey, refreshToken);
    
            } catch (Exception e) { 
                log.error("微盟刷新RefreshToken异常：" + e);
                return RdfaResult.fail("500", "微盟刷新RefreshToken异常");
            }
    
            return RdfaResult.success("200", "微盟刷新RefreshToken成功", refreshTokenMap);
        }
    }

结果集：RdfaResult

import java.io.Serializable;
    
    /** * 结果集 * * @author Jerry * @since 2021/8/7 **/
    final public class RdfaResult<T extends Serializable> implements Serializable { 
    
        private static final long serialVersionUID = 1L;
    
        private boolean success = true;
    
        private String code;
    
        private String message;
    
        private T data;
    
    
        /** * Constructs a new RdfaResult with no parameters. */
        public RdfaResult() { 
            super();
        }
    
        public RdfaResult(String code, String message) { 
            this(true, code, message);
        }
    
        public RdfaResult(boolean success, String code, String message) { 
            this(success, code, message, null, null);
        }
    
        public RdfaResult(boolean success, String code, String message, T data) { 
            this(success, code, message, data, null);
        }
    
        public RdfaResult(boolean success, String code, String message, T data, Throwable cause) { 
            this.success = success;
            this.code = code;
            this.message = message;
            this.data = data;
        }
    
    
        public static <T extends Serializable> RdfaResult<T> success(String code, String message, T data) { 
            RdfaResult rest = new RdfaResult();
            rest.setCode(code);
            rest.setMessage(message);
            rest.setData(data);
            rest.setSuccess(true);
            return rest;
        }
    
        public static <T extends Serializable> RdfaResult<T> success(T data) { 
            RdfaResult rest = new RdfaResult();
            rest.setCode("200");
            rest.setMessage("success");
            rest.setData(data);
            rest.setSuccess(true);
            return rest;
        }
    
        public static <T extends Serializable> RdfaResult<T> fail(String code, String message) { 
            RdfaResult<T> rest = new RdfaResult<T>();
            rest.setCode(code);
            rest.setMessage(message);
            rest.setSuccess(false);
            return rest;
        }
    
        public boolean isSuccess() { 
            return success;
        }
    
        public void setSuccess(boolean success) { 
            this.success = success;
        }
    
        public String getCode() { 
            return code;
        }
    
        public void setCode(String code) { 
            this.code = code;
        }
    
        public String getMessage() { 
            return message;
        }
    
        public void setMessage(String message) { 
            this.message = message;
        }
    
        public T getData() { 
            return data;
        }
    
        public void setData(T data) { 
            this.data = data;
        }
    }

微盟鉴权：WeimobTokenController

import com.ennova.tour.search.client.dto.resp.SearchContentRespDTO;
    import com.ennova.tour.search.core.service.WeimobTokenService;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import top.rdfa.framework.biz.ro.RdfaResult;
    
    import javax.annotation.Resource;
    
    /** * 微盟鉴权 * * @author zrj * @since 2021/8/2 **/
    @Api(tags = "微盟鉴权")
    @RestController
    @RequestMapping("/weimob")
    public class WeimobTokenController { 
    
        @Resource
        private WeimobTokenService weimobTokenService;
    
        /** * 微盟获取商品授权码 */
        @ApiOperation(value = "商品授权码")
        @GetMapping("/getgoodscode")
        public RdfaResult<SearchContentRespDTO> getGoodsCode(@RequestParam String code, @RequestParam String state) { 
            return weimobTokenService.getGoodsAuthCode(code, state);
        }
    
        /** * 微盟获取酒店授权码 */
        @ApiOperation(value = "酒店授权码")
        @GetMapping("/getstorecode")
        public RdfaResult<SearchContentRespDTO> getStoreCode(@RequestParam String code, @RequestParam String state) { 
            return weimobTokenService.getStoreAuthCode(code, state);
        }
    
        /** * 微盟获取token * STEP2_成功获取授权码code后，换取access_token */
        @GetMapping("/getGoodsAccessToken")
        @ApiOperation(value = "微盟获取商品AcessToken")
        public RdfaResult getGoodsAccessToken() { 
            return weimobTokenService.getGoodsAccessToken();
        }
    
        /** * 微盟刷新token * STEP 3_通过授权获取的refresh_token，可用来刷新access token */
        @GetMapping("/getGoodsRefreshToken")
        @ApiOperation(value = "微盟获取商品RefreshToken")
        public RdfaResult getGoodsRefreshToken() { 
            return weimobTokenService.getGoodsRefreshToken();
        }
    
        /** * 微盟获取token * STEP2_成功获取授权码code后，换取access_token */
        @GetMapping("/getStoreAccessToken")
        @ApiOperation(value = "微盟获取酒店AcessToken")
        public RdfaResult getStoreAccessToken() { 
            return weimobTokenService.getStoreAccessToken();
        }
    
        /** * 微盟刷新token * STEP 3_通过授权获取的refresh_token，可用来刷新access token */
        @GetMapping("/getStoreRefreshToken")
        @ApiOperation(value = "微盟获取酒店RefreshToken")
        public RdfaResult getStoreRefreshToken() { 
            return weimobTokenService.getStoreRefreshToken();
        }
    }

[https_cloud.weimob.com_saas_word_detail.html_tag_564_menuId_2]: https://cloud.weimob.com/saas/word/detail.html?tag=564&menuId=2
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70]: /images/20220829/c01bf8263afe44b3adf117c97afcb82c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 1]: /images/20220829/00b1bce2f6004602bc23c72f3a093573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 2]: /images/20220829/e5aefc6453f64c719f03e602fd67462e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 3]: /images/20220829/75de4fce781042c998180e9b9e62dedb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/f0f12acfe05540be9623e87dd5c618a9.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 5]: /images/20220829/5b4416f9718b4392a294ed66cb745fcd.png