反射加载SDK完成统一调用

叁歲伎倆 2024-02-05 07:18 2阅读 0赞

#### 文章目录 ####

*  1、需求背景
 *  2、接口+抽象类+具体实现类
 *  3、疑问
 *  4、存在的问题
 *  5、通过反射加载SDK并完成调用
 *  5、补充：关于业务网关
 *  7、补充：关于SDK的开发

关键点：

*  接口+抽象类（半抽象半实现）+具体实现类
 *  业务网关
 *  反射加载SDK，完成统一调用

![在这里插入图片描述][d9eb4e05a48d49caac86447d987e1b51.png]

半路接手一个需求，需要从自己系统出发，经过业务网关的统一校验和转发，来请求第三方供应商系统的接口，整理下看同事代码学到的一点思路。

## 1、需求背景 ##

第三方供应商需要上架自己的产品到公司的交易平台，但用户使用产品时，最后一步请求的自然是供应商自己的服务器资源和API。关于这个需求的实现思路，大致是在交易平台需要做接口有效性校验、服务实例有效性校验等，以及消费数据记录落库，最后转发到供应商接口去请求资源（既然是请求别人的系统，那就涉及到怎么通过人家的鉴权系统）。

@PostMapping("/data/{platform}/{apiId}")
    public Object redirect(@PathVariable String platform, @PathVariable String apiId,
                           @RequestBody Map<String, Object> parameterMap, HttpServletRequest request) {
        
        //直接把API的ID放进请求参数里，后面用完了，再调三方API时去掉就行
        parameterMap.put("apiId", apiId);
        return redirectHandler.redirect(platform, ServletUtils.getHeaders(request), parameterMap);
    }

这里给访问所有三方系统接口一个统一的入口，做为业务网关（后面展开说），接口传参中：

*  paltform：确定是哪个第三方系统
 *  apiID：用来标识想请求第三方系统哪个的API接口，通过这个ID，可以在库里查到API的路径、三方系统的host、密钥、以及后面会提到的SDK的存储路径、SDK里的核心方法名等信息
 *  parameterMap：用户传入的请求参数
 *  request：Http请求对象

其中用工具类获取下HTTP请求的全部请求头信息存入Map。

public class ServletUtils{
        
    	
    	/**
         * 获取Http请求的请求头信息
         */
    	public static Map<String, String> getHeaders(HttpServletRequest request) {
        
            Map<String, String> map = new LinkedHashMap<>();
            Enumeration<String> enumeration = request.getHeaderNames();
            if (enumeration != null) {
        
                while (enumeration.hasMoreElements()) {
        
                    String key = enumeration.nextElement();
                    String value = request.getHeader(key);
                    map.put(key, value);
                }
            }
            return map;
        }
     
    }

## 2、接口+抽象类+具体实现类 ##

既然需要对接很多第三方供应商系统，去调用第三方系统的API，那就考虑定义一个接口，里面抽象出一个做鉴权、转发的方法，对接不同的供应商系统时，去实现这个接口，然后走不同的实现。

public interface ApiRedirectHandler {
        
    
        /**
         * @param headerMap 请求头参数Map
         * @param paramMap 对第三方接口的请求参数
         * @return 返回第三方接用调用的结果
         */
        Object redirect(Map<String, String> headerMap, Map<String, Object> paramMap);
    
    
    }

前面提到，在交易平台要做一些校验和消费记录落库的操作，这些是对接所有三方系统的公共步骤，而后面请求第三方系统接口肯定要做的鉴权认证以及转发或者调用，则属于各个三方系统的定制化行为（因为一个系统有一个系统的认证方式，A系统用APP密钥、B系统可能用sign验签）。因此，考虑在接口下面垫一个抽象类，抽象类中，实现接口中的转发方法，里面做校验、记录落库等操作，同时调用本抽象类自己的抽象request方法（这个方法里做第三方系统的定制化的认证和转发或调用）。这样，对接不同的三方系统，只需就继承这个抽象类，实现里面的request方法，做自己的认证和转发即可。

> `总结`：全抽象的接口，过渡到半抽象的抽象类，抽象类中实现接口的抽象方法时，方法体中写一部分公共逻辑 + 调用本抽象类自己的一个抽象方法B，这个抽象方法B就给以后的普通类去继承和重写。

