@laijj@补充通用接口业务代码

ipu-show-server/pom.xml

@@ -70,10 +70,10 @@
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-starter-log4j2</artifactId>-->
<!--        </dependency>-->
        <!--        <dependency>-->
        <!--            <groupId>org.springframework.boot</groupId>-->
        <!--            <artifactId>spring-boot-starter-log4j2</artifactId>-->
        <!--        </dependency>-->
        <!--通用http接口-->
        <dependency>
            <groupId>cn.hutool</groupId>
@@ -97,6 +97,12 @@
            <artifactId>ipu-file-system</artifactId>
            <version>3.0</version>
        </dependency>
        <!--加密依赖包-->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk16</artifactId>
            <version>1.43</version>
        </dependency>
    </dependencies>
@@ -110,6 +116,19 @@
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
            </plugin>
            <!--引用本地jdk，主要是加解密组件需要用到-->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <compilerArguments>
                        <bootclasspath>${JAVA_HOME}/jre/lib/rt.jar:${JAVA_HOME}/jre/lib/jce.jar</bootclasspath>
                        <extdirs>${project.basedir}/libs</extdirs>
                    </compilerArguments>
                </configuration>
            </plugin>
        </plugins>
        <finalName>ipu-show-server</finalName>
    </build>

ipu-show-server/src/main/java/com/ai/ipu/show/bean/CommonBean.java

@@ -3,21 +3,25 @@ package com.ai.ipu.show.bean;
import cn.hutool.http.HttpRequest;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.server.frame.bean.AbstractBean;
import com.ai.ipu.server.config.MobileConfig;
import com.ai.ipu.show.core.bean.IpuAppBean;
import com.ai.ipu.show.util.AesUtils;
import com.ailk.common.data.IData;
import com.ailk.common.data.impl.DataMap;
import com.alibaba.fastjson.JSON;
import com.ai.ipu.show.util.Constant;
import com.ai.ipu.show.util.SpringContextUtils;
import org.springframework.core.env.Environment;
import org.springframework.util.StringUtils;
import java.util.HashMap;
import java.util.Map;
/**
 * @author
 * @desc
 */
