Java | 实现一个 ORM 真的很简单

实现一个 ORM 到底多简单

---

Table of Contents

• 实现一个 ORM 到底多简单
• 原理
• ORM 实现
  • 1. 通过注解来将 Java Bean 和数据库字段关联
  • 2. 反射工具类
  • 3. 简单的 model 示例
  • 4. 注解解析
  • 5. 数据库操作
  • 6. 结合反射实现查询操作
• 使用动态代理实现 @Query @Select 类似功能
  • 1. 动态代理
  • 2. 注解
  • 3. 表设计
  • 4. model
  • 5. repository
  • 7. 大体流程
  • 8. 代理使用
  • 9. 将生成代理放入 Spring IOC 容器中
  • 10. invoke方法处理

---

在这篇文章中主要用到了注解、反射、动态代理、正则、Jexl3 表达式来实现一个 ORM, 在大多数框架中，都会用到这些东西，在这里只是简单的使用一下，而不是原理分析

原理

在使用的 ORM 框架中，我可以像操作对象一样操作数据的存储，这是怎么实现的，我们知道数据库是认识 SQL 语句的，但并不认识java bean 呀！同时我们在使用ORM时，需要根据ORM框架的规定定义我们的bean，这是为什么？

这是因为 ORM 为我们提供了将对象操作转化为对应的 SQL语句，例如 save(bean), 这时就需要转化成一个 insert 语句，update(bean) 这时就需要转成成对应的 update 语句

通常 insert 语句格式为

insert into 表名 (列名) values( 值)

update 语句为

update 表名 set 列名 = 值 where id = 值

上面的格式可以看出，如果我们能从对象中得出 表名 列名 值，我们也可以写一个简单的ORM框架

ORM 实现

1. 通过注解来将 Java Bean 和数据库字段关联

上篇文章中提到了一下注解，以及自定义注解和解析注解的方法，通过使用注解，我们可以完成一个简单的ORM

要想实现对数据库的操作，我们必须知道数据表名以及表中的字段名称以及类型，正如hibernate 使用注解标识 model 与数据库的映射关系一样，这里我使用了Java Persistence API

注解说明

注解	作用	使用说明
@Entity	标记这是一个实体	标注在类上，标明该类可以被 ORM 处理
@Table	标记实体对应的表	标注在类上，标明该类对应的数据库标明
@Id	标记该字段是id	标注在字段上，标明该字段为 id
@Column	标记该字段对应的列信息	标记在字段上，标明对应的列信息，主要对应列名

字段属性表
用来存储对象中字段与数据表列的对应关系

package com.zyndev.tool.fastsql.core;

import lombok.Data;

import javax.persistence.GenerationType;

/**
 * The type Db column info.
 *
 * @author 张瑀楠 [email protected]
 * @version 0.0.1
 */
@Data
class DBColumnInfo {

    /**
     * (Optional) The primary key generation strategy
     * that the persistence provider must use to
     * generate the annotated entity primary key.
     */
    private GenerationType strategy = GenerationType.AUTO;

    private String fieldName;

    /**
     * The name of the column
     */
    private String columnName;

    /**
     * Whether the column is a unique key.
     */
    private boolean unique;

    /**
     * Whether the database column is nullable.
     */
    private boolean nullable = true;

    /**
     * Whether the column is included in SQL INSERT
     */
    private boolean insertAble = true;

    /**
     * Whether the column is included in SQL UPDATE
     */
    private boolean updatable = true;

    /**
     * The SQL fragment that is used when
     * generating the DDL for the column.
     */
    private String columnDefinition;

    /**
     * The name of the table that contains the column.
     * If absent the column is assumed to be in the primary table.
     */
    private String table;

    /**
     * (Optional) The column length. (Applies only if a
     * string-valued column is used.)
     */
    private int length =  255;

    private boolean id = false;

}

2. 反射工具类

提供一些常用的反射操作

通过反射我们可以动态的得到一个类所有的成员变量的信息，同时为这些变量取值或者赋值

