java反射機制編寫簡單萬能DAO類

阿新 • • 發佈：2019-01-29

由於在搭建編寫萬能DAO時，已經寫了大量的程式碼

在此只給出部分的測試原始碼

如有需要完整專案或者有任何建議聯絡973639421

package com.oman.bean;

public class Person {
	private int id;
	private String name;
	private int age;
	private int type;
	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;
	}
	public int getType() {
		return type;
	}
	public void setType(int type) {
		this.type = type;
	}
	
	
}

package com.oman.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;

import com.oman.bean.Person;
import com.oman.util.BaseConnection;

public class PersonDao {
	
	//編寫普通查詢方法
	public ArrayList<Person> getList(){
		ArrayList<Person> list = new ArrayList<Person>();
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		String sql = "select * from Person";
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				Person person = new Person();
				person.setId(rs.getInt("id"));
				person.setName(rs.getString("name"));
				person.setAge(rs.getInt("age"));
				person.setType(rs.getInt("type"));
				list.add(person);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps, rs);
		}
		return list;
	}
	
	//編寫普通插入方法
	public boolean insert(Person person){

		boolean flag = false;
		
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		
		String sql = "insert into Person(name,age,type) values(?,?,?)";
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, person.getName());
			ps.setInt(2, person.getAge());
			ps.setInt(3, person.getType());
			int a = ps.executeUpdate();
			if(a > 0){
				flag = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag;
		
	}
	
	//編寫普通修改方法
	public boolean update(Person person){
		boolean flag = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		String sql = "update person set name = ?,age = ?,type = ? where id = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, person.getName());
			ps.setInt(2, person.getAge());
			ps.setInt(3, person.getType());
			ps.setInt(4, person.getId());
			int a = ps.executeUpdate();
			if(a>0){
				flag = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag;
	}
	
	
}

