利用反射完成初级万能DAO

一、目标

二、注意

1.Field[] fi = clazz.getDeclaredFields(); 

for(Field ff : fi){
ff.setAccessible(true);
ff.set(ob, rs.getObject(ff.getName()));
}

三、代码

package com.jikexueyuan.util;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;

import com.jikexueyuan.bean.AnType;
import com.jikexueyuan.bean.Animals;

public class BaseDAO {
	public ArrayList getList(Class cl){
		ArrayList ar = new ArrayList();
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		String sql = "select *  from "+cl.getSimpleName();
		Field[] fi = cl.getDeclaredFields();
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				Object ob = cl.newInstance();//ʵÀý»¯Àà¶ÔÏó
				for(Field ff : fi){
					ff.setAccessible(true);
					ff.set(ob, rs.getObject(ff.getName()));
				}
				ar.add(ob);

			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps, rs);
		}

		return ar;
	}
	public Object getObById(Class cl,int id){
		Object ob = null;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs =null;
		Field[] fi = cl.getDeclaredFields();
		String sql = "select * from "+cl.getSimpleName()+" where "+fi[0].getName()+" = "+id;
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				ob = cl.newInstance();
				for(Field ff : fi){
					ff.setAccessible(true);
					ff.set(ob,rs.getObject(ff.getName()));
				}

			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps, rs);
		}
		return ob;
	}
	public ArrayList getListBySome(Class cl ,String name,Object value){
		ArrayList ar = new ArrayList();
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		Field[] fi = cl.getDeclaredFields();
		String sql = "select * from "+cl.getSimpleName()+" where "+name+" = ‘"+value+"‘";
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				Object ob = cl.newInstance();
				for(Field ff : fi){
					ff.setAccessible(true);
					ff.set(ob, rs.getObject(ff.getName()));
				}
				ar.add(ob);
			}

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps, rs);
		}
		return ar;

	}
	public boolean insert(Object ob){
		boolean b = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Class cl = ob.getClass();
		Field[] fi = cl.getDeclaredFields();
		//insert into animals (name,age,anid) values(?,?,?)
		String sql = "insert into "+cl.getSimpleName()+" (";
		for(int i = 1;i<fi.length;i++){
			sql = sql+fi[i].getName();
			//4  0 1 2 3
			if(i!=fi.length-1){
				sql = sql+" , ";
			}
		}
		sql = sql+") values (";
		for(int i = 1;i<fi.length;i++){
			sql = sql+" ? ";
			if(i!=fi.length-1){
				sql = sql+" , ";
			}
		}
		sql = sql+")";
		try {
			ps = conn.prepareStatement(sql);
			for(int i = 1;i<fi.length;i++){
				fi[i].setAccessible(true);
				ps.setObject(i, fi[i].get(ob));
			}
			int a = ps.executeUpdate();
			if(a>0){
				b = true;
			}

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps);
		}
		return b;
	}
	public boolean insert1(Object ob){
		boolean b = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Class cl = ob.getClass();
		Field[] fi = cl.getDeclaredFields();
		StringBuffer sb = new StringBuffer();
		//insert into animals (name,age,anid) values(?,?,?)
		sb.append("insert into ");
		sb.append(cl.getSimpleName());
		sb.append(" (");
		for(int i = 1;i<fi.length;i++){
			sb.append(fi[i].getName());
			if(i!=fi.length-1){
				sb.append(" , ");
			}
		}
		sb.append(") values (");
		for(int i = 1;i<fi.length;i++){
			sb.append(" ? ");
			if(i!=fi.length-1){
				sb.append(" , ");
			}
		}
		sb.append(" ) ");
		try {
			ps = conn.prepareStatement(sb.toString());
			for(int i = 1;i<fi.length;i++){
				fi[i].setAccessible(true);
				ps.setObject(i, fi[i].get(ob));
			}
			int a = ps.executeUpdate();
			if(a>0){
				b = true;
			}

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps);
		}
		return b;
	}

	public boolean update(Object ob){
		boolean b = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Class cl = ob.getClass();
		Field[] fi = cl.getDeclaredFields();
		StringBuffer sb = new StringBuffer();
		//update animals set name = ?,age = ?,anid = ? where id = ?
		sb.append(" update ");
		sb.append(cl.getSimpleName());
		sb.append(" set ");
		for(int i = 1;i<fi.length;i++){
			fi[i].setAccessible(true);
			sb.append(fi[i].getName());
			sb.append(" = ? ");
			if(i!=fi.length-1){
				sb.append(" , ");
			}
		}
		sb.append(" where ");
		sb.append(fi[0].getName());
		sb.append("=?");

		try {
			ps = conn.prepareStatement(sb.toString());
			for(int i = 1;i<fi.length;i++){
				fi[i].setAccessible(true);
				ps.setObject(i, fi[i].get(ob));
			}
			fi[0].setAccessible(true);
			ps.setObject(fi.length, fi[0].get(ob));
			int a = ps.executeUpdate();
			if(a>0){
				b = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps);
		}
		return b;
	}

	public boolean delete(Class cl , int id){
		boolean b = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Field[] fi = cl.getDeclaredFields();
		String sql = "delete from "+cl.getSimpleName()+" where "+fi[0].getName()+" = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setObject(1, id);
			int a = ps.executeUpdate();
			if(a>0){
				b = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps);
		}
	return b ;

	}
	public boolean deleteBySome(Class cl , String name,Object value){
		boolean b = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Field[] fi = cl.getDeclaredFields();
		String sql = "delete from "+cl.getSimpleName()+" where "+name+" = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setObject(1, value);
			int a = ps.executeUpdate();
			if(a>0){
				b = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRes(conn, ps);
		}
	return b ;

	}
	public static void main(String[] args) {
		BaseDAO bd = new BaseDAO();
//		Animals an = new Animals();
//		an.setName("½ð¾ÅÅÖ");
//		an.setAge(15);
//		an.setAnId(1);
//		an.setId(3);
//		boolean b = bd.update(an);

		bd.deleteBySome(Animals.class, "name","½ð¾ÅÅÖ");
		//bd.delete(Animals.class, 5);
//		ArrayList<Animals> ar = bd.getList(Animals.class);
//		for(Animals an : ar){
//			System.out.println("±àºÅ£º"+an.getId()+"Ãû×Ö£º"+an.getName()+"ÄêÁä:"+an.getAge());
//		}
//		ArrayList<AnType> arr = bd.getList(AnType.class);
//		for(AnType an : arr){
//			System.out.println("±àºÅ£º"+an.getAnId()+"Ãû×Ö£º"+an.getAnName());
//		}
//		Animals an = (Animals)bd.getObById(Animals.class, 2);
//		System.out.println(an.getName());
//		ArrayList<Animals> ar = bd.getListBySome(Animals.class, "age", "13");
//		for(Animals an : ar){
//			System.out.println("±àºÅ£º"+an.getId()+"Ãû×Ö£º"+an.getName()+"ÄêÁä:"+an.getAge());
//		}
	}
}

  源代码:http://files.cnblogs.com/files/shamgod/Java-DAO-4-v2.7z

