基于注解实现jackson动态JsonProperty

基于注解实现jackson动态JsonProperty

@JsonProperty 此注解用于属性上，作用是把该属性的名称序列化为另外一个名称，如把trueName属性序列化为name,但是值是固定的,(不贴代码,可以看其他博客)

目前跟某公司做接口对接时数据格式是这样的:

　　　　接口A:　　　　　　　　　　　　　　　　　　　　　　　　　　　　接口B:

映射实体对象 :(这里用到lombok工具)

报文第三个字段与具体的pojo类有关,@JsonProperty在这里显然无法实现;

这里写两种序列化方式:

第一种 : 注解@JsonAnyGetter (自己了解下这个注解,这里变相使用了下)

映射实体对象类做下调整

测试代码(注意测试时每个类里加些属性,否则抛异常):

第二种 : 自定义注解来实现(我不想做pojo类的变动,感觉Map怪怪的,因为这里接口对接这里是一个对象)

先贴测试代码:

这里@DynamicJsonProperty为自定义的注解,(不了解自定义注解的可以先百度下"jackson自定义序列化注解实现自己的序列逻辑")

下面是该注解相应的代码:

  1 import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;

  2 import com.fasterxml.jackson.core.JsonGenerator;

  3 import com.fasterxml.jackson.core.json.UTF8JsonGenerator;

  4 import com.fasterxml.jackson.core.json.WriterBasedJsonGenerator;

  5 import com.fasterxml.jackson.databind.BeanProperty;

  6 import com.fasterxml.jackson.databind.JsonMappingException;

  7 import com.fasterxml.jackson.databind.JsonSerializer;

  8 import com.fasterxml.jackson.databind.SerializerProvider;

  9 import com.fasterxml.jackson.databind.annotation.JsonSerialize;

 10 import com.fasterxml.jackson.databind.ser.ContextualSerializer;

 11 import com.sinosoft.ehs.utils.Reflector;

 12 import com.sinosoft.ehs.utils.Strings;

 13

 14 import java.io.IOException;

 15 import java.lang.annotation.*;

 16 import java.util.function.Function;

 17

 18 @Documented

 19 @Retention(RetentionPolicy.RUNTIME)

 20 @Target({ElementType.FIELD,ElementType.METHOD})

 21 @JacksonAnnotationsInside

 22 @JsonSerialize(using = DynamicJsonProperty.DynamicJsonPropertySerializer.class)

 23 public @interface DynamicJsonProperty {

 24

 25     AS[] value() default {};

 26

 27     Strategy strategy() default Strategy.CLASS_SIMPLE_NAME_LOWERCASE;

 28

 29

 30     @interface AS{

 31

 32         String name();

 33

 34         Class<?> value();

 35     }

 36

 37     @Retention(RetentionPolicy.RUNTIME)

 38     @interface Name{

 39         String value();

 40     }

 41

 42     interface KeyName{

 43         String jsonPropertyName();

 44     }

 45

 46

 47     enum Strategy{

 48

 49         CLASS_NAME(object -> object.getClass().getName()),

 50         CLASS_SIMPLE_NAME(object -> object.getClass().getSimpleName()),

 51         CLASS_SIMPLE_NAME_LOWERCASE(object -> object.getClass().getSimpleName().toLowerCase()),

 52         CLASS_SIMPLE_NAME_UPPERCASE(object -> object.getClass().getSimpleName().toUpperCase());

 53

 54         private Function<Object,String> function;

 55

 56         Strategy(Function<Object,String> function){

 57             this.function = function;

 58         }

 59

 60         public String getName(Object object){

 61             if(object==null)

 62                 return null;

 63             return function.apply(object);

 64         }

 65

 66     }

 67

 68     class DynamicJsonPropertySerializer extends JsonSerializer<Object> implements ContextualSerializer {

 69         /**key值是否重置*/

 70         private boolean gotName;

 71         private DynamicJsonProperty annotation;

 72         /**原先的key值*/

 73         private String originalName;

 74

 75

 76         @Override

 77         public void serialize(Object value, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {

 78             if(value != null && !gotName){

 79                 String name = getKeyName(value);

 80                 if(jsonGenerator instanceof WriterBasedJsonGenerator){

 81                     char[] _outputBuffer = Reflector.getFieldValue(jsonGenerator,"_outputBuffer",char[].class);

 82                     char _quoteChar = Reflector.getFieldValue(jsonGenerator,"_quoteChar",char.class);

 83                     int start = String.valueOf(_outputBuffer).lastIndexOf(originalName);

 84                     int end = start+name.length()+1;

 85                     Reflector.setFieldValue(jsonGenerator,"_outputTail",end);

 86

 87                     for(int i=0;i<name.length();i++){

 88                         _outputBuffer[start+i] = name.charAt(i);

 89                     }

 90                     _outputBuffer[start+name.length()] = _quoteChar;

 91                 }

 92

 93                 if(jsonGenerator instanceof UTF8JsonGenerator){

 94                     byte[] _outputBuffer = Reflector.getFieldValue(jsonGenerator,"_outputBuffer",byte[].class);

 95                     int _outputTail = Reflector.getFieldValue(jsonGenerator,"_outputTail",int.class);

 96

 97                     byte _quoteChar = Reflector.getFieldValue(jsonGenerator,"_quoteChar",byte.class);

 98                     System.err.println(new String(_outputBuffer,"UTF-8"));

 99                     int startIndex = getStartIndex(_outputBuffer, _outputTail, 1)+1;

100                     byte[] nameBytes = name.getBytes("UTF-8");

101                     int end = startIndex+nameBytes.length+1;

102                     Reflector.setFieldValue(jsonGenerator,"_outputTail",end);

103

104                     for(int i=0;i<nameBytes.length;i++){

105                         _outputBuffer[startIndex+i] = nameBytes[i];

106                     }

107                     _outputBuffer[startIndex+nameBytes.length] = _quoteChar;

108

109

110                 }

111             }

112             jsonGenerator.writeObject(value);

113         }

114

115

116         @Override

117         public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {

118             annotation = beanProperty.getAnnotation(DynamicJsonProperty.class);

119             /**

120              *     PropertyName fullName = beanProperty.getFullName();

121              *    PropertyName._simpleName 字段即为key健的值,反射直接赋值即可实现,

122              *    不过这里未获取操作的Object对象,只能获取Field或者Method

123              *  createContextual优先执行,serialize之后执行,这里顺序问题也不能操作

124              *  之后在细看程序研究,或者有大牛能解决的联系学习下

125              */

126             originalName = beanProperty.getName();

127             return this;

128         }

129

130         private String getKeyName(Object value){

131             Class<?> valueType = value.getClass();

132             AS[] asAnnotations = annotation.value();

133             for(int i=0;i<asAnnotations.length;i++){

134                 if(asAnnotations[i].value() == valueType)

135                     return asAnnotations[i].name();

136             }

137

138             Annotation[] annotations = valueType.getAnnotations();

139

140             Name nameAnnotation = valueType.getAnnotation(DynamicJsonProperty.Name.class);

141             if(nameAnnotation!=null)

142                 return nameAnnotation.value();

143

144             if(value instanceof DynamicJsonProperty.KeyName){

145                 String name = ((DynamicJsonProperty.KeyName)value).jsonPropertyName();

146                 if(!Strings.isBlank(name))

147                     return name;

148             }

149

150             return annotation.strategy().getName(value);

151         }

152

153         private int getStartIndex(byte[] _outputBuffer,int _outputTail,int index){

154             int currentIndex = 0;

155             for(int i=_outputTail;i>=0;i--){

156                 if(_outputBuffer[i] == 34){

157                     if(currentIndex == index)

158                         return i;

159                     currentIndex++;

160                 }

161             }

162             return -1;

163         }

164

165     }

166

167

168 }

四种写法实例:

注意 : 以上四种方法字段data均需加注解@DynamicJsonProperty

反序列话直接加set方法即可

这里是通过反射重新赋值来实现,不同版本可能存在差异或者异常,测试用maven依赖

附反射代码:

    public static Field getField(Class<?> formType,String fieldName) throws NoSuchFieldException{

        if(formType == Object.class)

            throw new NoSuchFieldException();

        Field[] fields = formType.getDeclaredFields();

        for(int i=0;i<fields.length;i++){

            if(fields[i].getName().equals(fieldName))

                return fields[i];

        }

        return getField(formType.getSuperclass(),fieldName);

    }

    @SuppressWarnings("unchecked")

    public static <T> T getFieldValue(Object srcObject,String fieldName,Class<T> fieldType){

        try {

            Field field = getField(srcObject.getClass(),fieldName);

            field.setAccessible(true);

            return (T) field.get(srcObject);

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

    public static void setFieldValue(Object srcObject,String fieldName,Object fieldValue){

        try {

            Field field = getField(srcObject.getClass(),fieldName);

            field.setAccessible(true);

            field.set(srcObject, fieldValue);

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

最后这个问题如能解决,麻烦留言下解决的代码

巴特西

基于注解实现jackson动态JsonProperty

最新文章

热门文章