@Slf4j
    public abstract class AbstractRedirectHandler implements ApiRedirectHandler {
        
    
        //抽象类中实现接口的方法
        @Override
        public Object redirect(Map<String, String> headerMap, Map<String, Object> paramMap) {
        
    
            //todo: 1.请求有效性验证
    
           //从请求参数paramMap中拿到你要调用APIId，然后查到的三方系统接口的路径、host等信息
           ApiInfo  apiDetailVo = queryApiInfo(paramMap);
           //API的ID用完了，它不是三方系统接口需要的请求参数，移除
           paramMap.remove("apiId"); 
    
            //todo: 2.服务实例有效性验证
            
            //request中去写不同三方系统的鉴权、转发或调用逻辑
            val responseData = request(headerMap, paramMap, apiDetailVo);
    
            //todo: 3.记录消费记录
       		
       		//返回第三方接口的响应结果
            return responseData;
        }
    
        /**
         * API转发请求，对接时，针对不同的三方系统去定制化实现
         *
         * @param headerMap 头信息
         * @param paramMap  请求参数
         * @Param apiDetailVo 接口信息，如接口路径、服务器host
         * @return 返回第三方接用调用的结果
         */
        protected abstract Object request(Map<String, String> headerMap, Map<String, Object> paramMap, ApiDetailVo apiDetailVo);
    
    
    
    }

**比如现在对接001号系统：按它们系统支持的方式做认证，比如header中添加APP密钥，然后组装请求URL成一个HttpRequest对象，发送Http请求即可完成对三方系统API的调用。**

public class System001RedirectHandler extends AbstractRedirectHandler {
        
    
        @Override
        public Object request(Map<String, String> headerParam, Map<String, Object> paramMap, ApiDetailVo apiDetailVo) {
        
            //拿到三方系统的服务器HOST以及接口路径
            String url = apiDetailVo.getHost() + apiDetailVo.getPath();
            //拿到三方系统接口的请求方式，POST还是GET...
            val method = Method.valueOf(apiDetailVo.getRequestMethod());
            //使用Hutool工具类的HTTP请求对象，方便后面调用现成的方法来发送HTTP请求
            HttpRequest request = null;
           //如果是GET
            if (method.equals(Method.GET)) {
        
                String headerBody = "";
                StringBuffer body = new StringBuffer();
                StringBuffer param = new StringBuffer();
                for (String key : paramMap.keySet()) {
        
                    body.append(key).append("=").append(paramMap.get(key)).append("&");
                    param.append(key).append("=").append(URLEncoder.encode((String) paramMap.get(key), StandardCharsets.UTF_8)).append("&");
                }
                //拼接出一个GET请求的完整路径
                if (param.length() > 0) {
        
                    headerBody = body.substring(0, body.length() - 1);
                    url = url + "?" + param.substring(0, param.length() - 1);
                }
                //创建request请求对象
                request = HttpUtil.createGet(url);
                //请求头中加入001系统的认证秘钥，以便通过认证
                request.addHeaders(getHeader(headerBody, apiDetailVo.getAppSecret()));
            } else {
        
                //POST请求
                request = HttpUtil.createPost(url).contentType("application/json");
                String body = JSON.toJSONString(paramMap);
                //组装请求头和请求体
                request.addHeaders(getHeader(body, apiDetailVo.getAppSecret())).body(body);
            }
            //库里存的API有要求超时时间
            if (apiDetailVo.getTimeout() > 0) {
        
                request.timeout(apiDetailVo.getTimeout());
            }
            //发送HTTP请求，拿到响应
            val httpResponse = request.execute();
            return JSON.parseObject(httpResponse.body());
        }
    
    ｝

## 3、疑问 ##

给所有三方系统接口的调用一个统一的请求入口，怎么实现根据传入的第三方系统类型platformType，来选择不同的实现类对象：考虑把转发接口ApiRedirectHandler的所有实现类放进一个List，遍历去匹配传入的platformType，匹配，则找到了三方系统对应的处理器实现类。找不到，就给个默认的处理器实现类。

@RequiredArgsConstructor
    public class CompositeRedirectHandler {
        
    
        private ArrayList<ApiRedirectHandler> handlers = new ArrayList<>();
    
