Mybatis——数据库json字段映射实体类

场景：数据库varchar字段存放json格式字符串数据，Mybatis查询解析json数据映射到实体类属性变量。

相关依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.74</version>
</dependency>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>4.6.10</version>
</dependency>

Json解析工具类：

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;

import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.TypeUtil;

/**
 * @Title: JsonUtil
 * @Description: Json工具类，暂时内部使用fastjson实现
 * @version V1.0
 */
public class JsonUtil {
    private JsonUtil() {}

    public static String obj2json(Object obj) {
        return obj2json(obj, DateUtil.DATE_TIME_PATTERN);
    }

    /**
     * 
     * @Description: 
     * @param obj
     * @param beIgnoreNull 是否忽略null值
     * @param beFormat  是否格式化
     * @param dataFormat  指定日期格式化 
     * @return
     */
    public static String obj2json2(Object obj, boolean beIgnoreNull, boolean beFormat, String dataFormat) {
        List<SerializerFeature> features = new ArrayList<>();
        if (!beIgnoreNull) {
            features.add(SerializerFeature.WriteMapNullValue);
            features.add(SerializerFeature.DisableCircularReferenceDetect);
            features.add(SerializerFeature.WriteNullStringAsEmpty);
            features.add(SerializerFeature.WriteNullListAsEmpty);
            features.add(SerializerFeature.WriteDateUseDateFormat);
        }
        if (beFormat) {
            features.add(SerializerFeature.PrettyFormat);
        }
        features.add(SerializerFeature.WriteDateUseDateFormat);
        return obj2json2(obj, dataFormat, features.toArray(new SerializerFeature[] {}));
    }

    public static String obj2json2(Object obj, boolean beIgnoreNull, boolean beFormat) {
        return obj2json2(obj, beIgnoreNull, beFormat, DateUtil.DATE_TIME_PATTERN);
    }

    public static String obj2json2(Object obj, boolean beIgnoreNull) {
        return obj2json2(obj, beIgnoreNull, false);
    }

    public static String obj2json2(Object obj) {
        return obj2json2(obj, false);
    }

    /**
     * 
     * @Description: 对象转json
     * @param obj
     *            对象
     * @param beFormat
     *            是否格式化
     * @return json字符串
     */
    public static String obj2json(Object obj, boolean beFormat) {
        return obj2json2(obj, false, beFormat);
    }

    /**
    * 
    * @Description: 对象转json
    * @param obj
    * @param dataFormat 日期格式
    * @return
    * 
    * 如果java bean的Date类型属性需要特殊处理，使用注解
    * @com.alibaba.fastjson.annotation.JSONField
    */
    public static String obj2json(Object obj, String dataFormat) {
        return obj2json2(obj, false, false, dataFormat);
    }

    private static String obj2json2(Object obj, String dataFormat, SerializerFeature... feature) {
        String defaultFormat = JSONObject.DEFFAULT_DATE_FORMAT;
        JSONObject.DEFFAULT_DATE_FORMAT = dataFormat;
        String json = JSON.toJSONString(obj, feature);
        JSONObject.DEFFAULT_DATE_FORMAT = defaultFormat;
        return json;
    }

    /**
     * 
     * @Description: xml转json
     * @param xml
     * @return json字符串
     */
    public static String xml2json(String xml) {
        return cn.hutool.json.JSONUtil.xmlToJson(xml).toJSONString(0);
    }

    /**
     * 
     * @Description: json转对象
     * @param jsonString
     * @param beanClass
     * @return 实体类对象
     */
    public static <T> T json2Obj(String jsonString, Class<T> beanClass) {
        return JSON.parseObject(jsonString, beanClass);
    }

    /**
     * 
     * @Description JSON字符串转为实体类对象，转换异常将被抛出
     *
     * @param <T>
     *            Bean类型
     * @param jsonString
     *            JSON字符串
     * @param typeReference
     *            {@link TypeReference}类型参考子类，可以获取其泛型参数中的Type类型
     * @param ignoreError
     *            是否忽略错误
     * @return 实体类对象
     */
    public static <T> T json2Obj(String jsonString, com.sf.nwms.core.util.lang.TypeReference<T> typeReference,
        boolean ignoreError) {
        /* return cn.hutool.json.JSONUtil.toBean(jsonString, TypeUtil.getTypeArgument(typeReference.getClass()),
            ignoreError);*/
        return json2Obj(jsonString, typeReference);
    }