转自jikexueyuan

时间: 2024-12-07 04:57:12

利用反射完成初级万能DAO的相关文章

利用反射搭建项目的dao层,从此可以告别被人的dao层框架了(spring+反射)

作为一名刚入手的小白程序猿,不但"TA"不懂我们,就连自己都不懂自己,苦逼的程序猿,只能每天都是在给自己充电了.让"TA"和自己更了解.今天笔者又来吹吹水了,各位客官请买好零食咯,好了废话不多说了. 在以前做项目的时候,一般想到搭项目都是用别人的框架来做,但是别人的框架都是别人封装好的很多东西,对不太熟源码的码农来说就是苦逼呀,所以像笔者这种小白又不甘心,所以笔者就用反射来自己封装一个操作dao层的框架(不算一个框架,就是这么称呼吧),说起反射可能是很多像笔者这样的

java JDBC 万能DAO的实现的补充 实现了增删查改

有了这个类  ,基本后台的所有逻辑操作都能实现,后端雏形就算搭建出来了 说说写这个类遇到的坑 1.Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 6, Size: 6   ResultSetMetaData中的getColumnCount()方法是从1开始的 代码如下: resultSet = DbHelper.getStatement().executeQuery(sql); ResultS

java JDBC 万能DAO的实现

数据库和实体类设计好以后,有几个实体类就需要几个Dao吗?显然不是... 利用java的反射机制,一个Dao就可以实现对所有实体类的操作 思路就是,传过来一个实体类,利用实体类得到表,把实体类的每一个字段取出,放到表对应的字段.... 但是,如果实体类字段发生变化,这个时候往数据库插入数据就会出错,原因是表里面没有与实体类属性对应的字段, 这个时候就要用到java的反射机制了 我们首先需要得到表的所有字段,然后得到实体类的所有属性,两个一一比较,实体类中有的属性而数据库没有与之对应的字段,就舍去

