Java开发SDK详解

落日映苍穹つ 2023-10-10 22:57 39阅读 0赞

## 一、服务端开发 ##

### 1、前言 ###

1）最近在对接外部平台的接口，对方提供了一个sdk，开发中直接引入到项目中。自己只需要组装参数，直接调用sdk中的方法就可以实现接口对接。  
2）sdk中包含了参数校验，加密验签，Http接口调用，还提供了各个接口入参和出参的实体类。 这些为我们减少很多的开发量，同时将一些不合规的入参直接在客户端过滤掉，减少资源浪费。还提供了一套完整的加密验签方法，避免了双发对接中因为加解密验签方法的不同导致的一些问题。很大程度上提高了我们的对接中开发联调的成本。  
3）sdk优点这么多，下面我们来开发一个简单的sdk吧。

### 2、步骤概述 ###

1）首先我们开发一下服务端： 服务端是一个SpringBoot项目提供了一个用户列表查询的接口。入参包含调用方分唯一编号（appId），加密的入参信息（data）,入参的加解密方式使用RSA非对称加密算法。

2）其次开发SDK： SDK是一个普通的maven项目，提供用户列表查询接口的Http调用方法，还有接口的参数校验，入参的加密，返回信息的解密。最后将项目打成jar包。

3）最后开发客户端调试： 客户端是一个SpringBoot项目，项目中引入上面打包好的SDK，组装参数，调用用户列表查询接口。

### 3、服务端开发 ###

#### 3.1代码实现 ####

3.1.1 服务端入口（SysUserApiController）

> 这个类是接收客户端请求的入口，继承了ApiAbstract

package com.zkaw.api;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:00 2023/5/19
     * @Modified By:
     */
    
    import com.alibaba.fastjson.JSONObject;
    import com.zkaw.service.IUserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/api/user/")
    public class SysUserApiController extends ApiAbstract<String> {
    
        @Autowired
        private IUserService sysUserService;
    
        @Override
        public String work(String type,JSONObject o) {
            return sysUserService.invokeApi(type,JSONObject.toJavaObject(o, SysUserDTO.class));
        }
    
        @PostMapping("/invokeApi")
        public HopeResponse invokeApi(@RequestBody HopeRequest hopeRequest) {
            return process(hopeRequest);
        }
    
    }

3.1.2 接口的抽象类（ApiAbstract）

> 这个类提供一些公用的方法，私钥的获取，入参的解密，出参的加密等。

