微信小微商户直连接口详解

项目背景：

       小微商户根据接口申请入驻、查看状态、进行签约。商户信息配置、Native扫码及小程序发起支付、查询订单、进行退款、查询退款。小微商户资料修改及提现。

 一、小微商户进件

遇到问题：

       1、返回错误信息及解决办法

                 (1)、输入商户号后、平台提示证书不存在。API文档中也没有具体解释（如图1-1）？

图 1-1

               已解决：关键在于参数中的商户号输入错误，经过沟通发现该商户号有两个，换个账号就可以解决问题

              (2)解密敏感信息失败                                        已解决--------仔细查看需要进行加密的参数，当时手机号没有加密导致微信方解密敏感信息失败

              (3)签名失败                                                      已解决--------参数中的sign字段应方在最后再进行签名，不能跟api中的参数顺序一样

              (4)身份证正面识别失败                                    已解决--------过期或失效的身份证无法识别成功

        2、Java实现AES加密，抛出异常（如图1-2）：

图 1-2

                去该地址http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html下载${jdk_home}/jre/lib/security和${jre_home}/lib/security目录下的 local_policy.jar 和 US_export_policy.jar文件并且将其覆盖   

        3、小微商户进件流程

• 申  请  入  驻：  (1)、先获取平台证书及序列号，并用返回的参数对证书进行解密得到平台证书的原文。ps：该原文用于对敏感信息加密

                                    (2)、使用加密方法对敏感信息进行加密

                                    (3)、将图片上传到接口获取图片id填写到请求入驻参数中

                                    (4)、剩下的参数依次填入map中最后进行签名使用证书通过接口上传商户信息，ps：注意中文编码

• 查询申请状态：(1)、查询时使用自定义的编号或者微信返回的申请单号其一即可查询，ps：签名也是在最后的参数

                                    (2)、将会返回审核状态，如果已审核成功变成待签约状态将会返回链接，商户扫码即可

 二、小微商户配置

       遇到问题：

        1、 返回错误信息及解决办法

                （1）绑定APPID时注意接口sub_appid参数示例                           已解决：此处的sub_appid对小程序支付有影响，需配置为小程序的id否则在下单时会造成公众号id与sub_appid不匹配

         2、配置流程

                （1）将商户的商户号与固定小程序id绑定即可

三、小微商户交易

        遇到问题：（appid-公众号id，mchid-商户号，subappid-小程序id及签名所需公钥请联系相关人员）

          1、返回错误信息及解决办法

                  （1）参数的必填项为可选填，结果返回缺少参数                         已解决：每个参数看好备注，不同的交易方式参数的可填项不一样

                  （2）native交易方式返回的支付URL打开无法支付                      已解决：必须生成二维码后进行扫码支付，无法直接打开链接支付

                  （3）每天在没有余额时退款失败                                                  已解决：每天都会自动提现到银行卡内导致账户无余额，无法直接退款，必须有余额

                  （4）查询退款时可能有多单返回                                                  已解决：查询退款时，尽量使用退款单号查询，一个订单号会有退款总金额不超过订单金额的退款单数，当超过20单时必须使用退款单号    

          2、交易流程

                 （1）提交自己内部的唯一商品订单号、商品详情、金额（分）、交易方式等参数返回扫码地址或小程序调起支付的参数

                 （2）查询订单时提供商户号、微信订单号或商户订单号即可

                 （3）订单生成后不能马上调用关单接口，最短调用时间间隔为5分钟，提供商户号、商户订单号即可关闭订单

                 （4）必须提供微信及内部订单号、内部唯一退款单号、订单总金额、退款金额申请退款，一笔退款失败后重新提交，请不要更换退款单号，请使用原商户退款单号再次申请退款

                 （5）查询退款提供退款单号即可

 四、小微商户资料修改及提现

           修改及提现流程：

             （1）输入商户号及提现单的日期即可，提现单的日期是前一天的金额的提现，不是当天的交易金额

             （2）提供商户号及银行名称、加密后的银行卡号即可修改成功

             （3）重新发起提现时，如果提现一号的交易请提供2号的日期

             （4）联系人信息提供后即可修改信息

 五、代码实现

　　　　本项目使用SSM模型开发

public class WeiXinAccountController {
    @Resource
    WeiXinAccountService weiXinAccountService;
    /**
     * 上传图片的序列id
     * @return 状态
     */
    public ReturnModel<?> getPhotoid(@RequestBody WXPhotoModel wxPhotoModel){
        ReturnModel returnModel = weiXinAccountService.getPhotoid(wxPhotoModel);
        return returnModel;
    }

    /**
     * 查询审核状态
     * @return 状态
     */
    public ReturnModel<?> queryForApply(@RequestBody WXApplyStateModel wxApplyStateModel){
        ReturnModel returnModel = weiXinAccountService.queryForApply(wxApplyStateModel);
        return returnModel;
    }

    /**
     * 提交参数进行审核
     * @param wxApplyForEntryModel 参数
     * @return 是否提交成功//商户存在时不可编辑（不可再次提交）
     */
    public ReturnModel<?> submitInfo(@RequestBody WXApplyForEntryModel wxApplyForEntryModel){
        return weiXinAccountService.submitInfo(wxApplyForEntryModel);
    }

    /***
     * 绑定AppID配置
     * @param wxAddSubDevConfigModel
     * @throws
     */
    public ReturnModel<?> addSubDevConfig(@RequestBody WXAddSubDevConfigModel wxAddSubDevConfigModel){
        return weiXinAccountService.addSubDevConfig(wxAddSubDevConfigModel);
    }