public class CommonBean extends AbstractBean {
public class CommonBean extends IpuAppBean {
    /**
     * 环境参数工具
@@ -98,5 +102,167 @@ public class CommonBean extends AbstractBean {
        sb.setLength(sb.length() - 1);
        return sb.toString();
    }
    /**
     * 通用公用接口请求方法
     *
     * @param requestParams
     * @return
     * @throws Exception
     */
    public IData commonInterfaceHandler(IData requestParams) throws Exception {
        //定义返回参数
        IData result = null;
        //先检查是否加密
        String encryptFlag = MobileConfig.getValue(Constant.COMMON_INTERFACE_KEY_ENCRYPTFLAG, Constant.COMMON_INTERFACE_DEFAULT_VALUE);
        String signFlag = MobileConfig.getValue(Constant.COMMON_INTERFACE_KEY_SIGNFLAG, Constant.COMMON_INTERFACE_DEFAULT_VALUE);
        //初始化正式参数，默认直接取上传的参数作为真实参数
        IData realReqParams = requestParams;
        if (Constant.COMMON_INTERFACE_TRUE_VALUE.equals(encryptFlag)) {
            //需要解密
            realReqParams = decryptReqData(requestParams);
        }
        if (Constant.COMMON_INTERFACE_TRUE_VALUE.equals(signFlag)) {
            //需要验签
            if (checkReqSign(realReqParams)) {
                result = createErrorMsg(realReqParams, "签名错误，请检查接口签名");
                return result;
            }
        }
        //请求类型(post/get)
        String requestType = realReqParams.getString(Constant.COMMON_INTERFACE_KEY_REQTYPE);
        //接口名称
        String interfaceName = realReqParams.getString(Constant.COMMON_INTERFACE_KEY_INTFNAME);
        if (StringUtils.isEmpty(requestType) || StringUtils.isEmpty(interfaceName)) {
            result = createErrorMsg(realReqParams, "请指定接口名称和请求方式");
            return result;
        }
        //重新组装业务请求参数
        //请求头内容
        Map<String, Object> headParamMap = new HashMap<>();
        IData headerDatas = realReqParams.getData(Constant.COMMON_INTERFACE_KEY_HEAD);
        for (String key : headerDatas.keySet()) {
            headParamMap.put(key, headerDatas.get(key));
        }
        //处理
        Map<String, Object> bodyParamMap = new HashMap<>();
        IData bodyDatas = realReqParams.getData(Constant.COMMON_INTERFACE_KEY_DATA);
        //请求body内容
        for (String key : requestParams.keySet()) {
            bodyParamMap.put(key, requestParams.get(key));
        }
        //获取json作为body
        String jsonParams = JSON.toJSONString(bodyParamMap);
        log.debug("获取到的json字符：jsonParams:" + jsonParams);
//        //接口加签名参数拼装
//        String appId = environment.getProperty(Constant.ENV_INTERFACE_APPID);
//        String timestamp = DateUtil.format(DateUtil.date(), "yyyyMMddHHmmss");
//        Map<String, String> signParam = new HashMap<String, String>();
//        signParam.put("appId", appId);
//        signParam.put("timestamp", timestamp);
//        // 如果业务参数需要加密，则这里需是加密后的值
//        signParam.put("content", jsonParams);
//        // 应用密钥
//        String key = environment.getProperty(Constant.ENV_INTERFACE_APPKEY);
//        //签名参数
//        String signValue = "";
//        try {
//            log.debug("接口签名加密参数：signParam:" + signParam.toString() + ",key:" + key);
//            signValue = SignUtil.sign(signParam, "HmacSHA256", key);
//            log.debug("接口签名加密结果：signValue:" + signValue);
//        } catch (Exception e) {
//            log.error("接口签名发生加密异常：" + e.getMessage());
//        }
        //外部接口返回的参数
        String reqResult = null;
        //请求url拼接
        String url = environment.getProperty(Constant.ENV_URL_BASEPATH) + interfaceName;
        //请求代理
        if (Boolean.parseBoolean(environment.getProperty(Constant.ENV_PROXY_FLAG))) {
            System.setProperty("http.proxySet", "true");
            System.setProperty("http.proxyHost", environment.getProperty(Constant.ENV_PROXY_SERVER));
            System.setProperty("http.proxyPort", environment.getProperty(Constant.ENV_PROXY_PORT));
        }
        //发送请求
        if (Constant.COMMON_INTERFACE_VALUE_POST.equalsIgnoreCase(requestType)) {
            log.debug("调用远端Post接口，接口请求地址:" + url + "，参数:" + jsonParams);
            HttpRequest httpRequest = HttpRequest.post(url);
            //添加header
            for (String headerKey : headParamMap.keySet()) {
                httpRequest.header(headerKey, headParamMap.get(headerKey).toString());
            }
            reqResult = httpRequest.contentType("application/json")
                    .body(jsonParams)
                    //超时，毫秒
                    .timeout(30000)
                    .execute().body();
            log.debug("调用远端Post接口，接口请求地址:" + url + "，返回:" + result);
        } else {
            //get请求，先要把参数转换到url里面
            String filterStrs = "requestType,interfaceName,token";
            String urlStr = idata2Url(requestParams, filterStrs);
            String reqUrl = url + urlStr;
            log.debug("调用远端get接口，接口请求地址:" + reqUrl);
            HttpRequest httpRequest = HttpRequest.get(reqUrl);
            //添加header
            for (String headerKey : headParamMap.keySet()) {
                httpRequest.header(headerKey, headParamMap.get(headerKey).toString());
            }
            reqResult = httpRequest
                    .contentType("x-www-form-urlencoded")
                    //超时，毫秒
                    .timeout(30000)
                    .execute().body();
            log.debug("调用远端get接口，接口请求地址:" + reqUrl + "，返回:" + reqResult);
        }
        IData retMap = createReturnData();
        if (Constant.COMMON_INTERFACE_TRUE_VALUE.equals(encryptFlag) && reqResult != null) {
            //需要加密
            String resultEncrypt = AesUtils.aes256ECBPkcs7PaddingHexEncrypt(reqResult, Constant.AES_KEY);
            retMap.put(Constant.COMMON_INTERFACE_KEY_DATA, resultEncrypt);
        } else {
            retMap.put(Constant.COMMON_INTERFACE_KEY_DATA, reqResult);
        }
        return retMap;
    }
    /**
     * 解密入参
     *
     * @param reqData
     * @return
     */
    public static IData decryptReqData(IData reqData) throws Exception {
        IData retIdata = new DataMap();
        //处理接口请求参数加解密
        String dataSrcStr = reqData.getString(Constant.COMMON_INTERFACE_KEY_DATA);
        log.debug("接口参数密文:" + dataSrcStr);
        if (dataSrcStr != null && dataSrcStr.length() > 0) {
            String dataJson = AesUtils.aes256ECBPkcs7PaddingHexDecrypt(dataSrcStr, Constant.AES_KEY);
            log.debug("接口参数解密后明文:" + dataJson);
            //把接口参数再次构造成DataMap赋值给参数对象
            retIdata = new DataMap(dataJson);
        }
        return retIdata;
    }
    /**
     * 签名验证方法
     *
     * @param reqData
     * @return
     * @throws Exception
     */
    public static boolean checkReqSign(IData reqData) throws Exception {
        //TODO Junjie.Lai 方法实现
        return true;
    }
}

ipu-show-server/src/main/java/com/ai/ipu/show/util/AesUtils.java

@@ -0,0 +1,112 @@
package com.ai.ipu.show.util;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.Security;
import java.util.Base64;
/**
 * AES加密工具类
 */
public class AesUtils {
    private static final String SECRET = "AES";
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS7Padding";
    static {
        Security.addProvider(new BouncyCastleProvider());
    }
    /**
     * AES加密ECB模式PKCS7Padding填充方式（Base64编码）
     * @param str 字符串
     * @param key 密钥
     * @return 加密字符串
     * @throws Exception 异常信息
     */
    public static String aes256ECBPkcs7PaddingEncrypt(String str, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
        byte[] doFinal = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
        return new String(Base64.getEncoder().encode(doFinal));
    }
    public static String encodeHexString(byte[] data) {
        StringBuilder sb = new StringBuilder();
        for (byte b : data) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
    public static String aes256ECBPkcs7PaddingHexEncrypt(String str, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
        byte[] doFinal = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
        return new String(encodeHexString(doFinal));
    }
    /**
     * AES解密ECB模式PKCS7Padding填充方式（Base64编码）
     * @param str 字符串
     * @param key 密钥
     * @return 解密字符串
     * @throws Exception 异常信息
     */
    public static String aes256ECBPkcs7PaddingDecrypt(String str, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
        byte[] doFinal = cipher.doFinal(Base64.getDecoder().decode(str));
        return new String(doFinal);
    }
    public static byte[] hexStringToByteArray(String hexString) {
        hexString = hexString.replaceAll(" ", "");
        int len = hexString.length();
        byte[] bytes = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
            bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
                    .digit(hexString.charAt(i+1), 16));
        }
        return bytes;
    }
    /**
     * AES解密ECB模式PKCS7Padding填充方式（Hex编码）
     * @param str 字符串
     * @param key 密钥
     * @return 解密字符串
     * @throws Exception 异常信息
     */
    public static String aes256ECBPkcs7PaddingHexDecrypt(String str, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, SECRET));
        byte[] doFinal = cipher.doFinal(hexStringToByteArray(str));
        return new String(doFinal);
    }
    public static void main(String[] args) throws Exception {
        String str = "fjadmin";
        System.out.println("字符串：" + str);
        String encryptStr = AesUtils.aes256ECBPkcs7PaddingEncrypt(str, "abcdefXXABCDEFxx");
        System.out.println("Base64编码，加密后字符串：" + encryptStr);
        String decryptStr = AesUtils.aes256ECBPkcs7PaddingDecrypt(encryptStr, "abcdefXXABCDEFxx");
        System.out.println("Base64编码，解密后字符串：" + decryptStr);
        String hexEncryptStr = AesUtils.aes256ECBPkcs7PaddingHexEncrypt(str, "abcdefXXABCDEFxx");
        System.out.println("Hex编码，加密后字符串：" + hexEncryptStr);
        String hexDecryptStr = AesUtils.aes256ECBPkcs7PaddingHexDecrypt(hexEncryptStr, "abcdefXXABCDEFxx");
        System.out.println("Hex编码，解密后字符串：" + hexDecryptStr);
    }
}

