自己动手模仿Hibernate写数据库框架

最新推荐文章于 2024-08-26 09:05:30 发布
最新推荐文章于 2024-08-26 09:05:30 发布
阅读量124 收藏
点赞数
分类专栏： Java EE&SE 文章标签： java DBUtil框架 hibernate sql
[align=center]自己动手模仿Hibernate写数据库框架[/align]
最近项目有点儿停滞，论文看的也比较浮躁，于是就打算重写下后台的框架，数据库部分模仿Hibernate随手写个小程序，当然还没有写完，不过最简单的功能已经能有了，打算把代码贴上来，后续不断的更新。
简单介绍下这个框架：采用DBCP连接池，然后实现了类似Hibernate的按对象插入、更新、删除等。当然还没有写生命周期、延迟加载这些，不过后续会慢慢的加上去，否则就太小儿科了不是么。这个框架是建立在我原有的一个BDUtil的小项目上的，当时做插入这些操作需要传SQL语句和参数，现在把这步也省略了，当然最大的好处就是不用写SQL。
下面就上代码：
Commons.java: DBCP连接池，返回Connection对象。 
package org.gfg.dbutil.common;

import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

@SuppressWarnings("static-access")
public class Commons {

	private static DataSource dataSource;
	static {
		try {
			Properties prop = new Properties();
			prop.load(Commons.class.getClassLoader().getResourceAsStream(
					"dbcpconfig.properties"));
			BasicDataSourceFactory factory = new BasicDataSourceFactory();
			dataSource = factory.createDataSource(prop);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static Connection getConnection() throws SQLException {
		return dataSource.getConnection();
	}

	public static void close(ResultSet rs, PreparedStatement ps, Connection conn) {
		try {
			if (rs != null) {

				rs.close();
			}
			if (ps != null) {
				ps.close();
			}
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}


DbUtils.java：主要封装了最基本的CRUD操作。注意在query方法的参数中传入了IResultSetHandler，这个接口的主要功能是对返回的结果集做封装。 
package org.gfg.dbutil.common;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.gfg.dbutil.handler.BeanHandler;
import org.gfg.dbutil.handler.IResultSetHandler;

public class DbUtils {

	public static void insert(String sql, Object[] params) throws SQLException {// insert
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = Commons.getConnection();
			ps = conn.prepareStatement(sql);

			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}

			ps.executeUpdate();
		} finally {
			Commons.close(rs, ps, conn);
		}
	}

	public static void update(String sql, Object[] params) throws SQLException {// update
		DbUtils.insert(sql, params);
	}

	public static void delete(String sql, Object[] params) throws SQLException {// delete
		DbUtils.insert(sql, params);
	}

	public static Object query(String sql, Object[] params,
			IResultSetHandler rsh) throws SQLException {
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = Commons.getConnection();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}
			rs = ps.executeQuery();
			return rsh.handler(rs);
		} finally {
			Commons.close(rs, ps, conn);
		}
	}

	public static Object load(String sql, Object[] params,Class<?> clazz) {
		IResultSetHandler rsh=new BeanHandler(clazz);
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			conn = Commons.getConnection();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}
			rs = ps.executeQuery();
			return rsh.handler(rs);			
		} catch (SQLException e) {

			e.printStackTrace();
		} finally {
			Commons.close(rs, ps, conn);
		}
		return null;
	}
}


IResultSetHandler.java：接口，加工ResultSet结果，可以返回Model，List等，这个可以自行扩展。 
package org.gfg.dbutil.handler;

import java.sql.ResultSet;

public interface IResultSetHandler {

	public Object handler(ResultSet rs);

}


BeanHandler.java:实现了IResultSetHandler接口，主要还是运用了反射。 
package org.gfg.dbutil.handler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

public class BeanHandler implements IResultSetHandler {

	private Class<?> beanClass;

	public BeanHandler(Class<?> beanClass) {
		this.beanClass = beanClass;
	}