    /**
     * 统一下单native
     * @param wxUnifiedOrderModel
     * @return
     */
    public ReturnModel<?> unifiedOrderByNATIVE(@RequestBody WXUnifiedOrderModel wxUnifiedOrderModel, HttpServletRequest httpServletRequest){
        String ip = WXHttpUtil.getSpbillCreateIp(httpServletRequest);
        wxUnifiedOrderModel.setSpbillCreateIp(ip);
        return weiXinAccountService.unifiedOrderByNATIVE(wxUnifiedOrderModel);
    }
    /**
     * 统一下单jsapi
     * @param wxUnifiedOrderModel
     * @return
     */
    public ReturnModel<?> unifiedOrderByJSAPI(@RequestBody WXUnifiedOrderModel wxUnifiedOrderModel, HttpServletRequest httpServletRequest){
        String ip = WXHttpUtil.getSpbillCreateIp(httpServletRequest);
        wxUnifiedOrderModel.setSpbillCreateIp(ip);
        return weiXinAccountService.unifiedOrderByJSAPI(wxUnifiedOrderModel);
    }
    /**
     * 查询订单
     * @param wxOrderQueryModel
     * @return
     */
    public ReturnModel<?> orderQuery(@RequestBody WXOrderQueryModel wxOrderQueryModel){
        return weiXinAccountService.orderQuery(wxOrderQueryModel);
    }
    /**
     * 关闭订单，如果支付失败则需要关闭订单避免重复支付或超时系统退出不再受理也需要关闭
     * @param wxCloseOrderModel
     * @return
     */
    public ReturnModel<?> closeOrder(@RequestBody WXCloseOrderModel wxCloseOrderModel){
        return weiXinAccountService.closeOrder(wxCloseOrderModel);
    }

    /**
     * 申请退款
     * @param wxRefundModel
     * @return
     */
    public ReturnModel<?> refund(@RequestBody WXRefundModel wxRefundModel){
        return weiXinAccountService.refund(wxRefundModel);
    }

    /**
     * 查询退款
     * @param wxRefundQueryModel
     * @return
     */
    public ReturnModel<?> refundQuery(@RequestBody WXRefundQueryModel wxRefundQueryModel){
        return weiXinAccountService.refundQuery(wxRefundQueryModel);
    }

    /**
     * 提现状态查询
     * @param wxQueryAutoWithdrawByDate
     * @return
     */
    public ReturnModel<?> queryAutoWithdrawByDate(@RequestBody WXQueryAutoWithdrawByDate wxQueryAutoWithdrawByDate){
        return weiXinAccountService.queryAutoWithdrawByDate(wxQueryAutoWithdrawByDate);
    }

    /**
     * 修改银行卡号
     * @param modifyarchives
     * @return
     * @throws Exception
     */
    public ReturnModel<?> modifyArchives(@RequestBody WXModifyArchivesModel modifyarchives) throws Exception {
        return weiXinAccountService.modifyArchives(modifyarchives);
    }

    /**
     * 重新发起提现
     * @param reautowithdrawbydate
     * @return
     */
    public ReturnModel<?> reAutoWithdrawByDate(@RequestBody WXQueryAutoWithdrawByDate reautowithdrawbydate) {
        return weiXinAccountService.reAutoWithdrawByDate(reautowithdrawbydate);
    }

    /**
     * 修改商户联系信息
     * @param modifycontactinfo
     * @return
     *
     * @throws Exception
     */
    public ReturnModel<?> modifyContactInfo(@RequestBody WXModifyContactInfoModel modifycontactinfo) throws Exception {
        return weiXinAccountService.modifyContactInfo(modifycontactinfo);
    }
}