package com.zyndev.tool.fastsql.util;


import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * The type Bean reflection util.
 *
 * @author yunan.zhang [email protected]
 * @version 0.0.3
 * @date 2017年12月26日 16点36分
 */
public class BeanReflectionUtil {

    public static Object getPrivatePropertyValue(Object obj,String propertyName)throws Exception{
        Class cls=obj.getClass();
        Field field=cls.getDeclaredField(propertyName);
        field.setAccessible(true);
        Object retvalue=field.get(obj);
        return retvalue;
    }

    /**
     * Gets static field value.
     */
    public static Object getStaticFieldValue(String className, String fieldName) throws Exception {
        Class cls = Class.forName(className);
        Field field = cls.getField(fieldName);
        return field.get(cls);
    }

    /**
     * Gets field value.
     */
    public static Object getFieldValue(Object obj, String fieldName) throws Exception {
        Class cls = obj.getClass();
        Field field = cls.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field.get(obj);
    }

    /**
     * Invoke method object.
     */
    public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
        Class cls = owner.getClass();
        Class[] argclass = new Class[args.length];
        for (int i = 0, j = argclass.length; i < j; i++) {
            argclass[i] = args[i].getClass();
        }
        @SuppressWarnings("unchecked")
        Method method = cls.getMethod(methodName, argclass);
        return method.invoke(owner, args);
    }

    /**
     * Invoke static method object.
     */
    public Object invokeStaticMethod(String className, String methodName, Object[] args) throws Exception {
        Class cls = Class.forName(className);
        Class[] argClass = new Class[args.length];
        for (int i = 0, j = argClass.length; i < j; i++) {
            argClass[i] = args[i].getClass();
        }
        @SuppressWarnings("unchecked")
        Method method = cls.getMethod(methodName, argClass);
        return method.invoke(null, args);
    }

    /**
     * New instance object.
     */
    public static Object newInstance(String className) throws Exception {
        Class clazz = Class.forName(className);
        @SuppressWarnings("unchecked")
        java.lang.reflect.Constructor cons = clazz.getConstructor();
        return cons.newInstance();
    }

    /**
     * New instance object.
     */
    public static Object newInstance(Class clazz) throws Exception {
        @SuppressWarnings("unchecked")
        java.lang.reflect.Constructor cons = clazz.getConstructor();
        return cons.newInstance();
    }

    /**
     * Get bean declared fields field [ ].
     */
    public static Field[] getBeanDeclaredFields(String className) throws ClassNotFoundException {
        Class clazz = Class.forName(className);
        return clazz.getDeclaredFields();
    }

    /**
     * Get bean declared methods method [ ].
     */
    public static Method[] getBeanDeclaredMethods(String className) throws ClassNotFoundException {
        Class clazz = Class.forName(className);
        return clazz.getMethods();
    }

    /**
     * Copy fields.
     */
    public static void copyFields(Object source, Object target) {
        try {
            List list = new ArrayList<>();
            Field[] sourceFields = getBeanDeclaredFields(source.getClass().getName());
            Field[] targetFields = getBeanDeclaredFields(target.getClass().getName());
            Map map = new HashMap<>(targetFields.length);
            for (Field field : targetFields) {
                map.put(field.getName(), field);
            }
            for (Field field : sourceFields) {
                if (map.get(field.getName()) != null) {
                    list.add(field);
                }
            }
            for (Field field : list) {
                Field tg = map.get(field.getName());
                tg.setAccessible(true);
                tg.set(target, getFieldValue(source, field.getName()));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 简单的 model 示例

package com.zyndev.tool.fastsql;

import javax.persistence.*;

/**
 * @author 张瑀楠 [email protected]
 * @date   2017/11/30 下午11:21
 */
@Data
@Entity
@Table(name = "tb_student")
public class Student {

    @Id
    @Column
    private Integer id;

    @Column
    private String name;

    @Column(updatable = true, insertable = true, nullable = false)
    private Integer age;

}

4. 注解解析

将对象的上的注解进行解析，得到对应关系

package com.zyndev.tool.fastsql.core;


import com.zyndev.tool.fastsql.util.StringUtil;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * The type Annotation parser.
 * 

 * 注解解析工具
 *
 * @author yunan.zhang [email protected]
 * @version 0.0.3
 * @since 2017-12-26 16:59:07
 */
public class AnnotationParser {

    /**
     * 存储类名和数据库表名的关系
     * 使用三个cache 主要为了减少反射的次数，提高效率
     */
    private final static Map tableNameCache = new HashMap<>(30);

    /**
     * 存储类名和数据库列的关联关系
     */
    private final static Map tableAllColumnNameCache = new HashMap<>(30);

    /**
     * 存储类名和对应的数据库全列名的关系
     */
    private final static Map> tableAllDBColumnCache = new HashMap<>(30);

    /**
     * Gets table name.
     * 获得表名
     * 判断是否有@Table注解，如果有得到注解的name,如果name为空，则使用类名做为表名
     * 如果没有@Table返回null
     *
     * @param     the type parameter
     * @param entity the entity
     * @return the table name
     */
    public static  String getTableName(E entity) {
        String tableName = tableNameCache.get(entity.getClass().getName());
        if (tableName == null) {
            Table table = entity.getClass().getAnnotation(Table.class);
            if (table != null && StringUtil.isNotBlank(table.name())) {
                tableName = table.name();
            } else {
                tableName = entity.getClass().getSimpleName();
            }
            tableNameCache.put(entity.getClass().getName(), tableName);
        }
        return tableName;
    }

    /**
     * Gets all db column info.
     */
    public static  List getAllDBColumnInfo(E entity) {
        List dbColumnInfoList = tableAllDBColumnCache.get(entity.getClass().getName());
        if (dbColumnInfoList == null) {
            dbColumnInfoList = new ArrayList<>();
            DBColumnInfo dbColumnInfo;
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                Column column = field.getAnnotation(Column.class);
                if (column != null) {
                    dbColumnInfo = new DBColumnInfo();
                    if (StringUtil.isBlank(column.name())) {
                        dbColumnInfo.setColumnName(field.getName());
                    } else {
                        dbColumnInfo.setColumnName(column.name());
                    }
                    if (null != field.getAnnotation(Id.class)) {
                        dbColumnInfo.setId(true);
                    }
                    dbColumnInfo.setFieldName(field.getName());
                    dbColumnInfoList.add(dbColumnInfo);
                }
            }
            tableAllDBColumnCache.put(entity.getClass().getName(), dbColumnInfoList);
        }
        return dbColumnInfoList;
    }

    /**
     * 返回表字段的所有字段  column1,column2,column3
     *
     * @param     the type parameter
     * @param entity the entity
     * @return string
     */
    public static  String getTableAllColumn(E entity) {

        String allColumn = tableAllColumnNameCache.get(entity.getClass().getName());
        if (allColumn == null) {
            List dbColumnInfoList = getAllDBColumnInfo(entity);
            StringBuilder allColumnsInfo = new StringBuilder();
            int i = 1;
            for (DBColumnInfo dbColumnInfo : dbColumnInfoList) {
                allColumnsInfo.append(dbColumnInfo.getColumnName());
                if (i != dbColumnInfoList.size()) {
                    allColumnsInfo.append(",");
                }
                i++;
            }
            allColumn = allColumnsInfo.toString();
            tableAllColumnNameCache.put(entity.getClass().getName(), allColumn);
        }
        return allColumn;

    }
}

5. 数据库操作

数据库交互使用spring 提供的 JdbcTemplate，这里没有在自己写一套 DBUtil

6. 结合反射实现查询操作

保存一个entity

保存操作相对简单，这里主要是将 entity 转换为 insert 语句

/**
 * Save int.
 * @param entity the entity
 * @return the int
 */
@Override
public int save(Object entity) {
    try {
        String tableName = AnnotationParser.getTableName(entity);
        StringBuilder property = new StringBuilder();
        StringBuilder value = new StringBuilder();
        List