Jackson自定義序列化反序列化注解加解密字段詳解

更新時間：2023年11月06日 09:41:01 作者：LOOPY_Y

這篇文章主要介紹了Jackson自定義序列化反序列化注解加解密字段詳解,一些場景中,數(shù)據(jù)庫字段用于存儲json格式數(shù)據(jù),處于安全的考慮,該json數(shù)據(jù)中,某些敏感信息字段需要做加密存儲,例如身份證號、手機號等,需要的朋友可以參考下

1 問題場景

一些場景中，數(shù)據(jù)庫字段用于存儲json格式數(shù)據(jù)，處于安全的考慮，該json數(shù)據(jù)中，某些敏感信息字段需要做加密存儲，例如身份證號、手機號等。如果將整個json數(shù)據(jù)進行加密處理，加密后的數(shù)據(jù)較大，只對需解密的字段進行加密處理更符合實際。

如何實現(xiàn)呢？

之前寫過一篇脫敏注解，通過自定義序列化實現(xiàn)的，結合來看，其實可以復用之前的脫敏注解的模式，定義字段加解密注解，通過自定義序列化和反序列化實現(xiàn)。

2 代碼實現(xiàn)

注解類

import com.test.jsonencrypt.EncryptJsonFiledDeSerializer;
import com.test.jsonencrypt.EncryptJsonFiledSerializer;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <pre>
 * 加解密注解，標注在屬性上
 * </pre>
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@JacksonAnnotationsInside
// 使用自定義的序列化實現(xiàn)
@JsonSerialize(using = EncryptJsonFiledSerializer.class)
// 使用自定義的序列化實現(xiàn)
@JsonDeserialize(using = EncryptJsonFiledDeSerializer.class)
public @interface EncryptJsonFiled {

}

自定義序列化實現(xiàn)類

import com.test.jsonencrypt.annotation.EncryptJsonFiled;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.test.util.EncryUtil;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.util.Objects;

/**
 * <pre>
 * 序列化注解自定義實現(xiàn)
 * JsonDeserializer<String>：指定String類型，deserialize()方法用于將修改后的數(shù)據(jù)載入
 * Jackson使用ContextualSerializer在序列化時獲取字段注解的屬性
 * </pre>
 */
public class EncryptJsonFiledDeSerializer extends JsonDeserializer<String> implements ContextualDeserializer {

    @Override
    public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        String valueAsString = p.getValueAsString();
        // 數(shù)據(jù)不為空時解密數(shù)據(jù)
        if (StringUtils.isNotBlank(valueAsString)) {
            // EncryUtil為封裝的加解密工具
            return EncryUtil.decrypt(valueAsString);
        }
        return valueAsString;
    }

    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
        EncryptJsonFiled annotation = property.getAnnotation(EncryptJsonFiled.class);
        // 只針對String類型
        if (Objects.nonNull(annotation)&&Objects.equals(String.class, property.getType().getRawClass())) {
            return this;
        }
        return ctxt.findContextualValueDeserializer(property.getType(), property);
    }
}

自定義反序列化實現(xiàn)類

import com.test.jsonencrypt.annotation.EncryptJsonFiled;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.test.util.EncryUtil;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.util.Objects;

/**
 * <pre>
 * 序列化注解自定義實現(xiàn)
 * JsonSerializer<String>：指定String類型，serialize()方法用于將修改后的數(shù)據(jù)載入
 * Jackson使用ContextualSerializer在序列化時獲取字段注解的屬性
 * </pre>
 */
public class EncryptJsonFiledSerializer extends JsonSerializer<String> implements ContextualSerializer {

    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        // 數(shù)據(jù)不為空時加密數(shù)據(jù)
        if (StringUtils.isNotBlank(value)) {
            String encrypt = EncryUtil.encry(value);
            gen.writeString(encrypt);
            return;
        }
        gen.writeString(value);
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
        EncryptJsonFiled annotation = property.getAnnotation(EncryptJsonFiled.class);
        // 只針對String類型
        if (Objects.nonNull(annotation)&&Objects.equals(String.class, property.getType().getRawClass())) {
            return this;
        }
        return prov.findValueSerializer(property.getType(), property);
    }

}

3 測試

用于測試的簡易實體類

@Data
@Accessors(chain = true)
public class User {

    private String name;
    
    private int age;
    
    @EncryptJsonFiled
    private String idCard;

}

測試類

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * <pre>
 * 測試加解密注解
 * </pre>
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestEntry {

    @Test
    public void test() throws JsonProcessingException {
        User user = new User().setAge(11)
                .setName("小明")
                .setIdCard("13523451124");
        // 注意使用Jackson的json工具
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(user);
        System.out.println("序列化后的json數(shù)據(jù)：" + json);

        User user1 = objectMapper.readValue(json, User.class);
        System.out.println("反序列化后的解密數(shù)據(jù)：" + user1.getIdCard());
    }

}

測試結果：