JDBC连接数据库反射实现O/R映射（2）

最新推荐文章于 2023-11-29 16:51:03 发布
最新推荐文章于 2023-11-29 16:51:03 发布
阅读量1.9k 收藏
点赞数
分类专栏： Java基础 文章标签： java jdbc连接数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luming_xml/article/details/51589030
版权 
测试preparedStatement   
 public void testPreparedStatement(){
    	Connection connection=null;
    	PreparedStatement preparedStatement=null;
    	try{
    		connection =JDBCTools.getConnection();
    		String sql="insert into customers(name,email,birth) "+
    		"values(?,?,?)";
    		preparedStatement=connection.prepareStatement(sql);
    		preparedStatement.setString(1, "ATGUIGU");
    		preparedStatement.setString(2, "simleint@163.com");
    		preparedStatement.setDate(3, new Date(new java.util.Date().getTime()));
    		preparedStatement.executeUpdate();
    	}catch(Exception e){
    		e.printStackTrace();
    	}finally{
    		JDBCTools.release(null, preparedStatement, connection);
    	}
    }
测试结果集元数据： 利用SQL进行查询，得到结果集。
利用反射创建实体对象，获取结果集的列的别名。
在获取结果集的每一列的值，结合3得到一个Map，键的别名，值：列的值。</span>
再利用反射为2的对应的属性赋值：属性为Map的键，值为Map的值。</span>
  public void testResultSetMetaData(){
		Customer customer=null;
		Connection conn=null;
		PreparedStatement preparedStatement=null;
		ResultSet rs=null;
		try{
			String sql="select ID id,NAME name,EMAIL email,BIRTH birth from customers";
			conn=JDBCTools.getConnection();
			preparedStatement=conn.prepareStatement(sql);
//1得到rs
			rs=preparedStatement.executeQuery();
			
			Map<String,Object>values=
					new HashMap<String,Object>();
			//2得到结果集ResultSetMetaData对象。
			ResultSetMetaData rsmd=rs.getMetaData();
			while(rs.next()){
			for(int i=0;i<rsmd.getColumnCount();i++){
				String columnLabel=rsmd.getColumnLabel(i+1);
				Object columnValue=rs.getObject(columnLabel);
				
				values.put(columnLabel,columnValue);
			}
		}
			System.out.println(values);
			Class clazz=Customer.class;
			Object object=clazz.newInstance();
			for(Map.Entry<String, Object>entry:values.entrySet()){
				String fieldName=entry.getKey();
				Object fieldValue=entry.getValue();
				System.out.println(fieldName+" :"+fieldValue);
				ReflectionUtils.setFieldValue(object,fieldName,fieldValue);
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCTools.release(rs,preparedStatement,conn);
		}
	
  }

抽取出泛型方法：

    public void testGet(){
    	String sql="select ID id,NAME name,EMAIL email,BIRTH birth "+"From customers";
    	Customer customer=get(Customer.class,sql);
    	System.out.println(customer);
    	
    }
    public <T> T get(Class<T> clazz,String sql,Object...args){
         T entity=null;
		Connection conn=null;
		PreparedStatement preparedStatement=null;
		ResultSet rs=null;
		try{
			conn=JDBCTools.getConnection();
			preparedStatement=conn.prepareStatement(sql);
			for(int i=0;i<args.length;i++)
			{
				preparedStatement.setObject(i+1, args[i]);
			}
             //1得到rs
			rs=preparedStatement.executeQuery();
			//2得到结果集ResultSetMetaData对象。
			ResultSetMetaData rsmd=rs.getMetaData();
			//3创建一个Map<String,Object>对象，键：SQL查询的别名。值：列的值
			Map<String,Object>values=
					new HashMap<String,Object>();
            //处理结果集。
			while(rs.next()){
			for(int i=0;i<rsmd.getColumnCount();i++){
				String columnLabel=rsmd.getColumnLabel(i+1);
				Object columnValue=rs.getObject(columnLabel);
				
				values.put(columnLabel,columnValue);
			}
		}
		//5若Map不为空利用反射创建clazz对应的对象。
			if(values.size()>0){
			entity=clazz.newInstance();
			for(Map.Entry<String, Object>entry:values.entrySet()){
				String fieldName=entry.getKey();
				Object fieldValue=entry.getValue();
				ReflectionUtils.setFieldValue(entity,fieldName,fieldValue);
			}
		}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCTools.release(rs,preparedStatement,conn);
		}
	return entity;
  }
其中JDBCTools.java为： 

/*
 * 操作JDBC的工具类，其中封装了一些工具方法
 * 通过读取配置文件从数据库服务器获取一个连接*/
public class JDBCTools {
	public static Connection getConnection() throws IOException, ClassNotFoundException, SQLException{
		//1.准备连接数据库的4个字符串。
		  //1)z创建jdbc.properties对象。
		Properties properties=new Properties();
		  //2)加载对应的输入流。
		InputStream in=JDBCTools.class.getClassLoader().getResourceAsStream("jdbc.properties");
		//3)加载2）对应的输入流 
		  properties.load(in);
		//4)具体决定user，password等4个字符串。
		  String user=properties.getProperty("user");
		  String password=properties.getProperty("password");
		  String driver=properties.getProperty("driverClass");
		  String jdbcUrl=properties.getProperty("jdbcUrl");
		//2.加载数据库驱动（对应的Driver实现类中有注册驱动的静态代码块）
		  Class.forName(driver);
		//3.通过DriverManager的getConnection（）方法获取数据库连接。
		  return DriverManager.getConnection(jdbcUrl,user,password);
	}
	/*
	 *关闭Statement，Connection */
	public static void  release(ResultSet rs,Statement statement,Connection conn){
		if(rs!=null){
			try {
				rs.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	    if(statement!=null){
	    	  try{
	    		  statement.close();
	    	  }catch(Exception e2){
	    	  e2.printStackTrace();
	        }
	      }
	      if(conn!=null){
	    	  try{
	    		  conn.close();
	    	  }catch(Exception e2){
	    	  e2.printStackTrace();
	      }
	    }
	}

	public static void update(String sql) throws SQLException{		
		Connection conn=null;
		Statement statement=null;
		try{
		conn=JDBCTools.getConnection();
		statement=conn.createStatement();
		statement.executeUpdate(sql);
		}catch(Exception e){
			e.printStackTrace();
		}finally{
	    JDBCTools.release(null,statement, conn);
	}
   }
	public static void update(String sql,Object...args) throws IOException, ClassNotFoundException{
		Connection conn=null;
		  PreparedStatement pstmt=null;
		  try{
			  conn=JDBCTools.getConnection();
			   pstmt=conn.prepareStatement(sql);
			  for(int i=0;i<args.length;i++){
				  pstmt.setObject(i+1,args[i]);
			  }
			  pstmt.executeUpdate();
		  }catch(SQLException e){
			  System.out.println("使用预编译语句更新数据操作发生异常");
		  }
	}
	/*
	 * 1ResultSetMetaData是描述ResultSet的元数据的对象，即从中可以获取到结果集中有多少列，列名是多少。。。
	 * 2得到ResultSetNataData对象：调用ResultSet的getMetaData()方法
	 * ResultSetMetaData有哪些方法。
	 * int getColumnCount（）：SQL语句中包含哪些列。
	 * String getColumnLable（int column）获取指定的列的别名，其中索引从1开始。*/
 

	
	   public <T> T get(Class<T> clazz,String sql,Object...args){
			/*
			 * 1先利用SQL进行查询得到结果集
			 * 2利用反射创建实体类的对象
			 * 3获取结果集的列的别名：idcard。。。
			 * 4获取结果集的每一列的值，结合3得到一个Map。键：列的别名，值：列的值
			 * 5再利用反射为2的对应的属性赋值。*/
	         T entity=null;
			Connection conn=null;
			PreparedStatement preparedStatement=null;
			ResultSet rs=null;
			try{
				conn=JDBCTools.getConnection();
				preparedStatement=conn.prepareStatement(sql);
				for(int i=0;i<args.length;i++)
				{
					preparedStatement.setObject(i+1, args[i]);
				}
	             //1得到rs
				rs=preparedStatement.executeQuery();
				//2得到结果集ResultSetMetaData对象。
				ResultSetMetaData rsmd=rs.getMetaData();
				//3创建一个Map<String,Object>对象，键：SQL查询的别名。值：列的值
				Map<String,Object>values=
						new HashMap<String,Object>();
	            //处理结果集。
				while(rs.next()){
				for(int i=0;i<rsmd.getColumnCount();i++){
					String columnLabel=rsmd.getColumnLabel(i+1);
					Object columnValue=rs.getObject(columnLabel);
					
					values.put(columnLabel,columnValue);
				}
			}
			//5若Map不为空利用反射创建clazz对应的对象。
				if(values.size()>0){
				entity=clazz.newInstance();
				for(Map.Entry<String, Object>entry:values.entrySet()){
					String fieldName=entry.getKey();
					Object fieldValue=entry.getValue();
					ReflectionUtils.setFieldValue(entity,fieldName,fieldValue);
				}
			}
			}catch(Exception e){
				e.printStackTrace();
			}finally{
				JDBCTools.release(rs,preparedStatement,conn);
			}
		return entity;
	  }	
	
	
	public Customer getCustomer(String sql,Object...args){
		Customer customer=null;
		Connection conn=null;
		PreparedStatement preparedStatement=null;
		ResultSet rs=null;
		try{
			conn=JDBCTools.getConnection();
			preparedStatement=conn.prepareStatement(sql);
			for(int i=0;i<args.length;i++)
			{
				preparedStatement.setObject(i+1, args[i]);
			}
			rs=preparedStatement.executeQuery();
			
			if(rs.next()){
				customer=new Customer();
				customer.setId(rs.getInt(1));
				customer.setName(rs.getString(2));
				customer.setEmail(rs.getString(3));
				customer.setBirth(rs.getDate(4));
			}
			
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCTools.release(rs,preparedStatement,conn);
		}
		return customer;
	} 
	
	
}
ReflectionUtils.java为： 

package com.atguigu.jdbc;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * 反射的 Utils 函数集合
 * 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数
 * @author Administrator
 *
 */
public class ReflectionUtils {

	
	/**
	 * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
	 * 如: public EmployeeDao extends BaseDao<Employee, String>
	 * @param clazz
	 * @param index
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(Class clazz, int index){
		Type genType = clazz.getGenericSuperclass();
		
		if(!(genType instanceof ParameterizedType)){
			return Object.class;
		}
		
		Type [] params = ((ParameterizedType)genType).getActualTypeArguments();
		
		if(index >= params.length || index < 0){
			return Object.class;
		}
		
		if(!(params[index] instanceof Class)){
			return Object.class;
		}
		
		return (Class) params[index];
	}
	
	/**
	 * 通过反射, 获得 Class 定义中声明的父类的泛型参数类型
	 * 如: public EmployeeDao extends BaseDao<Employee, String>
	 * @param <T>
	 * @param clazz
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static<T> Class<T> getSuperGenericType(Class clazz){
		return getSuperClassGenricType(clazz, 0);
	}
	
	/**
	 * 循环向上转型, 获取对象的 DeclaredMethod
	 * @param object
	 * @param methodName
	 * @param parameterTypes
	 * @return
	 */
	public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){
		
		for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
			try {
				//superClass.getMethod(methodName, parameterTypes);
				return superClass.getDeclaredMethod(methodName, parameterTypes);
			} catch (NoSuchMethodException e) {
				//Method 不在当前类定义, 继续向上转型
			}
			//..
		}
		
		return null;
	}
	
	/**
	 * 使 filed 变为可访问
	 * @param field
	 */
	public static void makeAccessible(Field field){
		if(!Modifier.isPublic(field.getModifiers())){
			field.setAccessible(true);
		}
	}
	
	/**
	 * 循环向上转型, 获取对象的 DeclaredField
	 * @param object
	 * @param filedName
	 * @return
	 */
	public static Field getDeclaredField(Object object, String filedName){
		
		for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
			try {
				return superClass.getDeclaredField(filedName);
			} catch (NoSuchFieldException e) {
				//Field 不在当前类定义, 继续向上转型
			}
		}
		return null;
	}
	
	/**
	 * 直接调用对象方法, 而忽略修饰符(private, protected)
	 * @param object
	 * @param methodName
	 * @param parameterTypes
	 * @param parameters
	 * @return
	 * @throws InvocationTargetException 
	 * @throws IllegalArgumentException 
	 */
	public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
			Object [] parameters) throws InvocationTargetException{
		
		Method method = getDeclaredMethod(object, methodName, parameterTypes);
		
		if(method == null){
			throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
		}
		
		method.setAccessible(true);
		
		try {
			return method.invoke(object, parameters);
		} catch(IllegalAccessException e) {
			System.out.println("不可能抛出的异常");
		} 
		
		return null;
	}
	
	/**
	 * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter
	 * @param object
	 * @param fieldName
	 * @param value
	 */
	public static void setFieldValue(Object object, String fieldName, Object value){
		Field field = getDeclaredField(object, fieldName);
		
		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
		
		makeAccessible(field);
		
		try {
			field.set(object, value);
		} catch (IllegalAccessException e) {
			System.out.println("不可能抛出的异常");
		}
	}
	
	/**
	 * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
	 * @param object
	 * @param fieldName
	 * @return
	 */
	public static Object getFieldValue(Object object, String fieldName){
		Field field = getDeclaredField(object, fieldName);
		
		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
		
		makeAccessible(field);
		
		Object result = null;
		
		try {
			result = field.get(object);
		} catch (IllegalAccessException e) {
			System.out.println("不可能抛出的异常");
		}
		
		return result;
	}
}
Customer类为： 