package com.zkaw.api;
    
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:04 2023/5/19
     * @Modified By:
     */
    
    
    @Slf4j
    public abstract class ApiAbstract<R> {
    
        private static final Map<String, String> PRIVATE_KEY_MAP = new HashMap<>();
    
        static {
            PRIVATE_KEY_MAP.put("zkawTest", "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALCvyp0epQHwTaU+WPx+Zue2iVR3JcheHZTUEITPHW9anhW8iMkteE3m83Zu2e6V1/LbnaVoNG3GO3i65C6MiBMeJha1PKgYrlvHe5cLzWlWwQ6BxCOCto2m5sLWXd24xJp259qlKypw1F9dMVqJAaCO+2sDTUBbdBL9yJLB6J51AgMBAAECgYBMZseTZ3Pswa+hm7M5A6OV4N3Dc34YBXJ/L7Aw7aqJw0KGna78ZzgVX5+5f7enLo5hysuBgezh5w1CaHZRFp2kBqsYn7z3oGo2Mbs8H6fF1M4r3pRwtt70FgNuTGDm7KLkzHyFHxBmTl15AxujNTTQBxai/rZkUlfVCbHS3+PJpQJBANsY2MxiRLxM2CcWy+AuKLGNx+sT7Z3WfJOKQ09Jay55fsMrIhCKuE/yf4pGVaQuNMsNsRhpiZEE4nbAoZXGtiMCQQDOckUMKy4rEY2i2yI1g8JcaI7lGKA+Ey22Sy2azFSSPpfIW5ZkgCpzKUx241Z6CCNmIw8nhM7SfaYTUoR0+0aHAkEAv/DmjTdRzDzt6GC6Py1xDQuOps0QkARFouOv0Bgbw91ARi7VavR8P93MChFQGcM5EOJv0Vkz4U4ML8jWRmaNTQJAbNaTjmnJak1TxZMPwvTW6A77ns5P1MoZpGyX+29T+tHjBW87p3pmZtZUCK2r7qQRvYwoNiZvP0uc3bz4NhAvSwJBAKjsvDaf/JXdS9wrfHTT/d7DuBOf3WVkiex8pVeStBcd65qHzF+faWw5VJb3Y6IMgtoSt1QMgMuEjlst4bcL6ss=");
        }
    
        /**
         * 统一处理
         *
         * @param hopeRequest 统一请求
         * @return 统一响应
         */
        public HopeResponse process(HopeRequest hopeRequest) {
            try {
                String privateKey = getPrivateKey(hopeRequest.getAppId());
                String type = hopeRequest.getType();
                JSONObject o = before(hopeRequest.getData(), privateKey);
                System.out.println(o);
                R r = work(type,o);
                return after(r, privateKey);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("ServerAbstract process exception! hopeRequest={}", hopeRequest, e);
                return HopeResponse.builder()
                        .success(false)
                        .message(e.getCause().toString())
                        .build();
            }
    
        }
    
        /**
         * 处理前置解密
         *
         * @param data       请求密文
         * @param privateKey 秘钥
         * @return 请求参数
         */
        private JSONObject before(String data, String privateKey) {
            return JSON.parseObject(RsaUtil.decryptPrivate(privateKey, data));
        }
    
        /**
         * 业务处理
         *
         * @param o 入参
         * @return 返回
         */
        abstract R work(String type,JSONObject o);
    
        /**
         * 后置处理加密
         *
         * @param r          业务数据
         * @param privateKey 秘钥
         * @return 统一返回
         */
        private HopeResponse after(R r, String privateKey) {
            return HopeResponse.builder()
                    .success(true)
                    .message("访问成功")
                    .data(RsaUtil.encryptPrivate(privateKey, (String) r))
                    .build();
        }
    
        /**
         * 通过appId获取对应的私钥，不同的接入方提供不同的公私钥。
         * 实际业务开发中这些会存在文件中或者配置中心中如阿波罗，这里简单实现
         *
         * @param appId appId
         * @return 私钥
         */
        private String getPrivateKey(String appId) {
            return PRIVATE_KEY_MAP.get(appId);
        }
    }

3.1.3 接口入参[实体类][Link 1]（HopeRequest）

> 这个是接口的入参，这里简单演示，一个客户端唯一编号（用来获取对应的私钥），一个是加密的入参。

package com.zkaw.api;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:04 2023/5/19
     * @Modified By:
     */
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class HopeRequest {
        /**
         * 客户端唯一编号
         */
        private String appId;
    
        private String type;
        /**
         * 加密后业务相关的入参
         */
        private String data;
    }

3.1.4 接口返回实体类（HopeResponse）

> 这个是服务端接口的返回信息。返回的字段有成功表示，提示信息，还有业务相关的查询结果（查询到的用户信息）加密的信息。

package com.zkaw.api;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:05 2023/5/19
     * @Modified By:
     */
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class HopeResponse {
    
        /**
         * 是否成功
         */
        private boolean success;
    
        /**
         * 返回信息
         */
        private String message;
    
        /**
         * 业务相关的返回信息，私钥加密之后的
         */
        private String data;
    
    }

3.1.5 具体的业务实现层（SysUserService）  
这里是具体的业务层，通过入参去数据库查询对应的结果，在封装成实体类返回，这里不再深入。PageMode是用查询的结果封装的分页实体类。BaseResponse是业务层处理的结果有返回码和提示信息。其实这里不用封装这么多层，我这个是用以前的老代码简单的做个示例。

package com.zkaw.service;
    
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import com.zkaw.api.SysUser;
    import com.zkaw.api.SysUserDTO;
    import com.zkaw.pojo.User;
    
    import java.util.List;
    
    /**
     * @Author: LiuXingJie
     * @Description:
     * @Date Create in 11:06 2022/6/29
     * @Modified By:
     */
    public interface IUserService {
    
        int insertSaveBanch(List<User> list);
    
        int insert( User user);
    
        int delete( User user);
    
        IPage<User> selectPage(User user);
    
        int update( User user);
    
        List<User> selectList(User user);
    
        List<SysUser> queryUserList(SysUserDTO dto);
    
        SysUser selectById(String userId);
    
        String invokeApi(String type,SysUserDTO dto);
    }

3.1.6 业务相关的入参（SysUserDTO）

