@Test
    public void createRSA() {
        SecureRandom random = new SecureRandom();
        //这个数字不可以随便输入
        RSAUtils.getInstance().generatorKeyPair(4096, random);
    }

package com.healerjean.proj.a_test.dto;

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;


/**
 * @author HealerJean
 * @ClassName MessageDTO
 * @date 2019/10/29  14:22.
 * @Description
 */
@Data
@JacksonXmlRootElement(localName = "MESSAGE")
public class MessageDTO {

    @JacksonXmlProperty(localName = "BASIC_INFO")
    private BasicInfo basicInfo;

    @JacksonXmlProperty(localName = "BUSINESS_DATA")
    private BussinssData bussinssData;

}

@ApiModel(description = "交易基础消息体")
@Data
public class BasicInfo {

    @ApiModelProperty(value = "交易编号")
    private String transCode;

    @ApiModelProperty(value = "交易类型")
    private String transType;

    @ApiModelProperty(value = "交易时间")
    private Date transTime;

    @ApiModelProperty(value = "签名：一般我们只对业务数据data进行签名就可以了，没必要全部签名，有些浪费时间")
    private String signedMsg;

    /** 返回代码 */
    private String retCode;
    /** 错误信息 */
    private String retMsg;

}

/**
 * @author HealerJean
 * @ClassName BussinssData
 * @date 2019-10-28  23:07.
 * @Description
 */
@Data
public class BussinssData {

    @ApiModelProperty(value = "企业Id")
    private Long companyId;

    @ApiModelProperty(value = "企业名称")
    private String companyName;

