Spring boot 使用FastJsonHttpMessageConverter 导致Springboot注解失效处理

问题描述

想接收数组类型用字符串接收，因此使用了

    @Bean
    public HttpMessageConverters fastJsonHttpMessageConverters() {
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();

        List<SerializerFeature> list = new ArrayList<>();
        list.add(SerializerFeature.PrettyFormat);
        list.add(SerializerFeature.WriteMapNullValue);
        list.add(SerializerFeature.WriteNullStringAsEmpty);
        list.add(SerializerFeature.WriteNullListAsEmpty);
        list.add(SerializerFeature.QuoteFieldNames);
        list.add(SerializerFeature.WriteDateUseDateFormat);
        list.add(SerializerFeature.DisableCircularReferenceDetect);
        list.add(SerializerFeature.WriteBigDecimalAsPlain);

        fastJsonConfig.setSerializerFeatures(list.toArray(new SerializerFeature[list.size()]));

        fastConverter.setFastJsonConfig(fastJsonConfig);
        HttpMessageConverter<?> converter = fastConverter;
        fastJsonConfig.setSerializeFilters(new ValueFilter() {
            @Override
            public Object process(Object object, String name, Object value) {
                if ( value != null && value.getClass() == Long.class && value.toString().length()>17) {
                    return String.valueOf(value);
                }
                return value;
            }
        });
        return new HttpMessageConverters(converter);
    }

但是，这个会导致Spring boot的注解【@JsonInclude、@JsonSerialize、@JsonIgnore】等全部失效

解决办法

自定义处理

继承MappingJackson2HttpMessageConverter

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;

/**
 * @Author zhangjing
 * @Date 2023/9/14
 */
public class MappingJackson2HttpMessageConverter2 extends MappingJackson2HttpMessageConverter {


    private FastJsonConfig fastJsonConfig = new FastJsonConfig();
//private final static LongToStringSerializer longToStringSerializer = new LongToStringSerializer();
    static Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder = Jackson2ObjectMapperBuilder.json();



    //解决long值问题
    static {
        jacksonObjectMapperBuilder.serializerByType(Long.TYPE, ToStringSerializer.instance);
        jacksonObjectMapperBuilder.serializerByType(Long.class, ToStringSerializer.instance);


//jacksonObjectMapperBuilder.serializerByType(Long.class, longToStringSerializer);
//jacksonObjectMapperBuilder.serializerByType(Long.TYPE, longToStringSerializer);
    }

	//解决时间格式化问题
	   @Override
    protected void init(ObjectMapper objectMapper) {
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        objectMapper.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        super.init(objectMapper);
    }

    public MappingJackson2HttpMessageConverter2() {

        super(jacksonObjectMapperBuilder.build());
    }



    @Override
    public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException {

        JavaType javaType = getJavaType(type, contextClass);
        return readJavaType(javaType, inputMessage);
    }



    private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) throws IOException {

        InputStream in = inputMessage.getBody();
        JSONObject object = JSON.parseObject(in, fastJsonConfig.getCharset(), javaType, fastJsonConfig.getFeatures());
        return object.toJavaObject(javaType.getRawClass());
    }



}

增加处理器

import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import java.util.List;


/**
 *  InterceptorConfig
 * @author   qbk
 * @date     2019/11/10FastJsonHttpMessageConverter
 * @Param
 * @return
 * @see
 */
@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter  {


    /**
     * 增加自定义处理器，处理数组跨域字符接收等
     * @Author: zhangjing
     * @Date: 2023/9/14 17:24
     * @param converters
     * @return void
     **/
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new MappingJackson2HttpMessageConverter2());
        super.configureMessageConverters(converters);
    }
}

到此解决

既能解决json接收问题，又能保证注解生效

自定义序列化

想自定义序列化，比如long超过17为转为字符串

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitable;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonschema.SchemaAware;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import org.apache.poi.ss.formula.functions.T;

import java.io.IOException;
import java.lang.reflect.Type;

/**
 * @Author zhangjing
 * @Date 2023/9/15
 */
@JacksonStdImpl
@SuppressWarnings("serial")
public class LongToStringSerializer extends JsonSerializer<Object> {

    
    public LongToStringSerializer() {
        super();
    }


    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider provider)
            throws IOException
    {
        if(value!=null && value.toString().length()>17){
            gen.writeString(value.toString());
        }
        else {
            gen.writeNumber((long)value);
        }
    }
}