> 这个类是真正传递业务相关查询条件的实体类。PageBase 是一个分页相关的类，参数为pageSize和pageIndex。

package com.zkaw.api;
    import lombok.Data;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:05 2023/5/19
     * @Modified By:
     */
    
    @Data
    public class SysUserDTO extends PageBase {
    
    
        private int id;
    
        /**
         * 昵称
         */
        private String userId;
        private String age;
    
        /**
         * 用户名称
         */
        private String userName;
    
        /**
         * 用户手机号
         */
        private String userPhone;
    
        /**
         * 用户邮箱
         */
        private String userEmail;
    
        /**
         * 用户状态 0、正常 1、锁定 2、注销
         */
        private Integer status;
    }

3.1.7 RSA加解密的工具类（RsaUtil）

package com.zkaw.api;
    
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    import lombok.extern.slf4j.Slf4j;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Arrays;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:07 2023/5/19
     * @Modified By:
     */
    
    @Slf4j
    public class RsaUtil {
    
        /**
         * 算法加解密算法
         */
        private static final String ALGORITHM = "RSA";
    
        /**
         * 最大加密字节数，超出最大字节数需要分组加密
         */
        private static final Integer MAX_ENCRYPT_BLOCK = 117;
    
        /**
         * 最大解密字节数，超出最大字节数需要分组解密
         */
        private static final Integer MAX_DECRYPT_BLOCK = 128;
        /**
         * RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024
         */
        public static final int KEY_SIZE = 1024;
        
    
        /**
         * 请求报文公钥解密
         *
         * @param publicKeyString 公钥
         * @param text            报文
         * @return 加密报文
         */
        public static String encryptPublic(String publicKeyString, String text) {
            try {
                PublicKey publicKey = getPublicKey(publicKeyString);
                return encryptRSA(publicKey, text);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("RsaUtil encryptPublic exception! publicKeyString={} text={}", publicKeyString, text);
                return null;
            }
        }
    
        /**
         * 应答报文公钥解密
         *
         * @param publicKeyString 公钥
         * @param text            应答密文
         * @return 解密报文
         */
        public static String decryptPublic(String publicKeyString, String text) {
            try {
                PublicKey publicKey = getPublicKey(publicKeyString);
                return decryptRSA(publicKey, text);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("RsaUtil decryptPublic exception! publicKeyString={} text={}", publicKeyString, text);
                return null;
            }
        }
    
        /**
         * 请求报文私钥解密
         *
         * @param privateKeyString 私钥
         * @param text             报文
         * @return 加密报文
         */
        public static String encryptPrivate(String privateKeyString, String text) {
            try {
                PrivateKey privateKey = getPrivateKey(privateKeyString);
                return encryptRSA(privateKey, text);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("RsaUtil encryptPrivate exception! publicKeyString={} text={}", privateKeyString, text);
                return null;
            }
        }
    
        /**
         * 应答报文私钥解密
         *
         * @param privateKeyString 私钥
         * @param text             应答密文
         * @return 解密报文
         */
        public static String decryptPrivate(String privateKeyString, String text) {
            try {
                PrivateKey privateKey = getPrivateKey(privateKeyString);
                return decryptRSA(privateKey, text);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("RsaUtil decryptPrivate exception! privateKeyString={} text={}", privateKeyString, text);
                return null;
            }
        }
    
        /**
         * RSA 加密
         *
         * @param key  密钥
         * @param text 原文
         * @return 密文
         * @throws Exception 异常
         */
        private static String encryptRSA(Key key, String text) throws Exception {
            // 创建加密对象
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            // 对加密进行初始化 第一个参数是加密模式，第二个参数是你想用的公钥加密还是私钥加密
            cipher.init(Cipher.ENCRYPT_MODE, key);
            // 分段加密
            byte[] make = doCrypt(text.getBytes(), cipher, MAX_ENCRYPT_BLOCK);
            return Base64.encode(make);
        }
    
        /**
         * RSA 解密
         *
         * @param key  密钥
         * @param text 密文
         * @return 明文
         * @throws Exception 异常
         */
        private static String decryptRSA(Key key, String text) throws Exception {
            // 创建加解密对象
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            // 对解密进行初始化 第一个参数是加密模式，第二个参数是你想用的公钥解密还是私钥解密
            cipher.init(Cipher.DECRYPT_MODE, key);
            //分段解密
            byte[] make = doCrypt(Base64.decode(text), cipher, MAX_DECRYPT_BLOCK);
            return new String(make);
        }
    
        /**
         * 分段加解密
         *
         * @param data     要加解密的内容数组
         * @param cipher   加解密对象
         * @param maxBlock 分段大小
         * @return 结果
         * @throws IllegalBlockSizeException 异常
         * @throws BadPaddingException       异常
         */
        private static byte[] doCrypt(byte[] data, Cipher cipher, Integer maxBlock) throws IllegalBlockSizeException, BadPaddingException {
            int inputLength = data.length;
            // 标识
            int offSet = 0;
            byte[] resultBytes = {};
            byte[] cache;
            while (inputLength - offSet > 0) {
                if (inputLength - offSet > maxBlock) {
                    cache = cipher.doFinal(data, offSet, maxBlock);
                    offSet += maxBlock;
                } else {
                    cache = cipher.doFinal(data, offSet, inputLength - offSet);
                    offSet = inputLength;
                }
                resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
                System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
            }
            return resultBytes;
        }
    
        /**
         * 获取私钥
         *
         * @param privateKeyString 私钥路径
         * @return 私钥
         */
        private static PrivateKey getPrivateKey(String privateKeyString) throws Exception {
            // 创建key的工厂
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            // 创建私钥key的规则
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
            // 返回私钥对象
            return keyFactory.generatePrivate(keySpec);
        }
    
        /**
         * 获取公钥
         *
         * @param publicKeyString 公钥
         * @return 公钥
         * @throws Exception 异常
         */
        private static PublicKey getPublicKey(String publicKeyString) throws Exception {
            // 创建key的工厂
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            // 创建公钥key的规则
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
            // 返回公钥对象
            return keyFactory.generatePublic(keySpec);
        }
    
    
        public static void main(String[] args) throws NoSuchAlgorithmException {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            //所以当密钥位数为2048时，最大解密长度应为256.
            keyPairGenerator.initialize(KEY_SIZE);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            System.out.println("publicKey="+publicKey);
            System.out.println("==============================");
            System.out.println("privateKey="+privateKey);
        }
    
    }

