springboot 使用注解加解密

package corporateform.domain;

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import corporateform.serialize.AESDecryptDeserialize;
import corporateform.serialize.AESEncryptSerialize;
import corporateform.serialize.SensitiveSerialize;
import lombok.Setter;
import ls07.form.common.bean.representations.application.openAccountBatch.OpenAccountBatchResponse;

/**
 * @author IT007155
 *
 * 处理客户号的加密解密
 */
public class OpenAccountBatchBFFResponse extends OpenAccountBatchResponse {

    /**
     * 单位客户号
     */
    private String customerNumber;

    /**
     * 脱敏的客户号
     */
    @Setter
    private String sensitiveCustomerNumber;
    
    /**
     * 获取的客户号加密
     * @return
     */
    @JsonSerialize(using = AESEncryptSerialize.class)
    public String getCustomerNumber() {
        return customerNumber;
    }

    /**
     * 设置的客户号解密
     * @param customerNumber
     */
    @JsonDeserialize(using = AESDecryptDeserialize.class)
    public void setCustomerNumber(String customerNumber) {
        this.customerNumber = customerNumber;
    }
    
    /**
     * 获取的客户号脱敏
     * @return
     */
    @JsonSerialize(using = SensitiveSerialize.class)
    public String getSensitiveCustomerNumber() {
        return sensitiveCustomerNumber;
    }
}

package corporateform.serialize;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import corporateform.util.AESCipherHelper;

import java.io.IOException;

import static corporateform.constant.Constant.CUSTOMER_SECURITY;


/**
 * author IT007155
 * 客户号加密
 */
public class AESEncryptSerialize extends JsonSerializer<String> {

    @Override
    public void serialize(String customerNumber, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        String encrypt = AESCipherHelper.encrypt(customerNumber, CUSTOMER_SECURITY);
        jsonGenerator.writeString(encrypt);
    }

}

package corporateform.serialize;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import corporateform.util.AESCipherHelper;

import java.io.IOException;

import static corporateform.constant.Constant.CUSTOMER_SECURITY;


/**
 * author IT007155
 * 客户号解密
 */
public class AESDecryptDeserialize extends JsonDeserializer<String> {

    @Override
    public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        String customerNumber = jsonParser.getText();
        String decrypt = AESCipherHelper.decrypt(customerNumber, CUSTOMER_SECURITY);
        return decrypt;

    }
}

package corporateform.serialize;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import corporateform.util.AESCipherHelper;
import corporateform.util.MaskUtil;

import java.io.IOException;

/**
 * author IT007155 * 客户号脱敏
 */
public class SensitiveSerialize extends JsonSerializer<String> {
    @Override
    public void serialize(String customerNumber, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        String maskCustomerNumber = MaskUtil.maskCustomerNumber(customerNumber);
        jsonGenerator.writeString(maskCustomerNumber);
    }
}

package corporateform.util;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;

public class AESCipherHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(AESCipherHelper.class);
    private static final String KEY_AES = "AES";

    public static String encrypt(String content, String secretKey) {
        byte[] result;
        try {
            result = doAES(content, secretKey, Cipher.ENCRYPT_MODE);
        } catch (Exception e) {
            LOGGER.error("can not do the AES encrypt: ", e);
            throw new IllegalStateException("can not do the AES encrypt");
        }
        return Base64.encodeBase64String(result);
    }

    public static String decrypt(String content, String secretKey) {
        byte[] result;
        try {
            result = doAES(content, secretKey, Cipher.DECRYPT_MODE);
        } catch (Exception e) {
            LOGGER.error("can not do the AES decrypt: ", e);
            throw new IllegalStateException("can not do the AES decrypt");
        }
        return new String(result, StandardCharsets.UTF_8);
    }

    public static byte[] doAES(String data, String key, int mode) throws Exception{

        if (StringUtils.isBlank(data) || StringUtils.isBlank(key)) {
            return null;
        }
        //判断是加密还是解密
        byte[] content;
        //true 加密内容 false 解密内容
        if (mode == Cipher.ENCRYPT_MODE) {
            content = data.getBytes(StandardCharsets.UTF_8);
        } else {
            content = Base64.decodeBase64(data);
        }
        KeyGenerator kgen = KeyGenerator.getInstance(KEY_AES);
        //根据规则初始化密钥生成器
        //生成一个128位的随机源,根据传入的字节数组
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(key.getBytes());
        kgen.init(128, secureRandom);
        //产生原始对称密钥
        SecretKey secretKey = kgen.generateKey();
        //获得原始对称密钥的字节数组
        byte[] enCodeFormat = secretKey.getEncoded();
        //根据字节数组生成AES密钥
        SecretKeySpec keySpec = new SecretKeySpec(enCodeFormat, KEY_AES);

        Cipher cipher = Cipher.getInstance(KEY_AES);// 创建密码器
        //初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
        cipher.init(mode, keySpec);
        return cipher.doFinal(content);

    }
}