写出你自己的ORM框架(一)

前言:读完本片文章大约20分钟

一、架构说明

主要分为如下几个包,和以下几个类,接口(一级为包,二级(普通颜色为类,黄色为接口),加粗为说明)

  • cn.gxm.sorm.bean
    • ColumnInfo 对应数据库中的每一个字段结构
    • TableInfo 对应数据库中的每表结构
    • Configuration 映射资源文件(数据源 ,dataSource,将配置文件中的信息映射成对象)
  • cn.gxm.sorm.core
    • DBManager 根据配置信息,维持连接对象的管理(增加连接池功能)
    • Query 操作数据库的核心接口,CRUD都在这里定义
    • QueryFactory 工厂模式创建核心 query 对象
    • TableContext 理数据库中的所有表和java中的对象的关系可以根据表生成java对象
    • TypeConvertor 用于数据数据类型与java数据类型转换,因为数据库的不同,类型转换也不同,所以定义为接口
  • cn.gxm.sorm.utils
    • JavaFileUtils 操作文件工具类
    • JDBCUtils 封装数据库连接操作工具类
    • ReflectUtils 反射的工具类
    • StringUtils 操作字符串的工具类

二、第一部分实现

2.0 实现db.properties文件,以及对应的映射类configuration

  • db.properties文件即datasourse,连接数据库的必要参数,如下:
    前四个大家都知道,
    • srcPath 是以后使用我们这个框架项目的src路径
    • pojoPackage 是我们根据数据库的表信息生成的pojo的位置
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/sorm
username=root
password=123456
srcPath=D://IntelliJ_IDEA//MyDemo//SORM//src
pojoPackage=cn.gxm.sorm.pojo
  • configuration类就不用多说了(set,get等方法省略),如下
/**
     * 数据库驱动
     */
    private String driver;

    /**
     * 连接数据库url
     */
    private String url;

    /**
     * 数据库用户名
     */
    private String username;

    /**
     * 数据库密码
     */
    private String password;

    /**
     * 项目src绝对路径
     */
    private String srcPath;

    /**
     * 生成的表对象的包路径
     */
    private String pojoPackage;

2.1 实现数据库中表对应的Pojo

后面我们将会通过数据库的元数据获取表,以及表中的字段,所以,我们需要对应的pojo,如下
字段:(set,get等方法省略)

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/15
 *
 * 对应数据库中的每一个字段结构
 */
public class ColumnInfo {

    /**
     * 字段名称 例如 id,name,age
     */
    private String name;

    /**
     * 字段类型 例如 varchar
     */
    private String dataType;

    /**
     * 字段键类型 例如 1:普通键 2:主键 3:外键
     */
    private Integer keyType;

(set,get等方法省略)

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/15
 *
 * 对应数据库中的表结构
 */
public class TableInfo {
    /**
     * 表的名称 例如 User
     */
    private String name;

    /**
     * 表中的字段,使用map为方便后期获取
     * 例如 map<id,ColumnInfo>
     */
    private Map<String,ColumnInfo> columns;

    /**
     * 表中的唯一主键
     */
    private ColumnInfo onlyPriKey;

    /**
     * 联合主键即(多个字段组成的主键)
     */
    private List<ColumnInfo> unionKey;

2.2 实现连接的提供,datasourse资源文件的映射

从前面的架构来说,连接的提供以及资源文件的映射都在DBManager中处理,因为资源文件映射只需要一次即可,所以放在static中(只会加载一次),并且向外提供了获取连接的静态方法,以及Configuration静态方法,方便外界的操作!

package cn.gxm.sorm.core;

import cn.gxm.sorm.bean.Configuration;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/15
 *
 * 根据配置信息,维持连接对象的管理(增加连接词功能)
 */
public class DBManager {

    private static Configuration configuration = null;

    private static Properties properties = null;
    public DBManager() {
    }