public class WeiXinAccountServiceImpl implements WeiXinAccountService {
    private final Logger LOGGER = LoggerFactory.getLogger(WeiXinAccountServiceImpl.class);
    /**
     * 准备申请入驻的参数
     * @return 入驻的参数
     * @throws Exception
     */
    public SortedMap<String, String> applyForEntry(WXApplyForEntryModel wxApplyForEntryModel) throws Exception {
        //先获取平台证书及序列号，并用返回的参数对证书进行解密得到平台证书的原文。
        // ps：该原文用于对敏感信息加密
        String certificatesInfo = getCertficates();
        if(("fail").equals(certificatesInfo) || ("").equals(certificatesInfo)){
            return null;
        }
        JSONArray data = JSONObject.parseArray(
                JSONObject.parseObject(certificatesInfo).getString("data"));
        //得到平台系列号
        String serialNo = JSONObject.parseObject(
                JSONObject.toJSONString(data.get(0))).getString("serial_no");
        //得到用于加密敏感信息的证书原文
        String cert = WXPayUtil.getWXCert(data);
        String name = RSAEncryptUtil.rsaEncrypt(wxApplyForEntryModel.getIdCardName(),cert);
        wxApplyForEntryModel.setVersion("3.0");
        wxApplyForEntryModel.setCertSn(serialNo);
        wxApplyForEntryModel.setMchId(WXConstant.MCHID);
        wxApplyForEntryModel.setNonceStr(String.valueOf(new Date().getTime()));
        wxApplyForEntryModel.setSignType(WXConstant.SIGNTTYPE);
        wxApplyForEntryModel.setIdCardNumber(
                RSAEncryptUtil.rsaEncrypt(wxApplyForEntryModel.getIdCardNumber(),cert));
        wxApplyForEntryModel.setIdCardName(name);
        wxApplyForEntryModel.setAccountName(name);
        wxApplyForEntryModel.setAccountNumber(
                RSAEncryptUtil.rsaEncrypt(wxApplyForEntryModel.getAccountNumber(),cert));
        wxApplyForEntryModel.setContact(name);
        wxApplyForEntryModel.setContactPhone(
                RSAEncryptUtil.rsaEncrypt(wxApplyForEntryModel.getContactPhone(),cert));
        SortedMap reqPara = AnnotationUtil.parseObjectToMap(wxApplyForEntryModel);
        return reqPara;
    }
    /**
     * 得到平台证书包含的参数json
     * @return
     */
    public String getCertficates(){
        SortedMap<String, String> reqDataToZS = new TreeMap<>();
        reqDataToZS.put("mch_id", WXConstant.MCHID);//服务商商户号
        reqDataToZS.put("nonce_str", WXPayUtil.getRandomString(32));//随机字符串
        reqDataToZS.put("sign_type", WXConstant.SIGNTTYPE);//签名类型
        reqDataToZS.put("sign", WXPayUtil.generateSignature(reqDataToZS,WXConstant.KEY,WXConstant.HMACSHA256TYPE));//签名
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithoutCert(WXConstant.ZHENGSHUURL,reqDataToZS);//证书接口返回所需参数
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("FAIL").equals(result.get("result_code"))){
            return "fail";
        }
        return result.get("certificates");
    }

    /**
     * 得到上传照片的id
     * @param wxPhotoModel 图片
     * @return 图片id
     */
    @Override
    public ReturnModel<?> getPhotoid(WXPhotoModel wxPhotoModel){
        String cent = "";
        InputStream fileInputStream = null;
        DataInputStream dis = null;
        byte[] bufferOut;
        try {
            URL url = new URL(wxPhotoModel.getFileUrlPath());
            HttpURLConnection httpUrl = (HttpURLConnection) url.openConnection();
            httpUrl.setDoInput(true);
            httpUrl.setRequestMethod("GET");
            fileInputStream = httpUrl.getInputStream();
            dis = new DataInputStream(fileInputStream);
            bufferOut = new byte[httpUrl.getContentLength()];
            dis.read(bufferOut);
            cent = MD5.md5HashCode(bufferOut);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),e.getMessage());
        }finally {
            if (fileInputStream!=null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    LOGGER.error(e.getMessage());
                    return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),e.getMessage());
                }
            }
            if(dis!=null){
                try {
                    dis.close();
                } catch (IOException e) {
                    LOGGER.error(e.getMessage());
                    return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),e.getMessage());
                }
            }
        }
        if ("".equals(cent) || fileInputStream == null)
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"图片未获取到");
        SortedMap<String, String> reqData = new TreeMap<>();
        reqData.put("mch_id", WXConstant.MCHID);
        reqData.put("sign_type", WXConstant.SIGNTTYPE);
        reqData.put("media_hash", cent);
        reqData.put("sign", WXPayUtil.generateSignature(reqData,
                WXConstant.KEY, WXConstant.HMACSHA256TYPE));
        MultipartEntityBuilder builder = MultipartEntityBuilder.create();
        builder.addTextBody("mch_id",WXConstant.MCHID, ContentType.MULTIPART_FORM_DATA);
        builder.addBinaryBody("media",bufferOut, ContentType.DEFAULT_BINARY,wxPhotoModel.getFileName());
        builder.addTextBody("media_hash",cent, ContentType.MULTIPART_FORM_DATA);
        builder.addTextBody("sign_type",WXConstant.SIGNTTYPE, ContentType.MULTIPART_FORM_DATA);
        builder.addTextBody("sign",reqData.get("sign"), ContentType.MULTIPART_FORM_DATA);
        String returnStr = WXPayHttpUtil.WXHttpPostFormWithCert(WXConstant.MEDIAUURL,
                WXConstant.MCHID,WXConstant.CERTPATH,builder);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(result.isEmpty()){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"未获取到微信方图片id");
        }
        return new ReturnModel<>(result);
    }

    @Override
    public ReturnModel<?> unifiedOrderByNATIVE(WXUnifiedOrderModel wxUnifiedOrderModel) {
        wxUnifiedOrderModel.setProductId(WXPayUtil.getRandomString(32));
        wxUnifiedOrderModel.setTradeType("NATIVE");
        return unifiedOrder(wxUnifiedOrderModel);
    }

    @Override
    public ReturnModel<?> unifiedOrderByJSAPI(WXUnifiedOrderModel wxUnifiedOrderModel) {
        wxUnifiedOrderModel.setSubAppid(WXConstant.SUBAPPID);
        wxUnifiedOrderModel.setTradeType("JSAPI");
        return unifiedOrder(wxUnifiedOrderModel);
    }

    /**
     * 查询审核状态
     * @param applyState 参数-商户号、服务商自定义的用户编号
     * @return
     */
    @Override
    public ReturnModel<?> queryForApply(WXApplyStateModel applyState){
        applyState.setVersion("1.0");
        applyState.setMchId(WXConstant.MCHID);
        applyState.setNonceStr(WXPayUtil.getRandomString(32));
        applyState.setSignType(WXConstant.SIGNTTYPE);
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(applyState);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.QUERYURL,
                reqData,WXConstant.CERTPATH);
        if(("").equals(returnStr)){
            return new ReturnModel<>(ErrorCode.SERVER_ERROR.getCode(),"安全证书无法解析");
        }
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        if(("SUCCESS").equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            String applymentStateDesc = "申请状态:"+result.get("applyment_state_desc");
//            if(("REJECTED").equals(result.get("applyment_state"))){
//                //审核结果json
//                JSONArray audit_detail = JSONObject.parseArray(
//                        JSONObject.parseObject(
//                                result.get("audit_detail")).getString("audit_detail"));
//                //得到审核详情
//                String reject_reason = JSONObject.parseObject(
//                        JSONObject.toJSONString(audit_detail.get(0))).getString("reject_reason");
//                return applymentStateDesc+"	审核详情:"+reject_reason;
//            }
//            if(("TO_BE_SIGNED").equals(result.get("applyment_state"))){
//                return applymentStateDesc+"	小微商户号:"
//                        +result.get("sub_mch_id")+"	签约链接:"
//                        +result.get("sign_url");
//            }
//            if(("FINISH").equals(result.get("applyment_state"))){
//                return applymentStateDesc+"	小微商户号:"+result.get("sub_mch_id");
//            }
//            return applymentStateDesc;
        }
        return new ReturnModel<>(ErrorCode.SERVER_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 提交商户申请
     * @param wxApplyForEntryModel 请求商户信息
     * @return
     */
    @Override
    public ReturnModel<?> submitInfo(WXApplyForEntryModel wxApplyForEntryModel) {
        SortedMap<String,String> reqData = new TreeMap<>();
        try {
            reqData = applyForEntry(wxApplyForEntryModel);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());

        }
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.SUBMITURL,
                reqData, WXConstant.CERTPATH);
        if(("").equals(returnStr)){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"安全证书无法解析");
        }
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),
                    "返回信息:"+result.get("return_msg")+"错误描述:"+result.get("err_code_des"));
        }
        if(("SUCCESS").equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if(("SUCCESS").equals(result.get("result_code"))){
//                return "微信分配的申请单号："+result.get("applyment_id");
//            }
//            if(("FAIL").equals(result.get("result_code"))){
//                if(("EXIST").equals(result.get("err_code"))){
//                    return "商户已存在，对应的申请单当前状态不可编辑";
//                }
//                return result.get("err_code_des");
//            }
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 提现状态
     * @param wxQueryAutoWithdrawByDate
     * @return
     */
    @Override
    public ReturnModel<?> queryAutoWithdrawByDate(WXQueryAutoWithdrawByDate wxQueryAutoWithdrawByDate) {
        wxQueryAutoWithdrawByDate.setMchId(WXConstant.MCHID);
        wxQueryAutoWithdrawByDate.setSignType(WXConstant.SIGNTTYPE);
        wxQueryAutoWithdrawByDate.setNonceStr(WXPayUtil.getRandomString(32));
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxQueryAutoWithdrawByDate);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.QUERYAUTOWITHDRAWURL,
                reqData,WXConstant.CERTPATH);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if("SUCCESS".equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if("SUCCESS".equals(result.get("result_code"))){
//                if ("PROCESSING".equals(result.get("withdraw_status"))){
//                    return result.get("withdraw_status");
//                }else if ("SUCCESS".equals(result.get("withdraw_status"))){
//                    return result.get("date")+"	金额(分):"+result.get("amount")+"	提现成功时间："
//                            +result.get("success_time");
//                }
//                return result.get("withdraw_status");
//            }else if ("FAIL".equals(result.get("result_code"))){
//                if(result.get("err_code_des") != null && !"".equals(result.get("err_code_des"))){
//                    return result.get("err_code_des");
//                }
//                return result.get("err_code");
//            }
        }else if("FAIL".equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 统一下单
     * @param wxUnifiedOrderModel
     * @return
     */
    @Override
    public ReturnModel<?> unifiedOrder(WXUnifiedOrderModel wxUnifiedOrderModel) {
        wxUnifiedOrderModel.setAppid(WXConstant.APPID);
        wxUnifiedOrderModel.setMchId(WXConstant.MCHID);
        wxUnifiedOrderModel.setNonceStr(WXPayUtil.getRandomString(32));
        wxUnifiedOrderModel.setSignType(WXConstant.SIGNTTYPE);
        wxUnifiedOrderModel.setNotifyUrl(WXConstant.NOTIFYURL);
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxUnifiedOrderModel);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithoutCert(WXConstant.UNIFIEDORDERURL, reqData);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("SUCCESS").equals(result.get("return_code"))){
            if(("SUCCESS").equals(result.get("result_code"))){
//                if ("NATIVE".equals(wxUnifiedOrderModel.getTradeType())){
//                    return new ReturnModel<>(result);
//                }else
                    if("JSAPI".equals(wxUnifiedOrderModel.getTradeType())){
                    Map<String,String> payinfo = new HashMap<>();
                    payinfo.put("appId",wxUnifiedOrderModel.getAppid());
                    payinfo.put("nonceStr",WXPayUtil.getRandomString(32));
                    payinfo.put("package","prepay_id="+result.get("prepay_id"));
                    payinfo.put("signType",WXConstant.MD5TYPE);
                    payinfo.put("timeStamp",String.valueOf(new Date().getTime()));
                    payinfo.put("paySign",WXPayUtil.generateSignature(payinfo,WXConstant.KEY,WXConstant.MD5TYPE));
//                    String info = JSONObject.toJSONString(payinfo);
                    return new ReturnModel<>(payinfo);
                }
            }
//            if(("FAIL").equals(result.get("result_code"))){
//                return result.get("err_code_des");
//            }
            return new ReturnModel<>(result);
        }else if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 绑定AppID配置
     * @param wxAddSubDevConfigModel
     * @return
     */
    @Override
    public ReturnModel<?> addSubDevConfig(WXAddSubDevConfigModel wxAddSubDevConfigModel) {
        wxAddSubDevConfigModel.setAppid(WXConstant.APPID);
        wxAddSubDevConfigModel.setMchId(WXConstant.MCHID);
        wxAddSubDevConfigModel.setSubAppid(WXConstant.SUBAPPID);
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxAddSubDevConfigModel);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.ADDSUBDEVCONFIGURL, reqData, WXConstant.CERTPATH);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("SUCCESS").equals(result.get("return_code"))) {
            return new ReturnModel<>(result);
//            if(("SUCCESS").equals(result.get("result_code"))){
//                return "配置成功";
//            }else if(("FAIL").equals(result.get("result_code"))){
//                return result.get("err_code_des").replaceAll("[a-zA-Z]","");
//            }
        }else if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 订单查询
     * @param wxOrderQueryModel
     * @return
     */
    @Override
    public ReturnModel<?> orderQuery(WXOrderQueryModel wxOrderQueryModel) {
        wxOrderQueryModel.setSubAppid(WXConstant.SUBAPPID);
        wxOrderQueryModel.setAppid(WXConstant.APPID);
        wxOrderQueryModel.setMchId(WXConstant.MCHID);
        wxOrderQueryModel.setNonceStr(WXPayUtil.getRandomString(32));
        wxOrderQueryModel.setSignType(WXConstant.SIGNTTYPE);
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxOrderQueryModel);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithoutCert(WXConstant.ORDERQUERYURL, reqData);
        Map<String,String> result= WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("SUCCESS").equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if(("SUCCESS").equals(result.get("result_code")) && ("SUCCESS").equals(result.get("trade_state"))){
//                return result.get("trade_state_desc");
//            }else if(("SUCCESS").equals(result.get("result_code"))){
//                return result.get("out_trade_no")+"交易状态:"+result.get("trade_state");
//            }else if(("FAIL").equals(result.get("result_code"))){
//                return result.get("err_code_des");
//            }
        }else if (("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 关闭订单
     * @param wxCloseOrderModel
     * @return
     */
    @Override
    public ReturnModel<?> closeOrder(WXCloseOrderModel wxCloseOrderModel) {
        wxCloseOrderModel.setAppid(WXConstant.APPID);
        wxCloseOrderModel.setMchId(WXConstant.MCHID);
        wxCloseOrderModel.setNonceStr(WXPayUtil.getRandomString(32));
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxCloseOrderModel);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithoutCert(WXConstant.CLOSEORDERURL,reqData);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("SUCCESS").equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if(("SUCCESS").equals(result.get("result_code"))){
//                return "关闭成功";
//            }else if(("FAIL").equals(result.get("result_code"))){
//                if(("ORDERPAID").equals(result.get("err_code"))){
//                    return "订单已支付，不能发起关单，请当作已支付的正常交易";
//                }else if(("SYSTEMERROR").equals(result.get("err_code"))){
//                    return "系统异常，请重新调用";
//                }else if(("ORDERCLOSED").equals(result.get("err_code"))){
//                    return "订单已关闭，无需继续调用";
//                }else if(("SIGNERROR").equals(result.get("err_code"))){
//                    return "请检查签名参数和方法是否都符合签名算法要求";
//                }else if(("REQUIRE_POST_METHOD").equals(result.get("err_code"))){
//                    return "请检查请求参数是否通过post方法提交";
//                }else if(("REQUIRE_POST_METHOD").equals(result.get("err_code"))){
//                    return "请检查XML参数格式是否正确";
//                }
//            }
        }else if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 申请退款
     * @param wxRefundModel
     * @return
     */
    @Override
    public ReturnModel<?> refund(WXRefundModel wxRefundModel) {
        wxRefundModel.setSubAppid(WXConstant.SUBAPPID);
        wxRefundModel.setAppid(WXConstant.APPID);
        wxRefundModel.setMchId(WXConstant.MCHID);
        wxRefundModel.setNonceStr(WXPayUtil.getRandomString(32));
        wxRefundModel.setNotifyUrl(WXConstant.NOTIFYURL);
        wxRefundModel.setSignType(WXConstant.SIGNTTYPE);
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxRefundModel);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.REFUNDURL,
                reqData,WXConstant.CERTPATH);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("SUCCESS").equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if(("SUCCESS").equals(result.get("result_code"))){
//                return "申请退款成功";
//            }else if(("FAIL").equals(result.get("result_code"))){
//                return result.get("err_code_des");
//            }
        }else if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 查询退款（微信退款id查询，只查一笔）
     * @param wxRefundQueryModel
     * @return
     */
    @Override
    public ReturnModel<?> refundQuery(WXRefundQueryModel wxRefundQueryModel) {
        wxRefundQueryModel.setSubAppid(WXConstant.SUBAPPID);
        wxRefundQueryModel.setAppid(WXConstant.APPID);
        wxRefundQueryModel.setMchId(WXConstant.MCHID);
        wxRefundQueryModel.setSignType(WXConstant.SIGNTTYPE);
        wxRefundQueryModel.setNonceStr(WXPayUtil.getRandomString(32));
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(wxRefundQueryModel);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithoutCert(WXConstant.REFUNDQUERYURL,reqData);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if(("SUCCESS").equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if(("SUCCESS").equals(result.get("result_code"))){
//                return result.get("refund_status_0");
//            }else if(("FAIL").equals(result.get("result_code"))){
//                return result.get("err_code_des");
//            }
        }else if(("FAIL").equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 修改银行卡号
     * @param modifyarchives
     * @return
     */
    @Override
    public ReturnModel<?> modifyArchives(WXModifyArchivesModel modifyarchives) {
        modifyarchives.setVersion("1.0");
        modifyarchives.setMchId(WXConstant.MCHID);
        modifyarchives.setNonceStr(WXPayUtil.getRandomString(32));
        modifyarchives.setSignType(WXConstant.SIGNTTYPE);
        String certificatesInfo = getCertficates();
        if(("fail").equals(certificatesInfo) || ("").equals(certificatesInfo)){
            return new ReturnModel<>(ErrorCode.SERVER_ERROR.getCode(),"安全证书无法解析");
        }
        JSONArray data = JSONObject.parseArray(
                JSONObject.parseObject(certificatesInfo).getString("data"));
        //得到平台系列号
        String serialNo = JSONObject.parseObject(
                JSONObject.toJSONString(data.get(0))).getString("serial_no");
        //得到用于加密敏感信息的证书原文
        String cert = WXPayUtil.getWXCert(data);
        modifyarchives.setCertSn(serialNo);
        modifyarchives.setAccountNumber(RSAEncryptUtil.rsaEncrypt("6214830195599542",cert));

        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(modifyarchives);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.MODIFYARCHIVESURL,reqData,WXConstant.CERTPATH);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if("SUCCESS".equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if("FAIL".equals(result.get("result_code"))){
//                return result.get("err_code");
//            }else if ("SUCCESS".equals(result.get("result_code"))){
//                return result.get("sub_mch_id")+"商户下的银行卡号修改成功";
//            }
        }else if ("FAIL".equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 重新发起提现
     * @param reautowithdrawbydate
     * @return
     */
    @Override
    public ReturnModel<?> reAutoWithdrawByDate(WXQueryAutoWithdrawByDate reautowithdrawbydate) {
        reautowithdrawbydate.setSignType(WXConstant.SIGNTTYPE);
        reautowithdrawbydate.setMchId(WXConstant.MCHID);
        reautowithdrawbydate.setNonceStr(WXPayUtil.getRandomString(32));
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(reautowithdrawbydate);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.REAUTOWITHDRAWBYDATEURL,
                reqData,WXConstant.CERTPATH);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if("SUCCESS".equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if ("SUCCESS".equals(result.get("result_code"))){
//                return result.get("date")+"	金额:"+result.get("amount");
//            }else if ("FAIL".equals(result.get("result_code"))){
//                return result.get("err_code")+result.get("err_code_des");
//            }
        }else if ("FAIL".equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }

    /**
     * 修改商户联系信息
     * @param modifycontactinfo
     * @return
     */
    @Override
    public ReturnModel<?> modifyContactInfo(WXModifyContactInfoModel modifycontactinfo) {
        modifycontactinfo.setVersion("1.0");
        modifycontactinfo.setMchId(WXConstant.MCHID);
        modifycontactinfo.setNonceStr(WXPayUtil.getRandomString(32));
        modifycontactinfo.setSignType(WXConstant.SIGNTTYPE);
        String certificatesInfo = getCertficates();
        if(("fail").equals(certificatesInfo) || ("").equals(certificatesInfo)){
            return new ReturnModel<>(ErrorCode.SERVER_ERROR.getCode(),"安全证书无法解析");
        }
        JSONArray data = JSONObject.parseArray(
                JSONObject.parseObject(certificatesInfo).getString("data"));
        //得到平台系列号
        String serialNo = JSONObject.parseObject(
                JSONObject.toJSONString(data.get(0))).getString("serial_no");
        //得到用于加密敏感信息的证书原文
        String cert = WXPayUtil.getWXCert(data);
        modifycontactinfo.setCertSn(serialNo);
        modifycontactinfo.setMobilePhone(RSAEncryptUtil.rsaEncrypt(modifycontactinfo.getMobilePhone(),cert));
        modifycontactinfo.setEmail(RSAEncryptUtil.rsaEncrypt(modifycontactinfo.getEmail(),cert));
        SortedMap<String,String> reqData = AnnotationUtil.parseObjectToMap(modifycontactinfo);
        String returnStr = WXPayHttpUtil.WXHttpPostXMLWithCert(WXConstant.MODIFYCONTACTINFOURL,
                reqData,WXConstant.CERTPATH);
        Map<String,String> result = WXPayXmlUtil.parseXMLToMap(returnStr);
        if ("SUCCESS".equals(result.get("return_code"))){
            return new ReturnModel<>(result);
//            if ("SUCCESS".equals(result.get("result_code"))){
//                return result.get("sub_mch_id")+"商户修改信息成功";
//            }else if ("FAIL".equals(result.get("result_code"))){
//                return result.get("err_code")+result.get("err_code_des");
//            }
        }else if ("FAIL".equals(result.get("return_code"))){
            return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),result.get("return_msg"));
        }
        return new ReturnModel<>(ErrorCode.BUSINESS_ERROR.getCode(),"结果解析错误");
    }
}

public class WXPayHttpUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(WXPayHttpUtil.class);

    private final static String UTFCHARSET = "UTF-8";
    private final static String XMLCONTENT = "text/xml;charset=utf-8";
    private final static String FORMCONTENT = "multipart/form-data;charset=utf-8";
    /**
     * 需证书上传form表单形式接口
     * @param url 接口地址
     * @param mcdId 商户号即密码
     * @param certPath 证书文件位置
     * @param builder 表单参数
     * @return
     */
    public static String WXHttpPostFormWithCert(String url, String mcdId, String certPath, MultipartEntityBuilder builder){
        HttpPost uploadFile = new HttpPost(url);
        SSLConnectionSocketFactory sslsf = null;
        StringBuilder stringBuilder = new StringBuilder();
        //读取本机存放的PKCS12证书文件
        ClassLoader classLoader = WXPayHttpUtil.class.getClassLoader();
        URL resource = classLoader.getResource(certPath);
        try(FileInputStream pkcfile = new FileInputStream(new File(resource.getPath()));
        ){
            //指定读取证书格式为PKCS12
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            //"100000"为密码即商户号
            keyStore.load(pkcfile,  mcdId.toCharArray());
            SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore,  mcdId.toCharArray()).build();
            //指定TLS版本
            sslsf = new SSLConnectionSocketFactory(sslcontext);
        } catch (Exception e) {
            LOGGER.debug(e.getMessage());
            return "";
        }
        HttpEntity multipart = builder.build();
        uploadFile.setEntity(multipart);
        uploadFile.setHeader("Content-Type", FORMCONTENT);
        try(CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(sslsf).build();
            CloseableHttpResponse response = client.execute(uploadFile);)
        {
            if(response != null && response.getEntity() != null){
                HttpEntity entity = response.getEntity();
                try (
                        InputStream in = entity.getContent();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in,"UTF-8")))
                {
                    reader.lines().forEach(line->{
                        stringBuilder.append(line);
                    });
                }
            }
        } catch (IOException e) {
            LOGGER.debug(e.getMessage());
            return "";
        }


        return stringBuilder.toString();
    }

    /**
     * 不需证书上传xml形式接口
     * @param url   接口地址
     * @param reqDataTo  请求参数
     * @return
     */
    public static String WXHttpPostXMLWithoutCert(String url,SortedMap<String, String> reqDataTo){
        HttpPost httpPost = new HttpPost(url);
        StringEntity postEntity = new StringEntity(WXPayXmlUtil.parseMapToXML(reqDataTo), UTFCHARSET);
        httpPost.setHeader("Content-Type", XMLCONTENT);
        httpPost.setEntity(postEntity);
        StringBuilder stringBuilder = new StringBuilder();
        try(CloseableHttpClient client = HttpClients.createDefault();
            CloseableHttpResponse response = client.execute(httpPost);)
        {if(response != null && response.getEntity() != null){
            HttpEntity entity = response.getEntity();
            try (
                    InputStream in = entity.getContent();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in,"UTF-8")))
            {
                reader.lines().forEach(line->{
                    stringBuilder.append(line);
                });;
            }
        }
        } catch (IOException e) {
            LOGGER.debug(e.getMessage());
            return "";
        }
        return stringBuilder.toString();
    }

    /**
     * 需证书上传xml形式接口
     * @param url 接口地址
     * @param reqData 参数
     * @param certPath 证书文件位置
     * @return
     */
    public static String WXHttpPostXMLWithCert(String url,SortedMap<String, String> reqData,String certPath){
        HttpPost queryState = new HttpPost(url);
        SSLConnectionSocketFactory sslsf = null;
        //读取本机存放的PKCS12证书文件
        ClassLoader classLoader = ConfigTool.class.getClassLoader();
        URL resource = classLoader.getResource(certPath);
        try(FileInputStream pkcfile = new FileInputStream(new File(resource.getPath()));
        ){
            //指定读取证书格式为PKCS12
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            //"100000"为密码即商户号
            keyStore.load(pkcfile,  reqData.get("mch_id").toCharArray());
            SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(
                    keyStore,  reqData.get("mch_id").toCharArray()).build();
            sslsf = new SSLConnectionSocketFactory(sslcontext,
                    new String[]{"TLSv1"},
                    null,
                    new DefaultHostnameVerifier());
        } catch (Exception e) {
            LOGGER.debug(e.getMessage());
            return "";
        }
        StringBuilder stringBuilder = new StringBuilder();
        StringEntity postEntity = new StringEntity(WXPayXmlUtil.parseMapToXML(reqData), "UTF-8");
        queryState.setEntity(postEntity);
        queryState.setHeader("Content-Type", XMLCONTENT);
        try(CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(sslsf).build();
            CloseableHttpResponse response = client.execute(queryState);)
        {
            if(response != null && response.getEntity() != null){
                HttpEntity entity = response.getEntity();
                try (
                        InputStream in = entity.getContent();
                        BufferedReader reader = new BufferedReader(
                                new InputStreamReader(in,"UTF-8")))
                {
                    reader.lines().forEach(line->{
                        stringBuilder.append(line);
                    });
                }
            }
        } catch (IOException e) {
            LOGGER.debug(e.getMessage());
            return "";
        }
        return stringBuilder.toString();
    }

}