        public CompositeRedirectHandler(ArrayList<ApiRedirectHandler> redirectHandlerList) {
        
            handlers = redirectHandlerList;
        }
    
        public Object redirect(String platform, Map<String, String> headerMap, Map<String, Object> paramMap) {
        
            //给一个默认的通用执行器实现类对象
            ApiRedirectHandler execHandler = handlers.get(0);
           //根据平台信息匹配到ApiRedirectHandler接口的三方系统的实现类
            for (ApiRedirectHandler handler : handlers) {
        
                if (handler.isMatched(platform)) {
        
                    execHandler = handler;
                    break;
                }
            }
           //用实现类去调用转发方法  ==> 抽象类（包含抽象方法request） ==> 各个三方系统对抽象类的实现 ==> 完成三方系统API的请求
            return execHandler.redirect(headerMap, paramMap);
        }
    
    
    
    }

上面的接口中注入这个CompositeRedirectHandler对象，调用它的redirect方法，即可全部串起来。

private final CompositeRedirectHandler redirectHandler;
    
    @PostMapping("/data/{platform}/{apiId}")
    public Object redirect(@PathVariable String platform, @PathVariable String apiId,
                           @RequestBody Map<String, Object> parameterMap, HttpServletRequest request) {
        
        parameterMap.put("apiId", apiId);
        return redirectHandler.redirect(platform, ServletUtils.getHeaders(request), parameterMap);
    }

## 4、存在的问题 ##

如此，以后每对接一个三方系统，就得开发一个新的实现类，去按照他们系统支持的认证方式来做认证以及转发或调用。相当繁琐，现在考虑把这个认证的事交给三方系统自己去完成，比如让他们开发一个SDK，SDK里他们按照自己系统支持的认证方式，做能通过鉴权的操作（到底是header里放密钥还是做验签，我就不再关心了），以及组装HTTP请求，而我们只需要load这个SDK里的内容，传入请求参数和路径，做一个调用即可。

@Slf4j
    public class CommonRedirectHandler extends AbstractRedirectHandler {
        
    
    
