`

手写orm

阅读更多

what?

orm->object -relation -mapping。

 

why?

减少代码冗余,提高代码的可复用性。

 

 

数据库配置文件ORM-DriverConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<Driver nsme="Mysql" state="true">
    <DriverName>com.mysql.jdbc.Driver</DriverName>
    <url>jdbc:mysql://localhost:3306/test</url>
    <userName>root</userName>
    <pwd>xuxie</pwd>
</Driver>

 

 

封装sql与映射

<?xml version="1.0" encoding="UTF-8"?>
<sql>
	<resultMap id="UserResult" class="com.aptech.orm.pojo.User" table="s_user">
		<result property="id" column="id" />
		<result property="name" column="name" />
		<result property="age" column="age" />
	</resultMap>

	<SQL id="SELECT_ALL" resultMap = "UserResult">select age,name from s_user</SQL>
	<SQL id="DELETE_ID">delete from s_user where id =?</SQL>
	<SQL id="INSERT_OBJECT">insert into s_user values(?,?,?,'')</SQL>
	<SQL id="SELECT_NAME">select * from s_user where name like "%"?"%"</SQL>
</sql>

 

pojo

package com.aptech.orm.pojo;

import java.sql.Blob;



public class User
{
	private int id;
	private String name;
	private int age;
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	
}

 

工具类

package com.aptech.orm.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class ORMUtil {

	public static Document getDbDocument() {
		Document document = null;
		SAXBuilder builder = new SAXBuilder();
		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream(new File(
					"./src/ORM-DriverConfig.xml"));
			document = builder.build(fileInputStream);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != fileInputStream) {
					fileInputStream.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		return document;
	}

	public static Document getSqlDocument() {
		Document document = null;
		SAXBuilder builder = new SAXBuilder();
		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream(new File("./src/ORM-Sql.xml"));
			document = builder.build(fileInputStream);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != fileInputStream) {
					fileInputStream.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		return document;
	}

	public static Connection getConnection() {
		Connection con = null;
		try {
			Document document = getDbDocument();
			Element rootElement = document.getRootElement();
			String DriverName = rootElement.getChildText("DriverName");
			String url = rootElement.getChildText("url");
			String userName = rootElement.getChildText("userName");
			String pwd = rootElement.getChildText("pwd");
			Class.forName(DriverName);
			con = DriverManager.getConnection(url, userName, pwd);

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

	public static List<Element> getSqlElement() {
		Document document = getSqlDocument();
		Element root = document.getRootElement();
		List<Element> children = root.getChildren("SQL");
		return children;
	}

	public static List<Element> getResultMapElement() {
		Document document = getSqlDocument();
		Element root = document.getRootElement();
		List<Element> children = root.getChildren("resultMap");
		return children;
	}

	public static List<Element> getResultElement(String id) {
		List resultElementList = null;
		List<Element> children = getResultMapElement();
		for (Element element : children) {
			if (id.equals(element.getAttributeValue("id"))) {
				resultElementList = element.getChildren();
				break;
			}
		}
		return resultElementList;
	}

	public static String getSQL(String id) {
		String sql = "";
		List<Element> sqlElement = getSqlElement();
		for (Element element : sqlElement) {
			if (id.equals(element.getAttributeValue("id"))) {
				sql = element.getText();
				break;
			}
		}
		return sql;
	}
	
	public static String getResultMap(String id) {
		String resultMap = "";
		List<Element> sqlElement = getSqlElement();
		for (Element element : sqlElement) {
			if (id.equals(element.getAttributeValue("id"))) {
				resultMap = element.getAttributeValue("resultMap");
				break;
			}
		}
		return resultMap;
	}
	

	public static void close(Connection con, Statement stmt, ResultSet rs) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if (stmt != null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if (con != null) {
			try {
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	public static Map getResultMap(ResultSet rs) {
		Map map = new HashMap();
		try {
			ResultSetMetaData meta = rs.getMetaData();
			int clos = meta.getColumnCount();
			while (rs.next()) {
				for (int i = 1; i <= clos; i++) {
					map.put(meta.getColumnName(i), rs.getObject(i));
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return map;
	}
	
	/**
	 * 
	 * 〈获取查询的数据字段〉
	 * @param [rs]     [结果集]
	 * @return  [字段集合]
	 * @Author  YangZhuan
	 */
	public static List getResultFields(ResultSet rs) {
		List list = new ArrayList();
		try {
			ResultSetMetaData meta = rs.getMetaData();
			int clos = meta.getColumnCount();
				for (int i = 1; i <= clos; i++) {
					list.add(meta.getColumnName(i));
				}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return list;
	}
	
	/**
	 * 
	 * 〈关系型数据映射为对象〉
	 * @param [rs]     [结果集]
	 * @param [id]     [对应的mapping]
	 * @return  [Object]
	 * @Author  YangZhuan
	 */
	public static Object getObject(ResultSet rs,String id) {
		//获取类路径
		String classPath = getClass(id);		
		Object object = null;
		try {

			//所有字段
			List fieldsList = getResultFields(rs);
			
			//类实例化
			object = Class.forName(classPath).newInstance();
			//当前类的方法数组
			Method[] methods = object.getClass().getMethods();
			//遍历方法数组
			for (int i = 0; i < methods.length; i++) {
				//方法名
				String methodName = methods[i].getName();
				//只处理以set开头的方法
				if(methodName.startsWith("set")){
					//字段名
					String field = methodName.substring(3).toLowerCase();
					
					//判断当前子段是否使用
					if(fieldsList.contains(field)) {
						
						//隐式的方法调用
						methods[i].invoke(object, rs.getObject(field));	
					}
					
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return object;
	}

	
	public static String getClass(String id) {
		String classPath = "";
		try {
			List<Element> children = getResultMapElement();
			for (Element element : children) {
				if (id.equals(element.getAttributeValue("id"))) {
					classPath = element.getAttributeValue("class");
					break;
				}
			}	
		} catch (Exception e) {
			e.printStackTrace();
		}
		return classPath;
	}

}

 

执行

package com.aptech.orm.manage;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.aptech.orm.pojo.User;
import com.aptech.orm.util.ORMUtil;

public class ORMProcess {


	public static List QueryForList(String str) {
		List list = new ArrayList();
		Connection con = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			String sql = ORMUtil.getSQL(str);
			con = ORMUtil.getConnection();
			ps = con.prepareStatement(sql);
			ps.execute();
			rs = ps.getResultSet();
			while(rs.next()){
				Object obj = ORMUtil.getObject(rs, ORMUtil.getResultMap(str));
				list.add(obj);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			ORMUtil.close(con, ps, rs);
		}
		return list;
	}

	
	public static void main(String[] args) {
		List<User> list = QueryForList("SELECT_ALL");
		for (User user : list) {
			System.out.println("id:"+user.getId()+"name:"+user.getName()+"age:"+user.getAge());
		}
		
	}
}

 

 

分享到:
评论

相关推荐

    手写ORM框架笔记.txt

    ### 手写ORM框架知识点详解 #### 一、ORM框架概念 ORM(Object Relational Mapping)即对象关系映射,是一种编程技术,用于将关系数据库中的数据与面向对象语言(如Java)中的对象进行映射。它使得开发人员能够通过...

    手写ORM框架.java

    博文资源

    Java8应用封装,手写ORM,LOG,framework

    在这个“Java8应用封装,手写ORM,LOG,framework”的项目中,开发者显然专注于利用Java8的新特性来构建自己的轻量级框架,包括对象关系映射(ORM)、日志系统(LOG)以及一些通用的工具类和自动化配置。 1. **Java...

    .NET Core手写ORM框架专题-代码+脚本

    .NET Core手写ORM框架专题-代码+脚本

    手写ORM持久层框架(针对单表)

    手写ORM持久层框架(针对单表)

    手写ORM框架

    这是一个手写的ORM框架,类似于Mybaties框架,可以对数据库进行建表、增、删、查、改操作,每个功能都重载了多种方法,以满足用户需求。此外,还有缓存功能,第二次进行同样的查找操作时将不会调用数据库,而是在...

    手写简易版ORM框架(仿mybatis)

    ORM,全称Object-Relational ...学习并实践手写ORM框架,不仅有助于理解数据库操作的本质,还能加深对MyBatis等成熟ORM框架的理解。通过这种方式,开发者可以更好地掌握数据持久化的原理,提升在实际项目中的应用能力。

    Python 手写ORM-我的一个数据库访问工具

    对象-关系映射(Object-Relational Mapping,简称ORM),面向对象的开发方法是当今企业级应用开发环境中的主流开发方法,关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的...

    02-01-11-基于Spring JDBC手写定制自己的ORM框架1

    在本课程"02-01-11-基于Spring JDBC手写定制自己的ORM框架1"中,我们将探讨如何利用Spring的JdbcTemplate设计理念,来构建一个自定义的ORM(对象关系映射)框架。ORM框架的主要目的是简化Java应用程序与数据库之间的...

    .NET ORM架构源码

    .NET ORM架构源码是针对关系型数据库的一种编程技术,它允许开发者使用面向对象的方式来操作数据库,而无需直接编写SQL语句。ORM(Object-Relational Mapping)的核心思想是将数据库中的表格映射为程序中的对象,...

    myorm-master.zip

    《手写ORM框架——探索与实践》 ORM(Object-Relational Mapping)框架在Java开发中扮演着重要的角色,它将数据库操作与对象模型进行映射,极大地简化了数据库访问的复杂性。本篇我们将深入探讨如何手写一个简单的...

    MyReflectionProject_pressuretbm_反射的进阶使用_

    在线手写ORM框架的过程中,可以使用反射来创建对象实例,调用方法,以及处理字段的赋值。例如,对于一个从数据库查询返回的结果集,我们可以反射创建Java对象,然后逐行将数据字段映射到对象的相应属性上。 在`...

    为初学者写ORM,ORM的原理及测试案例

    概念:对象关系映射(ObjectRelationalMapping,简称ORM,或O/RM,或O/Rmapping),是一种程序技术,用于实现面向对象编程语言里不同类型系统的数据之间的转换。详细介绍:让我们从O/R开始。字母O起源于"对象"...

    自己写的orm辅助类

    自己写的orm辅助类 .定义实体的特性(如对应的表名 主键名 属性对应的列名 实体和数据库对象的相互转换 简单实体的 CRUD操作 QQ交流群60168829 欢迎C# ASP.NET 和SQL新手 老手 高手加入 谢谢

    spring-annotation:1.Spring 5.X源码分析2.手写框架3.设计模式4.Springcloud2 5.互联网高并发场景6.互联网安全架构

    手写框架2.1手写Spring事务框架2.2手写@服务和@资源注解2.3手写SpringMVC框架(手写SpringMVC控制框,手写@Controller注解,手写@RequestMapping注解)2.4手写数据库连接池2.5手写orm框架--mybatis2.6手写ArrayList...

    ORM框架ORM框架ORM框架ORM框架

    ORM(Object-Relational Mapping,...然而,ORM也有其局限性,如性能可能略逊于手写SQL,对于非常复杂的查询可能不易表达,以及可能增加内存消耗等。因此,在选择是否使用ORM时,需要根据项目需求和团队能力进行权衡。

    Dos.ORM Demo

    选择Dos.ORM的理由:  1.上手非常简单,0学习成本。使用方便,按照sql书写习惯编写C#代码。功能强大。  2....高性能,接近手写sql  5.支持Lambda表达式写法  6.国产的优秀ORM框架,必须支持

    Doc.ORM的演示Demo

    2)高性能(与Dapper媲美,接近手写Sql) 3)体积小(不到150kb,仅一个dll) 4)完美支持Sql Server(2000至最新版),MySql,Oracle,Access,Sqlite等数据库 5)支持大量Lambda表达式写法,国产ORM支持度最高,开源中国...

    单独提取django_orm

    1. 高效:ORM能减少手写SQL的繁琐,提高开发效率。 2. 安全:防止SQL注入攻击,因为所有查询都由Django处理。 3. 跨数据库支持:Django ORM支持多种数据库,如MySQL、PostgreSQL、SQLite等,无需大量修改代码即可...

Global site tag (gtag.js) - Google Analytics