public class WXPayUtil {
    private static final String ALGORITHM = "AES/GCM/NoPadding";
    private static final int TAG_LENGTH_BIT = 128;
    private static final String AES_KEY = "9bbbd2223e5240bb2252d05222210c27"; // APIv3密钥

    /**
     * 
     * @param aad
     * @param iv
     * @param cipherText
     * @return
     * @throws Exception
     */
    private static String aesgcmDecrypt(String aad, String iv, String cipherText){
        try {
            final Cipher cipher = Cipher.getInstance(ALGORITHM, "SunJCE");
            SecretKeySpec key = new SecretKeySpec(AES_KEY.getBytes(), "AES");
            GCMParameterSpec spec = new GCMParameterSpec(TAG_LENGTH_BIT, iv.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, key, spec);
            cipher.updateAAD(aad.getBytes());
            return new String(cipher.doFinal(Base64.getDecoder().decode(cipherText)));
        } catch (Exception e) {
            return "fail";
        }
    }
    public static String getWXCert(JSONArray data) {
        //敏感信息证书生成所需参数
        String encryptCertificate = JSONObject.parseObject(
                JSONObject.toJSONString(data.get(0))).getString("encrypt_certificate");
        String nonce = JSONObject.parseObject(
                encryptCertificate).getString("nonce");
        String associatedData = JSONObject.parseObject(
                encryptCertificate).getString("associated_data");
        //要被解密的证书字符串
        String cipherText = JSONObject.parseObject(
                encryptCertificate).getString("ciphertext");
        String wechatpayCert = "";
        try {
            wechatpayCert = aesgcmDecrypt(associatedData, nonce, cipherText);
        } catch (Exception e) {
            return wechatpayCert;
        }
        return wechatpayCert;
    }
    /**
     * 生成签名. 注意，若含有sign_type字段，必须和signType参数保持一致。
     *
     * @param data 待签名数据
     * @param key API密钥
     * @param signType 签名方式
     * @return 签名
     */
    public static String generateSignature(final Map<String, String> data, String key, String signType) {
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (k.equals("sign")) {
                continue;
            }
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("key=").append(key);
        if ("MD5".equals(signType)) {
            return MD5.getMD5(sb.toString()).toUpperCase();
        }
        else if ("HMACSHA256".equals(signType)) {
            return HMACSHAUtil.getHMACSHA256(sb.toString(), key);
        }
        return signType;
    }
    //获取指定位数的随机字符串(包含小写字母、大写字母、数字,0<length)
    public static String getRandomString(int length) {
        //随机字符串的随机字符库
        String KeyString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        StringBuffer sb = new StringBuffer(); int len = KeyString.length();
        for (int i = 0; i < length; i++) {
            sb.append(KeyString.charAt((int) Math.round(Math.random() * (len - 1))));
        }
        return sb.toString();
    }

public final class WXPayXmlUtil {
    public static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        documentBuilderFactory.setXIncludeAware(false);
        documentBuilderFactory.setExpandEntityReferences(false);