## 二、SDK开发 ##

### 1、前言 ###

*  前面已经将服务端开发好了（[服务端开发][Link 2]），现在我们来开发SDK吧。

### 2、SDK开发 ###

#### 2.1 创建项目 ####

*  创建一个普通的maven项目 maven----》jdk选择1.8-----》next
 *  输入groupId和artifactId
 *  输入项目名称，和项目存放位置

创建项目步骤不在这里面说了，相信大家应该都已经会了。

#### 2.2 开发代码 ####

先看看项目的整体结构

![5862ffe7ef234b0a82d1b0007952081f.png][]

2.2.1 pom文件

> 依赖的jar包

<dependencies>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.32</version>
            </dependency>
            
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.4</version>
            </dependency>
        </dependencies>

2.2.2 SysUserClient

> 用户查询的客户端，继承ClientAbstract 类

package com.best.hope.client;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.TypeReference;
    import com.best.hope.domain.SysUserDTO;
    import com.best.hope.domain.common.ApiRequest;
    import com.best.hope.domain.common.HopeRequest;
    import lombok.extern.slf4j.Slf4j;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:16 2023/5/19
     * @Modified By:
     */
    
    @Slf4j
    public class SysUserClient extends ClientAbstract {
    
        public static String invokeApi(HopeRequest hopeRequest) {
            ApiRequest<SysUserDTO> request = ApiRequest.<SysUserDTO>builder()
                    .appId(hopeRequest.getAppId())
                    .type(hopeRequest.getType())
                    .url("http://localhost:8090/api/user/invokeApi")
                    .publicKey(hopeRequest.getPublicKey())
                    .data(JSONObject.parseObject(hopeRequest.getData(),SysUserDTO.class))
                    .build();
            try {
                String str = post(request);
                return JSON.parseObject(str, new TypeReference<String>() {
                });
            } catch (Exception e) {
                log.error("SysUserClient queryUserList is exception! request={}", request);
                return null;
            }
        }
    }

2.2.3 ClientAbstract

> 提供了入参加密，返回解密的功能，http请求。这里也可以添加参数校验的功能，这里省略。

