深入Java日记——自己写一个ORM框架

最新推荐文章于 2024-05-10 14:21:41 发布

lldouble

最新推荐文章于 2024-05-10 14:21:41 发布

阅读量315

点赞数

分类专栏： ORM

ORM 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

众所周知，ORM框架有很多，例如Hibernate，MyBatis，还有BeetlSQL等等，里面获取有很多我们不需要的功能，本系列博客主要教大家如何写一个简单的ORM框架

这个ORM框架主要有以下功能：

1. 生成JavaBean代码
2. 通过JavaBean来实现增删查改

我们这次先讲如何生成JavaBean代码

主要有以下几个步骤：

1. 获取数据库连接
2. 获取表的信息
3. 将数据库的类型转为Java类型
4. 生成代码文件

1.获取数据库连接

先写配置文件

#数据库驱动
driver=com.mysql.jdbc.Driver
#数据库url
url=jdbc\:mysql\://localhost\:3306/shiro
#数据库用户名
user=root
#数据库密码
pwd=root
#使用数据库类型
usingDB=mysql
#项目src地址
srcPath=/home/xjk/IdeaProjects/SORM/src
#生成JavaBean包名
poPackage=com.jk.po

我们还需要一个配置信息的管理类

public class Configuration {
    private String driver;
    private String url;
    private String user;
    private String pwd;
    private String usingDB;
    private String srcPath;
    private String poPackage;
    public Configuration() {
    }
    /**
     * 省略setter和getter
     */
}

然后需要一个数据库管理类，来使用配置信息生成数据库连接