package com.oman.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class BaseConnection {
	
	//首先編寫一個獲取Connection的方法
	public static Connection getConnection (){
		Connection conn = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/school","root","root");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conn;
	}
	
	//其次編寫關閉資源的方法
	public static void closeRec(Connection conn,PreparedStatement ps){
		try {
			if(ps!=null){
				ps.close();
			}
			if(conn!=null){
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void closeRec(Connection conn,PreparedStatement ps,ResultSet rs){
		try {
			if(ps!=null){
				ps.close();
			}
			if(conn!=null){
				conn.close();
			}
			if(rs!=null){
				rs.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
}

package com.oman.util;

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

import com.oman.bean.Person;

//編寫萬能DAO類
public class BaseDao {

	//查詢所有
	public ArrayList getList(Class cl){
		ArrayList list = new ArrayList();
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		//由於資料庫中的表名對應的是實體類的類名，所以可以通過傳入的類得到表名cl.getSimpleName()
		String sql = "select * from " + cl.getSimpleName();
		//獲取類物件的所有屬性
		Field[] fi = cl.getDeclaredFields();
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				Object object = cl.newInstance();//例項化類物件
				for(Field ff:fi){
					ff.setAccessible(true);//開啟控制訪問許可權
					ff.set(object, rs.getObject(ff.getName()));
				}
				list.add(object);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps, rs);
		}
		return list;
	}

	//根據表的主鍵查詢表的物件
	public Object getObjectById(Class cl,int id){
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		Field[] fi = cl.getDeclaredFields();
		//由於類中不一定用id表示編號，但是通常類中的第一個屬性為編號id
		String sql = "select * from " + cl.getSimpleName() + " where " + fi[0].getName() + " = " + id;
		Object object = null;
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				object = cl.newInstance();
				for(Field ff:fi){
					ff.setAccessible(true);
					ff.set(object, rs.getObject(ff.getName()));
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps, rs);
		}
		return object;
	}
	
	//根據特定條件查詢
	public ArrayList getListByCondition(Class cl,String name,Object value){
		ArrayList list = new ArrayList();
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		
		String sql = "select * from " + cl.getSimpleName() + " where " + name + " = '" + value+"'";
		Field[] fi = cl.getDeclaredFields();
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				Object object = cl.newInstance();//例項化類物件
				for(Field ff:fi){
					ff.setAccessible(true);//開啟控制訪問許可權
					ff.set(object, rs.getObject(ff.getName()));
				}
				list.add(object);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps, rs);
		}
		return list;
	}
 	
	//插入物件
	public boolean insert(Object object){
		boolean flag = false;

		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		//獲取物件的類
		Class cl = object.getClass();
		Field[] fi = cl.getDeclaredFields();
				//insert into Person(name) values(?,?,?)
				//以下開始拼接sql語句
				//兩個String物件的連線是很耗費資源的，以下方法可以通過StringBuffer優化，
				//可以減少資源利用，使用apand對StringBuffer進行拼接
		String sql = "insert into " + cl.getSimpleName() + " (";
		for (int i = 1; i < fi.length; i++) {
			sql = sql + fi[i].getName();
			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(object));
			}
			int a = ps.executeUpdate();
			if(a > 0){
				flag = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag;

	}

	//優化插入
	public boolean insert1(Object object){
		boolean flag = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Class cl = object.getClass();
		Field[] fi = cl.getDeclaredFields();
		StringBuffer sb = new StringBuffer();
		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(object));
			}
			int a = ps.executeUpdate();
			if(a>0){
				flag = true;
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag;
	}
	
	//更新
	public boolean update(Object object){
		boolean flag = false;
		Connection conn = BaseConnection.getConnection();
		PreparedStatement ps = null;
		Class cl = object.getClass();
		Field[] fi = cl.getDeclaredFields();
		StringBuffer sb = new StringBuffer();
			//update person set name = ?,age = ?,type = ? 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(object));
			}
			fi[0].setAccessible(true);
			ps.setObject(fi.length, fi[0].get(object));
			int a = ps.executeUpdate();
			if(a>0){
				flag = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag;
	}
	
	//根據id刪除
	public boolean delete(Class cl , int id){
		boolean flag = 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){
				flag = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag ;
	
	}
	
	//根據特定條件刪除
	public boolean deleteByCondition(Class cl , String name,Object value){
		boolean flag = 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){
				flag = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			BaseConnection.closeRec(conn, ps);
		}
		return flag ;
	
	}

	
	public static void main(String[] args) {
		
		//測試getList()
		BaseDao baseDao = new BaseDao();
//		ArrayList<Person> plist = baseDao.getList(Person.class);
//		for(Person p:plist){
//			System.out.println("編號："+p.getId()+" 姓名："+p.getName()+" 年齡："+p.getAge());
//		}
			/*測試效果
				編號：1 姓名：小明 年齡：21
				編號：2 姓名：小華 年齡：22
				編號：3 姓名：李四 年齡：34
			*/
		
		//測試getObjectById()
//		Person person = (Person) baseDao.getObjectById(Person.class, 1);
//		System.out.println("編號："+person.getId()+" 姓名："+person.getName());
			/*測試效果
				編號：1 姓名：小明
			 */
		
		//測試getListByCondition()
//		ArrayList<Person> plist = baseDao.getListByCondition(Person.class,"name","李四");
//		for(Person p:plist){
//			System.out.println("編號："+p.getId()+" 姓名："+p.getName()+" 年齡："+p.getAge());
//		}
			/*測試效果
			  	編號：3 姓名：李四 年齡：34
			 */
		
		//測試insert()
//		Person person = new Person();
//		person.setName("王五");
//		person.setAge(44);
//		person.setType(2);
//		boolean flag = baseDao.insert(person);
//		if(flag == true){
//			System.out.println("插入成功");
//		}
			/*測試效果
			  	插入成功
			 */
		
		//測試update()
//		Person person = new Person();
//		person.setName("王五五");
//		person.setAge(444);
//		person.setType(2);
//		person.setId(4);
//		boolean flag = baseDao.update(person);
//		if(flag == true){
//			System.out.println("修改成功");
//		}
			/*測試效果
	  			修改成功
			 */
		
		//測試delete()與deleteBySome()
		boolean flag = baseDao.deleteByCondition(Person.class, "name","王五五");
		if(flag == true){
			System.out.println("刪除成功");
		}
			/*測試效果
				刪除成功
			 */
		//baseDao.delete(Person.class, 3);
	}
}

package com.oman.main;

import java.util.ArrayList;

import com.oman.bean.Person;
import com.oman.bean.Person_type;
import com.oman.dao.PersonDao;
import com.oman.dao.Person_typeDao;

public class TestMain {
	public static void main(String[] args) {
		
		PersonDao personDao = new PersonDao();
		ArrayList<Person> plist = personDao.getList();
		for(Person person : plist){
			System.out.println(person.getName());
		}
		
		System.out.println("------");
		
		Person_typeDao person_typeDao = new Person_typeDao();
		ArrayList<Person_type> ptlist = person_typeDao.getList();
		for(Person_type person_type : ptlist){
			System.out.println(person_type.getName());
		}
		
		
	}
}

java反射機制編寫簡單萬能DAO類

