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

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("");
        }
    }*/

}