    @ApiModelProperty(value = "企业编号")
    private String orgCode;

}

    @Test
    public void clientA() {

        String aPrivaetKey = "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";
        String dealPublicKey = "MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAloJZU18QoWuI+j4LhLNBKJyiDU++dQodqOG6+l+05gYgUdjYNQwHalSW4Sx+koidwbp7Wj9WtnyuH/C1Rp0gsSiVi8nba70ztXsn+LoD2A6PD2vqS/Weyuwhqwi5xm5P4r2gAi2gT6H9tolesxamIBqdRmiv5KwGROJnsnwWKticARY+Q10nqKE3u6ZGGWjfPENLfb0aVUb4DkZOzslo7roVIF6/A+iBfAM/vV/9hfFd3BnU1ZS6DPBJ5yLgvlX/mLhTh8+if2apl2WV3UI6XPjzzSi8q4f0IWLw170AOx4dq7z7orH2uezfOeZqsCMf0SNp5675g1yuO4Vf2Tn34S0+88HVTzQrhHw1QgBgYXVkSumyTC7DmQ9nwQXBD1d0dltwZKmEq0h+zYgeKJ9eVSBjrwIx79JZ7MamOeePkh9k/tWKYOS+tk4gQ/htaBl2XpWtKeM+ye8B+GQYHayOSQ4QS8RKXaajDjEFAwXHSSu4bI38sJW61GMBjL2LfIR9z9nQyMOR0WJEKBr5ta8z+GIRwRGP+GQXaWyExSGP2g6DaoHy3C4dxFCvJ0X1eJhWi2kg4VettpMs60pjTfpwlQrzFAy7YAkoK4guCpaVRCwhJZYIlUkWiaE4vu47ZPd5707faWu2LWZOVuLLJWVmdLAhsJFbmSAy3G9OicbZbbcCAwEAAQ==";


        RSAUtils rsaUtils = RSAUtils.getInstance();
        BussinssData bussinssData = new BussinssData();
        bussinssData.setCompanyName("企业名称");
        bussinssData.setOrgCode("123456789");
        BasicInfo basicInfo = new BasicInfo();
        basicInfo.setTransCode(UUID.randomUUID().toString().replace("-", ""));
        basicInfo.setTransType("T0001");
        basicInfo.setTransTime(new Date());

        MessageDTO messageDTO = new MessageDTO();
        messageDTO.setBasicInfo(basicInfo);
        messageDTO.setBussinssData(bussinssData);

        String xmlOrigin = XmlUtils.toXml(messageDTO);
        log.info("数据原文：【 {} 】", xmlOrigin);

        String signedXmlOrigin = XmlUtils.toXml(bussinssData);
        log.info("签名原文：【 {} 】", signedXmlOrigin);

        // 1、 私钥生成签名（只对业务数据进行签名）
        String sign = rsaUtils.signByPriKey(signedXmlOrigin, aPrivaetKey, RSAUtils.SHA1withRSA);
        log.info("签名：【 {} 】", sign);

        basicInfo.setSignedMsg(sign);
        String encryptOriginXml = XmlUtils.toXml(messageDTO);
        log.info("加密原文：【 {} 】", encryptOriginXml);

        // 2、公钥加密
        String encryptContent = rsaUtils.encryptByPubKey(encryptOriginXml, dealPublicKey);
        log.info("加密报文：【 {} 】", encryptContent);

        //模拟调用别人接口
        String resEncryptContent = clientB(encryptContent);
        log.info("响应加密报文：【 {} 】", resEncryptContent);

        // 1、解密
        String decryptXml = rsaUtils.decryptByPriKey(resEncryptContent, aPrivaetKey);
        log.info("响应解密报文：【 {} 】", decryptXml);

        // 验证签名
        messageDTO = XmlUtils.toObject(decryptXml, MessageDTO.class);
        sign = messageDTO.getBasicInfo().getSignedMsg();
        log.info("响应签名：【 {} 】", sign);

        bussinssData = messageDTO.getBussinssData();
        signedXmlOrigin = XmlUtils.toXml(bussinssData);
        log.info("响应签名原文：【 {} 】", signedXmlOrigin);
        boolean check = rsaUtils.verifySignByPubKey(signedXmlOrigin, sign, dealPublicKey, RSAUtils.SHA1withRSA);
        if (!check) {
            throw new RuntimeException("响应签名验证失败");
        }
        log.info("----------success----------------");


    }


    public String clientB(String encryptContent) {
        String aPublicKey = "MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0N6hPKO+05+ImOazyelOCe5d6UzahFNWD3BW3qBJDOaWgiMvT6G3uQuTEpprKZWP48/vZJ1uMYLXJhxGa5iMoFSB8JS+Mlc5WAnJEPwpop3Env9D5AyG5gLjtEa0KfKRph6R/PLttlN1n6UVnM/s0PpZY2MYO4RDd/xEAkgfStIs5lvfu3SehYDlfiNO/L5zL0u4FvM9mvNXEiEWK9PH3Bm9D72vebHhWGzJGfMed6OK96h47KcAiRY6hktNKEXwM5DzXF3jSRwnFl5ipmy/xkL4ffqlz0EsPvYUCumzOWmzED4vJEfW3brBVrZgVAi/KoC6OeVyA0MvD8AqoklpBLtZlk88QZPvqYy/g00U9DsCDzeTZ/CNdelFDtbYZOB3x93dnKn+N664t58cp/6X25CE0MCoJvWHS+tNFVVeZ7c3YB1Lp5NHmKFPuH0CfNcR3Wb462qm1nHMd6/LSMwDORb8ex0SR34QUpREhhhm1/xM/x1P9ZLWxs+3B1rSn5EGp96br3sJEOgsiK75o8Eq3ST7HuoQcMCp0nYVIxu8RkkJtCENBDQSsdQz5sGGBNbHWypXfVTz+U7Y6ybeCLhc3XKGMx6AWU5D0vRbAOoegnvKjChYKQfDgY4i39imMlvVQBeyibu361qbUpO9XVcPGEwWBiWiiMFVIrLa1kBqmgUCAwEAAQ==";
        String dealPrivaetKey = "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";

        log.info("----------------------------------------------------------------------");
        log.info("接收加密报文：【 {} 】", encryptContent);

        //1、私钥解密
        RSAUtils rsaUtils = RSAUtils.getInstance();
        String decryptXml = rsaUtils.decryptByPriKey(encryptContent, dealPrivaetKey);
        log.info("解密报文：【 {} 】", decryptXml);

        // 验证签名
        MessageDTO messageDTO = XmlUtils.toObject(decryptXml, MessageDTO.class);
        String sign = messageDTO.getBasicInfo().getSignedMsg();
        log.info("签名：【 {} 】", sign);
        BussinssData bussinssData = messageDTO.getBussinssData();
        String signedXmlOrigin = XmlUtils.toXml(bussinssData);
        log.info("签名原文：【 {} 】", signedXmlOrigin);
        boolean check = rsaUtils.verifySignByPubKey(signedXmlOrigin, sign, aPublicKey, RSAUtils.SHA1withRSA);
        if (!check) {
            throw new RuntimeException("验签失败");
        }

        //业务处理
        BasicInfo basicInfo = messageDTO.getBasicInfo();
        basicInfo.setRetCode("200");
        basicInfo.setRetMsg("Success");
        bussinssData.setCompanyId(1L);
        signedXmlOrigin = XmlUtils.toXml(bussinssData);

        // 1、 私钥生成签名（只对业务数据进行签名）
        sign = rsaUtils.signByPriKey(signedXmlOrigin, dealPrivaetKey, RSAUtils.SHA1withRSA);
        log.info("返回签名：【 {} 】", sign);
        basicInfo.setSignedMsg(sign);
        String encryptOriginXml = XmlUtils.toXml(messageDTO);
        log.info("返回加密原文：【 {} 】", encryptOriginXml);

        // 2、公钥加密
        encryptContent = rsaUtils.encryptByPubKey(encryptOriginXml, aPublicKey);
        log.info("返回加密报文：【 {} 】", encryptContent);

        log.info("----------------------------------------------------------------------");
        return encryptContent;
    }

