支持分表的ORM框架实现

本文带大家实现一个支持分表的ORM框架，通过简单代码实现来理解核心原理

惯例贴出GitHub地址：https://github.com/whiteBX/worm

首先明确一个我们要实现的效果，然后再考虑实现，下面以user表作为例子：

@Table("user_")
@SplitKey(column = "id", tableNum = 8)
public class UserDO {
    @Column(value = "id", columnType = JDBCType.BIGINT)
    private Long id;
    @Column(value = "user_name", columnType = JDBCType.VARCHAR)
    private String userName;
    @Column(value = "real_name", columnType = JDBCType.VARCHAR)
    private String realName;
    @Column(value = "phone", columnType = JDBCType.VARCHAR)
    private String phone;
    @Column(value = "sex", columnType = JDBCType.TINYINT)
    private short sex;
    // 省略getter/setter
}

我们想要实现的就是在UserDO上加上自定义的Table、SplitKey、Column注解，之后就可以通过操作对象的方式来实现对于用户表的增删改查，并且能支持根据SplitKey中配置的列和表数量来自动实现分表操作。

首先来定义之前用到的三个注解：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {

    String value();

    JDBCType columnType();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface SplitKey {
    /**
     * 分库分表的列,其类型必须为Long
     */
    String column();

    /**
     * 分表数量
     */
    int tableNum();
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {

    String value();
}

接下来是如何使用这些注解，这里我们用一个ReflectUtil来封装出从类中解析表名、分表规则、列名等操作：

public class ReflectUtil {

    /**
     * 解析表名
     */
    public static String parseTable(Class clazz) {
        AssertUtil.isTrue(clazz.isAnnotationPresent(Table.class), ErrorCode.ACCESS_ERROR, "class need annotation Table");
        Table table = (Table) clazz.getDeclaredAnnotation(Table.class);
        return table.value();
    }

    /**
     * 解析分表规则
     */
    public static SplitKey parseSplitKey(Class clazz) {
        AssertUtil.isTrue(clazz.isAnnotationPresent(SplitKey.class), ErrorCode.ACCESS_ERROR, "class need annotation SplitKey");
        return (SplitKey) clazz.getDeclaredAnnotation(SplitKey.class);
    }

    /**
     * 解析列
     */
    public static Column parseColumn(Class clazz, String fieldName) {
        try {
            return clazz.getDeclaredField(fieldName).getDeclaredAnnotation(Column.class);
        } catch (NoSuchFieldException e) {
            throw new BizException(ErrorCode.ACCESS_ERROR, "parse Column error");
        }
    }

    /**
     * 反射获取对象的属性
     */
    public static Object getFieldValue(Object obj, String fieldName) {
        Field field = null;
        boolean access = false;
        try {
            field = obj.getClass().getDeclaredField(fieldName);
            access = field.isAccessible();
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new BizException(ErrorCode.ACCESS_ERROR, "get Field value error: " + e.getMessage());
        } finally {
            field.setAccessible(access);
        }

    }

    /**
     * 解析获取tableMeta
     */
    public static TableMeta parseMeta(Class clazz) {
        TableMeta meta = new TableMeta();
        meta.setTableName(parseTable(clazz));
        meta.setTableClass(clazz);
        meta.setSplitKey(parseSplitKey(clazz));
        for (Field field : clazz.getDeclaredFields()) {
            Column column = parseColumn(clazz, field.getName());
            meta.addColumnMeta(field.getName(), column.value(), column.columnType());
        }
        return meta;
    }
}

上面工具类中引入了一个TableMeta类，这个类是我们用来缓存所有标注了Table注解的类的信息的，方便后面直接使用，也比每次去对表增删改查时新反射解析一次效率更高，其代码如下：

public class TableMeta {
    /**
     * 表名
     */
    private String tableName;
    /**
     * 对应实体类型
     */
    private Class tableClass;
    /**
     * 分库分表
     */
    private SplitKey splitKey;
    /**
     * 列属性
     */
    private List<ColumnMeta> columnMetaList;

    public class ColumnMeta {
        /**
         * 字段名
         */
        private String field;
        /**
         * 列名
         */
        private String column;
        /**
         * 列类型
         */
        private JDBCType jdbcType;

        public ColumnMeta(String field, String column, JDBCType jdbcType) {
            this.field = field;
            this.column = column;
            this.jdbcType = jdbcType;
        }
    }

    public ColumnMeta getColumnMetaByColumn(String columnName) {
        for (ColumnMeta columnMeta : columnMetaList) {
            if (columnMeta.equals(columnMeta.column)) {
                return columnMeta;
            }
        }
        return null;
    }

    public ColumnMeta getColumnMetaByField(String field) {
        for (ColumnMeta columnMeta : columnMetaList) {
            if (field.equals(columnMeta.field)) {
                return columnMeta;
            }
        }
        return null;
    }

    public void addColumnMeta(String field, String column, JDBCType jdbcType) {
        if (this.columnMetaList == null) {
            columnMetaList = new ArrayList<>();
        }
        columnMetaList.add(new ColumnMeta(field, column, jdbcType));
    }
//省略getter/setter
}

通过上面我们已经可以获取到表名、列这些需要的属性了，接下来来获取分表情况下实际的表名：

public class DefaultSplitStrategy {

    public static String getRealTableName(Object o) {
        TableMeta tableMeta = OrmHolder.get(o.getClass());
        AssertUtil.notNull(tableMeta, ErrorCode.ACCESS_ERROR, "");
        // not split
        if (tableMeta.getSplitKey() == null) {
            return tableMeta.getTableName();
        }
        SplitKey splitKey = tableMeta.getSplitKey();
        Object splitValue = ReflectUtil.getFieldValue(o, splitKey.column());
        AssertUtil.isTrue(splitValue instanceof Long, ErrorCode.ACCESS_ERROR, "split key must be long: " + splitKey.column());
        return tableMeta.getTableName() + (Long) splitValue % splitKey.tableNum();
    }
}

这里默认实现采用了取余的方式，如果需要更复杂的分表方式可以自行扩充。

到这一步已经拿到了数据库的所有信息了，包括：实际的表名、列名、列属性、列的值。接下来要做的就是根据增删该查来把SQL拼出来即可：

public class SqlUtil {

    public static String buildInsertSQL(String tableName, Object obj) {
        StringBuilder sql = new StringBuilder();
        StringBuilder valueStr = new StringBuilder();
        sql.append("Insert into ").append(tableName).append(" (");
        valueStr.append("VALUES (");
        List<TableMeta.ColumnMeta> columnMetaList = OrmHolder.get(obj.getClass()).getColumnMetaList();
        for (TableMeta.ColumnMeta columnMeta : columnMetaList) {
            sql.append(columnMeta.getColumn()).append(",");
            valueStr.append("'").append(ReflectUtil.getFieldValue(obj, columnMeta.getField())).append("',");
        }
        sql.deleteCharAt(sql.lastIndexOf(","));
        valueStr.deleteCharAt(valueStr.lastIndexOf(","));
        valueStr.append(")");
        sql.append(") ").append(valueStr);
        return sql.toString();
    }
}

这里只实现了拼装insert的sql，删改查原理差不多，大家自行拼一下即可。最后通过继承JdbcTemplate来实现一个我们自己的JdbcTemplate把所需要的东西组装起来就可以了：

public class WJdbcTemplate extends JdbcTemplate implements JdbcOperation {
    public WJdbcTemplate(DataSource dataSource) {
        super(dataSource);
    }

    public int insert(Object obj) {
        return this.update(SqlUtil.buildInsertSQL(DefaultSplitStrategy.getRealTableName(obj), obj));
    }
}

下面是测试代码：

@Configuration
@PropertySource("classpath:applications.properties")
public class BeanConfig {

    @Bean
    @ConfigurationProperties()
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    @Bean(name = "dataSource")
    public DataSource dataSource(DataSourceProperties dataSourceProperties) {
        return DataSourceBuilder.create(dataSourceProperties.getClass().getClassLoader())
                .type(HikariDataSource.class)
                .driverClassName(dataSourceProperties.getDriverClassName())
                .url(dataSourceProperties.getJdbcUrl())
                .username(dataSourceProperties.getUser())
                .password(dataSourceProperties.getPassword())
                .build();
    }

    @Bean(name = "wJdbcTemplate")
    public JdbcTemplate jdbcTemplate(
            @Qualifier("dataSource") DataSource dataSource) {
        return new WJdbcTemplate(dataSource);
    }
}
@RunWith(SpringRunner.class)
@SpringBootApplication
@ComponentScan("org.white.worm")
@SpringBootTest
public class TestOrm {

    @Resource
    private WJdbcTemplate wJdbcTemplate;

    @Test
    public void testInsert() {
        UserDO userDO = new UserDO();
        int count = 0;
        for (long i = 0; i < 1000; i++) {
            userDO.setId(i);
            userDO.setUserName("white" + i);
            userDO.setRealName("白" + i);
            userDO.setPhone("13100000000");
            userDO.setSex((short) (i % 2));
            count += wJdbcTemplate.insert(userDO);
        }
        System.out.println(count);
    }
}

启动mysql并创建好user_0 ~ user_7之后，运行TestOrm中的testInsert方法，我们发现数据库都按主键取余的方式插入了对应的表中。

至此我们一个自定义的支持分表的ORM框架就完成了!