package com.atguigu.jdbc;

import java.sql.Date;

public class Customer {
	 private int id;
	 private String name;
     private String email;
     private Date birth;
     
     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 getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
	public Customer(){}

	 public Customer(int id, String name, String email, Date birth) {
		super();
		this.id = id;
		this.name = name;
		this.email = email;
		this.birth = birth;
	}


	public String toString() {
		return "Customer [id=" + id + ", name=" + name + ", email=" + email
				+ ", birth=" + birth + "]";
	}
	
}






cag_are_god
关注
专栏目录
Java-JDBC【源码】实现ORM，结果集映射实体类（ResultSet、注解、反射）
05-04
文章地址：https://blog.csdn.net/m0_37969197/article/details/124568385 Java-JDBC【之】实现ORM，结果集映射实体类（ResultSet、注解、反射） 1.ORM实现思路 2.@Table、@Column、标识实体类 2.1.创建注解 @Table、@Column 2.2.标识实体类 2.3.数据库表 3.结果集解析，注解加反射填充实体类 3.1.结果集解析 3.2.注解加反射填充实体类 3.3.测试 4.完整源码
JDBC 将数据库字段映射实体类中
m0_52376209的博客
08-03 2750
实体类 public class Urls { private long id; private String province; private String city; private String url; @Override public String toString() { return "Urls{" + "id=" + id + ", province='"
JDBC连接池使用反射来创建实体类
zcs18338992657的博客
05-31 312
查了很多资料发现在执行Sql语句时，JDBC会将该语句的。去连接数据库查询Mysql表中的数据时，没有为实体类提供。以便将查询结果映射到实体类中。方法加载实体类，并调用该类的。具体来说，连接池会使用。来获取实体类中对应字段的。
Java-JDBC【之】实现ORM，结果集映射实体类（ResultSet、注解、反射）
WangYongJi
05-04 1879
Java-JDBC【之】实现ORM，结果集映射实体类（ResultSet、注解、反射） 1.ORM实现思路 2.@Table、@Column、标识实体类 2.1.创建注解 @Table、@Column 2.2.标识实体类 2.3.数据库表 3.结果集解析，注解加反射填充实体类 3.1.结果集解析 3.2.注解加反射填充实体类 3.3.测试 4.完整源码 《目录：Java-JDBC学习（编写中...）》 《幕》 1.ORM实现思路 ORM（Object Relational Mapping） ORM 是通过标
【JAVA基础】 反射实现JDBC工具类映射结果到实体类
weixin_46825305的博客
11-06 725
记录下自己觉得好的代码
通过类反射机制实现底层数据库连接
08-31
对于注解实现连接数据库，这是现代开发中常见的方式。Hibernate支持使用注解来定义实体类，比如`@Entity`表示这个类是数据库中的一个表，`@Table`定义对应的表名，`@Id`标记主键字段，`@Column`定义列名等。这种方式...
jdbc连接池封装及ORM框架jdbc.rar
11-17
JDBC（Java Database Connectivity）连接池允许程序管理多个数据库连接，而无需为每个连接创建新的资源，从而减少了资源消耗。在这个“jdbc连接池封装及ORM框架jdbc.rar”文件中，我们可以探讨几个核心概念和技术，...
java 解析xml类映射数据库 数据库操作 反射机制 源码
04-07
2. 数据库连接：使用JDBC建立数据库连接，获取Connection对象。 3. 数据库操作：创建Statement或PreparedStatement对象，执行SQL，处理ResultSet。 4. 反射应用：根据XML映射信息，使用反射动态地实例化对象，设置...
JDBC_Java反射技术入门
09-29
Java JDBC（Java Database Connectivity）是Java编程语言与各种数据库交互的一种标准接口，它允许Java程序通过JDBC API连接和操作数据库。在这个“JDBC_Java反射技术入门”资源中，初学者可以了解到如何使用Java进行...
JDBC结果集ResultSet映射为实体类(对象)
LuckFairyLuckBaby的博客
03-26 8976
1.方法抽取 public static List<Object> handler(ResultSet rs, Class<?> clazz) { List<Object> list = new ArrayList<>(); Object obj = null; try { ...
jdbc中的反射
z742182637的博客
12-24 805
使用JDBC时，我们都会很自然得使用下列语句： [java] view plaincopy Class.forName("com.mysql.jdbc.Driver");         String url = "jdbc:mysql://127.0.0.1/test?useUnicode=true&characterEncoding
JDBC与反射
wew25的博客
07-26 1075
jdbc: java database connectivity， java与数据库的连接。 连接 在进行连接数据库之前我们需要做一些准备工作。 　　 1.引入驱动包 　　 2.构建路径 build path 　　 3.测试用户是否正确登录 JDBC常用接口： 　　java.sql.Connection：连接 　　java.sql.Statement：静态处理块 　　java.sql.Prepar...
jdbc结果集映射成实体类
zhang_xiao_lun的专栏
08-07 3166
jdbc结果集映射成实体类
jdbc和反射
可了不得
11-05 1925
好久不写博客了，趁着今天周末，来写一波….今天说一下jdbc和反射的大概， JDBC（java dataBase Connectivity）：java语句使用JDBC来操作数据库，jdbc严格来说是java的一种规范。 Jdbc开发的步骤： 1.   获得连接 2.   通过连接来创建statement或者是preparedstatement 3.   关闭资源  而在第一步中常常有一
jdbc sql查询之后映射为实体
weixin_43167662的博客
04-12 332
jdbc连接mysql数据库，查询结果封装进实体类
weixin_41788067的博客
02-28 1335
文章目录1 新建实体类2 新建表3 插入数据4 连接数据库并测试5 控制台输出 1 新建实体类 public class MessageContent { private Integer id; private String title; private String message; private Date createDate; @Override ...
java jdbc映射实体_JdbcTemplate实体映射
weixin_36374366的博客
02-16 1493
JdbcTemplate实体映射如果你需要使用JdbcTemplate将查询的数据映射成Java POJO，那么这篇文章适合你。一个例子入门下面是一个将表中一行记录映射成Map的例子，也是JdbcTemplate默认提供的功能。List> result = jdbcTemplate.queryForList("select id, name, age from tbl");然而，我们更希望得...
JDBC与mysql数据类型的映射&通用crud操作的BaseDAO＜T＞的简单实现&dbutils工具类的简单使用
weixin_68366781的博客
04-26 1212
昨天通过druid连接mysql，使用dbutils工具类实现基本的crud操作，遇见了一个问题，后来发现是我javabean对象的数据类型错了，与数据库对不上号，今天总结一下mysql常用的数据类型在jdbc中的对应。 1 日期类型 日期与时间是重要的信息，在我们的系统中，几乎所有的数据表都用得到。我们需要知道数据的 时间标签，从而进行数据查询、统计和处理。 在mysql中常用的日期类型有: year 年 date ...
5种方法通过反射对JDBC的进行查询(简单的自己封装了一下)
最新发布
2301_77707071的博客
11-29 592
这里我们就以JavaBean当中的students为例进行结果演示。通过反射将你的JavaBean对象装入集合当中，最后返回集合。先看资源包,这里我们用到的是我红色框起来的资源包。结果如下，格式尽力在对齐了。
JDBC数据库链接封装及泛型与反射实践
总结来说，这篇文章深入探讨了JDBC数据库连接的封装，涉及了泛型、反射的应用，以及在Java中处理数据库连接的注意事项，包括单例模式的使用和垃圾回收问题。作者分享了学习过程中的挑战和对新技术的探索，表明了持续...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值