HMacSHA256签名方式

　　一：HMacSHA256的代码：

package com.huatech.httpapi.common.util;

import com.huatech.httpapi.business.i001.entity.comm.AccessTokenobject;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * String传参的HMacSHA256
 */
public class HMacSHA256 {
    private static String Encrypt(String message, String secret) {
        String hash = "";
        try {
            Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secret_key = new SecretKeySpec(secret.getBytes(), "HmacSHA256");
            sha256_HMAC.init(secret_key);
            byte[] bytes = sha256_HMAC.doFinal(message.getBytes());
            hash = byteArrayToHexString(bytes);
            System.out.println(hash);
        } catch (Exception e) {
            System.out.println("Error HmacSHA256 ===========" + e.getMessage());
        }
        return hash;
    }

    private static String byteArrayToHexString(byte[] b) {
        StringBuilder hs = new StringBuilder();
        String stmp;
        for (int n = 0; b!=null && n < b.length; n++) {
            stmp = Integer.toHexString(b[n] & 0XFF);
            if (stmp.length() == 1)
                hs.append('0');
            hs.append(stmp);
        }
        return hs.toString().toLowerCase();
    }

　　二：httpClient请求：

/**
 * @Description: TODO
 * @author: scott
 * @date: 2020年08月14日 15:29
 */
package com.huatech.httpapi.common.util;

import com.huatech.httpapi.business.i001.entity.comm.AccessTokenobject;
import com.huatech.httpapi.business.i001.entity.comm.PublicRequestobject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 是根据当前业务在httpclient的衍生出来的新的
 */
public class HttpHelper {
    public static String HttpPostWithJson(String url, String json) {
        String returnValue = "这是默认返回值，接口调用失败";
        CloseableHttpClient httpClient = HttpClients.createDefault();
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        try{
            //第一步：创建HttpClient对象
            httpClient = HttpClients.createDefault();
            //第二步：创建httpPost对象
            HttpPost httpPost = new HttpPost(url);
            //第三步：给httpPost设置JSON格式的参数
            StringEntity requestEntity = new StringEntity(json,"UTF-8");
            requestEntity.setContentEncoding("UTF-8");
            httpPost.setHeader("Content-type", "application/json; charset=utf-8");
            httpPost.setEntity(requestEntity);
            //第四步：发送HttpPost请求，获取返回值
            HttpResponse response = httpClient.execute(httpPost);
            //处理请求中文乱码的解决方案
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream instreams = entity.getContent();
                String str = convertStreamToString(instreams);
                httpPost.abort();
                return str;
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //第五步：处理返回值
        return returnValue;
    }
    //处理请求中文乱码的解决方法
    private static String convertStreamToString(InputStream is) {
        StringBuilder sb1 = new StringBuilder();
        byte[] bytes = new byte[4096];
        int size = 0;
        try {
            while ((size = is.read(bytes)) > 0) {
                String str = new String(bytes, 0, size, "UTF-8");
                sb1.append(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb1.toString();
    }



    //测试51接口的参数
    public static void main(String[] args) throws Exception {
        HMacSHA256 aMacSHA256 = new HMacSHA256();
        Class cls=Class.forName("com.huatech.httpapi.common.util.HMacSHA256");
        String url ="https://digi.aisino.com/accessToken/v1.0/get";
        PublicRequestobject p = new PublicRequestobject();
        p.setInterfaceCode("51.formatfile.build");
        p.setSpanId("");

        p.setDatagram("MIIOOQYJKoZIhvcNAQcEoIIOKjCCDiYCAQExgeYwgeMCAQAwXDBQMQswCQYDVQQGEwJDTjEQMA4G\\r\\nA1UECAwHTmluZ3hpYTERMA8GA1UEBwwIWWluY2h1YW4xDTALBgNVBAoMBENXQ0ExDTALBgNVBAMM\\r\\nBE5YQ0ECCBAAAAAAAAJWMA0GCSqBHM9VAYItAwUABHEEs032YArDNRbpsgc7X+dw+F2rGfUpoWwU\\r\\n8yZHAbRaBJz6UqRaeY+c8reqADPuTiYm7ghdA5h1oxoC2JLqa/9yuOGLmhxD3wmzTk/6p55NlkhY\\r\\nCphW7cu+LLeqXc2Mcgddxe0eEWlp0MeqEmEr4s3j0zEOMAwGCCqBHM9VAYMRBQAwggicBgkqhkiG\\r\\n9w0BBwEwGwYHKoEcz1UBaAQQVUo+6Vxu8qhIVkkRVavSs4CCCHCYjBC3ZVUEhf7Lh9r8H0+GnQkz\\r\\njG56czGZKFjXxLZEHfJn9DYlwp3PtLxvM+SLXKB4ORvzXlSLkAUz0iH/09fAxMexec1GX1/3vR1e\\r\\n/ybtR0p4WGKi/Y0HZvN4YemauC+GoXcFYy1IgYsCJjC6Ye40/LmpA+cn62sdlG4N7SR8h39UkkkY\\r\\naKeUM+wBjjxIUQGm8hENn6VSwJg8afI4liDjt8znw1ZV6pRk25QZKXVRL01U7YXDnZo7Yd5OJEqd\\r\\nBgzP1rPE7rKvUD5WJAT2lO1o9/oBDhl35v4MGlr8xrE3rbRRuNaa6ziqZHRHGPktwXuomXTsTgvq\\r\\nDmofv2lwBkkRjamoCMpZwCu20/nHc4NbHSemiSRXpCle/MXtfvdn9tqZW3dumtLt7+GoAeZx5bAt\\r\\nIYEnQ5qksvM+sxyhclOrTGqkdMMKv42R35t8vwhqNsQZoxhUe6A1X6KpOiTcmDR5iFdmohdKekAq\\r\\nTJcnfOR0EFQe1LHkpNkyE2edefM9D23giOfUsiFm/N4wr/ohGviZRn0mCnj54nDpx6gLm5UFqNLZ\\r\\nQHYZh9XmTronO01oCfgClDfMKJI51HfkWqvSm5yYyxPQ0ypf9yJr5SVN9x/MlQj+7rVtPqK8BVJf\\r\\nfKFoB6g+awdU2UTf9c3IdUDA+lut6aSMfINjbwgD1h2bT46sNsuzNdq/P1L4vQlLr+5WP3AZcvZY\\r\\n3Zhpu1Umexy7zOzBnpAtWHGMSDijpf5d6T0gIXtF1wh+HwoWCjrci6Gl07yX6lFGc6OQBY0NAqHP\\r\\nNCneTDy1AIARaHruu9pMLXim4U1b8P7oHGQhJ7ruX3R6kmOGzgeztq2lTgP5MX58Edt6/ZjERWaZ\\r\\nNejFxJ9vqn4zb0B5naAMD7aoSqkJAVfIvaqNh8uZCCHBRKVqKPfgQpeUp7EWzw0px2o+RZbQ/Au/\\r\\nkFAmUrTw9NFEjPMnHPWu9gX7HHA7kULgvRrwWK5yhd3VAvSd06MNm6+zu0xugcsgBdw2s+EBknCx\\r\\ng9SLF8fgy2J/zLAz2Du83U4VnuvhlYy5d+NnfycAO1YGx+bSa3MmxdyRPrfCVJld1get8UXkPtwt\\r\\nRZER0pR4hJoC5d6bDfc8d/j/ev5qLZ7yRlwRtbh4xXrglNmcdNajuzuIUIv8ufwXyyH6QgaA4JDS\\r\\nxDE6Xs0wnJZmc9rBuihepWCc44dlaeTXK/9Pa2bBCLbqGssNGwRsd9tca58DQIfRhWHE0GHILsVX\\r\\n3iDGVTv5+7EORF9l2AKIUc/NChUHe3snKv3ALLowCkUHnsEh67xG4V8iAC3Yi0vimBanrA+rlAAW\\r\\n0TNEn5DEeHjW0Jbc+e8gC5k+ZRqvrIdLswKK9OAhurR4tKMULGU7A1sj5J2QktNEgmyrwSWFy/dQ\\r\\ngR3SwBIoj+JRT7Bznn1hPsUGrcqeV3TBeDmPSu1Qk+rGBmW9/VW45oTbnIpxEDYHWzEyRMNNerPj\\r\\n3DrVTSn0bOuRCWQmWAqt3g7Vuem1ruC6u8DtiOYyORpcWqp28luHBOk8vw7KdvaCjCl1aiXCfhEq\\r\\n66Or3QN3RVbQVXaTR5munFQgky4CmTUEziG1cRj0majOUc1zJ8VymZLnfWVHZ795yRai//G6zVNi\\r\\nUX+OMoKNU3kbVh/FXPlnGgQVKlnpbr4+ECtyfiMsfQA+DOUwsENOjnONNd3woqQuM/RacBQ1logU\\r\\nLRAna03GkqsP7ajq6MMog+QPKyEE1rIyB5YMyQnl1AR+F5gXEYtzdJo6jkHKRAK4I0ElninQksoH\\r\\nmqdLGc635N4+mNGBAO5zK6t+28iRMAUsl73JHkVaUBl/L1qZbIiz3xSk/huzJRj+MM5QD3VssrjK\\r\\nTADJNnmrrze5uCLaBL1/YRyD6zKFbWagCOeGx/TDXIcKp/BN2SbNkHMkPV0oqB0azMm3dCaoON7z\\r\\nIQdbmi09tT7ajI7H8XTOPmaO+ke8UygN6iucRT22h/FEkV3hNnRkqtksfmBz8PmlB42wzNP/tCJI\\r\\nz7mkzeRjuaNR5nfik/xsmBysQJXOztZis+vTk1hUyA2/zrhejpkyYSrgVzJWlL2CXXTkpW5Azybz\\r\\nV2IAFksGXvzbMYhNq+C+DvOx2dLm4/3fyL7MxH9JGgbe87W5if9RPtLXKwvkhnt96p9ogWOeeqFe\\r\\n1KOGhCWO34MxDy4a8H6XEqPBRw0Y/CaLax/mAETt49Bx7Fc1yuGT19HEwZivIU0ufWD55RgwXgTO\\r\\n26/kLV1AD0zjCzzfQ3TNFHn3AnWPc13mNpG79en/q53X5V7hQojw3l/UTVZREGdo5qybmpepnnDY\\r\\ni3dtovdj/O2/xj/rpFKkhRoxrPWZ4IeqjBeid6VdHOb6txR4ULaKtrqlvBWU2HJbGNfmlskggCkY\\r\\n8JZRTFkAnzd9q43VtTDXwryRf5jDs5Kx1H2XNfP+mapvOwhnWGidQ6FDOV95+3gDveANYZ5XuNG4\\r\\nboeE5ChVVOG4biScp7rUOTOnjMZEl7yIPBUjYolJ9QZAF50oXpRVw9tlSzkQuV1Cgnw+n0ORMXeS\\r\\nnyRp1g9sMNsS6HFiUZOk+QZwxjpJOFKfHWi365UjO/5ymeW2oXdhynzz8iKMIXuvFG2vMUxClc7s\\r\\nZt2iCuQwhcD9bk7Lz7wI2oUDO8lhoyZysHG+52WaBNMRIUfZ87aR/TMX89rRbvD5D3dlsss+7Lnp\\r\\nry/iyv7HzHtypurdXCRUbh/HRlLW0pjAIiG35XSnIZPJAPwCYOjmU4ltutDPgiAXckCfK/d+/PwP\\r\\n1jgXAmyyfPYo+h9NBpmWvwDTnP0XrxFeaW3adLeDkIXO5HGyPvh+L+1B7IWN9P2y8fL4FulT/ofI\\r\\n0O/75TsK5/tNZLlAonIQfo5yc8UtHSpCVrG907s4RvKgggO9MIIDuTCCA12gAwIBAgIIEAAAAAEM\\r\\nTJYwDAYIKoEcz1UBg3UFADBQMQswCQYDVQQGEwJDTjEQMA4GA1UECAwHTmluZ3hpYTERMA8GA1UE\\r\\nBwwIWWluY2h1YW4xDTALBgNVBAoMBENXQ0ExDTALBgNVBAMMBE5YQ0EwHhcNMjAwNjE4MDc0MTUw\\r\\nWhcNMjMwNjE4MDc0MTUwWjCBjDEdMBsGA1UEAwwU6buR6b6Z5rGfNTHlubPlj7DllYYxHTAbBgNV\\r\\nBAsMFEhMSlBUMDAxMDAwMDAwMDAwMDAwMR0wGwYDVQQKDBTpu5HpvpnmsZ81MeW5s+WPsOWVhjEP\\r\\nMA0GA1UEBwwG5bmz5Y+wMQ8wDQYDVQQIDAblubPlj7AxCzAJBgNVBAYTAkNOMFkwEwYHKoZIzj0C\\r\\nAQYIKoEcz1UBgi0DQgAEfN3Ssqu8Ja2PYh9Jhzwz4Z+R/rrzwmOgroi1jv9mYuVjSDNd+Nma1ZEN\\r\\nHHIDGEuJWJ+32Ky8JpERWJpDV6j8mKOCAeAwggHcMB0GA1UdDgQWBBTUxZG1EKhXuAzWQg+iDjg/\\r\\n2pZ6djAfBgNVHSMEGDAWgBQaUUYQLj4n/Y0JC6HiYd0woT9IrTALBgNVHQ8EBAMCBsAwHQYDVR0l\\r\\nBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMEMIIBXgYDVR0fBIIBVTCCAVEwgbugY6Bhhl9sZGFwOi8v\\r\\nMjAyLjEwMC4xMDguMTM6Mzg5L2NuPWZ1bGxDcmwuY3JsLENOPU5YQ0FfTERBUCxPVT1OWENBLE89\\r\\nQ1dDQSxMPVlpbmNodWFuLFNUPU5pbmd4aWEsQz1DTqJUpFIwUDELMAkGA1UEBhMCQ04xEDAOBgNV\\r\\nBAgMB05pbmd4aWExETAPBgNVBAcMCFlpbmNodWFuMQ0wCwYDVQQKDARDV0NBMQ0wCwYDVQQDDARO\\r\\nWENBMIGQoDigNoY0aHR0cDovLzIwMi4xMDAuMTA4LjE1OjgxODEvbnhjYS8xMDAwMDAwMDAxMEM0\\r\\nQzAwLmNybKJUpFIwUDELMAkGA1UEBhMCQ04xEDAOBgNVBAgMB05pbmd4aWExETAPBgNVBAcMCFlp\\r\\nbmNodWFuMQ0wCwYDVQQKDARDV0NBMQ0wCwYDVQQDDAROWENBMAwGA1UdEwQFMAMBAQAwDAYIKoEc\\r\\nz1UBg3UFAANIADBFAiEA/PkawzIQRSGZbB8r2jkNnSXyzTkc+Aa9OefGctmm7bgCIGfCJ6wBQmhx\\r\\nP/4SAVZo4SfKiWeE1AoFkAyIiTbHUMofMYHGMIHDAgEBMFwwUDELMAkGA1UEBhMCQ04xEDAOBgNV\\r\\nBAgMB05pbmd4aWExETAPBgNVBAcMCFlpbmNodWFuMQ0wCwYDVQQKDARDV0NBMQ0wCwYDVQQDDARO\\r\\nWENBAggQAAAAAQxMljAMBggqgRzPVQGDEQUAMAoGCCqBHM9VAYN1BEYwRAIgUcjxI/KhNVL/vwsA\\r\\nFfZh3T8eg81iitd+eP+bZVJLXp0CIDdEyi3XmVcor5oBU5KD33UJuJc3Nh3ETjKjTcHSUMz1");
        p.setZipCode("0");
        p.setEncryptCode("2");
       // p.setSignature();

        p.setAccess_token("c35756480b5c6a542d7ea0a0065d56ce2643c56012ba71201311a3c208ed5050");


    }
}

　　三：测试申请身份令牌：

 public static void main(String[] args) {
        String url ="https://digi.aisino.com/accessToken/v1.0/get";
        AccessTokenobject atko = new AccessTokenobject();
        atko.setUserName("HLJTEST1");
        atko.setTaxpayerId("500102191212027426");
        atko.setTerminalId("1");
        atko.setSigntype("HMacSHA256");
        atko.setAuthorizationCode(HMacSHA256.Encrypt("Y4SKNBXECE","53244473").toUpperCase());
        atko.setTimestamp(new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()).toString());
        atko.setSignature(HMacSHA256.Encrypt(atko.getUserName()+atko.getTaxpayerId()+atko.getTerminalId()+atko.getSigntype()+atko.getAuthorizationCode()+atko.getTimestamp(),"53244473").toUpperCase());
        //调用接口请求身份令牌
        String s = HttpHelper.HttpPostWithJson(url, JsonUtils.object2Json(atko));
        System.out.println(s);

View Code

四：JSON处理工具类

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;

import com.fasterxml.jackson.databind.ObjectMapper;


public class JsonUtils {
    public static int PRETTY_PRINT_INDENT_FACTOR = 4;
    /**
     * <p>
     * 对象转JSON字符串
     * </p>
     *
     */
    public static String object2Json(Object obj) {
        String result = null;
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            result = objectMapper.writeValueAsString(obj);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }
    
    /**
     * <p>
     * JSON字符串转Map对象
     * </p>
     *
     */
    public static Map<?, ?> jsonToMap(String json) {
        return json2Object(json, Map.class);
    }
    
    /**
     * <p>
     * JSON转Object对象
     * </p>
     * @author xul
     *
     */
    public static <T> T json2Object(String json, Class<T> cls) {
        T result = null;
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            result = objectMapper.readValue(json, cls);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        return result;
    }
    
    /**
     * <p>
     * </p>
     * @author xul
     * @version V1.0
     */
    public static <T> T conveterObject(Object srcObject, Class<T> destObjectType) {
        String jsonContent = object2Json(srcObject);
        return json2Object(jsonContent, destObjectType);
    }
    
    /**
     * <p>
     * xml转json
     * </p>
     * @author xul
     * @version V1.0
     */
    public static  String xmlToJSON(String xml) {
        JSONObject obj = new JSONObject();
        try {
            InputStream is = new ByteArrayInputStream(xml.getBytes("utf-8"));
            SAXBuilder sb = new SAXBuilder();
            Document doc = sb.build(is);
            Element root = doc.getRootElement();
            Map map=iterateElement(root);
           obj.put(root.getName(),map);
           return obj.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * <p>
     * json转xml
     * </p>
     * @author xul
     * @version V1.0
     * @date 2018年05月03日 下午17:26:02
     * @param obj
     * @return
     */
    public static  String JsonToXml(Object json)
    {
        if(json==null){
            return null;
        }else{
         Element elements=new Element("return");
         getXMLFromObject(json,"return",elements);
         XMLOutputter xmlOut = new XMLOutputter();
         String res=xmlOut.outputString(elements);
         return res;
       }
    }
    
    private static Map  iterateElement(Element root) {
        List childrenList = root.getChildren();
        Element element = null;
        Map map = new HashMap();
        List list = null;
        for (int i = 0; i < childrenList.size(); i++) {
            list = new ArrayList();
            element = (Element) childrenList.get(i);
            if(element.getChildren().size()>0){
                if(root.getChildren(element.getName()).size()>1){
                    if (map.containsKey(element.getName())) {
                        list = (List) map.get(element.getName());
                    }
                    list.add(iterateElement(element));
                    map.put(element.getName(), list);
                }else{
                    map.put(element.getName(), iterateElement(element));
                }
            }else {
                if(root.getChildren(element.getName()).size()>1){
                    if (map.containsKey(element.getName())) {
                        list = (List) map.get(element.getName());
                    }
                    list.add(element.getTextTrim());
                    map.put(element.getName(), list);
                }else{
                    map.put(element.getName(), element.getTextTrim());
                }
            }
        }
        return map;
    }
  
    private static void getXMLFromObject(Object obj,String tag,Element parent)
    {
        if(obj==null)
            return;
        Element child;
        String eleStr;
        Object childValue;
        if(obj instanceof JSONObject)
        {
            JSONObject jsonObject=(JSONObject)obj;
            for(Object temp:jsonObject.keySet())
            {
                eleStr=temp.toString();
                childValue=jsonObject.get(temp);
                child=new Element(eleStr);
                if(childValue instanceof JSONArray)
                    getXMLFromObject(childValue,eleStr,parent);
                else{
                    parent.addContent(child);
                    getXMLFromObject(childValue,eleStr,child);
                }
            }
        }else if(obj instanceof JSONArray){
            JSONArray jsonArray=(JSONArray)obj;
            for(int i=0;i<jsonArray.size();i++)
            {
                childValue=jsonArray.get(i);
                child=new Element(tag);
                parent.addContent(child);
                getXMLFromObject(childValue,tag,child);
            }
        }else if(obj instanceof Date){
            SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            parent.setText(sf.format((Date)obj));
        }else{
            parent.setText(obj.toString());
        }
    }
}

View Code

五：FPTool工具类：

  1 package com.huatech.httpapi.common.util;
  2 
  3 import java.io.BufferedInputStream;
  4 import java.io.ByteArrayInputStream;
  5 import java.io.ByteArrayOutputStream;
  6 import java.io.FileInputStream;
  7 import java.io.IOException;
  8 import java.io.InputStream;
  9 import java.io.OutputStream;
 10 import java.util.zip.GZIPInputStream;
 11 import java.util.zip.GZIPOutputStream;
 12 
 13 import com.huatech.httpapi.business.i001.entity.comm.Kj;
 14 import com.huatech.httpapi.business.i001.entity.OpenInvoiceIn_001;
 15 import com.huatech.httpapi.business.i001.entity.comm.RePublicRequestobject;
 16 import sun.misc.BASE64Decoder;
 17 
 18 import com.aisino.ConfigurerInfo;
 19 import com.aisino.PKCS7;
 20 import com.huatech.httpapi.business.commentity.invoice.comm.ReturnStateInfo;
 21 import com.huatech.httpapi.business.i001.entity.comm.InvoiceConfig;
 22 
 23 /*
 24 http://192.169.254.175:8090/zzs_kpfw/webservice/eInvWS/211900999999307?wsdl
 25 */
 26 public class FPTool {
 27 
 28     public static final String zipCode = ConfigurerInfo.ZIP_NO; // 2：是否压缩
 29     public static final String encryptCode = ConfigurerInfo.ENCRYPT_YES; // 是否进行CA加密
 30     public static final String codeType = "CA"; // 加密方式
 31 
 32     private static String courseFile = FPTool.class.getResource("/").getPath()+"invoiceconfig/";
 33 
 34     // CA加密
 35     public static byte[] CAencode(String stringXml,String busiType,InvoiceConfig invoiceConfig) throws IOException,
 36             Exception {
 37         // 获取路径
 38         //String courseFile = FPTool.class.getResource("/").getPath()+"invoiceconfig/";
 39         // 定义变量
 40         byte[] dat, bszSignPfx, bszDecPfx, bszSrcData = null;
 41         String strEncCert = null, strTrusts = null;
 42         // 读取信任链文件
 43         System.out.println(courseFile + invoiceConfig.getTrustPath());
 44         dat = read(courseFile + invoiceConfig.getTrustPath());//"invoiceconfig\\trust.txt"
 45         strTrusts = new String(dat);
 46         if(busiType.equals("QZ")){//这个时候是签章
 47             // 读取公钥
 48             dat = read(courseFile + invoiceConfig.getQzPublicKeyPath());//"invoiceconfig\\51fapiao_20180523.cer"
 49             strEncCert = new String(dat);
 50             // 读取私钥
 51             bszSignPfx = read(courseFile + invoiceConfig.getQzPrivateKeyPath());//"invoiceconfig\\测试企业私钥.pfx"
 52         }else{
 53             // 读取公钥
 54             dat = read(courseFile + invoiceConfig.getKpPublicKeyPath());//"invoiceconfig\\51fapiao_20180523.cer"
 55             strEncCert = new String(dat);
 56             // 读取私钥
 57             bszSignPfx = read(courseFile + invoiceConfig.getKpPrivateKeyPath());//"invoiceconfig\\测试企业私钥.pfx"
 58         }
 59 
 60         //String strSignCertPfxPwd11 = new String(read(courseFile+ "私钥密码.txt"));
 61         // 密码为1234加证书名称
 62         String strSignCertPfxPwd = new String(invoiceConfig.getPrivateKeyPassword());//"invoiceconfig\\私钥密码.txt"
 63 
 64         // 加密
 65         dat = PKCS7.signedAndEnvelopedMulti(strTrusts, strEncCert, bszSignPfx,strSignCertPfxPwd, stringXml.getBytes("UTF-8"));
 66         if (dat == null) {
 67             System.out.println("CAerror" + PKCS7.getLastError());
 68             throw new Exception("" + PKCS7.getLastError());
 69         }
 70         System.out.println("CAsuccess==================");
 71 
 72         return dat;
 73     }
 74 
 75     public static byte[] CAencode(String stringXml) throws IOException, Exception {
 76         // 获取路径
 77         //String courseFile = FPTool.class.getResource("/").getPath() + "invoiceconfig\\";
 78         // 定义变量
 79         byte[] dat, bszSignPfx, bszDecPfx, bszSrcData = null;
 80         String strEncCert = null, strTrusts = null;
 81         // 读取信任链文件
 82         dat = read(courseFile + "trust.txt");//
 83         strTrusts = new String(dat);
 84         // 读取公钥
 85         dat = read(courseFile + "51fapiao_20180523.cer");// "invoiceconfig\\51fapiao_20180523.cer"
 86         strEncCert = new String(dat);
 87         // 读取私钥
 88         bszSignPfx = read(courseFile + "测试企业私钥.pfx");// "invoiceconfig\\测试企业私钥.pfx"
 89         // 密码为1234加证书名称
 90         String strSignCertPfxPwd = new String(read(courseFile
 91                 + "私钥密码.txt"));// "invoiceconfig\\私钥密码.txt"
 92         // 加密
 93         dat = PKCS7.signedAndEnvelopedMulti(strTrusts, strEncCert, bszSignPfx,
 94                 strSignCertPfxPwd, stringXml.getBytes("UTF-8"));
 95         if (dat == null) {
 96             System.out.println("CAerror" + PKCS7.getLastError());
 97             throw new Exception("" + PKCS7.getLastError());
 98         }
 99         System.out.println("CAsuss==================");
100         System.out.println("+++++++++++++++++++++++++++");
101         System.out.println(dat);
102         System.out.println("----------------------------");
103 
104         return dat;
105     }
106 
107 
108 
109     // CA解密
110     public static byte[] CAdecode(byte[] secondXmlByte,String busiType, InvoiceConfig invoiceConfig) throws IOException,
111             Exception {
112         // 获取路径
113         //String courseFile = FPTool.class.getResource("/").getPath()+"invoiceconfig/";
114         //System.out.println("====courseFile======="+courseFile);
115 
116         PKCS7 obj = null;
117 
118         byte[] bszDecPfx = null;
119 
120         if(busiType.equals("QZ")){//时候是签章
121             // 设置解密证书
122             bszDecPfx = read(courseFile + invoiceConfig.getQzPrivateKeyPath());//"invoiceconfig\\测试企业私钥.pfx"
123         }else{
124             // 设置解密证书
125             bszDecPfx = read(courseFile + invoiceConfig.getKpPrivateKeyPath());//"invoiceconfig\\测试企业私钥.pfx"
126         }
127         String strDecCertPfxPwd = new String(invoiceConfig.getPrivateKeyPassword());//"invoiceconfig\\私钥密码.txt"
128         // 读取信任链文件
129 
130         String strTrusts = new String(read(courseFile + invoiceConfig.getTrustPath()));//"invoiceconfig\\trust.txt"
131 
132 
133         obj = PKCS7.unpackMulti(strTrusts, bszDecPfx, strDecCertPfxPwd,secondXmlByte);
134         if (obj == null) {
135             System.out.println("unpackMulti :" + PKCS7.getLastError());
136         }
137         return obj.data;
138     }
139 
140     // CA解密
141     public static byte[] CAdecode(byte[] secondXmlByte) throws IOException,
142             Exception {
143         // 获取路径dll
144         //String courseFile = System.getProperty("user.dir");
145         //String courseFile = FPTool.class.getResource("/").getPath()+"invoiceconfig\\";
146         //System.out.println("====courseFile======="+courseFile);
147 
148         PKCS7 obj = null;
149         // 设置解密证书
150         byte[] bszDecPfx = read(courseFile + "测试企业私钥.pfx");//"invoiceconfig\\测试企业私钥.pfx"
151         String strDecCertPfxPwd = new String(read(courseFile + "私钥密码.txt"));//"invoiceconfig\\私钥密码.txt"
152         // 读取信任链文件
153 
154         String strTrusts = new String(read(courseFile + "trust.txt"));//"invoiceconfig\\trust.txt"
155 
156         obj = PKCS7.unpackMulti(strTrusts, bszDecPfx, strDecCertPfxPwd,secondXmlByte);
157         if (obj == null) {
158             System.out.println("unpackMulti :" + PKCS7.getLastError());
159         }
160         return obj.data;
161     }
162 
163     // Base64加密
164     public static String encodeStr(String encodeStr) throws Exception {
165         String s = new sun.misc.BASE64Encoder().encode(encodeStr
166                 .getBytes("UTF-8"));
167         return s;
168     }
169 
170     public static String encodeByte(byte[] encodeData) throws Exception {
171         String s = new sun.misc.BASE64Encoder().encode(encodeData);
172         return s;
173     }
174 
175     // Base64解密
176     public static byte[] decodeStr(String decodeStr) throws Exception {
177         byte[] b = new BASE64Decoder().decodeBuffer(decodeStr);
178         return b;
179     }
180 
181     // 数据压缩
182     public static byte[] compress(byte[] data) {
183         byte[] output = null;
184         try {
185             ByteArrayInputStream bais = new ByteArrayInputStream(data);
186             ByteArrayOutputStream baos = new ByteArrayOutputStream();
187             // 压缩
188             compress(bais, baos);
189             output = baos.toByteArray();
190 
191             baos.flush();
192             baos.close();
193 
194             bais.close();
195         } catch (Exception e) {
196             System.out.println("压缩数据失败:" + e);
197         }
198         return output;
199     }
200 
201     // 数据压缩
202     public static void compress(InputStream is, OutputStream os)
203             throws Exception {
204 
205         GZIPOutputStream gos = new GZIPOutputStream(os);
206 
207         int count;
208         byte data[] = new byte[1024];
209         while ((count = is.read(data, 0, 1024)) != -1) {
210             gos.write(data, 0, count);
211         }
212 
213         gos.finish();
214 
215         gos.flush();
216         gos.close();
217     }
218 
219     // 数据解压
220     public static byte[] decompress(byte[] data) throws Exception {
221         ByteArrayInputStream bais = new ByteArrayInputStream(data);
222         ByteArrayOutputStream baos = new ByteArrayOutputStream();
223 
224         decompress(bais, baos);
225         data = baos.toByteArray();
226 
227         baos.flush();
228         baos.close();
229         bais.close();
230 
231         return data;
232     }
233 
234     // 数据解压
235     public static void decompress(InputStream is, OutputStream os)
236             throws Exception {
237         GZIPInputStream gis = new GZIPInputStream(is);
238         int count;
239         byte data[] = new byte[1024];
240         while ((count = gis.read(data, 0, 1024)) != -1) {
241             os.write(data, 0, count);
242         }
243 
244         gis.close();
245     }
246 
247     public static byte[] read(String file) {
248         try {
249             BufferedInputStream in = new BufferedInputStream(
250                     new FileInputStream(file));
251             byte buf[] = new byte[in.available()];
252             in.read(buf, 0, buf.length);
253             in.close();
254             return buf;
255         } catch (IOException e) {
256             return null;
257         }
258     }
259 
260     /*
261      * QYInfo={ "interfaceCode"=接口编码, "nsrsbh"=纳税人识别号,
262      * "dataExchangeId"=数据交换流水号（唯一）(与发票请求流水号一致) }
263      */
264 
265     public static String request(String ReqContent,String busiCode,InvoiceConfig invoiceConfig) throws Exception {
266         // CA加密
267         byte[] encodeData = null;
268         boolean caB = false;
269         String BReqContent = "";
270         if (ConfigurerInfo.ENCRYPT_YES.equals(invoiceConfig.getQzCaType()) && busiCode.equals("QZ")) {
271             // CA加密
272             encodeData = CAencode(ReqContent,busiCode,invoiceConfig);
273             if (encodeData.length>(1024*10)){
274                 //如果传输数据大于10kb就进行压缩
275                 invoiceConfig.setQzGzipType("1");
276             }
277         } else if(ConfigurerInfo.ENCRYPT_YES.equals(invoiceConfig.getKpCaType()) && busiCode.equals("KP")){
278             // CA加密
279             encodeData = CAencode(ReqContent,busiCode,invoiceConfig);
280         }else{
281             caB = true;
282         }
283 
284         if (ConfigurerInfo.ZIP_YES.equals(invoiceConfig.getQzGzipType()) && busiCode.equals("QZ")) {
285             // 压缩
286             encodeData = compress(encodeData);
287         }else if(ConfigurerInfo.ZIP_YES.equals(invoiceConfig.getKpGzipType()) && busiCode.equals("KP")){
288             // 压缩
289             encodeData = compress(encodeData);
290         }
291         if(caB){
292             BReqContent = encodeStr(ReqContent);// Base64加密
293         }else{
294             BReqContent = encodeByte(encodeData);// Base64加密
295         }
296         return BReqContent;
297     }
298 
299     public static String QZRequest(String ReqContent) throws Exception {
300         // CA加密
301         byte[] encodeData = null;
302         if (ConfigurerInfo.ENCRYPT_YES.equals(encryptCode)) {
303             encodeData = CAencode(ReqContent);
304         } else if (ConfigurerInfo.ENCRYPT_NO.equals(encryptCode)) {
305             encodeData = ReqContent.getBytes();
306         }
307 
308         // 压缩
309         if (ConfigurerInfo.ZIP_YES.equals(zipCode)) {
310             encodeData = compress(encodeData);
311         }
312 
313         String BReqContent = encodeByte(encodeData);// Base64加密
314 
315 
316         return BReqContent;
317     }
318 
319     // 签章返回报文解析
320     public static String QZReturn(String ReturnStr,InvoiceConfig invoiceConfig) throws Exception {
321         String resXml = ReturnStr;
322         String returncontent = "";
323         // 截取外层报文中的returnCode和returnMessage
324         String returnCode = "";
325         String returnMessage = "";
326         returnCode = resXml.substring(resXml.indexOf("<returnCode>")
327                 + "<returnCode>".length(), resXml.indexOf("</returnCode>"));
328         // 判断returnMessage是否为空
329         if (resXml.contains("<returnMessage>")) {
330             returnMessage = new String(FPTool.decodeStr(resXml.substring(
331                     resXml.indexOf("<returnMessage>")
332                             + "<returnMessage>".length(),
333                     resXml.indexOf("</returnMessage>"))));
334         } else {
335             returnMessage = "测试服务器返回returnMessage为空";
336         }
337         // 判断内层报文Data是否为空
338         if (resXml.contains("<content>")) {
339             // 有内层报文进行处理（解压缩和解密）
340             String secondXml = resXml.substring(resXml.indexOf("<content>")
341                     + "<content>".length(), resXml.indexOf("</content>"));
342             // 判断需不需要解压缩
343             byte[] decodeData = null;
344             decodeData = FPTool.decodeStr(secondXml);// Base64解码
345             // 判断测试服务器返回内层报文是否进行了压缩：
346             if (ConfigurerInfo.ZIP_YES.equals(resXml.substring(
347                     resXml.indexOf("<zipCode>") + "<zipCode>".length(),
348                     resXml.indexOf("</zipCode>")))) {
349                 decodeData = FPTool.decompress(decodeData);// 解压
350             }
351 
352 
353             System.out.println("encryptCode:" + resXml.indexOf("<encryptCode>"));
354             System.out.println("/encryptCode:" + resXml.indexOf("</encryptCode>"));
355             System.out.println("encryptCode:" + resXml.substring(
356                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
357                     resXml.indexOf("</encryptCode>")));
358 
359             // 判断测试服务器返回是否进行了加密：
360             if (ConfigurerInfo.ENCRYPT_YES.equals(resXml.substring(
361                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
362                     resXml.indexOf("</encryptCode>")))) {
363                 decodeData = FPTool.CAdecode(decodeData,"QZ",invoiceConfig);// CA解密
364             }
365             returncontent = new String(decodeData, ConfigurerInfo.CHERSET_UTF8);
366         } else {
367             returncontent = "测试服务器返回内层报文为空";
368         }
369         System.out.println("returnCode:" + returnCode + "\nreturnMessage:"
370                 + returnMessage + "\ncontent:" + returncontent);
371 
372         return ReturnStr;
373     }
374     // 签章返回报文解析
375     public static String QZReturn(String ReturnStr) throws Exception {
376         String resXml = ReturnStr;
377         String returncontent = "";
378         // 截取外层报文中的returnCode和returnMessage
379         String returnCode = "";
380         String returnMessage = "";
381         returnCode = resXml.substring(resXml.indexOf("<returnCode>")
382                 + "<returnCode>".length(), resXml.indexOf("</returnCode>"));
383         // 判断returnMessage是否为空
384         if (resXml.contains("<returnMessage>")) {
385             returnMessage = new String(FPTool.decodeStr(resXml.substring(
386                     resXml.indexOf("<returnMessage>")
387                             + "<returnMessage>".length(),
388                     resXml.indexOf("</returnMessage>"))));
389         } else {
390             returnMessage = "测试服务器返回returnMessage为空";
391         }
392         // 判断内层报文Data是否为空
393         if (resXml.contains("<content>")) {
394             // 有内层报文进行处理（解压缩和解密）
395             String secondXml = resXml.substring(resXml.indexOf("<content>")
396                     + "<content>".length(), resXml.indexOf("</content>"));
397             // 判断需不需要解压缩
398             byte[] decodeData = null;
399             decodeData = FPTool.decodeStr(secondXml);// Base64解码
400             // 判断测试服务器返回内层报文是否进行了压缩：
401             if (ConfigurerInfo.ZIP_YES.equals(resXml.substring(
402                     resXml.indexOf("<zipCode>") + "<zipCode>".length(),
403                     resXml.indexOf("</zipCode>")))) {
404                 decodeData = FPTool.decompress(decodeData);// 解压
405             }
406 
407 
408             System.out.println("encryptCode:" + resXml.indexOf("<encryptCode>"));
409             System.out.println("/encryptCode:" + resXml.indexOf("</encryptCode>"));
410             System.out.println("encryptCode:" + resXml.substring(
411                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
412                     resXml.indexOf("</encryptCode>")));
413 
414             // 判断测试服务器返回是否进行了加密：
415             if (ConfigurerInfo.ENCRYPT_YES.equals(resXml.substring(
416                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
417                     resXml.indexOf("</encryptCode>")))) {
418                 decodeData = FPTool.CAdecode(decodeData);// CA解密
419             }
420             returncontent = new String(decodeData, ConfigurerInfo.CHERSET_UTF8);
421         } else {
422             returncontent = "测试服务器返回内层报文为空";
423         }
424         System.out.println("returnCode:" + returnCode + "\nreturnMessage:"
425                 + returnMessage + "\ncontent:" + returncontent);
426 
427         return ReturnStr;
428     }
429 
430     public static ReturnStateInfo judgeReturnCode(String ReturnStr) throws Exception {
431         ReturnStateInfo returnStateInfo = new ReturnStateInfo();
432         String resXml = ReturnStr;
433         // 截取外层报文中的returnCode和returnMessage
434         String returnCode = "";
435         String returnMessage = "";
436         returnCode = resXml.substring(resXml.indexOf("<returnCode>")
437                 + "<returnCode>".length(), resXml.indexOf("</returnCode>"));
438         returnStateInfo.setReturnCode(returnCode);
439         // 判断returnMessage是否为空
440         if (resXml.contains("<returnMessage>")) {
441             returnMessage = Encodes.decodeBase64String(resXml.substring(resXml.indexOf("<returnMessage>")+ "<returnMessage>".length(),resXml.indexOf("</returnMessage>")));
442             returnStateInfo.setReturnMessage(returnMessage);
443         } else {
444             returnMessage = "测试服务器返回returnMessage为空";
445             returnStateInfo.setReturnMessage(returnMessage);
446         }
447 
448         return returnStateInfo;
449     }
450 
451     public static String judgeReturnData(String ReturnStr) throws Exception {
452         String resXml = ReturnStr;
453         String returncontent = "";
454         // 判断内层报文Data是否为空
455         if (resXml.contains("<content>")) {
456             // 有内层报文进行处理（解压缩和解密）
457             String secondXml = resXml.substring(resXml.indexOf("<content>")
458                     + "<content>".length(), resXml.indexOf("</content>"));
459             // 判断需不需要解压缩
460             byte[] decodeData = null;
461             decodeData = FPTool.decodeStr(secondXml);// Base64解码
462             // 判断测试服务器返回内层报文是否进行了压缩：
463             if (ConfigurerInfo.ZIP_YES.equals(resXml.substring(
464                     resXml.indexOf("<zipCode>") + "<zipCode>".length(),
465                     resXml.indexOf("</zipCode>")))) {
466                 decodeData = FPTool.decompress(decodeData);// 解压
467             }
468 
469 
470             System.out.println("encryptCode:" + resXml.indexOf("<encryptCode>"));
471             System.out.println("/encryptCode:" + resXml.indexOf("</encryptCode>"));
472             System.out.println("encryptCode:" + resXml.substring(
473                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
474                     resXml.indexOf("</encryptCode>")));
475 
476             // 判断测试服务器返回是否进行了加密：
477             if (ConfigurerInfo.ENCRYPT_YES.equals(resXml.substring(
478                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
479                     resXml.indexOf("</encryptCode>")))) {
480                 decodeData = FPTool.CAdecode(decodeData);// CA解密
481             }
482             returncontent = new String(decodeData, ConfigurerInfo.CHERSET_UTF8);
483         } else {
484             returncontent = "测试服务器返回内层报文为空";
485         }
486 
487         return JsonUtils.object2Json(JsonUtils.jsonToMap(JsonUtils.xmlToJSON(returncontent)).get("RESPONSE_FPKJ"));
488     }
489     public static String judgeReturnData(String ReturnStr,InvoiceConfig invoiceConfig) throws Exception {
490         String resXml = ReturnStr;
491         String returncontent = "";
492         // 判断内层报文Data是否为空
493         if (resXml.contains("<content>")) {
494             // 有内层报文进行处理（解压缩和解密）
495             String secondXml = resXml.substring(resXml.indexOf("<content>")
496                     + "<content>".length(), resXml.indexOf("</content>"));
497             // 判断需不需要解压缩
498             byte[] decodeData = null;
499             decodeData = FPTool.decodeStr(secondXml);// Base64解码
500             // 判断测试服务器返回内层报文是否进行了压缩：
501             if (ConfigurerInfo.ZIP_YES.equals(resXml.substring(
502                     resXml.indexOf("<zipCode>") + "<zipCode>".length(),
503                     resXml.indexOf("</zipCode>")))) {
504                 decodeData = FPTool.decompress(decodeData);// 解压
505             }
506 
507 
508             System.out.println("encryptCode:" + resXml.indexOf("<encryptCode>"));
509             System.out.println("/encryptCode:" + resXml.indexOf("</encryptCode>"));
510             System.out.println("encryptCode:" + resXml.substring(
511                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
512                     resXml.indexOf("</encryptCode>")));
513 
514             // 判断测试服务器返回是否进行了加密：
515             if (ConfigurerInfo.ENCRYPT_YES.equals(resXml.substring(
516                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
517                     resXml.indexOf("</encryptCode>")))) {
518                 decodeData = FPTool.CAdecode(decodeData,"QZ",invoiceConfig);// CA解密
519             }
520             returncontent = new String(decodeData, ConfigurerInfo.CHERSET_UTF8);
521         } else {
522             returncontent = "测试服务器返回内层报文为空";
523         }
524 
525         return JsonUtils.object2Json(JsonUtils.jsonToMap(JsonUtils.xmlToJSON(returncontent)).get("RESPONSE_FPKJ"));
526     }
527 
528 
529     public static String judgeQzReturnData(String ReturnStr,InvoiceConfig invoiceConfig) throws Exception {
530         String resXml = ReturnStr;
531         String returncontent = "";
532         // 判断内层报文Data是否为空
533         if (resXml.contains("<content>")) {
534             // 有内层报文进行处理（解压缩和解密）
535             String secondXml = resXml.substring(resXml.indexOf("<content>")
536                     + "<content>".length(), resXml.indexOf("</content>"));
537             // 判断需不需要解压缩
538             byte[] decodeData = null;
539             decodeData = FPTool.decodeStr(secondXml);// Base64解码
540             // 判断测试服务器返回内层报文是否进行了压缩：
541             if (ConfigurerInfo.ZIP_YES.equals(resXml.substring(
542                     resXml.indexOf("<zipCode>") + "<zipCode>".length(),
543                     resXml.indexOf("</zipCode>")))) {
544                 decodeData = FPTool.decompress(decodeData);// 解压
545                 System.err.println("decodeData=="+new String(decodeData));
546             }
547 
548 
549             System.out.println("encryptCode:" + resXml.indexOf("<encryptCode>"));
550             System.out.println("/encryptCode:" + resXml.indexOf("</encryptCode>"));
551             System.out.println("encryptCode:" + resXml.substring(
552                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
553                     resXml.indexOf("</encryptCode>")));
554 
555             // 判断测试服务器返回是否进行了加密：
556             if (ConfigurerInfo.ENCRYPT_YES.equals(resXml.substring(
557                     resXml.indexOf("<encryptCode>") + "<encryptCode>".length(),
558                     resXml.indexOf("</encryptCode>")))) {
559 
560                 decodeData = FPTool.CAdecode(decodeData,"QZ",invoiceConfig);// CA解密
561             }
562             returncontent = new String(decodeData, ConfigurerInfo.CHERSET_UTF8);
563         } else {
564             returncontent = "测试服务器返回内层报文为空";
565         }
566 
567         return JsonUtils.object2Json(JsonUtils.jsonToMap(JsonUtils.xmlToJSON(returncontent)).get("RESPONSE_FPQZ"));
568     }
569 
570     public static String judgeQzReturnDataJson(RePublicRequestobject rePublicRequestobject, InvoiceConfig invoiceConfig) throws Exception {
571         String  returncontent =null;
572         // 判断内层报文Data是否为空
573         if (rePublicRequestobject!=null) {
574             // 有内层报文进行处理（解压缩和解密）
575             // 判断需不需要解压缩
576             byte[] decodeData = null;
577             decodeData = FPTool.decodeStr(rePublicRequestobject.getDatagram());// Base64解码
578             // 判断测试服务器返回内层报文是否进行了压缩：
579             if (ConfigurerInfo.ZIP_YES.equals(rePublicRequestobject.getZipCode())) {
580                 decodeData = FPTool.decompress(decodeData);// 解压
581                 System.err.println("decodeData=="+new String(decodeData));
582             }
583 
584             // 判断测试服务器返回是否进行了加密：
585             if (ConfigurerInfo.ENCRYPT_YES.equals(rePublicRequestobject.getEncryptCode())) {
586 
587                 decodeData = FPTool.CAdecode(decodeData,"QZ",invoiceConfig);// CA解密
588             }
589             returncontent = new String(decodeData, ConfigurerInfo.CHERSET_UTF8);
590         } else {
591             returncontent = "测试服务器返回内层报文为空";
592         }
593 
594         return returncontent;
595     }
596 
597 
598 
599 
600     public static void main(String[] args) throws Exception {
601         //json对象测试
602         Kj kj = new Kj();
603         kj.setAppid("4154564564");
604         kj.setBmb_bbh("4154564564");
605         kj.setBz("4154564564");
606         kj.setFhr("4154564564");
607         kj.setFp_mw("4154564564");
608         System.err.println("kj對象json數據" +JsonUtils.object2Json(kj));
609         //对象toString方法测试*********************************
610         OpenInvoiceIn_001 openInvoiceIn_001 = new OpenInvoiceIn_001();
611         openInvoiceIn_001.getOpenInvoiceInDetail_001().set_class("123132");
612         openInvoiceIn_001.setGhfNsrsbh("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
613 //        System.err.println(openInvoiceIn_001);
614 
615         //对选转换为xml测试********************************************************
616 //        OpenInvoiceIn_001 openInvoiceIn_001 = new OpenInvoiceIn_001();
617         openInvoiceIn_001.set_class("****************1************");
618         openInvoiceIn_001.setBmbBbh("*****************2***********");
619         openInvoiceIn_001.setFkfdzFkfdh("**************3**************");
620         openInvoiceIn_001.setGhfNsrsbh("***************4*************");
621         String s = XmlUtilHelper.beanToXmlWithOutVE(openInvoiceIn_001, OpenInvoiceIn_001.class);
622 
623 //        System.err.println("xml对象="+s);
624         //对象转换为json串*************************************************************
625         String  json ="{\"ghfmc\":null,\"ghfNsrsbh\":\"***************4*************\",\"fkfkhyhFkfyhzh\":null,\"fkfdzFkfdh\":\"**************3**************\",\"xhfkhyhSkfyhzh\":null,\"xhfdzXhfdh\":null,\"fpzlDm\":null,\"yfpDm\":null,\"yfpHm\":null,\"note\":null,\"kpr\":null,\"fhr\":null,\"sky\":null,\"xhqd\":null,\"fpqqlsh\":null,\"kplx\":null,\"jshj\":null,\"hjje\":null,\"hjse\":null,\"bmbBbh\":\"*****************2***********\",\"spbmjcbz\":null,\"byzd1\":null,\"byzd2\":null,\"_class\":\"****************1************\",\"openInvoiceInDetail_001\":{\"_class\":\"123132\",\"size\":null,\"list\":[]}}";
626         String s1 = JsonUtils.object2Json(json);
627         System.err.println("对象转换为json格式+++++++++++++++++++++++"+s1);
628 
629         //与税务局加解密原理演示
630 
631 //        String s = "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";
632 //        byte[] decodeData = null;
633 //        decodeData = FPTool.decodeStr(s);
634 //        System.out.println(decodeData.length+"=============111111111================");
635 //        System.out.println("data"+new String(decodeData));
636 //
637 //        decodeData = FPTool.decompress(decodeData);// 解压
638 //        System.out.println(decodeData.length+"=============222222222================");
639 //        System.out.println("data"+new String(decodeData));
640 //        decodeData = FPTool.CAdecode(decodeData);// CA解密
641 //        System.out.println( new String(decodeData, ConfigurerInfo.CHERSET_UTF8));
642 
643 
644         //签章密文解密测试  *****************************************************************************************************
645         String returnQZxml="<Data>" +
646                 "  <dataDescription>" +
647                 "   <zipCode>0</zipCode>" +
648                 "   <encryptCode>2</encryptCode>" +
649                 "   <codeType>CA</codeType>" +
650                 "  </dataDescription>" +
651                 "  <content>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</content>" +
652                 " </Data>";
653         InvoiceConfig  i = new InvoiceConfig();
654         i.setCompId("2310");
655         i.setCompName("中移铁通有限公司七台河分公司");
656         i.setTaxPayerId("91230900MA18WK2T5H");
657         i.setAuthOrizationCode("3N8S252FB3");
658         i.setRegisterNo("38234716");
659         i.setRequestCode("P0000001");
660         i.setTaxControlNo("661823736498");
661         i.setCompAddrTel("黑龙江省七台河市桃山区桃北街鸿顺丽景广场B座 0464-2931186");
662         i.setCompBankNo("中国工商银行七台河桃南支行0910020729221000907");
663         i.setKpWsdlUrl("http://10.108.0.81:8082/zzs_kpfw_ARM9/webservice/eInvWS/91230900MA18WK2T5H");
664         i.setKpQname("http://ws.aisino.com/");
665         i.setKpPublicKeyPath("91230900MA18WK2T5H.cer");
666         i.setKpPrivateKeyPath("91230900MA18WK2T5H.pfx");
667         i.setKpGzipType("0");
668         i.setKpCaType("0");
669         i.setQzWsdlUrl("http://106.39.231.100:20080/fpqz/webservice/eInvWS");
670         i.setQzQname("http://ws.aisino.com");
671         i.setQzPublicKeyPath("51fapiao.cer");
672         i.setQzPrivateKeyPath("91230900MA18WK2T5H.pfx");
673         i.setQzGzipType("0");
674         i.setQzCaType("2");
675         i.setQzCaCode("CA");
676         i.setPrivateKeyPassword("ThEDsYcFSG");
677         i.setTrustPath("trust.txt");
678         i.setDynamicLibPath("SOFJni_x64.dll");
679         String returnInvoiceDetail = FPTool.judgeQzReturnData(returnQZxml,i);
680 //          System.err.println("data:"+returnInvoiceDetail);
681 
682 
683         //测试json串转换为Map对象**********************************************
684         String  jsonText ="{\n" +
685                 "    \"appkey\":\"\" \n" +
686                 ",\"time\":\"\"\n" +
687                 ",\"busiCode\":\"R001\"\n" +
688                 "}";
689 //        Map jsonMap = JsonUtils.jsonToMap(jsonText);
690 //        System.err .println("jsonMap======="+jsonMap);
691 
692 
693 
694 
695 
696 
697     }
698 }

View Code

posted on 2020-08-16 20:48 逍遥人生MIAO 阅读(843) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

逍遥人生MIAO

HMacSHA256签名方式

导航

公告