package com.best.hope.client;
    
    import com.alibaba.fastjson.JSON;
    
    import com.alibaba.fastjson.JSONObject;
    import com.best.hope.domain.common.ApiRequest;
    import com.best.hope.domain.common.HopeRequest;
    import com.best.hope.domain.common.HopeResponse;
    import com.best.hope.enums.ReturnCodeEnum;
    import com.best.hope.exception.HopeException;
    import com.best.hope.utils.HttpUtil;
    import com.best.hope.utils.RsaUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:16 2023/5/19
     * @Modified By:
     */
    
    @Slf4j
    class ClientAbstract {
    
        static String post(ApiRequest request) {
            HopeRequest hopeRequest = HopeRequest.builder()
                    .appId(request.getAppId())
                    .type(request.getType())
                    .data(RsaUtil.encrypt(request.getPublicKey(), JSON.toJSONString(request.getData())))
                    .build();
            String s = HttpUtil.doPost(request.getUrl(), JSON.toJSONString(hopeRequest));
            if (StringUtils.isBlank(s)) {
                log.error("client post api result is null!");
                throw new HopeException("400", "请求结果为null");
            }
            HopeResponse hopeResponse = JSON.parseObject(s, HopeResponse.class);
            if (!hopeResponse.isSuccess()) {
                log.error("client post api error! hopeResponse={}", hopeResponse);
                throw new HopeException("400", hopeResponse.getMessage());
            }
            hopeResponse.setData(RsaUtil.decrypt(request.getPublicKey(), hopeResponse.getData()));
            return JSONObject.toJSONString(hopeResponse);
        }
    }

2.2.4 HttpUtil

> Http请求的工具类，这里简单写一个psot请求的方法。参数传递方法为application/json。