@Slf4j
public class RSAUtils {

    private static volatile RSAUtils rsaUtils;
    public static final String MD5withRSA = "MD5withRSA";
    public static final String SHA1withRSA = "SHA1withRSA";
    public static final String RSA = "RSA";

    private RSAUtils() {
    }

    public static RSAUtils getInstance() {
        if (null == rsaUtils) {
            synchronized (RSAUtils.class) {
                if (rsaUtils == null) {
                    rsaUtils = new RSAUtils();
                }
            }
        }
        return rsaUtils;
    }


    public static void main(String[] args) {
        SecureRandom random = new SecureRandom();
        //生成一对密钥对
        KeyPair keyPair = getInstance().generatorKeyPair(4096, random);
        System.out.println(keyPair);
    }


    /**
     * 生成密钥对
     *
     * @param keysize
     * @param random
     * @return
     */
    public KeyPair generatorKeyPair(int keysize, SecureRandom random) {
        String prefixStr = "【生成密钥对】";
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
            keyPairGenerator.initialize(keysize, random);
            java.security.KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            String publicKeyStr = Base64.encodeBase64String(rsaPublicKey.getEncoded());
            String privateKeyStr = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

            log.info("{}Public Key：【{}】", prefixStr, publicKeyStr);
            log.info("{}Private Key：【{}】", prefixStr, privateKeyStr);
            KeyPair generatorKeyPair = new KeyPair();
            generatorKeyPair.setPublicKeyStr(publicKeyStr);
            generatorKeyPair.setPrivateKeyStr(privateKeyStr);
            return generatorKeyPair;
        } catch (NoSuchAlgorithmException e) {
            log.error("{}异常，", prefixStr, e);
        }
        return null;
    }

    /**
     * 还原公钥，X509EncodedKeySpec 用于构建公钥的规范
     *
     * @param publicKeyStr 公钥
     * @return
     * @throws InvalidKeySpecException
     * @throws NoSuchAlgorithmException
     */
    private PublicKey restorePublicKey(String publicKeyStr) throws InvalidKeySpecException, NoSuchAlgorithmException {
        byte[] publicKeyByte = Base64.decodeBase64(publicKeyStr);
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyByte);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        return publicKey;
    }

    /**
     * 还原私钥 PKCS8EncodedKeySpec
     *
     * @param privateKeyStr 私钥
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private PrivateKey restorePrivateKey(String privateKeyStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] privateKeyByte = Base64.decodeBase64(privateKeyStr);
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyByte);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        return privateKey;
    }

    /**
     * 通过公钥获取秘钥属性
     *
     * @param publicKey
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private KeyPair getKeySizeByPubKey(PublicKey publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        KeyPair keyPair = new KeyPair();
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        RSAPublicKeySpec keySpec = keyFactory.getKeySpec(publicKey, RSAPublicKeySpec.class);
        BigInteger modulus = keySpec.getModulus();
        //RSA秘钥大小
        int keySize = modulus.toString(2).length();
        //RSA最大加密明文大小
        int maxEncryptSize = keySize / 8 - 11;
        //RSA最大解密密文大小
        int maxDecryptSize = keySize / 8;
        keyPair.setKeySize(keySize);
        keyPair.setMaxEncryptSize(maxEncryptSize);
        keyPair.setMaxDecryptSize(maxDecryptSize);
        return keyPair;
    }

    /**
     * 通过私钥获取秘钥属性
     *
     * @param privateKey
     * @return
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private KeyPair getKeySizeByPriKey(PrivateKey privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        KeyPair keyPair = new KeyPair();
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        RSAPrivateKeySpec keySpec = keyFactory.getKeySpec(privateKey, RSAPrivateKeySpec.class);
        BigInteger modulus = keySpec.getModulus();
        //RSA秘钥大小
        int keySize = modulus.toString(2).length();
        //RSA最大加密明文大小
        int maxEncryptSize = keySize / 8 - 11;
        //RSA最大解密密文大小
        int maxDecryptSize = keySize / 8;
        keyPair.setKeySize(keySize);
        keyPair.setMaxEncryptSize(maxEncryptSize);
        keyPair.setMaxDecryptSize(maxDecryptSize);
        return keyPair;
    }

    /**
     * 公钥加密
     *
     * @param original     原文
     * @param publicKeyStr 公钥
     * @return 密文
     */
    public String encryptByPubKey(String original, String publicKeyStr) {
        String prefixStr = "【公钥加密】";
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try {
            if (StringUtils.isEmpty(publicKeyStr)) {
                log.info("{}失败，publicKeyStr为空", prefixStr);
                return null;
            }
            byte[] originalByte = original.getBytes("UTF-8");
            if (null == originalByte) {
                log.info("{}失败，originalByte为空", prefixStr);
                return null;
            }
            PublicKey publicKey = restorePublicKey(publicKeyStr);
            KeyPair keyPair = getKeySizeByPubKey(publicKey);
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            //RSA最大加密明文大小
            int maxEncryptSize = keyPair.getMaxEncryptSize();
            int inputLen = originalByte.length;
            int offset = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offset > 0) {
                if (inputLen - offset > maxEncryptSize) {
                    cache = cipher.doFinal(originalByte, offset, maxEncryptSize);
                } else {
                    cache = cipher.doFinal(originalByte, offset, inputLen - offset);
                }
                out.write(cache, 0, cache.length);
                i++;
                offset = i * maxEncryptSize;
            }
            byte[] encryptedData = out.toByteArray();
            String ciphertext = Base64.encodeBase64String(encryptedData);
            log.debug("{}密文：【{}】", prefixStr, ciphertext);
            return ciphertext;
        } catch (Exception e) {
            log.error("{}异常，", prefixStr, e);
        } finally {
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    log.error("{}关闭字节数组流异常，", prefixStr, e);
                }
            }
        }
        return null;
    }
    /**
     * 私钥解密
     *
     * @param ciphertext    密文
     * @param privateKeyStr 私钥
     * @return 明文
     */
    public String decryptByPriKey(String ciphertext, String privateKeyStr) {
        String prefixStr = "【私钥解密】";
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try {
            if (StringUtils.isEmpty(privateKeyStr)) {
                log.info("{}失败，privateKeyStr为空", prefixStr);
                return null;
            }
            byte[] ciphertextByte = Base64.decodeBase64(ciphertext);
            if (null == ciphertextByte) {
                log.info("{}失败，ciphertextByte为空", prefixStr);
                return null;
            }
            PrivateKey privateKey = restorePrivateKey(privateKeyStr);
            KeyPair keyPair = getKeySizeByPriKey(privateKey);
            int maxDecryptSize = keyPair.getMaxDecryptSize();
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            int inputLen = ciphertextByte.length;
            int offset = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offset > 0) {
                if (inputLen - offset > maxDecryptSize) {
                    cache = cipher.doFinal(ciphertextByte, offset, maxDecryptSize);
                } else {
                    cache = cipher.doFinal(ciphertextByte, offset, inputLen - offset);
                }
                out.write(cache, 0, cache.length);
                i++;
                offset = i * maxDecryptSize;
            }
            byte[] decryptedData = out.toByteArray();
            String original = new String(decryptedData, "UTF-8");
            log.debug("{}明文：【{}】", prefixStr, original);
            return original;
        } catch (Exception e) {
            log.error("{}异常，", prefixStr, e);
        } finally {
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    log.error("{}关闭字节数组流异常，", prefixStr, e);
                }
            }
        }
        return null;
    }



    /**
     * 私钥数字签名
     *
     * @param original      原文
     * @param privateKeyStr 私钥
     * @param algorithm     算法
     * @return 数字签名
     */
    public String signByPriKey(String original, String privateKeyStr, String algorithm) {
        String prefixStr = "【私钥数字签名】";
        try {
            byte[] privateKeyByte = Base64.decodeBase64(privateKeyStr);
            if (null == privateKeyByte) {
                log.info("{}失败，privateKeyByte为空", prefixStr);
                return null;
            }
            byte[] originalByte = original.getBytes("UTF-8");
            if (null == originalByte) {
                log.info("{}失败，originalByte为空", prefixStr);
                return null;
            }
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyByte);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

            Signature signature = Signature.getInstance(algorithm);
            signature.initSign(privateKey);
            signature.update(originalByte);
            byte[] signByte = signature.sign();
            String signs = Base64.encodeBase64String(signByte);
            log.debug("{}数字签名：【{}】", prefixStr, original);
            return signs;
        } catch (Exception e) {
            log.error("{}异常，", prefixStr, e);
        }
        return null;
    }

    /**
     * 公钥数字签名进行验证
     *
     * @param original     原文内容
     * @param sign         数字签名
     * @param publicKeyStr 公钥
     * @param algorithm    算法
     * @return 验签结果
     */
    public boolean verifySignByPubKey(String original, String sign, String publicKeyStr, String algorithm) {
        String prefixStr = "【公钥验证数字签名】";
        try {
            byte[] publicKeyByte = Base64.decodeBase64(publicKeyStr);
            if (null == publicKeyByte) {
                log.info("{}失败，publicKeyByte为空", prefixStr);
                return false;
            }
            byte[] originalByte = original.getBytes("UTF-8");
            if (null == originalByte) {
                log.info("{}失败，originalByte为空", prefixStr);
                return false;
            }
            byte[] signByte = Base64.decodeBase64(sign);
            if (null == signByte) {
                log.info("{}失败，signsByte为空", prefixStr);
                return false;
            }
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyByte);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA);
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

            Signature signature = Signature.getInstance(algorithm);
            signature.initVerify(publicKey);
            signature.update(originalByte);
            boolean verify = signature.verify(signByte);
            log.info("{}验签结果：【{}】", prefixStr, verify);
            return verify;
        } catch (Exception e) {
            log.error("{}异常，", prefixStr, e);
        }
        return false;
    }
}