    // 将数据加载到Configuration类中
    static {
        try {
            properties = new Properties();
            configuration = new Configuration();
            properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));

            configuration.setDriver(properties.getProperty("driver"));
            configuration.setUrl(properties.getProperty("url"));
            configuration.setUsername(properties.getProperty("username"));
            configuration.setPassword(properties.getProperty("password"));
            configuration.setSrcPath(properties.getProperty("srcPath"));
            configuration.setPojoPackage(properties.getProperty("pojoPackage"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 提供connection
     * @return
     */
    public static Connection getConnection(){
        try {
            Class.forName(configuration.getDriver());
            Connection connection = DriverManager.getConnection(configuration.getUrl(),
                    configuration.getUsername(), configuration.getPassword());
            return connection;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }


    /**
     * 返回db.properties对应的bean
     * @return
     */
    public static Configuration getConfiguration() {
        return configuration;
    }
}

2.3 根据数据库的表结构生成对应的pojo

这部分知识需要用到数据库的元数据,不理解的请参考:JDBC元数据操作(一)-- DatabaseMetaData接口详解

这部分我们需要在tableContext类中完成,如下

package cn.gxm.sorm.core;

import cn.gxm.sorm.bean.ColumnInfo;
import cn.gxm.sorm.bean.Configuration;
import cn.gxm.sorm.bean.TableInfo;

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/15
 *
 * 管理数据库中的所有表和java中的对象的关系
 * 可以根据表生成java对象
 */
public class TableContext {

    /**
     * 对应数据库中所有的表
     * key 为表的名称, value为表对应的bean
     */
    private static Map<String, TableInfo> allTables = new HashMap<>();


    private TableContext(){
    }

    /**
     * 获取数据库中的所有表以及相关字段,并生成对应的pojo
     */
    static {
        Connection connection = DBManager.getConnection();
        ResultSet rs = null;
        try {
            // 根据metaData就可以获取到数据库的源信息(表,字段等等)
            // 具体请查看 https://blog.csdn.net/chen_zw/article/details/18816599
            DatabaseMetaData metaData = connection.getMetaData();

            //处理表
            rs = metaData.getTables(null, "%", "%", new String[]{ "TABLE" });
            while (rs.next()) {
                TableInfo tableInfo = new TableInfo();
                String tableName = rs.getString("TABLE_NAME");
                tableInfo.setName(tableName);

                //处理一个表中的所有列
                ResultSet set = metaData.getColumns(null, "%", tableName, "%");
                Map<String, ColumnInfo> columnInfoMap = new HashMap<>();
                while (set.next()){
                    ColumnInfo columnInfo = new ColumnInfo(set.getString("COLUMN_NAME"),
                            set.getString("TYPE_NAME"),1);
                    columnInfoMap.put(columnInfo.getName(),columnInfo);
                }

                //处理表中的主键,跟新字段的键类型
                List<ColumnInfo> columnInfoList = new ArrayList<>();
                ResultSet primaryKeys = metaData.getPrimaryKeys(null, "%", tableName);
                while (primaryKeys.next()){
                    ColumnInfo columnInfo = columnInfoMap.get(primaryKeys.getObject("COLUMN_NAME"));
                    columnInfo.setKeyType(2);
                    columnInfoMap.put((String)primaryKeys.getObject("COLUMN_NAME"),columnInfo);
                    columnInfoList.add(columnInfo);

                    if(columnInfoList.size() == 1){
                        tableInfo.setOnlyPriKey(columnInfo);
                    }else{
                        // 说明为联合主键
                        tableInfo.setUnionKey(columnInfoList);
                        tableInfo.setOnlyPriKey(null);
                    }
                }

                tableInfo.setColumns(columnInfoMap);
                allTables.put(tableName,tableInfo);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    /**
     * 对外提供获取数据库表信息的方法
     * @return
     */
    public static Map<String, TableInfo> getAllTables() {
        return allTables;
    }
}

在这里对该类做一个测试,数据库的两张表结构如下
company

CREATE TABLE `company` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  `address` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`,`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

emp

CREATE TABLE `emp` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

测试代码:

public static void main(String[] args) {
        System.out.println(TableContext.getAllTables());
    }

结果:(这样可能不舒服,推荐大家debug一下,在debug中看的更明显)

{emp=TableInfo{name='emp', columns={name=ColumnInfo{name='name', dataType='VARCHAR', keyType=1}, id=ColumnInfo{name='id', dataType='INT', keyType=2}, age=ColumnInfo{name='age', dataType='INT', keyType=1}}, onlyPriKey=ColumnInfo{name='id', dataType='INT', keyType=2}, unionKey=null}, company=TableInfo{name='company', columns={address=ColumnInfo{name='address', dataType='VARCHAR', keyType=1}, name=ColumnInfo{name='name', dataType='VARCHAR', keyType=2}, id=ColumnInfo{name='id', dataType='INT', keyType=2}}, onlyPriKey=null, unionKey=[ColumnInfo{name='id', dataType='INT', keyType=2}, ColumnInfo{name='name', dataType='VARCHAR', keyType=2}]}}

2.4 完成Mysql字段类型与java数据类型的转换

因为这里主要使用mysql所以就写这一部分即可,而且这里并不做所有数据的转化!

2.4.1 封装mysql字段类型

这样,方便以后的使用,与扩展
类MysqlType:

package cn.gxm.sorm.core;

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/16
 */
public class MySqlType {


    /**
     * mysql的varchar类型
     */
    public static final String VARCHAR = "varchar";
    /**
     * mysql的bigint类型
     */
    public static final String BIGINT = "bigint";
    /**
     * mysql的int类型
     */
    public static final String INT = "int";
    /**
     * mysql的integer类型
     */
    public static final String INTEGER = "integer";
    /**
     * mysql的date类型
     */
    public static final String DATE = "date";
    /**
     * mysql的time类型
     */
    public static final String TIME = "time";
    /**
     * mysql的double类型
     */
    public static final String DOUBLE = "double";
    /**
     * mysql的float类型
     */
    public static final String FLOAT = "float";
}

2.4.2 实现具体的mysql字段类型与java类型转化

写一个类MySqlTypeConvertor继承TypeConvertor

package cn.gxm.sorm.core;

import java.sql.Date;

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/16
 *
 * 实现mysql数据库与java数据类型的转换
 */
public class MySqlTypeConvertor implements TypeConvertor{

    /**
     * 暂时不实现
     * @param javaType java数据类型
     * @return
     */
    @Override
    public String javaType2DBType(String javaType) {

        return null;
    }

    /**
     * 现mysql数据库到java数据类型的转换
     * @param columnType 数据库类型
     * @return 与之对应的Java类型
     */
    @Override
    public String DBType2javaType(String columnType) {
        if(MySqlType.VARCHAR.equalsIgnoreCase(columnType)){
            return "String";
        }else if(MySqlType.INT.equalsIgnoreCase(columnType)
                || MySqlType.BIGINT.equalsIgnoreCase(columnType)
                || MySqlType.INTEGER.equalsIgnoreCase(columnType)){
            return "Integer";
        }else if(MySqlType.DATE.equalsIgnoreCase(columnType)
                || MySqlType.TIME.equalsIgnoreCase(columnType)){
            // 注意这里转为java.sql.Date而不是java.util.date
            // 如果直接转换为utils.date,则需要具体的实现,用到时,我们再转化即可
            return "java.sql.Date";
        }else if(MySqlType.DOUBLE.equalsIgnoreCase(columnType)){
            return "Double";
        }else if(MySqlType.FLOAT.equalsIgnoreCase(columnType)){
            return "Float";
        }

        // 这里不全部转化
        return "";
    }

}

三、完成javaFileUtils

上一部分我们已经做到了,可以根据数据库的表获取其中的元数据了,接下就是根据元数据完成pojo,说白了,就是拼接字符串,并生成文件

3.1 为完成javaFileUtils做出必要的准备

3.1.1 为更好的解耦,我们抽取公用的方法放到工具类中

StringUtils:

 /**
     * 将字符串的首字母大写
     * @param src
     * @return
     */
    public static String toUpperCaseHeadChar(String src){
        return src.toUpperCase().substring(0,1)+src.substring(1);
    }

3.1.2 设计一个属性的字段,与set,get方法

JavaFieldSetGet (set,get方法省略)

package cn.gxm.sorm.bean;

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/17
 *
 * 每一个pojo都有的java属性,set,get等等
 */
public class JavaFieldSetGet {

    /**
     * 例如  (private String id)
     */
    private String fieldInfo;

    /**
     * 例如
     * public String getId(){
     *     return id;
     * }
     */
    private String fieldGetInfo;

    /**
     * 例如
     * public void setId(String id){
     *     this.id = id;
     * }
     */
    private String fieldSetInfo;
    @Override
    public String toString() {
        return fieldInfo+fieldGetInfo+fieldSetInfo;
    }
}

3.2 java的file生成我们在javaFileUtils工具类里面完成,其主要方法如下

  • generateJavaFieldSetGet 每一个pojo都有属性和set,get方法,我们生成说白了就是字符串
    该方法 测试结果如图:generateJavaFieldSetGet 方法测试结果说明

  • generateJavaSrc 根据上面的方法我们可以完成一个属性的字符串所有功能,所以我们这里再将表的数据也拼接成字符串,合并最总变为一个java的pojo(只不过是字符串)
    该方法 测试结果如图:
    generateJavaSrc 方法测试结果说明

  • generatePOJOFile 对外提供方法生成pojo文件

其代码如下:

/**
 * @author GXM www.guokangjie.cn
 * @date 2019/5/15
 *
 * 操作文件(暂时先将columnInfo转为对应的java代码)
 */
public class JavaFileUtils {


    /**
     * 根据传入的数据库字段信息生成java的bean代码
     * varchar id -> private String id 以及相应set与get方法
     * @param columnInfo 数据库字段信息
     * @param typeConvertor 对应的数据库字段数据类型转换
     * @return 一个属性的bean代码
     */
    private static JavaFieldSetGet generateJavaFieldSetGet(@NotNull ColumnInfo columnInfo,
                                                          @NotNull TypeConvertor typeConvertor){
        if(columnInfo==null || typeConvertor == null){
            throw new SormException("ColumnInfo or TypeConvertor is null");
        }

        JavaFieldSetGet fieldSetGet = new JavaFieldSetGet();

        // 字段名称 id
        String columnName = columnInfo.getName();
        String javaFieldType = typeConvertor.DBType2javaType(columnInfo.getDataType());

        //private String id
        String fieldInfo = "\tprivate "+ javaFieldType +" "+ columnName +";\n";

        /**
         * public void getId(){
         *      return id;
         * }
         */
        StringBuilder fieldGetInfo = new StringBuilder("\tpublic  "+javaFieldType+" get"+StringUtils.toUpperCaseHeadChar(columnName)+" (){\n");
        fieldGetInfo.append("\t\treturn "+ columnName+";\n");
        fieldGetInfo.append("\t}\n");

        /**
         * public void setId(String id){
         *      this.id = id;
         * }
         */
        StringBuilder fieldSetInfo = new StringBuilder("\tpublic void set"+StringUtils.toUpperCaseHeadChar(columnName)+" ("+javaFieldType+" "+columnName+"){\n");
        fieldSetInfo.append("\t\tthis."+columnName+"="+ columnName+";\n");
        fieldSetInfo.append("\t}\n");

        fieldSetGet.setFieldInfo(fieldInfo);
        fieldSetGet.setFieldGetInfo(fieldGetInfo.toString());
        fieldSetGet.setFieldSetInfo(fieldSetInfo.toString());

        return fieldSetGet;
    }


    /**
     * 根据表结构生成对应的pojo
     * @param tableInfo 表信息
     * @param typeConvertor java与数据库字段类型转化器
     * @param author 生成的Pojo的作者
     * @return pojo字符串
     */
    private static String generateJavaSrc(@NotNull TableInfo tableInfo,
                                         @NotNull TypeConvertor typeConvertor,String author){

        if(tableInfo==null || typeConvertor == null){
            throw new SormException("tableInfo or TypeConvertor is null");
        }

        StringBuilder javaResourse = new StringBuilder();
        // 生成package 例如 package cn.gxm.sorm.pojo
        javaResourse.append("package "+ DBManager.getConfiguration().getPojoPackage()+";\n\n");

        // 生成import 例如 import java.sql.Date
        javaResourse.append("import java.sql.*;\n");
        javaResourse.append("import java.lang.*;\n");

        // 生成autor 以及日期等java文件说明
        /**
         * @author GXM www.guokangjie.cn
         * @date 2019/5/17
         */
        javaResourse.append("/**\n")
                .append(" * @author "+author+"\n")
                .append(" * @date "+new SimpleDateFormat("yyyy/MM/dd").format(new Date())+"\n")
                .append(" */\n");
        // 生成类的开始 例如 public class Emp {
        javaResourse.append("public class "+StringUtils.toUpperCaseHeadChar(tableInfo.getName())+"{\n");

        // 生成类的属性
        Set<Map.Entry<String, ColumnInfo>> entries = tableInfo.getColumns().entrySet();
        for (Map.Entry<String, ColumnInfo> entry: entries){
            JavaFieldSetGet fieldSetGet = generateJavaFieldSetGet(entry.getValue(), typeConvertor);
            javaResourse.append(fieldSetGet+"\n");
        }

        // 生成类的结束  }
        javaResourse.append("}");
        return javaResourse.toString();

    }


    /**
     * 生成与数据库字段匹配的java的pojo
     * @param tableInfo 表信息
     * @param typeConvertor java与数据库字段类型转化器
     * @param author 生成的Pojo的作者
     */
    public static void generatePOJOFile(TableInfo tableInfo,TypeConvertor typeConvertor,String author){
        String javaSrc = generateJavaSrc(tableInfo, typeConvertor, author);
        String dirPath = DBManager.getConfiguration().getSrcPath()+"//"+DBManager.getConfiguration().getPojoPackage().replaceAll("\\.","//");
        File pojoDir = new File(dirPath);
        //包不存在则创建包
        if(!pojoDir.exists()){
            pojoDir.mkdirs();
        }

        Writer writer = null;
        try {
            writer = new FileWriter(pojoDir.getAbsoluteFile()+"//"+StringUtils.toUpperCaseHeadChar(tableInfo.getName())+".java");
            writer.write(javaSrc);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                writer.close();
                System.out.println("pojo创建成功!!");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

四、完善TableContext

我们已经在TableContext类中获取了所有的数据库源信息(第一部分与第二部分),而在第三部分我们也完成了根据tableInfo来生成pojo的(.java文件),但是JavaFileUtils总归是一个工具类,我们将在TableContext对外提供生成的方法,即在TableContext类中添加方法

 /**
     * 生成或者跟新java的pojo与数据库的对应关系
     */
    public static void generateOrUpdateJavaFilePojo(){
        Set<Map.Entry<String, TableInfo>> entries = allTables.entrySet();
        for (Map.Entry<String, TableInfo> entry: entries){
            JavaFileUtils.generatePOJOFile(entry.getValue(),new MySqlTypeConvertor(),"GXM www.guokangjie.cn");
        }
    }

测试
配置正确的db.properties,就会在指定位置生成与数据库对应的pojo,如下图
pojo文件生成测试

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值