package com.best.hope.utils;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:17 2023/5/19
     * @Modified By:
     */
    
    @Slf4j
    public class HttpUtil {
    
        /**
         * Http post请求
         *
         * @param httpUrl 连接
         * @param param   参数
         * @return
         */
        public static String doPost(String httpUrl, String param) {
            log.info(" HttpUtil doPost begin! httpUrl={} param={}", httpUrl, param);
            StringBuilder result = new StringBuilder();
            //连接
            HttpURLConnection connection = null;
            OutputStream os = null;
            InputStream is = null;
            BufferedReader br = null;
            try {
                //创建连接对象
                URL url = new URL(httpUrl);
                //创建连接
                connection = (HttpURLConnection) url.openConnection();
                //设置请求方法
                connection.setRequestMethod("POST");
                //设置连接超时时间
                connection.setConnectTimeout(15000);
                //设置读取超时时间
                connection.setReadTimeout(15000);
                //DoOutput设置是否向httpUrlConnection输出，DoInput设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个
                //设置是否可读取
                connection.setDoOutput(true);
                connection.setDoInput(true);
                //设置通用的请求属性
                connection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
                connection.setRequestProperty("connection", "Keep-Alive");
                //拼装参数
                if (null != param && !param.equals("")) {
                    //设置参数
                    os = connection.getOutputStream();
                    //拼装参数
                    os.write(param.getBytes("UTF-8"));
                }
                //开启连接
                connection.connect();
                //读取响应
                if (connection.getResponseCode() == 200) {
                    is = connection.getInputStream();
                    if (null != is) {
                        br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                        String temp = null;
                        while (null != (temp = br.readLine())) {
                            result.append(temp);
                            result.append("\r\n");
                        }
                    }
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                log.error("HttpUtil doPost exception! httpUrl={} param={}", httpUrl, param, e);
            } finally {
                //关闭连接
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                //关闭连接
                if (connection != null) {
                    connection.disconnect();
                }
            }
            log.info(" HttpUtil doPost end! result={}", result);
            return result.toString();
        }
    
    }

2.2.5 RsaUtil

> RSA加解密的工具类

package com.best.hope.utils;
    
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    import lombok.extern.slf4j.Slf4j;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Arrays;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:18 2023/5/19
     * @Modified By:
     */
    
    @Slf4j
    public class RsaUtil {
    
    
        /**
         * 算法加解密算法
         */
        private static final String ALGORITHM = "RSA";
    
        /**
         * 最大加密字节数，超出最大字节数需要分组加密
         */
        private static final Integer MAX_ENCRYPT_BLOCK = 117;
    
        private static final Integer MAX_DECRYPT_BLOCK = 128;
    
        /**
         * 请求报文公钥解密
         *
         * @param publicKeyString 公钥
         * @param text            报文
         * @return 加密报文
         */
        public static String encrypt(String publicKeyString, String text) {
            try {
                PublicKey publicKey = getPublicKey(publicKeyString);
                return encryptRSA(publicKey, text);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("RsaUtil encrypt exception! publicKeyString={} text={}", publicKeyString, text);
                return null;
            }
        }
    
        /**
         * 应答报文公钥解密
         *
         * @param publicKeyString 公钥
         * @param text            应答密文
         * @return 解密报文
         */
        public static String decrypt(String publicKeyString, String text) {
            try {
                PublicKey publicKey = getPublicKey(publicKeyString);
                return decryptRSA(publicKey, text);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("RsaUtil decrypt exception! publicKeyString={} text={}", publicKeyString, text);
                return null;
            }
        }
    
        /**
         * RSA 加密
         *
         * @param key  密钥
         * @param text 原文
         * @return 密文
         * @throws Exception 异常
         */
        private static String encryptRSA(Key key, String text) throws Exception {
            // 创建加密对象
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            // 对加密进行初始化 第一个参数是加密模式，第二个参数是你想用的公钥加密还是私钥加密
            cipher.init(Cipher.ENCRYPT_MODE, key);
            // 分段加密
            byte[] make = doCrypt(text.getBytes(), cipher, MAX_ENCRYPT_BLOCK);
            return Base64.encode(make);
        }
    
        /**
         * RSA 解密
         *
         * @param key  密钥
         * @param text 密文
         * @return 明文
         * @throws Exception 异常
         */
        private static String decryptRSA(Key key, String text) throws Exception {
            // 创建加解密对象
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            // 对解密进行初始化 第一个参数是加密模式，第二个参数是你想用的公钥解密还是私钥解密
            cipher.init(Cipher.DECRYPT_MODE, key);
            //分段解密
            byte[] make = doCrypt(Base64.decode(text), cipher, MAX_DECRYPT_BLOCK);
            return new String(make);
        }
    
        /**
         * 分段加解密
         *
         * @param data     要加解密的内容数组
         * @param cipher   加解密对象
         * @param maxBlock 分段大小
         * @return 结果
         * @throws IllegalBlockSizeException 异常
         * @throws BadPaddingException       异常
         */
        private static byte[] doCrypt(byte[] data, Cipher cipher, Integer maxBlock) throws IllegalBlockSizeException, BadPaddingException {
            int inputLength = data.length;
            // 标识
            int offSet = 0;
            byte[] resultBytes = {};
            byte[] cache;
            while (inputLength - offSet > 0) {
                if (inputLength - offSet > maxBlock) {
                    cache = cipher.doFinal(data, offSet, maxBlock);
                    offSet += maxBlock;
                } else {
                    cache = cipher.doFinal(data, offSet, inputLength - offSet);
                    offSet = inputLength;
                }
                resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
                System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
            }
            return resultBytes;
        }
    
        /**
         * 获取私钥
         *
         * @param privateKeyString 私钥路径
         * @return 私钥
         */
        private static PrivateKey getPrivateKey(String privateKeyString) throws Exception {
            // 创建key的工厂
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            // 创建私钥key的规则
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
            // 返回私钥对象
            return keyFactory.generatePrivate(keySpec);
        }
    
        /**
         * 获取公钥
         *
         * @param publicKeyString 公钥
         * @return 公钥
         * @throws Exception 异常
         */
        private static PublicKey getPublicKey(String publicKeyString) throws Exception {
            // 创建key的工厂
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            // 创建公钥key的规则
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
            // 返回公钥对象
            return keyFactory.generatePublic(keySpec);
        }
    }

2.2.5 App

> 测试类

package com.best.hope;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:18 2023/5/19
     * @Modified By:
     */
    
    import com.alibaba.fastjson.JSONObject;
    import com.best.hope.client.SysUserClient;
    import com.best.hope.domain.SysUserDTO;
    import com.best.hope.domain.common.HopeRequest;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    
    public class App {
    
        /**
         * 公钥
         */
        private static final String PUBLIC_KEY_STRING = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwr8qdHqUB8E2lPlj8fmbntolUdyXIXh2U1BCEzx1vWp4VvIjJLXhN5vN2btnuldfy252laDRtxjt4uuQujIgTHiYWtTyoGK5bx3uXC81pVsEOgcQjgraNpubC1l3duMSadufapSsqcNRfXTFaiQGgjvtrA01AW3QS/ciSweiedQIDAQAB";
    
    //    public static void main(String[] args) {
    //        SysUserDTO dto = new SysUserDTO();
    //        dto.setUserName("吴素");
    //        dto.setId(9);
    //        dto.setAge("20");
    //        dto.setUserEmail("nangong@163.com");
    //        HopeRequest hopeRequest = new HopeRequest();
    //        hopeRequest.setAppId("zkawTest");
    //        hopeRequest.setPublicKey(PUBLIC_KEY_STRING);
    //        hopeRequest.setType("list");
    //        hopeRequest.setData(JSONObject.toJSONString(dto));
    //        String pageModelBaseResponse = SysUserClient.invokeApi(hopeRequest);
    //        System.out.println(pageModelBaseResponse);
    //    }
    
        /** @Author: best_liu
         * @Description:java中通过反射调用某个类中的方法
         * @Date: 9:38 2023/5/26
         * @Param [args]
         * @return void
         **/
        public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
            SysUserDTO dto = new SysUserDTO();
    //        dto.setUserName("吴素");
            dto.setId(9);
            dto.setAge("20");
            dto.setUserEmail("nangong@163.com");
            HopeRequest hopeRequest = new HopeRequest();
            hopeRequest.setAppId("zkawTest");
            hopeRequest.setPublicKey(PUBLIC_KEY_STRING);
            hopeRequest.setType("list");
            hopeRequest.setData(JSONObject.toJSONString(dto));
            Class clazz  =  SysUserClient.class;
            Method method =  clazz.getDeclaredMethod("invokeApi",new Class[]{HopeRequest.class});
            Object invoke = method.invoke(new SysUserClient(), new Object[]{hopeRequest});
            System.out.println(invoke);
        }
    
        /** @Author: best_liu
         * @Description: java中通过反射获取某个类中的所有方法信息
         * @Date: 14:52 2023/5/25
         * @Param [args]
         * @return void
         **/
    //    public static void main(String args[]) throws Exception {
    //        Class<?> cls = SysUserClient.class;
            public Method[] getMethods();//获取包括自身和继承（实现）过来的所有的public方法——Method不支持泛型<>，即后面不接<>
            public Method[] getDeclaredMethods();//获取自身所有的方法(private、public、protected，和访问权限无关)，不包括继承的
    //        Method methods[] = cls.getDeclaredMethods();
    //        for (Method met : methods) {
    //            String res = "";
    //            int mod = met.getModifiers();
    //            //先输出方法名字
    //            res = res + Modifier.toString(mod) + " " + met.getReturnType().getName() + " " + met.getName() +  "(";
    //            Class<?> params[] = met.getParameterTypes();
    //            for (int x = 0; x < params.length; x ++) {
    //                //拼凑出方法要求的数据类型
    //                res = res + params[x].getName() + " "  + "args-" + x;
    //                if (x < params.length - 1) {
    //                    res = res +",";
    //                }
    //            }
    //            res = res + ") ";
    //            Class<?> exp[] = met.getExceptionTypes();
    //            if (exp.length > 0) {
    //                //获取其支持处理的异常信息
    //                res = res + "throws ";
    //            }
    //            for (int x = 0 ; x < exp.length ; x ++) {
    //                res = res + exp[x].getName();
    //                if (x < exp.length - 1) {
    //                    res = res +",";
    //                }
    //            }
    //            System.out.println(res);
    //            System.out.println(); //换行
    //        }
    //    }
    }