private static Configuration conf;
    static {
        Properties properties=new Properties();
        try {
            properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        conf=new Configuration();
        conf.setDriver(properties.getProperty("driver"));
        conf.setPoPackage(properties.getProperty("poPackage"));
        conf.setSrcPath(properties.getProperty("srcPath"));
        conf.setPwd(properties.getProperty("pwd"));
        conf.setUser(properties.getProperty("user"));
        conf.setUrl(properties.getProperty("url"));
        conf.setUsingDB(properties.getProperty("usingDB"));
    }

    public static Connection getConn(){
        try {
            //要求JVM查找并加载指定的数据库驱动
            Class.forName(conf.getDriver());
            return DriverManager.getConnection(conf.getUrl(),conf.getUser(),conf.getPwd());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Configuration getConf(){
        return conf;
    }
}

2.获取表的信息

我们使用TableContext来装载所有表，使用T**ableInfo**来装载每个表的信息，ColumnInfo来装载每个字段的信息，我们先从最小单位开始
ColumnInfo

public  class ColumnInfo {
    /**
     * 字段名
     */
    String name;
    /**
     * 字段的数据类型
     */
    String dataType;
    /**
     * 字段的键类型（0：普通键，1：主键，2：外键）
     */
    int keyType;

    public ColumnInfo() {
    }
    /**
     * 省略setter和getter
     */
}

TableInfo

public class TableInfo {
    /**
     * 表名
     */
    private String tname;

    /**
     * 所有字段信息
     */
    private Map<String,ColumnInfo> columns;

    /**
     * 唯一主键（目前我们只能处理表中只有一个主键的情况）
     */
    private ColumnInfo onlyPriKey;

    /**
     * 联合主键
     */
    private List<ColumnInfo> priKeys;

    public TableInfo() {
    }
    /**
     * 省略setter和getter
     * /
}

TableContext

public class TableContext {
    /**
     * 表名为key，表结构为value
     */
    public static Map<String,TableInfo> tables=new HashMap<>();

    private TableContext(){}

    static {
        try {
            Connection con=DBManager.getConn();
            DatabaseMetaData dbmd=con.getMetaData();
            //获取所有表名
            ResultSet tableRet=dbmd.getTables(null,"%","%",new String[]{"TABLE"});
            while (tableRet.next()){
                String tableName= (String) tableRet.getObject("TABLE_NAME");
                TableInfo ti=new TableInfo(tableName,new HashMap<String,ColumnInfo>(),new ArrayList<ColumnInfo>());
                tables.put(tableName,ti);
                //获取多个字段和类型
                ResultSet set=dbmd.getColumns(null,"%",tableName,"%");
                while (set.next()){
                    ColumnInfo ci=new ColumnInfo(set.getString("COLUMN_NAME"),set.getString("TYPE_NAME"),0);
                    ti.getColumns().put(set.getString("COLUMN_NAME"),ci);
                }
                //获取多个主键
                ResultSet set2=dbmd.getPrimaryKeys(null,"%",tableName);
                while (set2.next()){
                    String columnName=set2.getString("COLUMN_NAME");
                    System.out.println(columnName);
                    ColumnInfo ci2=ti.getColumns().get(columnName);
                    ci2.setKeyType(1);//设为主键
                    ti.getPriKeys().add(ci2);
                }
                if (ti.getPriKeys().size()>0){//取唯一主键，如果是联合主键，则为空
                    ti.setOnlyPriKey(ti.getPriKeys().get(0));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

3.将数据库的类型转为Java类型

为了适配多种数据库，我们先定义一个类型转换器的接口

public interface TypeConvertor {
    /**
     * 将数据库类型转换为java数据类型
     * @param column 数据库字段的类型
     * @return java的数据类型
     */
    public String databaseType2JavaType(String column);

    /**
     * 将java数据类型转换为数据库类型
     * @param column java的数据类型
     * @return 数据库字段的类型
     */
    public String javaType2DatabaseType(String column);
}

我们这里只展示MySQL类型转换器的写法

public class MySQLTypeConvertor implements TypeConvertor{
    @Override
    public String databaseType2JavaType(String column) {
        switch (column.toLowerCase()){
            case "varchar":
            case "char":return "String";
            case "smallint":
            case "int":
            case "tinyint":return "Integer";
            case "bigint":return "Long";
            case "double":return "Double";
            case "float":return "Double";
            case "clob":return "java.sql.Clob";
            case "blob":return "java.sql.Blob";
            case "date":return "java.sql.Date";
            case "time":return "java.sql.Time";
            case "timestamp":return "java.sql.Timestamp";
            default:return null;
        }
    }

    @Override
    public String javaType2DatabaseType(String column) {
        //这里后面再完善
        return null;
    }
}

4.生成代码文件

我们需要用一个JavaFieldGetSet来装载MySQL每个字段对应的属性还有setter和getter

public class JavaFieldGetSet {
    /**
     * 属性源码信息，如：private int id;
     */
    private String fieldInfo;
    /**
     * get方法的源码信息，如：public int getId();
     */
    private String getInfo;
    /**
     * set方法的源码信息，如：public void setId(int id);
     */
    private String setInfo;

    public JavaFieldGetSet() {

    }
    /**
     * 省略setter和getter
     * /
}

在转换的时候我们还要把名字格式从下划线分隔转为小驼峰，我们需要一个字符安转换工具

public class StringUtils {
    /**
     * 将下划线转为大驼峰
     * @param str   目标字符串
     * @return  变为大驼峰的字符串
     */
    public static String underlineToBigCamel(String str){
        return underlineToSmallCamel(str.toUpperCase().substring(0,1)+str.substring(1));
    }

    /**
     * 将下划线转为小驼峰
     * @param str   目标字符串
     * @return  变为小驼峰的字符串
     */
    public static String underlineToSmallCamel(String str){
        if (str==null||"".equals(str.trim())){
            return "";
        }
        int len=str.length();
        StringBuilder sb=new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c=str.charAt(i);
            if (c=='_'){
                if (++i<len){
                    sb.append(Character.toUpperCase(str.charAt(i)));
                }
            }else{
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

代码生成的工具

public class JavaFileUtils {
    /**
     * 根据字段信息生成java属性信息，如：var username-->private String username;相应的set和get方法源码
     * @param column    字段信息
     * @param convertor 类型转换器
     * @return  java属性的set/get方法
     */
    public static JavaFieldGetSet createFieldGetSetSRC(ColumnInfo column, TypeConvertor convertor){
        JavaFieldGetSet jfgs=new JavaFieldGetSet();
        //将字段转为java属性
        String javaFiledType= convertor.databaseType2JavaType(column.getDataType());
        String colunmName=StringUtils.underlineToSmallCamel(column.getName());
        //生成字段信息
        jfgs.setFieldInfo("\tprivate "+javaFiledType+" "+colunmName+";\n");
        //生成getter
        StringBuilder getSrc=new StringBuilder();
        getSrc.append("\tpublic "+javaFiledType+" get"+StringUtils.underlineToBigCamel(column.getName())+"(){\n");
        getSrc.append("\t\treturn "+colunmName+";\n");
        getSrc.append("\t}\n");
        jfgs.setGetInfo(getSrc.toString());
        //生成setter
        StringBuilder setSrc=new StringBuilder();
        setSrc.append("\tpublic void set"+StringUtils.underlineToBigCamel(column.getName())+"("+javaFiledType+" "+colunmName+"){\n");
        setSrc.append("\t\tthis."+colunmName+"="+colunmName+";\n");
        setSrc.append("\t}\n");
        jfgs.setSetInfo(setSrc.toString());
        return jfgs;
    }

    /**
     * 根据表信息生成java源码
     * @param tableInfo 表信息
     * @param convertor 数据类型转换器
     * @return  java类的源代码
     */
    public static String createJavaSrc(TableInfo tableInfo,TypeConvertor convertor){
        Map<String,ColumnInfo>columns=tableInfo.getColumns();
        List<JavaFieldGetSet> javaFields=new ArrayList<>();
        for (ColumnInfo columnInfo:columns.values()){
            JavaFieldGetSet javaFieldGetSet=createFieldGetSetSRC(columnInfo,convertor);
            javaFields.add(javaFieldGetSet);
        }
        StringBuilder src=new StringBuilder();
        //生成package语句
        src.append("package "+ DBManager.getConf().getPoPackage()+";\n");
        //生成import语句
        src.append("import java.sql.*;\n");
        src.append("import java.util.*;\n\n");
        //生成类声明语句
        src.append("public class "+StringUtils.underlineToBigCamel(tableInfo.getTname())+"{\n");
        //生成属性列表
        for (JavaFieldGetSet javaFieldGetSet:javaFields){
            src.append(javaFieldGetSet.getFieldInfo());
        }
        src.append("\n\n");
        //生成get方法列表
        for (JavaFieldGetSet javaFieldGetSet:javaFields){
            src.append(javaFieldGetSet.getGetInfo());
        }
        src.append("\n\n");
        //生成set方法列表
        for (JavaFieldGetSet javaFieldGetSet:javaFields){
            src.append(javaFieldGetSet.getSetInfo());
        }
        src.append("\n\n");
        //生成结束符
        src.append("}");
        return src.toString();
    }

    /**
     * 生成java文件
     * @param tableInfo 表信息
     * @param convertor 类型转换器
     */
    public static void createJavaPoFile(TableInfo tableInfo,TypeConvertor convertor){
        //获取源码
        String src=createJavaSrc(tableInfo,convertor);
        String srcPath=DBManager.getConf().getSrcPath()+"/";
        //将包名转换为文件名，然后和srcPath拼接
        String packagePath=DBManager.getConf().getPoPackage().replace(".","/");
        File f=new File(srcPath+packagePath);
        if (!f.exists()){
            f.mkdirs();
        }
        BufferedWriter bw=null;
        try {
            //将源码写入文件
            bw=new BufferedWriter(new FileWriter(f.getAbsoluteFile()+"/"+StringUtils.underlineToBigCamel(tableInfo.getTname())+".java"));
            bw.write(src);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 更新表结构
     */
    public static void updateJavaPOFile(){
        Map<String,TableInfo>tables=TableContext.tables;
        for(TableInfo tableInfo:tables.values()){
            createJavaPoFile(tableInfo,new MySQLTypeConvertor());
        }
    }
}

当我们调用JavaFileUtils的updateJavaPOFile方法时，便会在相应的目录生成该数据库里所有表对象的JavaBean

lldouble

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
深入Java日记——自己写一个ORM框架

众所周知，ORM框架有很多，例如Hibernate，MyBatis，还有BeetlSQL等等，里面获取有很多我们不需要的功能，本系列博客主要教大家如何写一个简单的ORM框架这个ORM框架主要有以下功能：1. 生成JavaBean代码 2. 通过JavaBean来实现增删查改我们这次先讲如何生成JavaBean代码主要有以下几个步骤：1. 获取数据库连接 2. 获取表的信息 3. 将数据库的类型转为...
复制链接

扫一扫

专栏目录