自己动手实现一个简单的ORM框架

最新推荐文章于 2023-07-17 23:20:51 发布
最新推荐文章于 2023-07-17 23:20:51 发布
阅读量2.8k 收藏 8
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_jun_0820/article/details/84255758
版权

这里写自定义目录标题

一个最简单的ORM总结下来就两部分:

* 根据entity上的自定义注解生成mapping元数据信息
* 生成mapper接口的动态代理，根据具体的方法，动态生成sql并执行sql,然后通过反射的方式映射到具体的实体对象上去

解析自定义注解，生成元数据信息

首先我们先定义几个元信息注解：

  • @Table注解在entity类上，标注这个实体类对应的数据库的表名
/**
 * TODO
 *
 * @author : xiaojun
 * @since 10:57 2018/11/19
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Table {
    /**
     * <p>
     * 实体对应的表名
     * </p>
     */
    String value() default "";
}
  • @Column标注在实体类的属性上，用来和表的字段名进行映射
package com.example.mybatisplusdemo.orm.annotation;

import java.lang.annotation.*;

/**
 * 数据库表的列名
 *
 * @author : xiaojun
 * @since 10:58 2018/11/19
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {
    String value() default "";
}
  • @PK 用来标注表的主键字段
package com.example.mybatisplusdemo.orm.annotation;

import java.lang.annotation.*;

/**
 * 主键标识
 *
 * @author : xiaojun
 * @since 11:02 2018/11/19
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface PK {
}
  • 以下是一个具体的User entity demo
package com.example.mybatisplusdemo.orm.entity;

import com.example.mybatisplusdemo.orm.annotation.Column;
import com.example.mybatisplusdemo.orm.annotation.PK;
import com.example.mybatisplusdemo.orm.annotation.Table;

import java.sql.Timestamp;

/**
 * <p>
 * 系统用户
 * </p>
 *
 * @author xiaojun
 * @since 2018-11-16
 */
@Table("sys_user")
public class User {


    @PK
    @Column("user_id")
    private Long userId;

    @Column("username")
    private String username;

    @Column("password")
    private String password;

    @Column("salt")
    private String salt;

    @Column("email")
    private String email;

    @Column("mobile")
    private String mobile;

    @Column("status")
    private Integer status;

    @Column("dept_id")
    private Long deptId;

    @Column("create_time")
    private Timestamp createTime;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public Long getDeptId() {
        return deptId;
    }

    public void setDeptId(Long deptId) {
        this.deptId = deptId;
    }

    public Timestamp getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Timestamp createTime) {
        this.createTime = createTime;
    }


    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", username=" + username +
                ", password=" + password +
                ", salt=" + salt +
                ", email=" + email +
                ", mobile=" + mobile +
                ", status=" + status +
                ", deptId=" + deptId +
                ", createTime=" + createTime +
                "}";
    }
}
  • 接下来我们定义一个通用Mapper,泛型T为具体的Entity实体类，作为demo示例，我们就只创建一个selectById方法
package com.example.mybatisplusdemo.orm.mapper;

/**
 * base mapper
 *
 * @author : xiaojun
 * @since 11:05 2018/11/19
 */
public interface BaseMapper<T> {

    T selectById(Object id);

    //其他删除\修改\新增同理,demo目的忽略
}
  • 然后我们定义一个UserMapper 继承 BaseMapper<User>,User为上面定义的用户实体类
package com.example.mybatisplusdemo.orm.mapper;

import com.example.mybatisplusdemo.orm.entity.User;

/**
 * user mapper
 *
 * @author : xiaojun
 * @since 11:04 2018/11/19
 */
public interface UserMapper extends BaseMapper<User> {

}
  • 构建元数据信息,主要有表元数据信息TableMetadata和列元数据信息ColumnMetadata
package com.example.mybatisplusdemo.orm.metadata;

import com.example.mybatisplusdemo.orm.annotation.Column;
import com.example.mybatisplusdemo.orm.annotation.PK;
import com.example.mybatisplusdemo.orm.annotation.Table;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.StringUtils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 表元数据信息
 *
 * @author : xiaojun
 * @since 11:51 2018/11/19
 */
public class TableMetadata {

    private String tableName;

    private ColumnMetadata primaryKey;

    private List<ColumnMetadata> columns = new ArrayList<>();

    private String selectByIdSql;

    private Class entityClass;
    