    /**
     * 
     * @Description: 
     * @param <T>
     * @param jsonString
     * @param typeReference
     * @return
     * 
     * eg: JsonUtil.json2Obj(jsonString, new com.sf.nwms.core.util.lang.TypeReference<List<JavaBean>())
     */
    public static <T> T json2Obj(String jsonString, com.sf.nwms.core.util.lang.TypeReference<T> typeReference) {
        return JSON.parseObject(jsonString, TypeUtil.getTypeArgument(typeReference.getClass()));
    }

    /**
     * 
     * @Description: json转对象
     * @param jsonString
     *            json字符串
     * @param beanType
     *            实体类对象类型
     * @param ignoreError
     *            是否忽略错误
     * @return 实体类对象
     */
    public static <T> T json2Obj(String jsonString, Type beanType, boolean ignoreError) {
        return JSON.parseObject(jsonString, beanType);
    }

}

使用到日期工具类：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;

/**     
 * @Title: DateUtils   
 * @Description: 日期工具类       
 */
public class DateUtil {

    /** 分 */
    public static final long MINUTE_TTL = 60 * 1000L;
    /** 时 */
    public static final long HOURS_TTL = 60 * 60 * 1000L;
    /** 半天 */
    public static final long HALF_DAY_TTL = 12 * 60 * 60 * 1000L;
    /** 天 */
    public static final long DAY_TTL = 24 * 60 * 60 * 1000L;
    /** 月 */
    public static final long MONTH_TTL = 30 * 24 * 60 * 60 * 1000L;
    /** 时间格式(yyyy-MM-dd) */
    public final static String DATE_PATTERN = "yyyy-MM-dd";
    /** 时间格式(yyyy-MM-dd'T'HH:mm:ss.SSSZ) */
    public final static String DATE_TIME_PATTERN = "yyyy-MM-dd'T'HH:mm:ssZ";

    private static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat(DATE_TIME_PATTERN);
        }
    };

    public static Long getSystemTimeSeconds() {
        return System.currentTimeMillis() / 1000L;
    }

    /**
     * @Description:   将时间戳转换为时间
     * 输入形如：148851067484755 输出形如：2017-03-03T11:11:14.000+0800
     * 异常格式返回-1
     * @param s
     * @return
     */
    public static String getTimestampDateTimeLong(Long s) {
        String res;
        Date date = new Date(s * 1000);
        res = simpleDateFormatThreadLocal.get().format(date);
        return res;
    }

    /**
     * 
     * @Description: 将时间戳转换为时间
     * @param s 毫秒数
     * @return
     */
    public static String getTimestampDateLong(Long s) {
        return simpleDateFormatThreadLocal.get().format(new Date(s));
    }

    /**
     * 
     * @Description: 日期格式化 日期格式为：yyyy-MM-dd
     * @param date  日期
     * @return 返回yyyy-MM-dd格式日期
     */
    public static String formatShort(Date date) {
        return format(date, DATE_PATTERN);
    }

    /**
     * 
     * @Description: 日期格式化 日期格式为：yyyy-MM-dd'T'HH:mm:ss.SSSZ
     * @param date 日期
     * @return 返回
     */
    public static String formatLong(Date date) {
        return format(date, DATE_TIME_PATTERN);
    }

    /**
    * 
    * @Description: 格式化时间
    * @param date
    * @param pattern
    * @return
    */
    public static String format(Date date, String pattern) {
        if (date != null) {
            SimpleDateFormat df = null;
            if (DATE_TIME_PATTERN.equals(pattern)) {
                df = simpleDateFormatThreadLocal.get();
            } else {
                df = new SimpleDateFormat(pattern);
            }
            return df.format(date);
        }
        return null;
    }

    /**
     * 
     * @Description: 字符串转时间
     * @param strDate
     * @return
     * @throws ParseException
     */
    public static Date stringLongToDate(String strDate) throws ParseException {
        return stringToDate(strDate, DATE_TIME_PATTERN);
    }

    public static Date stringShortToDate(String strDate) throws ParseException {
        return stringToDate(strDate, DATE_PATTERN);
    }

    /**
     * 字符串转换成日期
     * @param strDate 日期字符串
     * @param pattern 日期的格式
     * @throws ParseException 
     */
    public static Date stringToDate(String strDate, String pattern) throws ParseException {
        if (StringUtils.isBlank(strDate)) {
            return null;
        }
        SimpleDateFormat df = null;
        if (DATE_TIME_PATTERN.equals(pattern)) {
            df = simpleDateFormatThreadLocal.get();
        } else {
            df = new SimpleDateFormat(pattern);
        }
        return df.parse(strDate);
    }

    /**
     * @Description: 日期计算
     * @param oldDate
     * @param addValue
     * @param unit
     * @return
     */
    public static Date add(Date oldDate, Long addValue, TimeUnit unit) {
        long milliseconds = oldDate.getTime();
        milliseconds += unit.toMillis(addValue);
        return new Date(milliseconds);
    }

}