由於在搭建編寫萬能DAO時，已經寫了大量的程式碼在此只給出部分的測試原始碼如有需要完整專案或者有任何建議聯絡973639421 package com.oman.bean; public class Person { private int id; privat

Java反射機制的簡單應用

mod arc pos ret system containe java反射機制 track san 一直感覺java的反射機制非常強大，可是可用的地方不多。在android學習的時候。一直想實現掛斷電話的功能，可是

java反射機制——獲取位元組碼對應類中的函式

package cn.itcast.reflect.demo; import java.lang.reflect.Constructor; import java.lang.reflect.Method; //獲取類中的函式 public class ReflectDemo4 { public

java反射機制——獲取位元組碼對應類中的欄位

package cn.itcast.reflect.demo; import java.lang.reflect.Field; public class ReflectDemo3 { public static void main(String[] args) throws ClassNot

java反射機制——獲取位元組碼對應類的物件

package cn.itcast.reflect.demo; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import cn.itcast.bean.demo

JAVA反射機制的簡單例項和說明

一：反射機制的作用主要是： 1：可以將.class檔案轉為.java檔案，實現反編譯 2：可以通過類的名字得到這個JAVA物件中所有的屬性和方法。 3：用的最多的就是spring框架了。因為我們在配置檔案中配置好類的應射關係後，就可以通過反射機制自動找它的屬性和方法了。框架

java反射機制及簡單工廠模式

This is Product A! This is Product B!以下方式，是未使用反射機制的簡單工廠類，根據判斷邏輯來建立具體產品 public class Factory{ public static Product getProduct(int product_index){ i

利用java反射機制實現javaweb自動呼叫類的方法

public class BookServlet extends HttpServlet { private static final long serialVersionUID = 1L; protected void doGet(HttpServletRequ

Java反射機制demo（五）—獲得並調用一個類中的方法

color 擁有 oca logs over super getmethod equals() bool 這個demo在使用反射機制操作屬性之前，主要原因是因為在.class文件字節碼中，方法排在屬性的前面。 1，獲得一個類中的方法先看一下方法和運行結果。獲取所有的方

java反射機制和Class類

面向物件思想一切皆物件類也是物件，Class類的物件，java.lang.Class Class類的構造器是私有的，只有虛擬機器可以直接建立它的物件，有三種建立方式：類.class、類物件.getClass、Class.forName 靜態載入：new，發生在編譯的時候動態載

Java反射機制的原理及在Android下的簡單應用

package crazypebble.reflectiontest;import java.lang.reflect.Constructor;import java.lang.reflect.Method;publicclass LoadMethod { /** * 在執行時載入指定的類，並呼

Java中的類載入和Class.forName()；java反射機制與原理

對於大部分人來說，第一次見到class.forName(String className)這句程式碼應該是在使用jdbc方式連線資料庫的時候。但這句程式碼本質上是什麼含義，做了什麼工作呢？本文將回答此問題。理解Class.forName方法需要一些知識鋪墊，也就是

java反射機制，註解類解讀

1.元資料的英文關於資料的組織，域資料及其關係的資訊，簡言之，元資料就是關於資料的資料（英文：間位），不同的領域有不同的理解：在軟體構造領域，元資料被定義為：。在程式中不是被加工的物件，而是通過其值的改變來改變程式的行為的資料它在執行過程中起著以解釋方式控制程式行為的作用在程

Java 反射機制的超簡單例項分析

菜鳥第一次寫這啥部落格呵呵就前幾天面試面試官提到的Java反射機制沒有回答上來回來鑽研了一下只是一些很淺顯的東西菜鳥而已(高手們懂的) 廢話不多說言歸正傳一什麼是 Java反射機制有什麼用（1）： JAVA反射機制是

java反射機制簡單例子

package com.yemaozi.reflect;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;public cla

通過java反射機制，獲取物件的屬性和值（包括所有繼承的父類）

java的反射機制提供了兩種方法： getDeclaredFields() ：該方法能獲取到本類的所有屬性，包括private，protected和public，但不能獲取到繼承的父類的屬性。 getFields()：既能獲取本類的屬性也能得到父類的

Java型別資訊與用反射機制編寫通用的Excel匯入匯出

Java類檔案編譯後，會在類中新增一個靜態屬性，這個屬性就是Class類的例項，用於描述型別資訊。描述類資訊的架構圖如： Class物件提供了一組方法，讓我們可以方便獲取類的屬性，方法，構造方法等資訊，並且用Field,Method,Constructor類

java反射機制以及通過反射獲得類的變數欄位，方法，建構函式

Class clz =Class.forName("day_29_ReflectAndJson.Person"); //前面獲取本類及其父類共有的方法就不再寫了直接獲得本類中的所有方法並傳引數後呼叫本方法 Method[] method=clz.getDec

java反射機制運用到BaseDao等通用基類

反射中主要應用的方法： 1.獲取類的Class物件推薦使用：第一種。通過Class.forName獲取Class物件. //方式1：通過Class.forName獲取Class物件.Class clazz1 = Class.forName("cn.itcast.

利用java反射機制一次性呼叫實體類get和set方法，簡化更多程式碼。

外部呼叫getProperty方法時只需要傳入實體物件即可；例如TestUtil.getProperty(new User()); 外部呼叫setProperty方法時只需要傳入實體物件和要set的值即可；例如TestUtil.setProperty(new User()

java反射機制編寫簡單萬能DAO類

相關推薦