JDBC 结果集转换成实体对象工具

业务需求

由于当前有个小项目，不太用的到 Mybatis 这样的框架，所以数据库操作直接使用了 JDBC 和连接池了。

但是由于查询的结果数据需要转换到数据库表的实体类上，而手动一个一个熟悉获取转换过于麻烦，且不利于后期修改，就写了个工具类使用。

实现思路

有两思路，都是需要用到反射。

一种是直接转换，根据数据表的属性名和对应实体对象的属性名匹配（数据库字段转换为驼峰命名法再进行匹配），再插值。

另一种是通过注解（推荐），自定义一个注解，注解属性里写上需要为属性匹配的字段名称和是否过滤该字段，根据注解上的属性字段匹配，进行插值。

具体代码

只给出了两种写法结合的思路，如果只需要其中一种实现，可以将另一种的判断在代码中删除即可，驼峰命名的转换比较也可删除。

工具类 ConvertUtils

其中有两个方法

一个是单个结果的转换，另一个是结果集的转换

import com.eternal.annotation.Column;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author wansheng
 * @createDate 2023/6/26 15:52
 */
@Slf4j
public class ConvertUtils {
    /**
     * 将结果转换为对象
     *
     * @param rs
     * @param clazz
     * @param <T>
     * @return
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> T convertToTarget(ResultSet rs, Class clazz) throws SQLException, InstantiationException, IllegalAccessException {
        //结果集的元素对象
        ResultSetMetaData rsmd = rs.getMetaData();
        //获取结果集的元素个数
        int colCount = rsmd.getColumnCount();
        //业务对象的属性数组
        Field[] fields = clazz.getDeclaredFields();
        T obj = (T) clazz.newInstance();//构造业务对象实体
        //将每一个字段取出进行赋值
        for (int i = 1; i <= colCount; i++) {
            boolean match = false;
            //寻找该列对应的对象属性
            for (int j = 0; j < fields.length; j++) {
                Field field = fields[j];
                //查看是否有注解，有则根据注解中的名称来匹配
                if (field.isAnnotationPresent(Column.class)) {
                    Column column = field.getAnnotation(Column.class);
                    if (column.ignore()) {
                        break;
                    }
                    String columnName = column.value();
                    String columnNameOfSql = rsmd.getColumnName(i);
                    if (columnName.equalsIgnoreCase(columnNameOfSql) && columnNameOfSql != null) {
                        match = true;
                    }
                }
                //如果匹配进行赋值,匹配时，将数据库的列名称转换为驼峰命名法再比较
                else if (field.getName().equalsIgnoreCase(RegexUtils.underlineToHump(rsmd.getColumnName(i)))) {
                    match = true;
                }
                if (match) {
                    boolean flag = field.isAccessible();
                    //通过类型获取属性值
                    Class<?> type = field.getType();
                    Object value = rs.getObject(i, type);
                    //直接获取会使jdbc将数据库中的int直接转化为Long类型，导致类型赋值错误
                    //Object value = rs.getObject(i);
                    field.setAccessible(true);
                    field.set(obj, value);
                    field.setAccessible(flag);
                    break;
                }
            }
        }
        return obj;
    }

    /**
     * 将rs结果转换成对象列表
     *
     * @param rs    jdbc结果集
     * @param clazz 对象的映射类
     *              return 封装了对象的结果列表
     */
    public static <T> List<T> convertToList(ResultSet rs, Class clazz) throws SQLException, InstantiationException, IllegalAccessException {
        //结果集的元素对象
        ResultSetMetaData rsmd = rs.getMetaData();
        //获取结果集的元素个数
        int colCount = rsmd.getColumnCount();
        //返回结果的列表集合
        List list = new ArrayList();
        //对每一条记录进行操作
        while (rs.next()) {
            T obj = convertToTarget(rs, clazz);
            list.add(obj);
        }
        return list;
    }
}

工具类 字符串转为驼峰命名

转换示例：my_name转为myName，create_time转为createTime

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author wansheng
 * @createDate 2023/6/26 16:11
 */
public class RegexUtils {

    private static Pattern UNDERLINE_PATTERN = Pattern.compile("_([a-z])");

    /**
     * 字符串转换为驼峰命名
     * @param str
     * @return
     */
    public static String underlineToHump (String str){
        //正则匹配下划线及后一个字符，删除下划线并将匹配的字符转成大写
        Matcher matcher = UNDERLINE_PATTERN.matcher(str);
        StringBuffer sb = new StringBuffer(str);
        if (matcher.find()) {
            sb = new StringBuffer();
            //将当前匹配的子串替换成指定字符串，并且将替换后的子串及之前到上次匹配的子串之后的字符串添加到StringBuffer对象中
            //正则之前的字符和被替换的字符
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
            //把之后的字符串也添加到StringBuffer对象中
            matcher.appendTail(sb);
        } else {
            //去除除字母之外的前面带的下划线
            return sb.toString().replaceAll("_", "");
        }
        return underlineToHump(sb.toString());
    }


}

自定义注解 @Column

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author wansheng
 * @createDate 2023/6/26 16:30
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {
    /**
     * 属性对应的数据库列名称
     * @return
     */
    String value();

    /**
     * 是否忽视该属性的赋值
     * @return
     */
    boolean ignore() default false;
}

import com.eternal.annotation.Column;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.Date;

/**
 * @author wansheng
 * @createDate 2023/6/26 10:27
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class ChannelEntity implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     * 数据id
     */
    private Integer id;
    /**
     * 通道编号
     */
    private String channel;
    /**
     * 通道名称
     */
    @Column("ch_name")
    private String chName;
    /**
     * 通道描述
     */
    private String description;
    /**
     * x坐标
     */
    @Column("layout_x")
    private Integer layoutX;
    /**
     * y坐标
     */
    @Column("layout_y")
    private Integer layoutY;
    /**
     * 创建时间
     */
    @Column("gmt_create")
    private Date gmtCreate;
    /**
     * 修改时间
     */
    @Column("gmt_modified")
    private Date gmtModified;
}