Java 利用反射、泛型实现dao层的增删改查

已于 2023-08-15 15:00:45 修改
阅读量7.1k 收藏 24
点赞数 4
分类专栏： java 文章标签： java 反射 dao 泛型
于 2016-02-26 17:42:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cuiyaoqiang/article/details/50751612
版权

Java利用反射实现dao层数据的增删改查，其中删除和修改没有必要使用反射，这里实现了增加、有条件的查询单个对象（单个条件），有条件的查询对象集合（单个条件）、有条件的查询单个对象（多个条件）。

实体层：

package com.bh.beans;

import java.util.Date;
//注意一定要有无参数的构造方法
public class UserInfo {
	
	private int id;
	private int age;
	private String name;
	private Date birth;
	
	public UserInfo(int id, int age, String name, Date birth) {
		super();
		this.id = id;
		this.age = age;
		this.name = name;
		this.birth = birth;
	}
	public UserInfo() {
		super();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
	@Override
	public String toString() {
		return "UserInfo [id=" + id + ", age=" + age + ", name=" + name
				+ ", birth=" + birth + "]";
	}
}

Dao层：

package com.bh.dao;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.bh.util.JdbcUtils_C3P0;

public class Dao {
	/**
	 * 解析出保存对象的sql语句
	 * @param object：需要保存的对象
	 * @return：保存对象的sql语句
	 */
	public static int getSaveObjectSql(Object object) {
		// 定义一个sql字符串
		String sql = "insert into ";
		// 得到对象的类
		Class<? extends Object> c = object.getClass();
		// 得到对象中所有的方法
		Method[] methods = c.getMethods();
		// 得到对象类的名字
		String cName = c.getName();
		// 从类的名字中解析出表名
		String tableName = cName.substring(cName.lastIndexOf(".") + 1,
				cName.length());
		sql += tableName + "(";
		List<String> mList = new ArrayList<String>();
		List<Object> vList = new ArrayList<Object>();
		for (Method method : methods) {
			String mName = method.getName();
			if (mName.startsWith("get") && !mName.startsWith("getClass")) {
				String fieldName = mName.substring(3, mName.length());
				if(fieldName.equals("Id")) break;
				mList.add(fieldName);
				try {
					Object value = method.invoke(object, null);//将该方法的返回值返回给调用者
					Class<?> returnType = method.getReturnType();

					String tpye=returnType.getName();
					switch (tpye) {
					case "int":

						break;
					case "java.util.Date":
						SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss z yyyy", java.util.Locale.US);
						Date date = sdf.parse(value.toString());
						value=new java.sql.Date(date.getTime());
						break;
					case "java.lang.String":
						value="'"+value+"'";
						break;

					default:
						break;
					}

					vList.add(value);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		for (int i = 0; i < mList.size(); i++) {
			if (i < mList.size() - 1) {
				sql += mList.get(i) + ",";
			} else {
				sql += mList.get(i) + ") values(";
			}
		}
		for (int i = 0; i < vList.size(); i++) {
			if (i < vList.size() - 1) {
				sql += vList.get(i) + ",";
			} else {
				sql += vList.get(i) + ")";
			}
		}
		System.out.println("增加语句："+sql);
		int result=0;
		try {
			result=	executeSql(sql);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}



	/**根据条件删除
	 * @param className
	 * @param param
	 * @param value
	 * @return
	 * @throws SQLException
	 */
	public int deleteObject(String className,String param,Object value) throws SQLException {
		// 得到表名字
		String tableName = className.substring(className.lastIndexOf(".") + 1,
				className.length());
		// 根据类名来创建Class对象
		Class<?> c = null;
		try {
			c = Class.forName(className);

		} catch (ClassNotFoundException e1) {

			e1.printStackTrace();
		}
		switch (value.getClass().getName()) {
		case "class java.lang.Integer":
			value=Integer.parseInt(value.toString());
			break;

		case "java.lang.String":
			value="'"+value+"'";
			break;

		default:
			break;
		}
		String sql = "delete  from " + tableName + " where " + param +"="+value;
		System.out.println("删除sql语句：" + sql);
		int result=0;
		try {
			result=	executeSql(sql);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}

	/**执行sql语句
	 * @param sql
	 * @return
	 * @throws SQLException
	 */
	public static int executeSql(String sql) throws SQLException {

		Connection con = JdbcUtils_C3P0.getConnection();
		try {
			PreparedStatement psmt = con.prepareStatement(sql);
			int result = psmt.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**查找返回单个对象
	 * @param className 返回结果对象类型
	 * @param param 查找条件key值
	 * @param value 查找条件value值
	 * @return
	 * @throws SQLException
	 */
	public Object getObject(String className,String param,Object value) throws SQLException {
		// 得到表名字
		String tableName = className.substring(className.lastIndexOf(".") + 1,
				className.length());
		// 根据类名来创建Class对象
		Class<?> c = null;
		try {
			c = Class.forName(className);

		} catch (ClassNotFoundException e1) {

			e1.printStackTrace();
		}
		switch (value.getClass().getName()) {
		case "class java.lang.Integer":
			value=Integer.parseInt(value.toString());
			break;

		case "java.lang.String":
			value="'"+value+"'";
			break;

		default:
			break;
		}
		String sql = "select * from " + tableName + " where " + param +"="+value;
		System.out.println("查找sql语句：" + sql);
		Connection con = JdbcUtils_C3P0.getConnection();
		// 创建类的实例
		Object obj = null;
		try {

			Statement stm = con.createStatement();
			// 得到执行查寻语句返回的结果集
			ResultSet rs = stm.executeQuery(sql);
			// 得到对象的方法数组
			Method[] methods = c.getMethods();
			// 遍历结果集
			while (rs.next()) {
				
				obj = c.newInstance();
				for (Method method : methods) {
					String methodName = method.getName();
					// 如果对象的方法以set开头
					if (methodName.startsWith("set")) {
						// 根据方法名字得到数据表格中字段的名字
						String columnName = methodName.substring(3,
								methodName.length());
						// 得到方法的参数类型
						Class[] parmts = method.getParameterTypes();
						if (parmts[0] == String.class) {
							// 如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法
							method.invoke(obj, rs.getString(columnName));
						}
						if (parmts[0] == int.class) {
							method.invoke(obj, rs.getInt(columnName));
						}
						if (parmts[0] == Date.class) {
							method.invoke(obj, rs.getDate(columnName));
						}
					}

				}
			}

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

	/**
	 * 查找 返回对象集合
	 * @param className 返回结果对象类型
	 * @param param 查找条件key值
	 * @param value 查找条件value值
	 * @return
	 * @throws SQLException
	 */
	public List<Object> getObjectList(String className,String param,Object value) throws SQLException {
		// 得到表名字
		String tableName = className.substring(className.lastIndexOf(".") + 1,
				className.length());
		// 根据类名来创建Class对象
		Class<?> c = null;
		try {
			c = Class.forName(className);
		} catch (ClassNotFoundException e1) {
			e1.printStackTrace();
		}
		switch (value.getClass().getName()) {
		case "class java.lang.Integer":
			value=Integer.parseInt(value.toString());
			break;

		case "java.lang.String":
			value="'"+value+"'";
			break;

		default:
			break;
		}
		String sql = "select * from " + tableName + " where " + param +"="+value;
		System.out.println("查找sql语句：" + sql);
		Connection con = JdbcUtils_C3P0.getConnection();
		List<Object> list = null;
		// 创建类的实例
		try {

			Statement stm = con.createStatement();
			// 得到执行查寻语句返回的结果集
			ResultSet rs = stm.executeQuery(sql);
			// 得到对象的方法数组
			Method[] methods = c.getMethods();
			list=new ArrayList<>();
			// 遍历结果集
			while (rs.next()) {
				Object	obj = c.newInstance();
				for (Method method : methods) {
					String methodName = method.getName();
					// 如果对象的方法以set开头
					if (methodName.startsWith("set")) {
						// 根据方法名字得到数据表格中字段的名字
						String columnName = methodName.substring(3,
								methodName.length());
						// 得到方法的参数类型
						Class[] parmts = method.getParameterTypes();
						if (parmts[0] == String.class) {
							// 如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法
							method.invoke(obj, rs.getString(columnName));
						}
						if (parmts[0] == int.class) {
							method.invoke(obj, rs.getInt(columnName));
						}
						if (parmts[0] == Date.class) {
							method.invoke(obj, rs.getDate(columnName));
						}
					}
				}
				list.add(obj);
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}
	/**根据多条件查找返回单个对象，多条件返回多个对象同理
	 * @param className 返回结果对象类型
	 * @param param 查找条件key值
	 * @param value 查找条件value值
	 * @return
	 * @throws SQLException
	 * 20160215新增
	 */
	@Override
	public Object getObject(String className,Map<String, Object> params) throws SQLException {
		// 得到表名字
		String tableName = className.substring(className.lastIndexOf(".") + 1,
				className.length());
		// 根据类名来创建Class对象
		Class<?> c = null;
		try {
			c = Class.forName(className);

		} catch (ClassNotFoundException e1) {

			e1.printStackTrace();
		}
		String sql;
		if(params!=null&&params.size()>0){

			Iterator<Entry<String, Object>> it=params.entrySet().iterator();       
			StringBuffer sbf=new StringBuffer(" where ");
			while(it.hasNext()){
				Map.Entry entry = (Map.Entry)it.next();          
				String key = entry.getKey().toString();          
				Object value=entry.getValue();          
				System.out.println(key+" ==== "+value+"  "+value.getClass().getName());                    

				switch (value.getClass().getName()) {
				case "java.lang.Integer":
					value=Integer.parseInt(value.toString());
					sbf.append(key+"="+value+" and ");
					break;

				case "java.lang.String":
					value="'"+value+"'";
					sbf.append(key+"="+value+" and ");
					break;

				default:
					break;
				}
			}
			sbf.delete(sbf.length()-4, sbf.length());
			 sql = "select * from " + tableName + sbf.toString();
		}else{
			
			 sql = "select * from " + tableName;
		}
		System.out.println("查找sql语句：" + sql);
		Connection con = JdbcUtils_C3P0.getConnection();
		// 创建类的实例
		Object obj = null;
		try {

			Statement stm = con.createStatement();
			// 得到执行查寻语句返回的结果集
			ResultSet rs = stm.executeQuery(sql);
			// 得到对象的方法数组
			Method[] methods = c.getMethods();
			// 遍历结果集
			while (rs.next()) {
				obj = c.newInstance();
				for (Method method : methods) {
					String methodName = method.getName();
					// 如果对象的方法以set开头
					if (methodName.startsWith("set")) {
						// 根据方法名字得到数据表格中字段的名字
						String columnName = methodName.substring(3,
								methodName.length());
						// 得到方法的参数类型
						Class[] parmts = method.getParameterTypes();
						if (parmts[0] == String.class) {
							// 如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法
							method.invoke(obj, rs.getString(columnName));
						}
						if (parmts[0] == int.class) {
							method.invoke(obj, rs.getInt(columnName));
						}
						if (parmts[0] == Date.class) {
							method.invoke(obj, rs.getDate(columnName));
						}
					}

				}
			}

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

测试类：

package com.bh.test;

import java.sql.SQLException;
import com.bh.dao.Dao;

public class Test {
	
	public static void main(String args[]) throws SQLException {
		//获得NetJavaSession对象
		Dao session = new Dao();
		//增加
		/*UserInfo user = new UserInfo();
		user.setAge(25);
		user.setName("zhangsan");
		user.setBirth(new Date());
		session.saveObject(user);*/
		//查找返回单个对象
		/*UserInfo userInfo = (UserInfo) session.getObject("com.bh.beans.UserInfo","name", "zhangsan" );
		System.out.println("UserInfo:" + userInfo);*/
		//查找返回集合
		/*List<Object> users=session.getObjectList("com.bh.beans.UserInfo","name", "zhangsan");
		for(int i=0;i<users.size();i++){
			System.out.println((UserInfo)users.get(i));
		}*/
		//删除
		int result=session.deleteObject("com.bh.beans.UserInfo","name", "zhangsan" );
		System.out.println("删除了"+result+" 行");
	}
}
崔耀强
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java之JDBC连接数据库实现增删改查(2018 使用Dao层实现)
09-25
Java之JDBC连接数据库实现增删改查(2018 使用Dao层实现) 实体类：User.java 接口类：IUserDao.java 实现接口类：UserDaoImpl.java 使用Junit4测试增删改查类：UserDaoTest.java
Java反射泛型，实现数据库的动态增删改查等功能
06-08
在Java中运用反射+泛型，实现数据库的动态增删改查等功能，可以是Mysql, 也可以是SQL Server，oracle 也行。本代码是支持SQL Server和oracle的。
java dao类 反射_Java 反射
weixin_42641869的博客
02-23 220
1.概述1.1 什么是反射java反射机制是指在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能调用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。1.2 为什么要使用反射正常的要实例化一个对象并调用sayHello方法ClassA objA = new ClassA();objA.sayHello();通过反射...
java做的Dao模式的增 删 改 查
09-22
java做的Dao模式的增，删，改，查，方便维护，修改。
java泛型集合增删查改_java学习笔记之分层增删改查
weixin_39791386的博客
02-24 193
1 public classProductWeb {2 public static voidmain(String[] args) {3 Scanner scanner=newScanner(System.in);4 while(true){5 System.out.println("请输入你的选择:");6 ...
java使用反射实现对数据库的增删改查
baidu_37789214的博客
06-20 5329
CurrentUtil 是一个分页工具类  在查找的时候使用 接口 package com.dao; import java.util.List; import com.util.CurrentUtil; public interface BaseDao { /** *@param t *@return *@作者Administrator *
java数据库增删改查操作实例（hibernate原理）支持泛型集合
06-07
写了一个通用java访问数据库操作的DAO类，非常简单，非常强大，非常方便，非常好用。绝对原版，绝对原创。把hibernate彻底扔掉。（根据C#改编的，原本我是搞C#开发的）支持泛型集合，让程序运行效率更高。
【微服务架构】-【接口设计】-使用SpringBoot开发Restful服务实现增删改查功能
最新发布
2301_82242988的博客
05-01 325
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
java数据库增删改查操作实例（hibernate原理）
05-29
本示例通过一个通用的DAO（Data Access Object）类，展示了如何在不依赖Hibernate等ORM框架的情况下，进行数据库的增删改查操作。这有助于理解底层的SQL执行过程，同时也提供了更灵活的控制权。 首先，DAO模式是一...
利用Java反射实现万能DAO
06-23
利用Java的反射机制实现的万能DAO工具类，包含对应的测试代码。具体功能包括：单表查询，多表查询，模糊查询，添加，修改，删除等。利用万能DAO可以对数据库中任意表进行操作，只需一个DAO类即可完成。阅读本代码需要掌握Java反射机制以及数据库DAO类基础。
mvc中dao层反射实现
12-18
里面包含java之mvc框架中的dao层反射，dao层里面方法的实现采取的都是反射机制，比较灵活
反射机制反射Dao 反射机制
06-17
反射反射反射反射反射反射反射反射反射反射反射反射反射反射反射反射
反射（DAO层的设计）<学习随笔>
强强强子的博客
08-28 1251
DAO public interface BaseDao {  void save(T entity);  void delete(Integer id);  void update(T entity);  T getById(Integer id);  List getByIds(Integer[] ids);  List findAll();  PageBean getPage
java泛型集合增删查改_Java 利用反射、泛型实现dao层的增删改查
weixin_42527160的博客
02-24 584
Java利用反射实现dao层数据的增删改查，其中删除和修改没有必要使用反射，这里实现了增加、有条件的查询单个对象(单个条件)，有条件的查询对象集合(单个条件)、有条件的查询单个对象(多个条件)。实体层：package com.bh.beans;import java.util.Date;//注意一定要有无参数的构造方法public class UserInfo {private int id;pr...
反射实现增删改查（DAO层）——插入数据
dfay89490的博客
05-19 620
先贴出代码，后续补充自己的思路、配置文件、使用方式： /** * 插入数据 */ @Override public void addObject(Object object, String tableName) { StringBuilder sql = new StringBuilder("INSERT " + tableName ...
基于Java的泛型和反射实现通用的增删改查(2)——通用增删改查操作的底层设计
如不來的博客
12-23 1380
一、设计理念  在互联网项目或者其他传统Web项目的开发过程中，对数据库的操作可以说是项目的核心和根本，而数据库操作无非就是增删改查，而对所有表的增删改查操作都大同小异，非常相似。如果我们能够将对单表的增删改查操作抽象出来放在父类中去实现，让所有的子类继承这个已实现了增删改查操作的父类，那么我们的工作效率无疑会大大地提升，也会使我们从这些简单无聊但又不得不去做的工作中解脱出来，将有限的精力投入到较...
java 反射 dao_Java通过反射机制简化Dao层的繁琐操作
weixin_34191434的博客
02-12 207
配置文件 jdbc.propertiesjdbc=jdbc:mysql://localhost:3306/wangyiDriver=com.mysql.jdbc.Drivername=rootpassword=123456Config.javapackage com.Wangyi.config;import java.io.IOException;import java.io.InputStrea...
【小白日记】JavaEE当中 JDBC通过Dao层实现增删改查 CRUD
WeiHaoLee
05-07 549
什么是DAO Data Access Object 数据访问对象 DAO层存在的意义 主要用于封装一些关于 项目当中对数据库访问的接口　实现分层开发，便于维护 DAO层与DAO的实现类 DAO层当中封装的接口 需要拿到DAO的实现类当中进行实现 @OVERRIDE 建立事例项目 目录结构 代码整理 UserDao.java DAO类 接口类 package com.sky.dao; /*...
JDBC通用增删改查基础类详解
本篇文章分享了如何使用JDBC实现通用的增删改查基础类方法，这对于初学者和有一定经验的Java开发者都具有很高的参考价值。作者基于自身的JDBC学习经历，强调了通过JDBC深入理解数据操作的重要性，并提供了名为`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值