map返回数据为空不返回问题

川长思鸟来 2022-12-28 11:14 425阅读 0赞

package com.fandemi.config;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.fasterxml.jackson.core.JsonGenerator;
    import com.fasterxml.jackson.databind.*;
    import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
    import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
    
    import java.io.IOException;
    import java.math.BigDecimal;
    import java.text.SimpleDateFormat;
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.util.Date;
    import java.util.List;
    import java.util.Set;
    
    /**
     * 处理 jackson 返回的null值
     *
     */
    @Configuration
    public class JacksonConfig {
    
        @Bean
        @Primary
        public ObjectMapper jacksonObjectMapper() {
            ObjectMapper objectMapper = new ObjectMapper();
            // 为mapper注册一个带有SerializerModifier的Factory
            objectMapper.setSerializerFactory(objectMapper.getSerializerFactory().withSerializerModifier(new YlBeanSerializerModifier()));
            objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
            objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
            objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            objectMapper.setDateFormat(sdf);
            //  long类型前端精度丢失问题（超过53位二进制数），
            //  建议在需要转换的字段上加注解 @JsonFormat(shape = JsonFormat.Shape.STRING)
            //  不做整体数值转换，防止无需转换的long类型也转为string
            return objectMapper;
        }
    
        //
         // Description: 此modifier主要做的事情为：
         // 当序列化类型为array，list、set时，当值为空时，序列化成[]
         // 为date,localdate,localdatetime 时，当值为空时，序列化成0
         // 为数值类型时，当值为空时，序列化成0
         // 为字符类型时，当值为空时，序列化成“”
         // @author  feiyang
         // @date    2019/6/24
         //
        public class YlBeanSerializerModifier extends BeanSerializerModifier {
    
            private JsonSerializer<Object> arrayJsonSerializer = new ArrayJsonSerializer();
            private JsonSerializer<Object> strJsonSerializer = new StrJsonSerializer();
            private JsonSerializer<Object> dateJsonSerializer = new DateJsonSerializer();
            private JsonSerializer<Object> numberJsonSerializer = new NumJsonSerializer();
    
            @Override
            public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc,
                                                             List<BeanPropertyWriter> beanProperties) {
                // 循环所有的beanPropertyWriter
                for (BeanPropertyWriter writer : beanProperties) {
                    // 判断字段的类型，如果是array，list，set则注册nullSerializer
                    if (isArrayType(writer)) {
                        //给writer注册一个自己的nullSerializer
                        writer.assignNullSerializer(arrayJsonSerializer);
                    } else if (isDate(writer)) {
                        writer.assignNullSerializer(dateJsonSerializer);
                    } else if (isNumber(writer)) {
                        writer.assignNullSerializer(numberJsonSerializer);
                    } else if (isStr(writer)) {
                        writer.assignNullSerializer(strJsonSerializer);
                    }
                }
                return beanProperties;
            }
    
            //
             // 判断数组类型
             // @param writer
             // @return
             //
            boolean isArrayType(BeanPropertyWriter writer) {
                Class<?> clazz = writer.getType().getRawClass();
                return clazz.isArray() || clazz.equals(List.class) || clazz.equals(Set.class);
    
            }
    
            //
             // 判断日期类型
             // @param writer
             // @return
             //
            boolean isDate(BeanPropertyWriter writer) {
                Class<?> clazz = writer.getType().getRawClass();
                return clazz.equals(Date.class) || clazz.equals(LocalDateTime.class) || clazz.equals(LocalDate.class);
            }
    
            //
             // 判断数字类型
             // @param writer
             // @return
             //
            boolean isNumber(BeanPropertyWriter writer) {
                Class<?> clazz = writer.getType().getRawClass();
                return clazz.equals(Short.class) || clazz.equals(Integer.class)
                        || clazz.equals(Long.class) || clazz.equals(BigDecimal.class)
                        || clazz.equals(Double.class) || clazz.equals(Float.class);
            }
    
            //
             // 判断字符类型
             // @param writer
             // @return
             //
            boolean isStr(BeanPropertyWriter writer) {
                Class<?> clazz = writer.getType().getRawClass();
                return clazz.equals(String.class) || clazz.equals(Character.class)
                        || clazz.equals(StringBuilder.class) || clazz.equals(StringBuffer.class);
            }
        }
    
        //
         // 数组以及集合序列化实现类
         //
        public class ArrayJsonSerializer extends JsonSerializer<Object> {
    
            @Override
            public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
                if (value == null) {
                    jgen.writeStartArray();
                    jgen.writeEndArray();
                } else {
                    jgen.writeObject(value);
                }
            }
        }
    
        //
         // 日期序列化实现类
         //
        public class DateJsonSerializer extends JsonSerializer<Object> {
            @Override
            public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
                if (value == null) {
                    //jgen.writeNumber(0);
                    jgen.writeString("");
                } else {
                    jgen.writeObject(value);
                }
            }
        }
    
        //
         // 字符串序列化实现类
         //
        public class StrJsonSerializer extends JsonSerializer<Object> {
            @Override
            public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
                if (value == null) {
                    jgen.writeString("");
                } else {
                    jgen.writeObject(value);
                }
            }
        }
    
        //
         // 数字序列化实现类
         //
        public class NumJsonSerializer extends JsonSerializer<Object> {
            @Override
            public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
                if (value == null) {
                    jgen.writeNumber(0);
                } else {
                    jgen.writeObject(value);
                }
            }
        }
    
        // 第一种
        /*@Bean
        @Primary
        @ConditionalOnMissingBean(ObjectMapper.class)
        public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
            ObjectMapper objectMapper = builder.createXmlMapper(false).build();
            objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
                @Override
                public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                    jsonGenerator.writeString("");
                }
            });
            return objectMapper;
        }*/
    
        /*
        // 第三种
        @Bean
        @Primary
        @ConditionalOnMissingBean(ObjectMapper.class)
        public ObjectMapper objectMapper(Jackson2ObjectMapperBuilder builder) {
            ObjectMapper objectMapper = builder.createXmlMapper(false).build();
            SerializerProvider serializerProvider = objectMapper.getSerializerProvider();
            serializerProvider.setNullValueSerializer(new NullSerializer());
            return objectMapper;
        }
    
        public class NullSerializer extends JsonSerializer<Object> {
            @Override
            public void serialize(Object value, JsonGenerator jsonGenerator, SerializerProvider provider)
                    throws IOException {
                jsonGenerator.writeString("");
            }
        }*/
    
    }