        return documentBuilderFactory.newDocumentBuilder();
    }

    public static Document newDocument() throws ParserConfigurationException {
        return newDocumentBuilder().newDocument();
    }

    /**
     * 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。
     *
     * @param strXML
     * @return
     */
    public static Map parseXMLToMap(String strXML) {
        Map<String, String> data = new HashMap<String, String>();
        try {
            DocumentBuilder documentBuilder = WXPayXmlUtil.newDocumentBuilder();
            InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
            Document doc = documentBuilder.parse(stream);
            doc.getDocumentElement().normalize();
            NodeList nodeList = doc.getDocumentElement().getChildNodes();
            for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                Node node = nodeList.item(idx);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    org.w3c.dom.Element element = (org.w3c.dom.Element) node;
                    data.put(element.getNodeName(), element.getTextContent());
                }
            }
            try {
                stream.close();
            } catch (Exception ex) {
                return data;
            }
        } catch (Exception ex) {
                return data;
        }
        return data;
    }

    /**
     * map转xml
     * @param data
     * @return
     */
    public static String parseMapToXML(SortedMap<String, String> data) {
//        StringBuffer sb = new StringBuffer();
//        sb.append("<xml>");
//        Set es = parameters.entrySet();
//        Iterator it = es.iterator();
//        while (it.hasNext()) {
//            Map.Entry entry = (Map.Entry)it.next();
//            String k = (String)entry.getKey();
//            String v = (String)entry.getValue();
//            if (null != v && !"".equals(v)) {
//                sb.append("<" + k + ">" + parameters.get(k) + "</" + k + ">
");
//            }
//        }
//        sb.append("</xml>");
//        return sb.toString();
//    }
        Document document = null;
        try {
            document = WXPayXmlUtil.newDocument();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        org.w3c.dom.Element root = document.createElement("xml");
        document.appendChild(root);
        for (String key: data.keySet()) {
            String value = data.get(key);
            if (value == null) {
                value = "";
            }
            value = value.trim();
            if(!("").equals(value)){
                org.w3c.dom.Element filed = document.createElement(key);
                filed.appendChild(document.createTextNode(value));
                root.appendChild(filed);
            }

        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = null;
        StringWriter writer = new StringWriter();
        String output = "";
        try {
            transformer = tf.newTransformer();
            DOMSource source = new DOMSource(document);
            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            StreamResult result = new StreamResult(writer);
            transformer.transform(source, result);
            output = writer.getBuffer().toString(); //.replaceAll("
|
", "");
        } catch (Exception e) {
            return output;
        }finally {
            try {
                writer.close();
            } catch (IOException e) {
                return output;
            }
        }
        return output;
    }
}

public class RSAEncryptUtil {
    private static final String CIPHER_PROVIDER = "SunJCE";
    private static final String TRANSFORMATION_PKCS1Paddiing = "RSA/ECB/PKCS1Padding";
    private static final String CHAR_ENCODING = "UTF-8";//固定值，无须修改
    //数据加密方法
    private static byte[] encryptPkcs1padding(PublicKey publicKey, byte[] data) throws Exception {
        Cipher ci = Cipher.getInstance(TRANSFORMATION_PKCS1Paddiing, CIPHER_PROVIDER);
        ci.init(Cipher.ENCRYPT_MODE, publicKey);
        return ci.doFinal(data);
    }
    //加密后的秘文，使用base64编码方法
    private static String encodeBase64(byte[] bytes) throws Exception {
        return Base64.getEncoder().encodeToString(bytes);
    }
    //对敏感内容（入参Content）加密，其中PUBLIC_KEY_FILENAME为存放平台证书的路径，平台证书文件存放明文平台证书内容，且为pem格式的平台证书（平台证书的获取方式参照平台证书及序列号获取接口，通过此接口得到的参数certificates包含了加密的平台证书内容ciphertext，然后根据接口文档中平台证书解密指引，最终得到明文平台证书内容）
     public static String rsaEncrypt(String Content,String cert){
         final byte[] PublicKeyBytes = cert.getBytes();
         X509Certificate certificate = null;
         try {
             certificate = X509Certificate.getInstance(PublicKeyBytes);
         } catch (CertificateException e) {
             return "";
         }
         PublicKey publicKey = certificate.getPublicKey();
         try {
             return encodeBase64(encryptPkcs1padding(publicKey, Content.getBytes(CHAR_ENCODING)));
         } catch (Exception e) {
             return "";
         }
     }
}

public class MD5 {

    /**
     * 签名字符串
     *
     * @param text
     *            需要签名的字符串
     * @param key
     *            密钥
     * @param input_charset
     *            编码格式
     * @return 签名结果
     */
    public static String sign(String text, String key, String charset) throws Exception {
        text = text + key;
        return DigestUtils.md5Hex(getContentBytes(text, charset));
    }

    /**
     * 签名字符串
     *
     * @param text
     *            需要签名的字符串
     * @param sign
     *            签名结果
     * @param key
     *            密钥
     * @param input_charset
     *            编码格式
     * @return 签名结果
     */
    public static boolean verify(String text, String sign, String key, String charset) throws Exception {
        text = text + key;
        String mysign = DigestUtils.md5Hex(getContentBytes(text, charset));
        if (mysign.equals(sign)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * @param content
     * @param charset
     * @return
     * @throws SignatureException
     * @throws UnsupportedEncodingException
     */
    private static byte[] getContentBytes(String content, String charset) {
        if (charset == null || "".equals(charset)) {
            return content.getBytes();
        }
        try {
            return content.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
        }
    }
    /**
     * 对文件进行MD5获取其Hash值
     *
     * @param fis
     * @return
     */
    public static String md5HashCode(InputStream fis) {
        try {
            MessageDigest MD5 = MessageDigest.getInstance("MD5");
            byte[] buffer = new byte[8192];
            int length;
            while ((length = fis.read(buffer)) != -1) {
                MD5.update(buffer, 0, length);
            }
            return new String(Hex.encodeHex(MD5.digest()));
        } catch (Exception e) {
            return "";
        }
    }

    public static String md5HashCode(byte[] fis) {
        try {
            MessageDigest MD5 = MessageDigest.getInstance("MD5");
            MD5.update(fis, 0, fis.length);
            return new String(Hex.encodeHex(MD5.digest()));
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * 生成 MD5
     *
     * @param data 待处理数据
     * @return MD5结果
     */
    public static String getMD5(String data) {
        MessageDigest md;
        byte[] array = new byte[0];
        try {
            md = MessageDigest.getInstance("MD5");
            array = md.digest(data.getBytes("UTF-8"));
        } catch (NoSuchAlgorithmException e) {
            return "";
        } catch (UnsupportedEncodingException e) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }
}

public class AnnotationUtil {
    /**
     * object转map
     * @param
     * @return
     */
    public static SortedMap<String, String> parseObjectToMap(Object obj){
        ArrayList<Field> fileds = new ArrayList<>();
        Class<?> objClass = obj.getClass();
        fileds.addAll(Arrays.asList(objClass.getDeclaredFields()));
        if(objClass.getSuperclass()!=null){
            fileds.addAll(Arrays.asList(objClass.getSuperclass().getDeclaredFields()));
        }
        SortedMap<String,String> map = new TreeMap<>();
        fileds.forEach(filed->{
            filed.setAccessible(true);
            Annotation annotations = filed.getAnnotation(WXPayParam.class);
            String k = ((WXPayParam) annotations).value();
            try {
               String v =  String.valueOf(filed.get(obj));
               if (null != v && !"".equals(v) && !"null".equals(v)) {
                   map.put(k,v);
               }
            } catch (IllegalAccessException e) {
                return;
            }
        });
        if(WXConstant.SIGNTTYPE.equals(map.get("sign_type"))){
            map.put("sign",WXPayUtil.generateSignature(map,WXConstant.KEY,WXConstant.HMACSHA256TYPE));
        }else{
            map.put("sign",WXPayUtil.generateSignature(map,WXConstant.KEY,WXConstant.MD5TYPE));
        }
        return map;
    }
}

public class HMACSHAUtil {
    /**
     * 生成 HMACSHA256
     * @param data 待处理数据
     * @param key 密钥
     * @return 加密结果
     * @throws Exception
     */
    public static String getHMACSHA256(String data, String key){
        Mac sha256_HMAC;
        byte[] array = null ;
        try {
            sha256_HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secret_key = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
            sha256_HMAC.init(secret_key);
            array = sha256_HMAC.doFinal(data.getBytes("UTF-8"));
        } catch (Exception e) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (byte item : array) {
            sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString().toUpperCase();
    }
}

 六、接口学习总结

　　　　微信接口可以说是相当标准的API文档，说明也比较详细但是对参数的说明不是很准确，导致自己在连接接口的时候看不懂什么意思，一顿询问相关人员参数的含义，希望自己连接微信接口后对于其他的接口也会轻车熟路，一定要细心每一个参数的配置、顺序就没多大问题

 ps:关注一下本人公众号，每周都有新更新哦！

有问题的话，博客回复太慢，可以加一下本人微信：请备注问题！谢谢