Hibernate 自动进行数据封装

1. 前言

Hibernate 可以构建各种复杂的 SQL 语句，但其本质都是反射机制结合映射关系完成的。

框架也仅是一款程序产品，人为编写的产物。要相信，只要你愿意，你完全可以实现自己的 JDBC 框架。

本节课和大家继续聊聊 Hibernate 是如何自动封装数据的。

2. 理想状态

程序中的数据通过 SQL 语句传递给数据库，从 IO 流的角度上理解是数据的输出。

把数据库中的数据封装成程序能识别、使用的类型，这个过程叫数据库封装。从 IO 流的角度上讲是数据的输入。

数据封装的实现还是利用反射机制。

数据封装的思路也简单。

表结构对应类结构，一行记录或说一个实体对应一个对象，字段对应属性。还是同样的配方。

即将编写实例之前，先做一个理想化的假设：

表名和类名相同；
表中的字段名和类中的属性名相同；
实体类中没有特别复杂的数据类型。

理想状态设定便于大家由浅入深理解实现过程。

真实项目中，很难达到理想化状态。因为 JAVA 程序和关系型数据库的命名规范有差异性，不管谁迁就谁，都会让彼此难受。

在上一节课的自定义 Session 对象中添加一个封装方法：

public class MySession<T> {
public T get(Class<T> clz, Serializable id) throws Exception {
    String sql = createSql_(clz, id);
    // JDBC 常规操作…… 得到结果集
    ResultSet rs=this.getRs(sql);
    //数据封装
    T entity= this.wrap(clz, rs);   
    return entity;
}
/**
*构建 SQL ，具体代码参考本系列的《Hibernate 自动生成SQL语句》 
*/
private String createSql(Class<T> clz, Serializable id) {
    return null;
}
/**
*得到结果集，此方法就是常规的 JDBC 操作
*/
private ResultSet getRs(String sql) {
    return  null;
}
/**
*数据封装
*/
private T  wrap(Class<T> clz,ResultSet rs) throws InstantiationException, IllegalAccessException {
    return null;
}
}

关注 wrap（）方法即可，直接让代码说话：

private T  wrap(Class<T> clz,ResultSet rs) throws InstantiationException, IllegalAccessException {
    // 通过反射创建对象
    T entity = clz.newInstance();
    String attName = null;
    Object value = null;
    // 检查结果集中是否存在数据
    if (rs.next()) {
        // 属性信息
        Field[] fields = clz.getDeclaredFields();
        for (Field field : fields) {
            // 表的字段名即类的属性名
            attName = field.getName();
            // 从结果集获取值
            value = rs.getObject(attName);
            //允许直接访问私有属性
            field.setAccessible(true);
            //数据封装
            field.set(entity, value);
        }
    }
    return entity;
}

上面代码没有进行类型转换相关操作，依靠 JAVA 自动类型转换完成，对于常用的基本类型，不会出多大问题。但对于较复杂的数据类型，需要编码进行强制类型转换。

下面这 2 行代码，通过打破私有属性的壁垒，直接给属性赋值。只适合用于验证、测试环境下。

field.setAccessible(true);
field.set(entity, value);

测试一下代码：

Student stu = new MySession<Student>().get(Student.class, new Integer(1));
System.out.println(stu);

在一切理想的状态下，一个简易的 JDBC 框架就开始工作了。

虽然它很薄弱，且不堪重负，但是，它是黑暗中的一道光，能指导你认识框架本质。

3. 非理想状态

再来一个非理想状态下的实现：

类名与表名不同名；
类中的属性名与表中的字段名有不同的命名；

整体思想和上面代码没有区别，通过属性名找到字段名，因为属性名和字段名不相同，所以需要通过属性上面的注解信息得到字段名。

让代码自己说话：

private T wrap_(Class<T> clz, ResultSet rs) throws InstantiationException, IllegalAccessException, SQLException,NoSuchMethodException, SecurityException, IllegalArgumentException,InvocationTargetException {
    // 使用反射创建对象
    T entity = clz.newInstance();
    // 属性名
    String attName = null;
    // 列名
    String columnName = null;
    Object value = null;
    Column columnAnnotaiton = null;
    // 检查结果集中是否存在数据
    if (rs.next()) {
        // 属性信息
        Field[] fields = clz.getDeclaredFields();
        for (Field field : fields) {
            // 属性名
            attName = field.getName();
            // 查看属性上面的注解
            columnAnnotaiton = field.getAnnotation(Column.class);
            if (columnAnnotaiton != null) {
                columnName = columnAnnotaiton.name();
            } else {
                columnName = attName;
            }
            // 从结果集中获取值
            value = rs.getObject(columnName);
            // 属性的 set 方法名
            String setMethodName = "set" + attName.substring(0, 1).toUpperCase() + attName.substring(1);
            // 属性的 set 方法
            Method setMethod = clz.getDeclaredMethod(setMethodName, new Class[] { field.getType() });
            setMethod.invoke(entity, new Object[] { value });
            }
        }
        return entity;
    }

上面代码一样没有考虑复杂类型存在情况。

4. 小结

本节课程和大家聊了聊 Hibernate 是如何自动实现数据封装的，从实现原理上讲，还是比较容易理解的。

但是，真实环境的需求总是千变万化的，理想只存于理想中。

Hibernate 的实现和我们实现的最大区别在于，它总是能适应不同的需求，要适应不同的需求，无论是代码的设计还是编码都会有难度。

但是，千里之行，始于脚下，一步一步，终能看透所有的本质。