Jackson 序列化失败问题-oracle数据返回类型找不到对应的Serializer

Jackson在序列化List<Map>的类型数据时，由于未指定Map中的数据类型，因此，序列化时会自定匹配相应的数据类型，如果找不到相应的Serializer，就会序列化时出现异常。

Caused by: com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Direct self-reference leading to cycle (through reference chain: com.foresee.sdk.client.OpenApiResponse["resData"]->java.util.ArrayList[0]->java.util.HashMap["DT_SJJD"]->oracle.sql.CLOB["dbaccess"]->oracle.jdbc.driver.T4CConnection["wrapper"])

为了解决这种匹配不到的情况，可以自定义相应类型的Serializer，例如：oracle.sql.TIMESTAMP，oracle.sql.CLOB等。

1.定义Serializer

自定义OracleTimestampSerializer，继承JsonSerializer<TIMESTAMP>

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import oracle.sql.TIMESTAMP;

import java.io.IOException;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class OracleTimestampSerializer extends JsonSerializer<TIMESTAMP> {


    @Override
    public void serialize(TIMESTAMP value, JsonGenerator gen,
                          SerializerProvider serializers) throws IOException,
            JsonProcessingException {
        Timestamp tt = null;
        try {
            tt = value.timestampValue();
            Date date = new Date(tt.getTime());
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            gen.writeString(dateFormat.format(date));
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

自定义OracleClobSerializer，继承JsonSerializer<CLOB>

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import oracle.sql.CLOB;

import java.io.IOException;
import java.sql.SQLException;

public class OracleClobSerializer  extends JsonSerializer<CLOB> {
 @Override
 public void serialize(CLOB clob, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
     try {
         jsonGenerator.writeString(clob.stringValue());
     } catch (SQLException e) {
         e.printStackTrace();
     }
 }
}

2.将定义的Serializer注册到ObjectMapper实例中

下面是完整的Jackson序列化工具类

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.databind.type.MapType;
import com.google.common.base.Charsets;
import com.google.common.io.CharStreams;
import oracle.sql.CLOB;
import oracle.sql.TIMESTAMP;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class JacksonUtil {

    private static ObjectMapper mapper;

    private final static Logger LOG = LoggerFactory.getLogger(JacksonForTyCxUtil.class);


    public static <T> T jsonToBean(String jsonStr, Class<T> cls) {
        if(StringUtils.isEmpty(jsonStr)){
            return null;
        }
        try {
            return getMapper().readValue(jsonStr, cls);
        } catch (IOException e) {
            LOG.error("json to Bean 转换失败，{}", e);
            return null;
        }

    }

    private static ObjectMapper getMapper() {
        if (mapper == null) {
            mapper = new ObjectMapper();
            mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            mapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
            mapper.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);
            mapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);

            SimpleModule module = new SimpleModule();
            // 注册相关类型的自定义Serializer
            module.addSerializer(TIMESTAMP.class, new OracleTimestampSerializer());
            module.addSerializer(CLOB.class, new OraclClobSerializer());
            mapper.registerModule(module);
        }
        return mapper;
    }

    public static String beanToJson(Object src) {
        // Convert object to JSON string
        try {
            return getMapper().writeValueAsString(src);
        } catch (JsonProcessingException e) {
            LOG.error("bean to json 失败，{}", e);
            return null;
        }

    }
 
    /**
     * beanToBean
     * @param ob
     * @param t
     * @return T
     */
    public static <T>T  beanToBean(Object ob,Class<T> t){
        String json = toJson(ob);
        return fromJson(json, t);
    }
    
    /**
     * 
     * beanToBean
     * @param ob
     * @param t
     * @return T
     */
    public static <T>T  beanToBean(Object ob,T t){
        BeanUtils.copyProperties(ob, t);
        return t;
    }
    
    public static String toJson(Object object) {
        try {
            return getMapper().writeValueAsString(object);
        } catch (JsonProcessingException e) {
            throw new IllegalStateException("序列化为JSON失败", e);
        }
    }

    public static <T> T fromJson(InputStream inputStream, Class<T> klass) {
        String json;
        try {
            json = CharStreams.toString(new InputStreamReader(inputStream, Charsets.UTF_8));
        } catch (IOException e) {
            throw new IllegalStateException("读取输入流失败", e);
        }
        JavaType javaType = getMapper().getTypeFactory().constructType(klass);
        return fromJsonViaJavaType(json, javaType);
    }
    public static <T> T fromJson(String json, Class<T> klass) {
        JavaType javaType = getMapper().getTypeFactory().constructType(klass);
        return fromJsonViaJavaType(json, javaType);
    }
    
    private static <T> T fromJsonViaJavaType(String json, JavaType javaType) {
        try {
            return getMapper().readerFor(javaType).readValue(json);
        } catch (IOException e) {
            throw new IllegalStateException("反序列化失败", e);
        }
    }

    public static <T> T fromJson(String json, Type type) {
        JavaType javaType = getMapper().getTypeFactory().constructType(type);
        return fromJsonViaJavaType(json, javaType);
    }
    
    public static JavaType constructType(Type type) {
        return getMapper().getTypeFactory().constructType(type);
    }

    public static Map<String, Object> jsonToMap(String json) {
        return jsonToMap(json, String.class, Object.class);
    }

    public static <K, V> Map<K, V> jsonToMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            JavaType kType = getMapper().getTypeFactory().constructType(kClass);
            JavaType vType = getMapper().getTypeFactory().constructType(vClass);
            MapType mapType = getMapper().getTypeFactory().constructMapType(HashMap.class, kType, vType);
            return getMapper().readValue(json, mapType);
        } catch (IOException e) {
            throw new IllegalStateException("反序列化失败", e);
        }
    }

    public static <T> List<T> fromJsonArray(String json, Class<T> clazz) {
        CollectionType javaType = getMapper().getTypeFactory().constructCollectionType(List.class, clazz);
        return fromJsonViaJavaType(json, javaType);
    }
    
    public static ObjectReader readerFor(JavaType javaType) {
        return mapper.readerFor(javaType);
    }
    
    
    public static <T> List<T> jsonStrArrToListBean(String jsonStrArr,Class<T> t) {
        List<?> jsonArr= jsonToBean(jsonStrArr, List.class);
        return arr2ListBean(jsonArr,t);
    }
    public static <T> List<T> mapToListBean(Object mapObj,Class<T> t) {
        String jsonStrArr = toJson(mapObj);
        List<?> jsonArr = fromJson(jsonStrArr, List.class);
        return arr2ListBean(jsonArr,t);
    }
    public static <T> List<T> arr2ListBean(List<?> src_ls,Class<T> t){
        List<T> mxLs=new ArrayList<T>();
        for(Object obj :src_ls){
            T tmpObj= mapToJavaBean(obj,t);
            mxLs.add(tmpObj);
        }
        return mxLs;
    }
    
    public static <T> T mapToJavaBean(Object mapObj, Class<T> t) {
        String str = toJson(mapObj);
        if (!StringUtils.isEmpty(str)) {
            return fromJson(str, t);
        } else {
            return null;
        }
    }
}