2.2.6 HopeRequest

> 这个是接口的入参，这里简单演示，一个客户端唯一编号（用来获取对应的私钥），一个是加密的入参。

package com.best.hope.domain.common;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:20 2023/5/19
     * @Modified By:
     */
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class HopeRequest {
        /**
         * 客户端唯一编号
         */
        private String appId;
    
        private String publicKey;
    
        private String type;
    
        /**
         * 加密后业务相关的入参
         */
        private String data;
    }

2.2.6 HopeResponse

package com.best.hope.domain.common;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:21 2023/5/19
     * @Modified By:
     */
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class HopeResponse {
    
        /**
         * 是否成功
         */
        private boolean success;
    
        /**
         * 返回信息
         */
        private String message;
    
        /**
         * 业务相关的返回信息，私钥加密之后的
         */
        private String data;
    
    }

2.2.7 ApiRequest

> 这个类是创建入参是用的，有客户端唯一Id（appId）,请求的接口地址，公钥还有业务相关的入参。

package com.best.hope.domain.common;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @Author: best_liu
     * @Description:
     * @Date Create in 10:21 2023/5/19
     * @Modified By:
     */
    
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class ApiRequest<T> {
    
        private String url;
        private String type;
        private String publicKey;
        private String appId;
        private T data;
    
    }