mysql存储json的字段类型转换抽象类：

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import com.alibaba.fastjson.JSON;

/**     
 * @Title: AbstractObjectTypeHandler   
 * @Description: mysql存储json的字段类型转换抽象类 
 */
// @Slf4j
// @MappedJdbcTypes(JdbcType.VARCHAR)
public abstract class AbstractObjectTypeHandler<T> extends BaseTypeHandler<T> {

    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
        if (null != parameter) {
            ps.setString(i, JsonUtil.obj2json(parameter));
        }
    }

    @Override
    public T getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return deserialize(rs.getString(columnName));
    }

    @Override
    public T getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return deserialize(rs.getString(columnIndex));
    }

    @Override
    public T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return deserialize(cs.getString(columnIndex));
    }

    /**    
     * @Description: json反序列化
     * @param data
     * @return          
     */
    private T deserialize(String data) {
        return StringUtils.isBlank(data) ? null : string2Obj(data);
    }

    // 重点，解析方法，子类可重写json解析
    @SuppressWarnings("unchecked")
    protected T string2Obj(String jsonString) {
        Class<T> clazz = (Class<T>)getRawType();
        return JSON.parseObject(jsonString, clazz);
    }
}

解析实体

数据库表test：

字段名	类别	参考值
id	bigint	1
json_value	varchar	{name:“张三”,age:14}
…

正常Mybatis映射实体类：

@Data
public class Test{
    private Long id;
    private String jsonValue;
}

Json内容实体类：

@Data
public class Person{
    private String name;
    private int age;
}

Mybatis映射实体类时，解析json字段数据到变量，改造Test实体类：

@Data
public class Test{
    private Long id;
    
    @ColumnType(jdbcType = JdbcType.VARCHAR, typeHandler = PersonTypeHandler.class)
    private Person jsonValue;
}

添加Json解析转换器：

import com.alibaba.fastjson.JSON;

/**     
 * @Description: Person类型转换器       
 */
public class PersonTypeHandler extends AbstractObjectTypeHandler<Person> {}

Mybatis xml映射

<resultMap type="com.test.model.Test" id="TestMap">
    <result property="id" column="id" jdbcType="INTEGER"/>
    <result typeHandler="com.test.typehandler.PersonTypeHandler" property="jsonValue" column="json_value" jdbcType="VARCHAR"/>
</resultMap>

查询test数据时，使用以上resultMap接收，在映射实体类时自动解析json字段。

解析List

数据库表test：

字段名	类别	参考值
id	bigint	1
json_list_value	varchar	[{name:“张三”,age:14},{name:“李四”,age:15}]
…

正常Mybatis映射实体类：

@Data
public class Test{
    private Long id;
    private String jsonListValue;
}

Json内容实体类：

@Data
public class Person{
    private String name;
    private int age;
}

Mybatis映射实体类时，解析json字段数据到变量，改造Test实体类：

@Data
public class Test{
    private Long id;
    
    // 映射成List<Person>
    @ColumnType(jdbcType = JdbcType.VARCHAR, typeHandler = ListPersonTypeHandler.class)
    private List<Person> jsonValue;
}

添加Json解析转换器：

import com.alibaba.fastjson.JSON;

/**     
 * @Description: List<Person>类型转换器       
 */
public class ListPersonTypeHandler extends AbstractObjectTypeHandler<List<Person>> {
    @Override
    protected List<Person> string2Obj(String jsonString) {
        return JSON.parseArray(jsonString, Person.class);
    }
}

Mybatis xml映射

<resultMap type="com.test.model.Test" id="TestMap">
    <result property="id" column="id" jdbcType="INTEGER"/>
    <result typeHandler="com.test.typehandler.ListPersonTypeHandler" property="jsonListValue" column="json_list_value" jdbcType="VARCHAR"/>
</resultMap>

查询test数据时，使用以上resultMap接收，在映射实体类时自动解析json集合字段。