	@Override
	public Object handler(ResultSet rs) {
		try {
			if (!rs.next()) {
				return null;
			}
			// 用于封装数据的bean
			Object bean = beanClass.newInstance();

			ResultSetMetaData meta = rs.getMetaData();
			int columnCount = meta.getColumnCount();
			for (int i = 0; i < columnCount; i++) {
				String columnName = meta.getColumnName(i + 1);
				Object columnValue = rs.getObject(columnName);
				try {
                 //属性修改器
					PropertyDescriptor pd = new PropertyDescriptor(columnName,
							bean.getClass());
					Method method = pd.getWriteMethod();
					method.invoke(bean, columnValue);
				} catch (Exception e) {
					continue;
				}
			}
			return bean;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}


Session.java:取名字所幸和Hibernate一样了，很简单的利用了反正将运行时的状态给拿出来。 
package org.gfg.dbutil.session;

import java.lang.reflect.Field;

import org.gfg.dbutil.common.DbUtils;


public class Session {

	public void save(Object obj) { //session.save

		int term=obj.getClass().getName().lastIndexOf(".")+1;
		StringBuffer sql = new StringBuffer("Insert into "
				+ obj.getClass().getName().substring(term) + " (");
		Field[] fields = obj.getClass().getDeclaredFields();

			int size = fields.length;
			Field field = null;
			Object[] params = new Object[size];

			try {
			for (int i = 0; i < size - 1; i++) {
				field = fields[i];
				field.setAccessible(true);//运行时 把private 转成 public
				params[i] = field.get(obj);
				sql.append(field.getName() + ",");
			}

			fields[size-1].setAccessible(true);
			params[size - 1] = fields[size - 1].get(obj);
			sql.append(fields[size - 1].getName() + ") VALUES (");

			for (int i = 0; i < size - 1; i++) {
				sql.append("? , ");
			}
			sql.append("?) ");

			String strSQL = new String(sql);
			DbUtils.insert(strSQL, params);//insert

		} catch (Exception e) {
			e.printStackTrace();
		}

		System.out.println(sql);
		for(Object objValue:params){
			System.out.print("  value："+objValue);
		}
	}


	public void update(Object obj) {

		int term=obj.getClass().getName().lastIndexOf(".")+1;
		StringBuffer sql = new StringBuffer("UPDATE "
				+ obj.getClass().getName().substring(term) + " SET ");
		Field[] fields = obj.getClass().getDeclaredFields();

			int size = fields.length;
			Field field = null;
			Object[] params = new Object[size+1];

			try {
			for (int i = 0; i < size - 1; i++) {
				field = fields[i];
				field.setAccessible(true);//运行时 把private 转成 public
				params[i] = field.get(obj);
				sql.append(field.getName() + "=?,");
			}

			fields[size-1].setAccessible(true);
			params[size - 1] = fields[size - 1].get(obj);
			sql.append(fields[size - 1].getName() + "=? WHERE " +fields[0].getName()+"=?");
			params[size]=params[0];

			String strSQL = new String(sql);
			DbUtils.update(strSQL, params);

		} catch (Exception e) {
			e.printStackTrace();
		}

		System.out.println(sql);
		for(Object objValue:params){
			System.out.print("  value："+objValue);
		}	
	}

	public void delete(Object obj){
		int term=obj.getClass().getName().lastIndexOf(".")+1;
		StringBuffer sql = new StringBuffer("DELETE from  "
				+ obj.getClass().getName().substring(term) + " WHERE ");
		Field[] fields = obj.getClass().getDeclaredFields();
		sql.append(fields[0].getName()+"=?");


		Object[] params = new Object[1];
		try {
			fields[0].setAccessible(true);
			params[0]=fields[0].get(obj);

			String strSQL = new String(sql);
			DbUtils.delete(strSQL, params);

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		System.out.println(sql);
		for(Object objValue:params){
			System.out.print("  value："+objValue);
		}	
	}

	public Object load(Class<?> clazz,Object uuid){

		Object obj=null;
		try {
			obj = clazz.newInstance();			
			Field[] fields = obj.getClass().getDeclaredFields();
			Object[] params = new Object[1];
			int term=obj.getClass().getName().lastIndexOf(".")+1;
			StringBuffer sql = new StringBuffer("SELECT * from  "
					+ obj.getClass().getName().substring(term) + " WHERE "+fields[0].getName()+"=?");
			params[0]=uuid;

			String strSQL = new String(sql);
			obj=DbUtils.load(strSQL,params,clazz);

			System.out.println(sql);
			for(Object objValue:params){
				System.out.print("  value："+objValue);
			}	

		} catch (Exception e) {
			e.printStackTrace();
		}		
		return obj;
	}
}


然后是POJO对象，这里我还没有写映射，所以数据库还得自己建立，当然表名和类名一致，数据库字段名称和类的成员变量名一直。[color=red]这里有个需要注意：建立POJO对象时，要将成员变量的第一个设置为数据库的索引[/color]，例如我这里用了ID做索引。 
package org.gfg.dbutil.model;

public class User {
	private int id;
	private  String name;
	private String pass;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPass() {
		return pass;
	}

	public void setPass(String pass) {
		this.pass = pass;
	}

}


最后是单元测试类：写个save和load方法的测试，其他的都差不多。 
package test;

import org.gfg.dbutil.model.User;
import org.gfg.dbutil.session.Session;

import junit.framework.TestCase;

public class TestSession extends TestCase{
	public void testSessionSave(){
		User user=new User();
		user.setId(0);
		user.setName("Alin");
		user.setPass("123456");
		Session session=new Session();
		session.save(user);
	}

	public void testSessionLoad(){
		Session session=new Session();
		session.load(User.class, 1);//Clazz & ID
	}
}


程序暂告一段落了，写这个文章的时候突然想起来，好多模式还没用上去，不过这样的小东西应付应付一般的也够用了，当然还需要完善很多东西，等有空了接着把他写完。最后面会附下载链接，一个DEMO。


以上只是一种思路。个人愚见，谢谢观看。
本文原创，转载请指明出处，谢谢。
ielts0909
关注
专栏目录
easysql,中国人自己开发的类似Hibernate的框架，使用简单
12-19
easysql是一款完全由中国人自主开发的基于JDBC的数据库连接框架。该框架支持多版本数据库，使用方便。开发人员只需要通过一条SQL语句即可实现对数据库的增删改查，完全实现了代码的可重用性和对象的持久化。当然，由于作者的水平有限，该套框架目前还处于开发阶段，目前发布的是第一个版本（1.0.1）。该套框架是开源的，作者希望有能力，有水平的国人能在这套框架的基础上继续完善，给作者提出意见和建议。使这套框架能够拥有强大的生命力和持久力(就像当初的mysql一样，才出来的时候被人鄙视为一个玩具。但是经过开发人员和广大开源爱好者的共同努力，现在已经不亚于sqlserver了)。作者的邮箱是：zttsky@qq.com，希望各位国人能踊跃修改源代码，给作者提意见。（国货当自强）
第一个手写Hibernate
09-06
第一个手写Hibernate,为那些手写Hibernate手写中注意事项做了注释!
自己写的类似hibernate框架
h273166784的专栏
08-12 195
呵呵，小人我做了一个和hibernate类似的框架，也是面向对象的框架； 有save,saveorupdate,find**()系列方法，delete(Object); 也是面向对象的，save的时候传入对象，saveorupdate也是以对象为参数； find**方法返回的时候也是返回的实体对象，比如说查询的一个类名，查询出来的结果是这个实体的对象的集合； 呵呵，不知道这样算什么...
bdutil 项目使用教程
最新发布
gitblog_00276的博客
08-26 237
bdutil 项目使用教程 bdutil[DEPRECATED] Script used to manage Hadoop and Spark instances on Google Compute Engine项目地址:https://gitcode.com/gh_mirrors/bd/bdutil 1. 项目的目录结构及介绍 bdutil 项目的目录结构如下： conf: 配置文件目录。 ...
手写 Hibernate ORM 框架-02-实体 Bean 定义，建表语句自动生成
05-02 4万+
目录 目录 本节内容 定义实体 Bean Table 实现 测试 Table 中涉及到的工具类 FieldUtil TableUtil ReflectionUtil StringBuilderUtil StringUtil CollectionUtil 目录导航 本节内容 实体 Bean 的定义。 根据实体 Bean 生成对应的建表语句。 定义实体 Bean ...
手写Hibernate 步骤（图，文字）以及原因
11-18
手写Hibernate 步骤（图，文字）以及原因， 我花了半个小时，截图，总结的。
自己动手写框架(含PPT、UML、文档、依赖包、代码)
09-20
1 ORM框架——模仿Hibernate 2 MVC框架——模仿struts2 3 IOC框架——模仿Spring 4 框架整合及项目实例 使用技术： 开发语言：Java 开发工具：Eclipse，MyEclipse 数据库：MySQL 数据库工具：Navicat 建模工具：...
sorm.zip_JEM_SORM_模仿hibernate库.
09-21
标题 "sorm.zip_JEM_SORM_模仿hibernate库" 暗示这是一个与ORM（对象关系映射）框架相关的项目，它模仿了著名的Java持久化库Hibernate。ORM是编程领域中的一个重要概念，它允许开发者用面向对象的方式来操作数据库，...
自己编写仿hibernate的java框架
11-07
本项目旨在模仿Hibernate的核心功能，以加深对ORM的理解并锻炼Java编程能力。 首先，让我们了解Hibernate的基本概念。Hibernate是一个开源的ORM框架，它允许开发人员将Java类映射到数据库表，Java对象映射到数据库...
spring+hibernate，自己封装了原生sql的处理，模仿mybatis使用
11-17
而Hibernate则是一个对象关系映射（ORM）框架，它简化了数据库操作，允许开发者通过Java对象来操作数据库，减少了对SQL的直接使用。 标题中的"spring+hibernate"表明这是一个将两者结合使用的项目。Spring和...
手写myHibernate的代码（可以直接使用）
11-18
手写myHibernate的代码（可以直接使用），只需要修改配置就可以了。开发项目过程中，我一直使用这个，也可以连接mysql oracle,数据库哦。很实用的哦
手写 Hibernate ORM 框架-04-数据库交互，数据持久化
05-02 4万+
目录 目录 本节内容 执行建表语句 Session 测试 数据的持久化 测试构建 测试入库 目录导航 本节内容 执行建表语句。 执行数据的保存 执行建表语句 Session package com.ryo.hibernate.simulator.hibernate; import com.mysql.jdbc.PreparedStatement;...
手写 Hibernate ORM 框架-00-环境准备
热门推荐
05-02 4万+
导航 手写 Hibernate ORM 框架-00-环境准备 手写 Hibernate ORM 框架-01-注解定义、常量定义 手写 Hibernate ORM 框架-02-实体 Bean 定义，建表语句自动生成 手写 Hibernate ORM 框架-03-Hibernate 配置文件读取, 数据库连接构建 手写 Hibernate ORM 框架-04-数据库交互，数据持久化 目录 ...
手写 Hibernate ORM 框架-03-Hibernate 配置文件读取, 数据库连接构建
05-02 4万+
目录 目录 本节内容 hibernate.cfg.xml 读取 文件内容 读取测试 构建 Connetion 目录导航 本节内容 hibernate.cfg.xml 配置文件的读取 数据库访问 Connection 的构建 hibernate.cfg.xml 读取 当然，代码中为了快速模拟，我们也可以将属性 hard code。 但此处为了模拟，就进行简单的实...
手写 Hibernate ORM 框架-01-注解定义、常量定义
05-02 4万+
目录 目录 本节内容 注解定义 @Entity @Column @Id @GenerateValue 常量定义 HibernateConstant.java TypeMap.java 目录导航 本节内容 进行 Hibernate 的注解定义，常量定义 注解定义 直接模拟 Hibernate 定义几个最常见的注解。 @Entity package co...
【ORM思想】源码手写篇：仿Hibernate手写ORM框架
不想当架构师的程序员不是好程序员
08-21 1159
ORM思想之源码手写篇：仿Hibernate手写ORM框架 前面我们通过跟踪源码的方式剖析了 Hibernate 和 MyBatis 两个框架是如何应用 ORM 思想的，接下来我们自己定义一个简单的 ORM 框架（仿Hibernate），希望能通过这种方式让大家亲自零距离的去应用一下 ORM。 1. ORM 框架的结构设计 第一层为配置层： orm.cfg.xml 是框架的核心配置...
如何使用DBUtil
m0_46621420的博客
10-08 576
如何使用DBUtils 什么是DBUtils DBUtils API及工具类介绍 使用DBUtils步骤 一：什么是DBUtils Commons DBUtils是Apache组织提供的一个对JDBC（java数据库连接，java的数据库操作的基础API）。进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。 二：DBUtils API及工具类介绍 DBUtils的三个核心对象 （1）org.apache.commons.dbutils.QueryRunner （
BDUtil
weixin_45503563的博客
11-21 222
package qst.com.Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; /** 连接数据库工具类 @author hzh ...
Java数据库连接池详解及Hibernate整合指南
同时，提到了这些连接池如何与Hibernate框架进行整合，以提升数据库操作的效率和性能。" 数据库连接池是Java应用中用于管理数据库连接的重要组件，它的主要作用是通过复用已建立的数据库连接，减少频繁创建和销毁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值