ipu-show-server/src/main/java/com/ai/ipu/show/util/Constant.java

@@ -89,4 +89,55 @@ public class Constant {
     */
    public static final String FILE_SAVE_PATH = "appserver.file.savepath";
    /**通用接口固定参数*/
    /**
     * 请求数据加密标识
     */
    public static final String COMMON_INTERFACE_KEY_ENCRYPTFLAG = "commInterfaceEncrypt";
    /**
     * 请求数据签名标识
     */
    public static final String COMMON_INTERFACE_KEY_SIGNFLAG = "commInterfaceSign";
    /**
     * AES加解密的KEY
     */
    public static final String AES_KEY = "onLineTradeTKAMC";
    /**
     * 参数标识，默认false
     */
    public static final String COMMON_INTERFACE_DEFAULT_VALUE = "false";
    /**
     * 参数标识，true
     */
    public static final String COMMON_INTERFACE_TRUE_VALUE = "true";
    /**
     * 接口请求类型
     */
    public static final String COMMON_INTERFACE_KEY_REQTYPE = "requestType";
    /**
     * 接口请求值
     */
    public static final String COMMON_INTERFACE_VALUE_POST = "POST";
    public static final String COMMON_INTERFACE_VALUE_GET = "GET";
    /**
     * 接口名称
     */
    public static final String COMMON_INTERFACE_KEY_INTFNAME = "interfaceName";
    /**
     * 发送到后端的请求head
     */
    public static final String COMMON_INTERFACE_KEY_HEAD = "head";
    /**
     * 发送到后端的请求data
     */
    public static final String COMMON_INTERFACE_KEY_DATA = "data";
}