         @Override
         public Object request(Map<String, String> headerMap, Map<String, Object> paramMap, ApiDetailVo apiDetailVo) {
        
              //根据apiDetailInfo加载对应的SDK，完成调用
              //....
         ｝
    ｝

如此，我就只需要一个通用的实现类CommonRedirectHandler就可以实现对所有三方系统的对接，这个通用类中也实现了上面的抽象类的request方法，request方法中只需load SDK里三方系统开发者写的方法，传入请求路径和请求参数即可完成三方系统接口的调用。

## 5、通过反射加载SDK并完成调用 ##

现在问题成了如何加载SDK，完成调用。 ⇒ 通过反射拿到核心类的对象，以及负责认证和转发请求的核心方法，最后完成调用即可。这里的反射直接用hutool这个强大的第三方依赖库。

<dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.3.9</version>
    </dependency>

加载SDK的示意代码：

@Slf4j
    public class CommonRedirectHandler extends AbstractRedirectHandler {
        
    
    
        /**
         * 动态加载sdk，调用里面已经完成鉴权和转发的方法，以实现转发请求
         *
         * @param headerMap 头信息
         * @param paramMap  请求参数
         * @return 三方系统接口的返回数据
         */
        @Override
        public Object request(Map<String, String> headerMap, Map<String, Object> paramMap, ApiDetailVo apiDetailVo) {
        
        	//SDK的路径、类名、核心方法名
            val jarFilePath = apiDetailVo.getSdkJarFilePath();   
            val classFullName = apiDetailVo.getClassFullName();
            val invokeMethodName = apiDetailVo.getInvokeMethodName();
            val httpMethod = apiDetailVo.getRequestMethod().toUpperCase();
            //拼接完整的三方系统接口的URL
            String apiUrl = apiDetailVo.getHost() + apiDetailVo.getPath();
    
            log.info("file = {}", new File(jarFilePath));
            //hutool工具类加载SDK成class对象
            Class<?> clazz = ClassLoaderUtil.loadClass(new File(jarFilePath), classFullName);
    		//反射拿到构造方法对象
            final val constructors = ReflectUtil.getConstructor(clazz);
            Object instance = null;
            try {
        
            	//SDK核心类的对象
                instance = constructors.newInstance();
                final val requestMethod = ReflectUtil.getMethodByName(clazz, invokeMethodName);
                //调用
                return requestMethod.invoke(instance, apiUrl, httpMethod, headerMap, paramMap);
            } catch (InstantiationException e) {
        
                log.error(e.getMessage());
                throw new ServiceException(ExceptionCodeEnum.API_GATEWAY_REQUEST_API_ERROR);
            } catch (IllegalAccessException e) {
        
                log.error(e.getMessage());
                throw new ServiceException(ExceptionCodeEnum.API_GATEWAY_REQUEST_API_ERROR);
            } catch (InvocationTargetException e) {
        
                log.error(e.getCause().getMessage());
                throw new ServiceException(ExceptionCodeEnum.API_GATEWAY_REQUEST_API_ERROR);
            }
        }
    }

## 5、补充：关于业务网关 ##

本需求里，给请求第三方系统接口资源提供了一个统一的API入口，比如：

@POSTMapping(/data/{
        platformType}/{
        API_ID})
    public Object redirect(@PathVariable String platformType, @PathVariable String API_ID, 
    					   @RequestBody Map<String, Object> requestParam, HttpServletRequset requset){
        
    
    	//.....
    }

有了这个统一入口，请求三方系统资源就都从这个接口过，前面说的各种合法性、有效性校验、记录落库、转发等就可以在这里完成了，由此可见，其虽然不比常规的Gateway服务，比如SpringCloudGateway，但干的活儿是类似的，即校验和转发（路由），因此，称业务网关。

> 思路：给所有三方系统的api调用提供一个统一的入口(Api)

## 7、补充：关于SDK的开发 ##

SDK，Software Development Kit，即软件开发工具包。简单说就是[造轮子][Link 1]，实现一个小功能，别人引入，就能使用。往大了说，如Java开发工具包JDK，使用import引入相关的包：

import java.util.*;

往小了说，如文件上传的SDK，其他系统引入后就可用。关于SDK的开发，需要注意：

*  **易用性**：提供统一调用，用户不用关心内部实现的细节，只需知道调谁、传什么、能返回什么即可

//常见方式1.直接调用
    FileManage.upload(String filePath);
    
    //常见方式2.需要new对象
    FileManage fileManage = new FileManage();
    fileManage.upload(String filePath);

*  **轻量依赖**：尽量减少SDK本身对其他类库的依赖，以减少用户项目中的已有依赖和SDK依赖的冲突
 *  **结构清晰**：如maven项目下，service包下编写业务逻辑、constant包下存放常量、utils包下放工具类
 *  **见名知意**：不用看说明文档也知道这个方法是干啥用的
 *  **可扩展**：提供接口或者抽象类对外，支持用户自己继承和按需写实现类，如密码相关SDK，做加密解密，起名PasswordHandler，其加密方法encode需要传入一个密码，一个加密器，这个加密器就可以提供成接口，用户可通过实现这个接口来自定义加密方式。

//加密器对象：按照非对称算法加密
    Encoder encoder = new SignEncoder();
    String password = PasswordHandler.encode("daihao9527", encoder);

//用户自己实现加密器接口
    public MyEncoder implements Encoder {
        
    	
    	@Override
    	void doEncode(){
        
    		//...用户自己写，如采用时间戳、或自定义的MD5工具类
    		Calendar calendar = Calendar.getInstance();
    		Long timestamp = calendar.getTime.getTime();
    		String sign = MD5Utils.getMD5Str(timestamp + secretKey);
    		//..
    	}
    }

//此时，用户可以自己指定加密器
    String password = PasswordHandler.encode("daihao9527", new MyEncoder());

SDK中的内容一般包括：

*  功能模块：实现功能
 *  API：SDK的门面，调用和使用功能的入口
 *  文档：附相关使用说明和指引
 *  Demo：使用示例，运行Demo，直观体验SDK功能

[d9eb4e05a48d49caac86447d987e1b51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/74c8e48954d94aabb4ec4cc6441721d4.png
[Link 1]: https://www.cnblogs.com/yupi/p/15233457.html