@Data
class KeyPair {
    /**
     * 公钥
     */
    String publicKeyStr;
    /**
     * 私钥
     */
     String privateKeyStr;
    /**
     * 秘钥keySize
     */
     int keySize;
    /**
     * 最大加密明文大小
     */
     int maxEncryptSize;
    /**
     * 最大解密密文大小
     */
    private int maxDecryptSize;
}

final class Base64 {
    private static final char[] base64EncodeChars = new char[] {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
        'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};

    private static final byte[] base64DecodeChars = new byte[] {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1,
        -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1};

    public static final String encode(byte[] data) {
        StringBuilder sb = new StringBuilder();
        int r = data.length % 3;
        int len = data.length - r;
        int i = 0;
        int c;
        while (i < len) {
            c = (0x000000ff & data[i++]) << 16 | (0x000000ff & data[i++]) << 8 | (0x000000ff & data[i++]);
            sb.append(base64EncodeChars[c >> 18]);
            sb.append(base64EncodeChars[c >> 12 & 0x3f]);
            sb.append(base64EncodeChars[c >> 6 & 0x3f]);
            sb.append(base64EncodeChars[c & 0x3f]);
        }
        if (r == 1) {
            c = 0x000000ff & data[i++];
            sb.append(base64EncodeChars[c >> 2]);
            sb.append(base64EncodeChars[(c & 0x03) << 4]);
            sb.append("==");
        } else if (r == 2) {
            c = (0x000000ff & data[i++]) << 8 | (0x000000ff & data[i++]);
            sb.append(base64EncodeChars[c >> 10]);
            sb.append(base64EncodeChars[c >> 4 & 0x3f]);
            sb.append(base64EncodeChars[(c & 0x0f) << 2]);
            sb.append("=");
        }
        return sb.toString();
    }

    public static final byte[] decode(String str) {
        byte[] data = str.getBytes();
        int len = data.length;
        ByteArrayOutputStream buf = new ByteArrayOutputStream(len);
        int i = 0;
        int b1, b2, b3, b4;

        while (i < len) {

            /* b1 */
            do {
                b1 = base64DecodeChars[data[i++]];
            } while (i < len && b1 == -1);
            if (b1 == -1) {
                break;
            }

            /* b2 */
            do {
                b2 = base64DecodeChars[data[i++]];
            } while (i < len && b2 == -1);
            if (b2 == -1) {
                break;
            }
            buf.write((int)((b1 << 2) | ((b2 & 0x30) >>> 4)));

            /* b3 */
            do {
                b3 = data[i++];
                if (b3 == 61) {
                    return buf.toByteArray();
                }
                b3 = base64DecodeChars[b3];
            } while (i < len && b3 == -1);
            if (b3 == -1) {
                break;
            }
            buf.write((int)(((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));

            /* b4 */
            do {
                b4 = data[i++];
                if (b4 == 61) {
                    return buf.toByteArray();
                }
                b4 = base64DecodeChars[b4];
            } while (i < len && b4 == -1);
            if (b4 == -1) {
                break;
            }
            buf.write((int)(((b3 & 0x03) << 6) | b4));
        }
        return buf.toByteArray();
    }
}

@Slf4j
public class XmlUtils {

    public static final XmlMapper xmlMapper;


    static {
        xmlMapper = new XmlMapper();
        SimpleModule module = new SimpleModule();
        xmlMapper.registerModule(module);
        xmlMapper.setDefaultUseWrapper(false);
        //字段为null，自动忽略，不再序列化
        xmlMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //XML标签名:使用骆驼命名的属性名，
        xmlMapper.setPropertyNamingStrategy(new UpperCaseSnackNamingStrategy());
        //设置转换模式
        xmlMapper.enable(MapperFeature.USE_STD_BEAN_NAMING);
    }


    public static String toXml(Object object) {
        try {
            return xmlMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            log.error("Xml转换失败", e);
            throw new RuntimeException("Xml转换失败", e);
        }
    }


    public static <T> T toObject(String xml, Class<T> c) {
        try {
            return xmlMapper.readValue(xml, c);
        } catch (IOException e) {
            log.error("Xml转换失败", e);
            throw new RuntimeException("Xml转换失败", e);
        }
    }


}