ipu-show-server/src/main/resources/server-config.xml

@@ -21,6 +21,10 @@
    <config name="indexPage" value="Index"/>
    <!-- 文件是否加密 -->
    <config name="fileEncrypt" value="true"/>
    <!--通用接口是否加密-->
    <config name="commInterfaceEncrypt" value="false"/>
    <!--通用接口是否签名-->
    <config name="commInterfaceSign" value="false"/>
    <!-- 自定义异常管理器 -->
    <config name="exceptionHandler" value="com.ai.ipu.show.core.handler.IpuExceptionHandler"/>
    <!-- 自定义Session管理器 -->

ipu-show-server/src/main/resources/server-data.xml

@@ -5,7 +5,6 @@
    <!-- 模拟发送验证码 -->
    <action name="LoginBean.sendVerificationCode" class="com.ai.ipu.show.bean.LoginBean" method="sendVerificationCode" verify="false"></action>
    as>
    <!-- 上传下载 -->
    <action name="UploadDownloadBean.download" 	class="com.ai.ipu.show.bean.UploadDownloadBean" method="download" verify="false"></action>
    <action name="UploadDownloadBean.upload" 	class="com.ai.ipu.show.bean.UploadDownloadBean" method="upload" 	verify="false"></action>
@@ -61,4 +60,8 @@
    <!-- 通用转发接口 -->
    <action name="CommonBean.interfaceHandler" class="com.ai.ipu.show.bean.CommonBean" method="interfaceHandler" verify="false"></action>
    <!-- 通用转发功能接口，参数已经过优化处理，支持加密和验签 -->
    <action name="CommonBean.commonInterfaceHandler" class="com.ai.ipu.show.bean.CommonBean" method="commonInterfaceHandler" verify="false"></action>
</datas>