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

最新推荐文章于 2022-08-24 09:57:57 发布
最新推荐文章于 2022-08-24 09:57:57 发布
阅读量2k 收藏
点赞数
分类专栏： 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
关注
专栏目录
JDBC 和数据库连接池
sunyusong666的博客
06-25 705
JDBC 和数据库连接池
JDBC连接mysql数据库
weixin_54236608的博客
10-20 1092
JDBC 环境 JDK1.8 第三方依赖：mysql-connector-java-8.0.15.jar 将依赖放到lib文件中，右键add as libiary 通过反射机制加载MySQL类驱动器：Class.forName("com.mysql.cj.jdbc.Driver") 创建Java与MySQL的连接通道：DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/数据库名?useUnicode=true&charact
JAVA反射机制和JDBC和各种数据库的连接
07-07
JAVA的反射机制 JDBC连接各种数据库的方法
JDBC 映射方式
伯恩大帝的博客
01-06 1190
1.映射成MAP方式 List list = this.createSqlQuery(sql, parameter).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list(); if(list!=null&&list.size()>0){ Map map = (Map)list.g
Java学习十四,JDBC,反射
土豆科技的博客
03-20 973
目录1.JDBC入门1.1.JDBC的概念1.1 JDBC的基本操作1.2 JDBC的API1.3 JDBC的CRUD操作(createStatement类)1.4 JDBC防sql注入(prepareStatement类)1.5 JDBC连接池2.反射入门2.1 反射的概述 1.JDBC入门 1.1.JDBC的概念 JDBC（Java Data Base Connectivity,java数据库...
关于MySQL到JDBC类型映射
数据矿工的博客
11-16 707
　 MySQL数据类型 JAVA数据类型 JDBC TYPE 普通变量类型 主键类型 1 BIGINT Long BIGINT 支持 支持 2 TINYINT Byte TINYINT 支持 不支持 3 SMALLINT Short SMALLINT 支持 不支持 ...
反射在JDBC中的使用
超域的博客
06-26 431
package com.sy.jdbcframework.test; import com.sy.jdbcframework.entity.Dept; import com.sy.jdbcframework.entity.Emp; import com.sy.jdbcframework.utils.DBUtils; import java.lang.reflect.Field; import...
Java-JDBC【源码】实现ORM，结果集映射实体类（ResultSet、注解、反射）
05-04
Java-JDBC【之】实现ORM，结果集映射实体类（ResultSet、注解、反射） 1.ORM实现思路 2.@Table、@Column、标识实体类 2.1.创建注解 @Table、@Column 2.2.标识实体类 2.3.数据库表 3.结果集解析，注解加反射填充实体...
JDBC操作数据库
weixin_44080194的博客
08-24 502
JDBC操作数据库流程，开启事务，设置隔离级别等，连接池
通过类反射机制实现底层数据库连接
08-31
对于注解实现连接数据库，这是现代开发中常见的方式。Hibernate支持使用注解来定义实体类，比如`@Entity`表示这个类是数据库中的一个表，`@Table`定义对应的表名，`@Id`标记主键字段，`@Column`定义列名等。这种方式...
通用的增删改查方法（反射）附带MySQL数据库连接
wxj123465的博客
11-07 1060
/**  * 数据库连接类  * getConnection获取一个Connection对象，利用的是从文件中读取配置文件，此处这个配置文件在项目下，不在包下。  * getPreparedStatement(String sql) 赋值前的preparedStatment  * setPreparedStatement(PreparedStatement statement, Objec
利用反射封装JDBC
qq_43538697的博客
08-20 1265
利用反射封装JDBC为什么用反射封装什么是Java的反射 为什么用反射封装 在上篇文章的封装中我没有用到反射去给实体类赋值，那么在这篇文章我将介绍一下java的反射机制，以及对DAO层(Data Access Object 数据访问层，也叫持久层，意思就是对数据永久化存储到硬盘（数据库）的封装)数据访问的封装。 什么是Java的反射 ...
JDBC连接方式2反射连接
qq_46093575的博客
05-15 220
一、JDBC连接方式2 使用反射加载Driver类，动态加载，减少依赖，更加灵活 package com.jun.jdbc; import java.sql.Connection; import java.sql.Driver; import java.util.Properties; /** * JDBC连接方式2 */ public class Jdbc02 { public static void main(String[] args) throws Exception{
JDBC:使用映射增加JDBC语句通用性
javy_codercoder的博客
10-16 672
以下是一段使用jdbc连接MySql的代码： public static void main(String[] args) { Connection conn = null; Statement state = null; ResultSet set = null; try { // 注册数据库驱动 DriverManager.registerDriver(n
JDBC日期类型的映射
qq_40678832的博客
11-15 543
JDBC中可以用以下三个类表示时间： Date:只表示日期； Time:只表示时间 Timestamp:表示一个精确的时间(日期+时间) 这三个类型都是java.util.Date 的子类；但存在java.sql包中； 三个类的例子如下 import java.sql.Time; import java.sql.Timestamp; import java.sql.Connection; imp...
简单的反射实现JDBC操作
Leon的博客
08-05 3142
创建User.java文件 /** 1. @Author: Chendc 2. @Date: 2019/7/23 19:57 */ public class User { private Long id; private String name; private Long age; private String email; public Lon...
数据库反射
Vicali的博客
12-08 508
通过 ResultSetMetaData 可以获得select语句产生的虚拟表的表结构(表名，列名，数据类型，列的个数) public static void main(String[] args) throws ClassNotFoundException, SQLException { 获得Connection对象 Class.forName("com.mysql.cj.jdbc.Driver"); String url="jdbc:mysql://localhost:3306/scho
jdbc连接数据库原理与反射机制
qq_44671288的博客
07-07 1317
JDBC（java dataBase Connectivity）：java语句使用JDBC来操作数据库，jdbc严格来说是java的一种规范。 Jdbc开发的步骤： 1.获得连接 2.通过连接来创建statement或者是preparedstatement 3.关闭资源 那我们先来了解一下什么是反射： 反射（Reflection）： java的反射机制是在运行状态中，对于任意的一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用他的任意方法和属...
JDBC数据库链接封装及泛型与反射实践
总结来说，这篇文章深入探讨了JDBC数据库连接的封装，涉及了泛型、反射的应用，以及在Java中处理数据库连接的注意事项，包括单例模式的使用和垃圾回收问题。作者分享了学习过程中的挑战和对新技术的探索，表明了持续...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值