     /**
     * 解析Mapper类构建表元数据信息
     *
     * @param mapperClass 具体的Mapper类入UserMapper
     */
    public TableMetadata(Class<?> mapperClass) {
        ResolvableType resolvableType = ResolvableType.forClass(mapperClass);

        ResolvableType baseMapperType = resolvableType.getInterfaces()[0];
        //获得泛型父接口的具体泛型类型，这里是具体的Entity类
        this.entityClass = baseMapperType.resolveGeneric(0);
        //获取实体类上注解的数据库表名
        Table tableName = AnnotationUtils.getAnnotation(entityClass, Table.class);
        this.tableName = tableName.value();
        //获取实体类属性上所有注解了@Column的属性的数据库表字段名
        for (int i = 0; i < entityClass.getDeclaredFields().length; i++) {
            ColumnMetadata columnMetadata = new ColumnMetadata();
            Field field = entityClass.getDeclaredFields()[i];
            //获取列名注解
            Column column = AnnotationUtils.getAnnotation(field, Column.class);
            if (column != null) {
                columnMetadata.setColumnIndex(i + 1);
                columnMetadata.setColumnName(column.value());
                ResolvableType columnResolvableType = ResolvableType.forField(field);
                columnMetadata.setJavaType(columnResolvableType.resolve());
                columnMetadata.setField(field);
                //解析主键字段
                PK pk = AnnotationUtils.getAnnotation(field, PK.class);
                if (pk != null) {
                    primaryKey = columnMetadata;
                }
                columns.add(columnMetadata);
            }
        }

        this.selectByIdSql = genSelectByIdSql();
    }

    public Class getEntityClass() {
        return entityClass;
    }

    public void setEntityClass(Class entityClass) {
        this.entityClass = entityClass;
    }

    public String getSelectByIdSql() {
        return selectByIdSql;
    }

    public void setSelectByIdSql(String selectByIdSql) {
        this.selectByIdSql = selectByIdSql;
    }

    public String getTableName() {
        return tableName;
    }

    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    public ColumnMetadata getPrimaryKey() {
        return primaryKey;
    }

    public void setPrimaryKey(ColumnMetadata primaryKey) {
        this.primaryKey = primaryKey;
    }

    public List<ColumnMetadata> getColumns() {
        return columns;
    }

    public void setColumns(List<ColumnMetadata> columns) {
        this.columns = columns;
    }


    /**
     * 生成一个select <columns> from <table> where pk=? 查询语句
     *
     * @return SelectByIdSql
     */
    public String genSelectByIdSql() {
        StringBuilder selectByIdBindSql = new StringBuilder("select ")
                .append(StringUtils.collectionToCommaDelimitedString(columns.stream().map(ColumnMetadata::getColumnName).collect(Collectors.toList())))
                .append(" from ").append(tableName).append(" where ").append(primaryKey.getColumnName() + " = ?");
        return selectByIdBindSql.toString();
    }
}


package com.example.mybatisplusdemo.orm.metadata;

import java.lang.reflect.Field;

/**
 * 列元数据信息
 *
 * @author : xiaojun
 * @since 11:42 2018/11/19
 */
public class ColumnMetadata {
    /**
     * 列名
     */
    private String columnName;
    /**
     * 列序号
     */
    private int columnIndex;

    /**
     * 对应的java类型
     */
    private Class<?> javaType;

    /**
     * Entity类的属性字段,用来反射设置值
     */
    private Field field;

    public Field getField() {
        return field;
    }

    public void setField(Field field) {
        this.field = field;
    }

    public Class<?> getJavaType() {
        return javaType;
    }

    public void setJavaType(Class<?> javaType) {
        this.javaType = javaType;
    }


    public String getColumnName() {
        return columnName;
    }

    public void setColumnName(String columnName) {
        this.columnName = columnName;
    }

    public int getColumnIndex() {
        return columnIndex;
    }

    public void setColumnIndex(int columnIndex) {
        this.columnIndex = columnIndex;
    }
}

这里不得不提一下spring core提供的org.springframework.core.ResolvableType类，帮助我们简化了解析类元数据信息的工作，还有各种的util类如org.springframework.core.annotation.AnnotationUtils,org.springframework.core.annotation.AnnotatedElementUtils等等

生成一个动态代理

  • 通过jdk提供的Proxy类来生成动态代理
package com.example.mybatisplusdemo.orm.proxy;

import com.example.mybatisplusdemo.orm.metadata.ColumnMetadata;
import com.example.mybatisplusdemo.orm.metadata.TableMetadata;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**
 * mapper 动态代理类
 *
 * @author : xiaojun
 * @since 11:29 2018/11/19
 */