利用反射处理多个表结构相同的数据的查询和数据库表的关联

最近做一个项目,需要对人口数据进行查询,但是人口数据分布在不同的街道表中,首先进行了数据表结构的统一,每个数据表以街道名开头,然后其他的名字都一样 前期将各个表中的字段也进行了统一 抽象出一张字典表 将街道编号和街道的名字的首字母连接起来,因为查询的时候是利用街道编号来的,这样可以根据街道标号拼出相对于的街道表的名字,(每个人口相关的表不止一张,因此需要统一):在查询过程中,将查询到的结构返回一个LIST,(不同的表在dao中当然对于不同的类啊,返回来再判断是哪一类),然后利用反射Field[]

利用反射来实现动态代理

实现动态代理,在mybaties中,不需要实现类框架帮创建,只需要 有一个dao接口就OK了 dao接口类 public interface UserDao { public void save(); public void delete(); public void uodate();} 实现类,只有增删该查方法 public class UserDaoImp implements UserDao { @Override public void save() { System.out.prin

利用反射技术实现POJO的数据库操作

记得第一次写项目的时候,傻傻的数据库一张表,代码里就写一个DAO类,几张表就写几个DAO类,大量的重复代码,自己粘着都嫌烦,后来接触了Hibernate,不得不说对我们这种小白用处还是很大的,那么多的实体类,一个DAO就可以实现基本的数据库操作了,于是我用的不亦乐乎,但到底是怎么做的,从来没有考虑过,现在用这些框架已经有一段时间了,原谅我脑洞大开,想自己实现一下这种类似的功能: 在准备写之前,我们需要一些规则: 1.由实体类名,可以知道我这个类是存放在哪张表里---这里我采用的是和t_类名 2.

利用反射实现工厂模式

需求:工厂类根据参数生成对应类的实例. 示例: RoomParts.cs namespace ReflectionFactory { /// <summary> /// 屋子产品的零件 /// </summary> public enum RoomParts { Roof, Window, Pillar } } ProductAttribute.cs using System; namespace ReflectionFactory { /// <summary> //

利用反射动态操作数组

java语言中,数组对象并不是从某个类实例化出来的,而是JVM动态创建的.对数组对象使用如下操作,可看到数组对应的Class对象.通过RTTI(Run-Time Type Information)可直接检查数组的运行时类型,以及它的签名.下方的 "[L"就是int[]/Integer[] 的运行类型. 1 Integer[] integers = (Integer[]) Array.newInstance(Integer.class,4); 2 System.out.println(i

C#利用反射,遍历获得一个类的所有属性名,以及该类的实例的所有属性的值

转自goldeneyezhang原文 C#利用反射,遍历获得一个类的所有属性名,以及该类的实例的所有属性的值 C#利用反射,遍历获得一个类的所有属性名,以及该类的实例的所有属性的值总结: 对应某个类的实例化的对象tc, 遍历获取所有属性(子成员)的方法(采用反射): Type t = tc.GetType();//获得该类的Type //再用Type.GetProperties获得PropertyInfo[],然后就可以用foreach 遍历了 foreach (PropertyInfo pi