2.3 打包  
2.3.1 设置  
File ——》 Project Structure ——》 Project Settings ——》 Artifacts ——》 右栏左上角+ ——》JAR ——》 From Modules with dependencies——》OK

直接确定无需指定主类

不用更改 点击apply

2.3.2 构建  
Build ——》 Build Artifacts

Build（第一次构建）  
Rebuild（重新构建，会先自定清理上次构建jar包）  
Clean（清理构建好的jar包）

jar生成在out文件夹下

## 三、maven 引入本地sdk包 ##

### 3.1、cmd执行以下命令 ###

mvn install:install-file -Dmaven.repo.local=C:\Users\lx\.m2\repository -DgroupId=com.taobao -DartifactId=taobao-sdk-java-auto -Dversion=1.0.1 -Dpackaging=jar -Dfile=C:\Users\lx\Downloads\taobao-sdk-java-auto_1479188381469-20211105.jar

参数

Dmaven.repo.local   指定的maven仓库的地址
    DgroupId            指maven创库存放jar包的路径, 也是pom文件中groupId：标签中的值；
    DartifactId         指是pom文件中artifactId标签中的值
    Dversion            指版本号；
    Dfile               指当前jar所存放的位置

### 3.2、在pom中引入依赖 ###

<dependency>
                <groupId>com.best.hope</groupId>
                <artifactId>hope-sdk</artifactId>
                <version>1.0.1</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-api</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>ch.qos.logback</groupId>
                        <artifactId>logback-classic</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

### 3.3、测试 ###

/** @Author: best_liu
         * @Description:java中通过反射调用某个类中的方法
         * @Date: 9:38 2023/5/26
         * @Param [args]
         * @return void
         **/
        public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
            SysUserDTO dto = new SysUserDTO();
    //        dto.setUserName("吴素");
            dto.setId(9);
            dto.setAge("20");
            dto.setUserEmail("nangong@163.com");
            HopeRequest hopeRequest = new HopeRequest();
            hopeRequest.setAppId("zkawTest");
            hopeRequest.setPublicKey(PUBLIC_KEY_STRING);
            hopeRequest.setType("list");
            hopeRequest.setData(JSONObject.toJSONString(dto));
            Class clazz  =  SysUserClient.class;
            Method method =  clazz.getDeclaredMethod("invokeApi",new Class[]{HopeRequest.class});
            Object invoke = method.invoke(new SysUserClient(), new Object[]{hopeRequest});
            System.out.println(invoke);
        }

接口已经调通结果已经打印在控制台

![ba26e46337f4439781a2a8e7c2e6582c.png][]

## 四、最后 ##

一个简单的java开发sdk得demo完成~

maven 引入本地sdk包：[JAVA----maven 引入本地sdk包\_Best\_Liu~的博客-CSDN博客][JAVA----maven _sdk_Best_Liu_-CSDN]

java反射获取类方法及调用类方法：[java反射获取方法以及调用方法\_Best\_Liu~的博客-CSDN博客][java_Best_Liu_-CSDN]

[Link 1]: https://so.csdn.net/so/search?q=%E5%AE%9E%E4%BD%93%E7%B1%BB&spm=1001.2101.3001.7020
[Link 2]: https://blog.csdn.net/weixin_38538285/article/details/107435312
[5862ffe7ef234b0a82d1b0007952081f.png]: https://img-blog.csdnimg.cn/5862ffe7ef234b0a82d1b0007952081f.png
[ba26e46337f4439781a2a8e7c2e6582c.png]: https://img-blog.csdnimg.cn/ba26e46337f4439781a2a8e7c2e6582c.png
[JAVA----maven _sdk_Best_Liu_-CSDN]: https://blog.csdn.net/askuld/article/details/130886732
[java_Best_Liu_-CSDN]: https://blog.csdn.net/askuld/article/details/130879471