public class MapperProxy implements InvocationHandler {
    private final String url = "jdbc:mysql://localhost:3306/test?Unicode=true&characterEncoding=UTF-8&autoReconnect=true&connectTimeout=60000&socketTimeout=60000&useInformationSchema=true";
    private final String username = "root";
    private final String pwd = "111";
    private Class<?> mapperClass;

    private TableMetadata tableMetadata;

    public MapperProxy(Class<?> mapperClass) {
        this.mapperClass = mapperClass;
        this.tableMetadata = new TableMetadata(mapperClass);
    }

    public static <T> T getMapper(Class<T> mapperClass) {
        return (T) Proxy.newProxyInstance(MapperProxy.class.getClassLoader(), new Class[]{mapperClass}, new MapperProxy(mapperClass));
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try (Connection connection = DriverManager.getConnection(url, username, pwd)) {
            //这里demo简化直接创建数据库连接，然后实现selectById方法
            if ("selectById".equals(method.getName())) {
                String selectByIdSql = tableMetadata.getSelectByIdSql();
                try (PreparedStatement preparedStatement = connection.prepareStatement(selectByIdSql)) {
                    preparedStatement.setObject(1, args[0]);
                    try (ResultSet resultSet = preparedStatement.executeQuery()) {
                        //反射创建实体类
                        Object entity = tableMetadata.getEntityClass().newInstance();
                        if (resultSet.next()) {
                            for (ColumnMetadata columnMetadata : tableMetadata.getColumns()) {
                                //反射设置属性
                                columnMetadata.getField().setAccessible(true);
                                columnMetadata.getField().set(entity, resultSet.getObject(columnMetadata.getColumnIndex()));
                            }
                            return entity;
                        }
                    }

                }

            }
        }
        return null;
    }
}

最后，我们测试一下功能

package com.example.mybatisplusdemo;

import com.example.mybatisplusdemo.orm.entity.User;
import com.example.mybatisplusdemo.orm.mapper.UserMapper;
import com.example.mybatisplusdemo.orm.proxy.MapperProxy;

/**
 * 测试 orm 
 *
 * @author : xiaojun
 * @since 13:34 2018/11/19
 */
public class TestOrm {
    public static void main(String[] args) {
        UserMapper userMapper = MapperProxy.getMapper(UserMapper.class);
        User user = userMapper.selectById(1);
        System.out.println(user);

    }
}

正确输出了数据库中的记录:

User{userId=2, username=xiaojun, password=659d0db693e9f694ee53b0a96c3e4db87e0e8a23fa039064dd444bcc9d7950a6, salt=zZRlJqdSlqBmsMK8oic6, email=xiaoj@xx.com, mobile=13311111111, status=1, deptId=7, createTime=2018-11-16 15:10:31.0}

我们的简单orm框架生效了，对于使用者来说是透明的，怎么去查询，然后封装成实体对象，全部交由orm框架来完成，仅仅是调用了BaseMapper.selectById方法,然后就获得了User实体对象

当然这里只是最简单的demo而已，阐述的是一个核心原理，看客们可以自己发散思维重构完善代码

