数据库工具类（二）

最新推荐文章于 2022-03-13 19:53:25 发布

无双孟堂

最新推荐文章于 2022-03-13 19:53:25 发布

阅读量269

点赞数

通过调用DataBaseClass实现调用

DataBaseClass类

package com.lbf.database;

import java.sql.*;
import java.util.*;

/**
 * 数据库访问操作类（操作数据库时使用）
 * @author Wing.King
 */
public class DataBaseClass 
{
	private static final ThreadLocal<Connection> THREAD_LOCAL = new ThreadLocal<Connection>();//数据库连接集合
	
	private static boolean isDriver=false;//数据库驱动是否加载成功（默认失败）
	private static String errorDriver="NO";//数据库驱动是否加载成功（错误消息）
	
	private static String DRIVER="";//加载数据库驱动
	private static String DATABASE="";//数据库连接字符串
	private static String USERNAME="";//数据库登录用户名
	private static String PASSWORD="";//数据库登录密码
	
	/**
	 * 静态构造函数：关联类。当首次使用该类时，该静态构造函数就会被系统调用。
	 * 当首次使用该类时，类中的代码才会被系统加载到代码区。
	 * 加载数据库的驱动
	 */
	static { 
		try { 
			//1.知道数据库的连接字符串：数据库IP地址,端口号码,数据库名称,登陆账户,密码（决定连接哪一个数据库）。
			DataBaseClass.DRIVER=PropertiesReader.getConnectionKey("driver");//读取配置文件中的内容
			DataBaseClass.DATABASE=PropertiesReader.getConnectionKey("dataBase");//读取配置文件中的内容
			DataBaseClass.USERNAME=PropertiesReader.getConnectionKey("userName");//读取配置文件中的内容
			DataBaseClass.PASSWORD=PropertiesReader.getConnectionKey("passWord");//读取配置文件中的内容
			
			//2.加载数据库驱动（决定操作什么类型的数据库。是SQL还是Oracle）
			Class.forName(DataBaseClass.DRIVER);//Class.forName()函数的本意不是用来加载数据库驱动。本意加载类，将类读取到内存中。
			DataBaseClass.isDriver=true;
			DataBaseClass.errorDriver="OK";
		} catch(ClassNotFoundException e) { 
			DataBaseClass.isDriver=false;
			DataBaseClass.errorDriver=e.getMessage();//System.err.println("加载数据库驱动失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
	
	/**
	 * 构造函数：关联对象。每创建一个类的实例是会被系统自动调用（new创建对象时）。
	 * 私有构造函数，用于说明该类在类的外部不能被实例化
	 */
	private DataBaseClass() { 
		//
	}
	
	/**
	 * 创建并获取数据库连接
	 * @return 数据库连接
	 * @throws DataBaseException 
	 */
	private static Connection getConnection() throws DataBaseException { 
		if (!DataBaseClass.isDriver) { 
			throw new DataBaseException("加载数据库驱动失败！Error:"+DataBaseClass.errorDriver);
		}
		//3.建立数据库连接
		Connection conn=(Connection)DataBaseClass.THREAD_LOCAL.get();
		try { 
			if (conn==null || conn.isClosed()) { 
				conn=DriverManager.getConnection(DataBaseClass.DATABASE,DataBaseClass.USERNAME,DataBaseClass.PASSWORD);//创建数据库连接
				//通过DriverManager.getConnection()函数获得一个数据库连接对象，该对象根据加载的数据库驱动的不同而不同。
				//不论Oralce，还是SQL所建立的这个对象都继承Connection。
				DataBaseClass.THREAD_LOCAL.set(conn);
				System.out.println("数据库连接已开启");
			}
		} catch (SQLException e) {
			throw new DataBaseException("创建数据库连接失败！Error:"+e.getMessage());//System.err.println("创建数据库连接失败！Error:"+e.getMessage());//e.printStackTrace();
		}
		return conn;
	}
	
	/**
	 * 开始一个事务
	 * @throws DataBaseException 
	 */
	public static void beginTransaction() throws DataBaseException {
		Connection conn=DataBaseClass.getConnection();
		try {
			conn.setAutoCommit(false);
			System.out.println("数据库事务已开启");
		} catch (SQLException e) {
			throw new DataBaseException("开始数据库事务失败！Error:"+e.getMessage());//System.err.println("开始数据库事务失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
	
	/**
	 * 结束一个事务
	 * @throws DataBaseException
	 */
	private static void endTransaction() throws DataBaseException {
		Connection conn=DataBaseClass.getConnection();
		try {
			conn.setAutoCommit(true);
			System.out.println("数据库事务已结束");
		} catch (SQLException e) {
			throw new DataBaseException("结束数据库事务失败！Error:"+e.getMessage());//System.err.println("结束数据库事务失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
	
	/**
	 * 提交事务
	 * @throws DataBaseException 
	 */
	public static void commit() throws DataBaseException {
		Connection conn=DataBaseClass.getConnection();
		try {
			conn.commit();
			System.out.println("数据库事务已提交");
		} catch (SQLException e) {
			throw new DataBaseException("提交数据库事务失败！Error:"+e.getMessage());//System.err.println("提交数据库事务失败！Error:"+e.getMessage());//e.printStackTrace();
		}
		DataBaseClass.endTransaction();
		DataBaseClass.closeConnection();
	}
	
	/**
	 * 回滚事务
	 * @throws DataBaseException 
	 */
	public static void rollback() throws DataBaseException {
		Connection conn=DataBaseClass.getConnection();
		try {
			conn.rollback();
			System.out.println("数据库事务已回滚");
		} catch (SQLException e) {
			throw new DataBaseException("回滚数据库事务失败！Error:"+e.getMessage());//System.err.println("回滚数据库事务失败！Error:"+e.getMessage());//e.printStackTrace();
		}
		DataBaseClass.endTransaction();
		DataBaseClass.closeConnection();
	}
	
	/**
	 * 创建SQL数据库操作对象
	 * @return 数据库操作对象
	 * @throws DataBaseException
	 */
	private static Statement createSqlCommand() throws DataBaseException { 
		Connection conn=DataBaseClass.getConnection();
		try { 
			return conn.createStatement();//无参数创建文本
		} catch (SQLException e) {
			throw new DataBaseException("创建数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
	
	/**
	 * 创建SQL数据库操作对象
	 * @param sql sql语句
	 * @param params sql参数
	 * @return 数据库操作对象
	 * @throws DataBaseException
	 */
	private static PreparedStatement createSqlCommand(String sql,Object[] params) throws DataBaseException { 
		Connection conn=DataBaseClass.getConnection();
		try { 
			if (params!=null && params.length>0) { 
				PreparedStatement cmdTemp=conn.prepareStatement(sql);//有参数创建预编译操作对象
				for (int i=0;i<params.length;i++) { 
					if (params[i] instanceof java.util.Date) { 
						java.util.Date temp=(java.util.Date)params[i];
						java.sql.Date date=new java.sql.Date(temp.getTime());
						cmdTemp.setDate(i+1, date);
					} else { 
						cmdTemp.setObject(i+1, params[i]);
					}
				}
				return cmdTemp;
			} else { 
				throw new SQLException("操作参数不存在.");
			}
		} catch (SQLException e) {
			throw new DataBaseException("创建数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
	
	/**
	 * 执行数据库操作:添加，修改，删除
	 * @param sql 执行的SQL语句
	 * @return 执行语句所影响的行数（大于0执行成功）。
	 * @throws DataBaseException
	 */
	public static int executeUpdate(String sql) throws DataBaseException { 
		try { 
			return DataBaseClass.createSqlCommand().executeUpdate(sql);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:添加，修改，删除
	 * @param sql 执行的SQL语句
	 * @param params 执行SQL语句所需的参数
	 * @return 执行语句所影响的行数（大于0执行成功）。
	 * @throws DataBaseException
	 */
	public static int executeUpdate(String sql,Object[] params) throws DataBaseException { 
		try { 
			return DataBaseClass.createSqlCommand(sql, params).executeUpdate();
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:查询（通用集合）
	 * @param sql 执行的SQL语句
	 * @return 持久化后的查询结果
	 * @throws DataBaseException
	 */
	public static DataTable executeReader(String sql) throws DataBaseException { 
		try { 
			ResultSet rs=DataBaseClass.createSqlCommand().executeQuery(sql);
			return new DataTable(rs);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:查询（通用集合）
	 * @param sql 执行的SQL语句
	 * @param params 执行SQL语句所需的参数
	 * @return 持久化后的查询结果
	 * @throws DataBaseException
	 */
	public static DataTable executeReader(String sql,Object[] params) throws DataBaseException { 
		try { 
			ResultSet rs=DataBaseClass.createSqlCommand(sql, params).executeQuery();
			return new DataTable(rs);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:查询（类的反射）
	 * @param sql 执行的SQL语句
	 * @param className 持久化反射类
	 * @return 持久化后的查询结果
	 * @throws DataBaseException
	 */
	public static List<Object> executeQuery(String sql,String className) throws DataBaseException { 
		try {  
			ResultSet rs=DataBaseClass.createSqlCommand().executeQuery(sql);
			return Persistence.loadResultToSet(rs, className);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:查询（类的反射）
	 * @param sql 执行的SQL语句
	 * @param params 执行SQL语句所需的参数
	 * @param className 持久化反射类
	 * @return 持久化后的查询结果
	 * @throws DataBaseException
	 */
	public static List<Object> executeQuery(String sql,Object[] params,String className) throws DataBaseException { 
		try { 
			ResultSet rs=DataBaseClass.createSqlCommand(sql, params).executeQuery();
			return Persistence.loadResultToSet(rs, className);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:查询（函数回调）
	 * @param sql 执行的SQL语句
	 * @param handle 持久化操作类
	 * @return 持久化后的查询结果
	 * @throws DataBaseException
	 */
	public static List<Object> executeQuery(String sql,DataBaseListener handle) throws DataBaseException { 
		try { 
			ResultSet rs=DataBaseClass.createSqlCommand().executeQuery(sql);
			return handle.entity(rs);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 执行数据库操作:查询（函数回调）
	 * @param sql 执行的SQL语句
	 * @param params 执行SQL语句所需的参数
	 * @param handle 持久化操作类
	 * @return 持久化后的查询结果
	 * @throws DataBaseException
	 */
	public static List<Object> executeQuery(String sql,Object[] params,DataBaseListener handle) throws DataBaseException { 
		try {  
			ResultSet rs=DataBaseClass.createSqlCommand(sql, params).executeQuery();
			return handle.entity(rs);
		} catch (DataBaseException e) { 
			throw e;
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally { 
			DataBaseClass.closeConnection();
		}
	}
	
	/**
	 * 关闭数据库连接
	 * @param conn 数据库的连接
	 * @throws DataBaseException 
	 */
	private static void closeConnection() throws DataBaseException { 
		Connection conn=(Connection)DataBaseClass.THREAD_LOCAL.get();
		try { 
			//5.关闭数据库连接。
			if (conn!=null && !conn.isClosed()) { 
				if (conn.getAutoCommit()) {
					conn.close();
					DataBaseClass.THREAD_LOCAL.set(null);
					System.out.println("数据库连接已关闭");
				}
			}
		} catch (SQLException e) { 
			throw new DataBaseException("执行数据库操作失败！Error:"+e.getMessage());//System.err.println("关闭数据库连接失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
}

DataBaseException类

package com.lbf.database;

import java.sql.SQLException;

/**
 * 数据库访问异常类
 * @author Wing.King
 */
public class DataBaseException extends SQLException {
	/**
	 * 
	 */
	private static final long serialVersionUID = -53992627346981792L;
	
	public DataBaseException() {
		super();
	}
	
	public DataBaseException(String message) {
		super(message);
	}
}

DataBaseListener类

package com.lbf.database;

import java.sql.*;
import java.util.*;

/**
 * 数据持久化接口
 * @author Wing.King
 */
public interface DataBaseListener { 
	/**
	 * 数据持久化函数
	 * @param rs 查询结果集
	 * @return 持久化的数据
	 */
	public List<Object> entity(ResultSet rs) throws SQLException;
}

DataTable类

package com.lbf.database;

import java.sql.*;
import java.util.*;

/**
 * 持久化数据库表
 * @author Wing.King
 */
public class DataTable { 
	private ArrayList<String> columnList=new ArrayList<String>();//保存表的列名
	private ArrayList<ArrayList<Object>> dataList=new ArrayList<ArrayList<Object>>();//表的内容（每一行数据）
	
	public DataTable(ResultSet rs) throws SQLException { 
		ResultSetMetaData rsmd=rs.getMetaData();//获取查询结果集的结构
		for (int i=1;i<=rsmd.getColumnCount();i++) { 
			this.columnList.add(rsmd.getColumnName(i));
		}
		while(rs.next()) { 
			ArrayList<Object> row=new ArrayList<Object>();
			for (int i=1;i<=rsmd.getColumnCount();i++) { 
				row.add(rs.getObject(i));
			}
			this.dataList.add(row);
		}
	}
	
	/**
	 * 获取查询结果首行首列值
	 * @return Object数值
	 */
	public Object getFirstValue() { 
		return this.dataList.get(0).get(0);
	}
	
	/**
	 * 获取查询结果任意一行一列的值
	 * @param row 行的索引
	 * @param col 列的索引
	 * @return Object数值
	 */
	public Object getValue(int row,int col) { 
		return this.dataList.get(row).get(col);
	}
	
	/**
	 * 获取查询结果行的数量
	 * @return int行数
	 */
	public int getRowCount() { 
		return this.dataList.size();
	}
	
	/**
	 * 获取查询结果列的数量
	 * @return int列数
	 */
	public int getColumnCount() { 
		return this.columnList.size();
	}
	
	/**
	 * 获取查询结果列的名称
	 * @param index 列索引
	 * @return String列名
	 */
	public String getColumnName(int index) { 
		return this.columnList.get(index);
	}
}

Persistence类

package com.guigu.macheng.database.core;

import java.sql.*;
import java.util.*;
import java.lang.reflect.*;
import com.guigu.macheng.database.core.map.*;

/**
 * 持久化处理类（反射处理）
 * @author Wing.King
 */
public class Persistence { 
    public static ArrayList<Object> loadResultToSet(ResultSet rs,String className) throws SQLException { 
        Class<?> demo = null;
        ArrayList<MappingData> mapList=new ArrayList<MappingData>();
        //=========================================================================
        try { 
            demo = Class.forName(className);
            Field[] field=demo.getDeclaredFields();
            for (int i=0;i<field.length;i++) { 
                MappingData map=new MappingData();
                map.getMappingClass().setName(field[i].getName());
                map.getMappingClass().setType(field[i].getType().getName());
                mapList.add(map);
            }
        } catch (Exception e) { 
            e.printStackTrace();
        }
        //=========================================================================
        ResultSetMetaData rsmd=rs.getMetaData();//获取结果集的结构
        for (int i=1;i<=rsmd.getColumnCount();i++) { 
            String name=rsmd.getColumnName(i);
            String type=rsmd.getColumnTypeName(i);
            for (int j=0;j<mapList.size();j++) { 
                if (mapList.get(j).getMappingClass().getName().equalsIgnoreCase(name)) { 
                    mapList.get(j).getMappingTable().setName(name);
                    mapList.get(j).getMappingTable().setType(type);
                    break;
                }
            }
        }
        //=========================================================================
        ArrayList<Object> dataSet=new ArrayList<Object>();
        try { 
            while(rs.next()) { 
                Class<?> temp = Class.forName(className);
                Object obj = temp.newInstance();
                for (int i=0;i<mapList.size();i++) { 
                    String name=mapList.get(i).getMappingClass().getName();
                    String type=mapList.get(i).getMappingClass().getType();
                    if(mapList.get(i).getMappingClass().getName().equalsIgnoreCase(mapList.get(i).getMappingTable().getName())){
                        Object value=rs.getObject(mapList.get(i).getMappingTable().getName());
                        Persistence.setter(obj,name,value,Class.forName(type));
                    }
                }
                dataSet.add(obj);
            }
        } catch(Exception e) { 
            dataSet=null;
            e.printStackTrace();
        }
        return dataSet;
    }
    
    /**
     * 执行实体Bean的get方法
     * @param obj 操作的对象
     * @param att 操作的属性
     */
    public static void getter(Object obj, String att) { 
        try { 
            att=att.replaceFirst(att.substring(0,1),att.substring(0,1).toUpperCase());
            Method method=obj.getClass().getMethod("get"+att);
            System.out.println(method.invoke(obj));
        } catch (Exception e) { 
            e.printStackTrace();
        }
    }
 
    /**
     * 执行实体Bean的set方法
     * @param obj 操作的对象
     * @param att 操作的属性
     * @param value 设置的值
     * @param type 参数的属性
     */
    public static void setter(Object obj, String att, Object value, Class<?> type) { 
        try { 
            att=att.replaceFirst(att.substring(0,1),att.substring(0,1).toUpperCase());
            Method method=obj.getClass().getMethod("set"+att,type);
            String[] strList=type.toString().split("\\.");
            String strType=strList[strList.length-1];
            if(strType.equals("Long")) { 
                method.invoke(obj,Long.parseLong(value.toString()));
            } else if(strType.equals("Integer")) { 
                method.invoke(obj,Integer.parseInt(value.toString()));
            } else if(strType.equals("Float")) { 
                method.invoke(obj,Float.parseFloat(value.toString()));
            } else if(strType.equals("Double")) { 
                method.invoke(obj,Double.parseDouble(value.toString()));
            } else { 
                method.invoke(obj,value);
            }
        } catch (Exception e) { 
            e.printStackTrace();
        }
    }
}

PropertiesReader类

package com.lbf.database;

import java.io.*;
import java.util.*;

/**
 * 数据库配置文件读取类
 * @author Wing.King
 */
class PropertiesReader { 
	/**
	 * 构造函数：关联对象。每创建一个类的实例是会被系统自动调用（new创建对象时）。
	 * 私有构造函数，用于说明该类在类的外部不能被实例化
	 */
	private PropertiesReader() { 
		//
	}
	
	/**
	 * 返回数据库连接字符串的数据
	 * @param KeyName连接名称（driver:数据库驱动;dataBase:数据库连接;userName:用户名称;passWord:用户密码;）
	 * @return 连接内容
	 */
	public static String getConnectionKey(String keyName) { 
		String keyValue="";
		InputStream inputStream = null;
		try { 
			//读取config.properties文本文件的内容，将其保存到inputStream对象中
			inputStream = PropertiesReader.class.getClassLoader().getResourceAsStream("config.properties");//文件的读取对象，类似FileReader
			//创建操作config.properties配置文件的对象
			Properties format=new Properties();//文件的读取格式，类似BufferedReader
			//将文件的内容和操作文件的对象相关联
			format.load(inputStream);//将文件读取和文件读取格式相关联
			//输入键名，返回对应的键值
			keyValue=format.getProperty(keyName);//通过键名获取键值
		} catch (FileNotFoundException e) { 
			System.err.println("数据库配置文件“config.properties”,不存在！");
			e.printStackTrace();
		} catch (IOException e) { 
			System.err.println("数据库配置文件“config.properties”,读取失败！");
			e.printStackTrace();
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return keyValue;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) { 
		System.out.println(PropertiesReader.getConnectionKey("driver"));
	}
}

TransactionProxy类

package com.lbf.database;

import java.lang.reflect.*;

/**
 * 数据库操作：事务代理
 * @author macheng
 */
public class TransactionProxy implements InvocationHandler { 
	
    private Object action;//这个就是我们要代理的真实对象
    
    /**
     * 获取代理对象
     * @param className 被代理对象的类名
     * @param isProxy 是否返回代理对象（true代理对象，false源对象）
     * @return 代理对象|源对象
     * @throws Throwable 
     */
	public static Object getInstance(String className,boolean isProxy) throws DataBaseException { 
		if (isProxy) { 
			try {
				return TransactionProxy.getInstance(Class.forName(className).newInstance());
			} catch (InstantiationException e) {
				throw new DataBaseException("获取事务代理对象失败！Error:"+e.getMessage());//e.printStackTrace();
			} catch (IllegalAccessException e) {
				throw new DataBaseException("获取事务代理对象失败！Error:"+e.getMessage());//e.printStackTrace();
			} catch (ClassNotFoundException e) {
				throw new DataBaseException("获取事务代理对象失败！Error:"+e.getMessage());//e.printStackTrace();
			}
		} else { 
			try {
				return Class.forName(className).newInstance();
			} catch (InstantiationException e) {
				throw new DataBaseException("获取业务的源对象失败！Error:"+e.getMessage());//e.printStackTrace();
			} catch (IllegalAccessException e) {
				throw new DataBaseException("获取业务的源对象失败！Error:"+e.getMessage());//e.printStackTrace();
			} catch (ClassNotFoundException e) {
				throw new DataBaseException("获取业务的源对象失败！Error:"+e.getMessage());//e.printStackTrace();
			}
		}
	}
	
    /**
     * 获取代理对象
     * @param className 被代理对象的类名
     * @return 代理对象
     * @throws Throwable 
     */
	public static Object getInstance(String className) throws DataBaseException { 
		return TransactionProxy.getInstance(className, true);
	}
    
    /**
     * 获取代理对象
     * @param action 被代理对象
     * @return
     */
	public static Object getInstance(Object action) throws DataBaseException { 
		/*
         * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数。
         * 第一个参数 handler.getClass().getClassLoader()，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象。
         * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了。
         * 第三个参数handler，我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上。
         */
		
		//创建一个动态的代理对象
		//loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载。
		//interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了。
		//h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上。
		try {
			Object proxy=Proxy.newProxyInstance(
					action.getClass().getClassLoader(),//取得当前对象所属的Class对象后，在获取该Class对象的类装载器。
					action.getClass().getInterfaces(), //获取当前对象的实现接口Class对象数组。
					new TransactionProxy(action)     //创建代理类的实例，并和被代理类关联。
			);
	    	return proxy;
		} catch (Throwable e) {
			throw new DataBaseException("创建事务代理对象失败！Error:"+e.getMessage());//e.printStackTrace();
		}
	}
	
    /**
     * 构造方法：给我们要代理的真实对象赋初值
     * @param action 被代理的对象
     */
    private TransactionProxy(Object action) { 
        this.action=action;
    }
    
	/**
	 * 执行函数的返回结果
	 * @param proxy 指代我们所代理的那个真实对象
	 * @param method 指代的是我们所要调用真实对象的某个方法的Method对象
	 * @param args 指代的是调用真实对象某个方法时接受的参数
	 * @return
	 * @throws Throwable
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws DataBaseException {
        try {
    		//在代理真实对象前我们可以添加一些自己的操作
            this.doBefore();//代理前动作
    		//当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        	Object object = method.invoke(action, args);//System.out.println("Method:" + method);
			DataBaseClass.commit();
			return object;
		} catch (Throwable e) {
			DataBaseClass.rollback();
			throw new DataBaseException("执行事务代理操作失败！Error:"+e.getMessage());//e.printStackTrace();
		} finally {
	        //在代理真实对象后我们也可以添加一些自己的操作
	        this.doAfter();//代理后动作
		}
    }
	
	/**
	 * 代理前动作
	 * @throws Throwable 
	 */
	public void doBefore() throws DataBaseException { 
		DataBaseClass.beginTransaction();//System.out.println("开始事务...");//代理前动作
	}
	
	/**
	 * 代理后动作
	 * @throws Throwable 
	 */
	public void doAfter() throws DataBaseException { 
		//DataBaseClass类事务提交或事务回滚后自动结束事务//System.out.println("结束事务...");//代理后动作
	}
}

MappingClass类

package com.lbf.database.map;

import java.io.Serializable;

/**
 * 数据映射类（类）
 */
public class MappingClass implements Serializable { 
	/**
	 * 
	 */
	private static final long serialVersionUID = 5374376991148428908L;
	
	private String name=null;
	private String type=null;
	
	public MappingClass() { 
		this("","");
	}
	
	public MappingClass(String name,String type) { 
		this.name=name;
		this.type=type;
	}
	
	public String getName() { 
		return name;
	}
	
	public void setName(String name) { 
		this.name = name;
	}
	
	public String getType() { 
		return type;
	}
	
	public void setType(String type) { 
		this.type = type;
	}
	
	@Override
	public String toString() { 
		return "Class:"+name+"-"+type;
	}
}

MappingData类

package com.lbf.database.map;

import java.io.Serializable;

/**
 * 数据映射类（类和表关联）
 */
public class MappingData implements Serializable { 
	/**
	 * 
	 */
	private static final long serialVersionUID = 5051257007902027488L;
	
	private MappingClass mappingClass=null;
	private MappingTable mappingTable=null;
	
	public MappingData() { 
		this(new MappingClass(),new MappingTable());
	}
	
	public MappingData(MappingClass mappingClass,MappingTable mappingTable) { 
		this.mappingClass=mappingClass;
		this.mappingTable=mappingTable;
	}

	public MappingClass getMappingClass() { 
		return mappingClass;
	}

	public void setMappingClass(MappingClass mappingClass) { 
		this.mappingClass = mappingClass;
	}

	public MappingTable getMappingTable() { 
		return mappingTable;
	}

	public void setMappingTable(MappingTable mappingTable) { 
		this.mappingTable = mappingTable;
	}
	
	@Override
	public String toString() { 
		return mappingClass.toString()+"="+mappingTable.toString();
	}
}

MappingTable类

package com.lbf.database.map;

import java.io.Serializable;

/**
 * 数据映射类（表）
 */
public class MappingTable implements Serializable { 
	/**
	 * 
	 */
	private static final long serialVersionUID = -1864473153906695987L;
	
	private String name=null;
	private String type=null;
	
	public MappingTable() { 
		this("","");
	}
	
	public MappingTable(String name,String type) { 
		this.name=name;
		this.type=type;
	}
	
	public String getName() { 
		return name;
	}
	
	public void setName(String name) { 
		this.name = name;
	}
	
	public String getType() { 
		return type;
	}
	
	public void setType(String type) { 
		this.type = type;
	}
	
	@Override
	public String toString() { 
		return "Table:"+name+"-"+type;
	}
}

无双孟堂

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数据库工具类（二）

通过调用DataBaseClass实现调用DataBaseClass类package com.lbf.database;import java.sql.*;import java.util.*;/** * 数据库访问操作类（操作数据库时使用） * @author Wing.King */public class DataBaseClass { private st
复制链接

扫一扫