xiao_jun_0820
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自己实现orm框架
07-28
自己实现简单的orm框架。。 可以参照着自己写。。。。
手把手带你从0搭建一个Golang ORM框架（全）！
QcloudCommunity的博客
12-29 1233
导语|当我深入的学习和了解了GORM、XORM后，我觉得它们不够简洁和优雅，有些笨重，有很大的学习成本。本着学习和探索的目的，于是我自己实现了一个简单且优雅的go语言版本的ORM。本文...
DORM框架的第一个测试用例
随心居
10-31 405
因为很早前学习了Java的Hibernate（现在纳入Spring家族里作为JPA的唯一实现存在），对于对象持久化框架产生了浓厚的兴趣，甚至有一段时间尝试写一个Delphi版的ORM框架出来；写了一部分后因为不可言说的原因就放弃了。后来因为工作转向运维支持和其他开发语言，就没有再深入去了解Delphi的ORM框架。最近因为工作需要，再次回到Delphi上来，然后对ORM这个曾经投入了极大热情的东东也再次有了了解的兴趣。 上网搜索了下“Delphi ORM框架”，找到几个ORM框架： EntityDac：
手写ORM框架，从创建工程开始超详细步骤
每日一记，每周一结。
06-12 440
手写ORM框架: O(Object 对象) R(Relative 关系) M(Mapping 映射) 对象关系映射。把数据中的表映射为java中的实体类，表中的一条记录映射为java实体类对象。表中的列映射实体的属性了。之前我们学习过一个ORM—Mybatis.-----单表的CRUD无需写任何sql语句。我们自己手写的ORM框架使用的技术: 泛型 注解 反射。
InstantObjects是delphi上的一个不错的ORM框架，可以实现类似hibernate的功能。
刘永锋的专栏
01-16 1054
ORM框架是数据库和类或者record之间快速转换的一个技术(猜的),很有用的技术. InstantObjects是delphi上的一个不错的ORM框架，可以实现类似hibernate的功能。 具有如下优点 * 将数据表间关系转化成了对象和对象的关系，简单直观。 * 可以自动创建数据库，简化了部署的和安装的过程。 * 支持多种数据库，方便了程序的移植。 * 便于进行测试
Java逐步实现一个简单的ORM框架
最新发布
Poldroc的博客
07-17 747
Java结合druid实现一个简单的ORM框架
手工实现一个ORM框架
闻竹
01-10 140
手工实现一个ORM框架
Go语言实现ORM框架
zhongliwen1981的专栏
04-28 2101
一、项目结构 beego：请求访问控制器 controller：控制器结构体 models：定义需要映射建表的结构体 orm：实现models中结构体 routers：初始化路由入口 二、控制器接口设计 ControllerInterface：控制器接口，提供Get和Post函数。 Controller：公共控制器，实现ControllerInterface接口，并实现了Ge...
ORM框架设计及实现
o983950935的博客
11-03 1962
文章目录一 对象记录映射二 效率和性能三 数据访问描述信息四 字段类型转换五 数据访问基类六 统一异常处理七 数据访问框架八 数据源创建工厂九 SQL指令解析十 补充DAO接口实现十一 测试十二 其他问题 一 对象记录映射   本质上来说，ORM框架需要处理的就是如何将JAVA对象与数据表记录进行关联，便于JAVA对象的持久化，以及将表记录自动转换为JAVA对象。   这就需要存在一个中间态的描述...
C#手把手教你写一个自己的ORM（一）
qq_43535970的博客
10-26 1940
网上的ORM框架很多，比如Freesql、sqlsugar、EF等等，在一个新项目中，我们可以直接引入使用；但是有个问题，如果你接手的事一个老项目，实体不能动，代码不能给人家搞乱，那你该怎么办呢？这个时候，我们就需要自己了解一下ORM的原理，然后自己写一个简易的，符合自己公司框架逻辑的ORM进行使用了。下面我会从浅到深，讲解一下ORM的基本实现方法。
.Net-ORM框架-三层架构完整程序代码
09-17
教你从无到有完完整整地搭建一个基于三层架构的ORM框架
自己写的ORM
03-28
自己写的ORM，看看大家给几分
自定义Orm框架的实现
05-30
该项目是一个Hibernate框架的简单实现，里面通过Jdk5.0的Annotation实现从对象到数据库之间的映射, 功能类似于小型的Hibernate框架
基于java 简易ORM 框架实现(一)
08-09
NULL 博文链接：https://fengzhenbing98.iteye.com/blog/2194829
自己动手做框架——ORM，MVC，IOC框架
03-07
自己动手做框架——ORM，MVC，IOC框架及整合视频教程 源码
自己动手建设ORM框架--IntegORM1
01-21
一个自建的Java应用开发ORM框架，名为Integ，有分页查询功能，有很好的灵活度和扩展性。此为第一期的代码，后续还会增强。欢迎下载，欢迎批评指正。
一步一个脚印实现一个自己的简易MVVM框架
08-11
一步一个脚印实现一个自己的简易MVVM框架
Java注解（2）：实现自己的ORM
分享专业、有用、有趣的技术、产品、运营和管理知识。
10-15 175
搞过Java的码农都知道，在J2EE开发中ORM是一类很重要的框架，但其实它的本质一点都不复杂，通过对反射和注解的了解，就试着来实现咱们自己的缝合怪。
【ORM】怎样自己写一个ORM框架-1
Old Wang的博客
07-05 2068
最近一直在看一些Spring JDBC 的一些东西，觉得吧手动的方式真的不太习惯，而MyBatis需要配置Mapping，虽然更加灵活了，也不简单，hibernate 基本上可以实现单表Nosql但是比较重量级。纠结了这么长时间，还是现在用的的ORM框架比较好用。 我们一般的默认都是 约定优于配置 也就是说我们的规范更加重要，比如说为什么我们的JAVA类命名规则是驼峰，接口或者实现类加上I或者I...
能否创建一个简易的ORM框架
04-01
因此，一个简易的ORM框架需要实现以下功能： 1. 数据库连接和操作：需要支持与数据库的连接和操作，如执行SQL语句、事务管理等。 2. 对象关系映射：需要将数据库中的表和记录映射成对象和属性，支持多种数据类型的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值