easyjdbengine.java

EasyDBO是一个超轻量级对象-关系映射（Object/Relation Mapping

package com.easyjf.dbo;

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

import javax.sql.*;

import com.easyjf.dbo.config.*;
import com.easyjf.dbo.sql.*;

import org.apache.log4j.*;

/**
 * 
 * <p>
 * Title: 数据库处理引擎，实现DBObject对象到数据库的转换，完成具体的数据库操作
 * </p>
 * 
 * <p>
 * Description:这个类是EasyDBO通过JDBC与数据库交互的核心类，负责Java对象到数据表的相关操作，是提供给EasyJDB类调用的，一般情况下用户不需要使用该类！
 * </p>
 * 
 * <p>
 * Copyright: Copyright (c) 2006
 * </p>
 * 
 * <p>
 * Company:EasyJF开源团队-EasyDBO项目组
 * </p>
 * 
 * @author 大峡、piginzoo
 * @version 1.0
 */
public class EasyJDBEngine {
	private final static Logger logger = Logger.getLogger(EasyJDBEngine.class);

	private final static Map engines = new HashMap();

	// private final static EasyJDBEngine singleton;

	private DataSource dataSource; // 数据源,可以通过IOC的方式植入

	private ISqlQuery sqlQuery; // 查询方言,可以通过IOC的方式植入

	private boolean showSql = false;

	private boolean autoCommit = true; // add 是否为自动提交

	private Vector vec = new Vector();

	private Vector vecExe = new Vector();
	
	private  int maxSize=1000;

	public EasyJDBEngine()
	{
		
	}
	/**
	 * 
	 * @param dataSource
	 *            DataSource
	 */
	public EasyJDBEngine(DataSource dataSource) {
		this(dataSource, new MySqlQuery());
	}

	/**
	 * 
	 * @param dataSource
	 *            DataSource
	 * @param sqlQuery
	 *            ISqlQuery
	 */
	public EasyJDBEngine(DataSource dataSource, ISqlQuery sqlQuery) {
		this.dataSource = dataSource;
		this.sqlQuery = sqlQuery;
	}

	/**
	 * 
	 * @return EasyJDBEngine
	 */
	public static EasyJDBEngine getInstance() throws EasyDBOException {
		// 数据库操作，这里写法还有问题，将会修改为由配置文件中读取参数
		EasyJDBEngine engine = null;
		if (engines.isEmpty()) {
			logger.info("初始化数据库查询引擎！");
			ISqlQuery dialect = null;
			try {
				System.out
						.println("方言：" + DBOConfig.getInstance().getDialect());
				dialect = (ISqlQuery) Class.forName(
						DBOConfig.getInstance().getDialect()).newInstance();

			} catch (Exception e) {
				logger.error("数据库类型(方言)配置错误，系统将使用默认MySQL数据类型方言！\n" + e);
				e.printStackTrace();
			}
			if (dialect == null) {
				dialect = new MySqlQuery();
			}
			DataSource ds = null;
			try {
				ds = DataSourceManager.getDataSource();
				engine = new EasyJDBEngine(ds, dialect);
				engine.setShowSql(DBOConfig.getInstance().isShow_sql());
			} catch (EasyDBOException e) {
				logger
						.error("通过EasyDBO配置文件easyjf-dbo.xml文件创建数据源错误,请在程序中手动设置EasyDBO数据源， ！\n"
								+ e);
				throw e;
			}
		}
		if (engine.getDataSource() == null) {
			logger
					.warn("通过EasyDBO的配置文件无法读取数据源配置信息，若要使用EasyDBO，必须在应用程序中手动设置数据源 ！");
		}
		return engine;
	}

	/**
	 * 初始化数据源
	 * 
	 */
	public static void init() {
		if (!engines.isEmpty()) {
			engines.clear();
		}
		Map sources = null;
		try {
			sources = DataSourceManager.getDataSources();

		} catch (EasyDBOException e) {
			logger
					.warn("通过EasyDBO配置文件easyjf-dbo.xml文件创建数据源错误,请在程序中手动设置EasyDBO数据源 ！\n"
							+ e);
		}
		if (sources != null) {
			Iterator it = sources.keySet().iterator();
			while (it.hasNext()) {
				String name = (String) it.next();
				DataSource dsource = (DataSource) sources.get(name);
				if (dsource != null) {
					engines.put(name, dsource);
				}
			}
		}
	}

	/**
	 * 
	 * @param name
	 *            String
	 * @return EasyJDBEngine
	 */
	public static EasyJDBEngine getInstance(String name) {
		// 数据库操作，这里还有问题，将会修改为由配置文件中读取参数
		EasyJDBEngine engine =(EasyJDBEngine)engines.get(name);
		return engine;
	}

	/**
	 * 释放当前连接
	 */
	public void releaseConnection() {
		JDBCContext.getJdbcContext(dataSource).releaseConnection();
	}

	/**
	 * 
	 * @param sql String
	 * @return Object
	 */
	public Object uniqueResult(String sql) {
		return uniqueResult(sql, null);
	}

	/**
	 * 
	 * @param sql
	 *            String
	 * @param params
	 *            Collection
	 * @return Object
	 */
	public Object uniqueResult(String sql, Collection params) {
		ResultSet rs = null;
		Object ret = null;
		DatabaseDAO dba = null; // 引入数据库操作工具类
		try {
			dba = getDatabaseDAO();
			if (this.showSql) {
				System.out.println("EasyDBO:" + sql);
			}
			dba.readOnlyPrepare(sql);
			dba.setQueryParams(params);
			rs = dba.preparedQuery();
			if (rs.next()) {
				ret = rs.getObject(1);
			}
			rs.close();
			// dba.close();即然finally中用close，这里就不要close了，关一次就行，关不了拉倒
		} catch (Exception e) {
			logger.error("数据查询错误：" + e + ":sql=" + sql);
			if (dba != null) {
				try {
					dba.rollback();
					if (autoCommit)
						releaseConnection();
					// dba.close();
				} catch (SQLException sqle) {
				}
			}

		} finally {
			try {
				dba.close();
				if (autoCommit)
					releaseConnection();
			} catch (Exception e) {
				logger.error("释放数据库资源错误：" + e);
			}
		}
		return ret;
	}
	public List callQuery(String procedureName )
	{
		return callQuery(procedureName,null);
	}
	public List callQuery(String procedureName, Object[] parameter)
	{
		List list = new ArrayList();
		DatabaseDAO dba = null; // 引入数据库操作工具类
		ResultSet rs = null;
		try{
		dba=getDatabaseDAO();
		rs =dba.callQuery(procedureName, parameter);
		int fecth=0;
		while (rs.next() && fecth<maxSize) {
			DBObject obj = new DBObject(new DBTable());
			obj.setValue(dba.resultSet2Map(rs));
			list.add(obj);
			fecth++;
		}
		}
		catch(Exception e)
		{

		logger.error("调用存储过程出错!"+e);
		e.printStackTrace();
		}
		return list;
	}
	/**
	 * 
	 * @param sql
	 *            String
	 * @return DBObject
	 */
	public DBObject get(String sql) {
		return get(sql, null);
	}

	/**
	 * 
	 * @param sql
	 *            String
	 * @param params
	 *            Collection
	 * @return DBObject
	 */
	public DBObject get(String sql, Collection params) { // 通过完整的sql语句读取得单个对象
		DBObject obj = null;;
		
		List list = new ArrayList();
		list = query(sql, params, 0, 1);
		if (list != null && (list.size() > 0)) {
			obj = (DBObject) list.get(0);
			// obj.setIdValue(obj.getValue().get(obj.getTable().getId()));
		}
		return obj;
	}

	/**
	 * 
	 * @param obj
	 *            DBObject
	 * @param idvalue
	 *            Object
	 * @return DBObject
	 */
	public DBObject get(DBObject obj, Object idvalue) { // 通过ID值读取数据表数据
		DatabaseDAO dba = null; // 引入数据库操作工具类
		ResultSet rs = null;
		if (obj == null) {
			return null;
		}
		String sql = sqlQuery.getQuerySql(obj);
		if (sql.equals("")) {
			logger.error("找不到查询参数!");
			return null;
		}

		List list = new ArrayList();
		try {
			dba = getDatabaseDAO();
			if (this.showSql) {
				System.out.println("EasyDBO:" + sql + ":" + idvalue);
			}
			dba.readOnlyPrepare(sql);
			dba.setParameter(1, idvalue);
			rs = dba.preparedQuery();
			list = dba.resultSet2List(rs);
			if (list != null && (list.size() > 0)) {
				obj.setValue((Map) list.get(0));				
				obj.setIdValue(obj.getValue().get(obj.getTable().getId()));
			} else { // 没有查询到数据
				return null;
			}
			rs.close();
			// dba.close();
		} catch (Exception e) {
			obj = null;
			logger.error("数据查询错误：" + e + ":sql=" + sql);
			e.printStackTrace();
			if (dba != null) {
				try {
					dba.rollback();
					// dba.close();
				} catch (SQLException sqle) {
				}
			}

		} finally {
			try {
				dba.close();
				if (autoCommit)
					releaseConnection();
			} catch (Exception e) {
				logger.error("释放数据库资源错误：" + e);
			}
		}
		return obj;
	}

	/**
	 * 
	 * @param obj
	 *            DBObject
	 * @param scope
	 *            String
	 * @param params
	 *            Collection
	 * @return DBObject
	 */
	public DBObject get(DBObject obj, String scope, Collection params) { // 通过ID值读取数据表数据
		if (obj == null) {
			return null;
		}
		List list = new ArrayList();
		String sql = sqlQuery.getQuerySql(obj, scope);
		list = query(sql, params, 0, 1);
		if (list != null && (list.size() > 0)) {
			DBObject dbo = (DBObject) list.get(0);
			obj.setValue(dbo.getValue());
			obj.setIdValue(obj.get(obj.getTable().getId()));
		} else { // 没有查询到数据
			return null;
		}
		return obj;
	}

	/**
	 * *把对象obj保存到数据库中
	 * 
	 * @param obj
	 *            DBObject
	 * @return boolean
	 */
	public boolean add(DBObject obj) { // 添加一个对象
		DatabaseDAO dba = null; // 引入数据库操作工具类
		String sql = sqlQuery.getInsertSql(obj);
		if (sql.equals("")) {
			logger.error("空的sql语句无法执行!");
			return false;
		}
		boolean ret = false;
		try {
			dba = getDatabaseDAO();
			if (this.showSql) {
				System.out.println("EasyDBO:" + sql);
			}
			dba.prepare(sql);
			if (obj.getValue() != null) {
				dba.setQueryParams(obj.getValue().values());
			}
			// todo : add piginzoo 加入事务支持
			if (autoCommit == false) {
				vec.add(dba.getPreparedStatement());
			} else {
				// rs = dba.preparedQuery();
				ret = dba.isPreparedUpdate();
				// dba.close();
			}
		} catch (Exception e) {
			logger.error("添加数据错误：" + e + ":sql=" + sql);
			e.printStackTrace();
			if (dba != null) {
				try {
					dba.rollback();
					// dba.close();
				} catch (SQLException sqle) {
				}
			}

		} finally {
			try {
				dba.close();
				if (autoCommit)
					releaseConnection();
			} catch (Exception e) {
				logger.error("释放数据库资源错误：" + e);
			}
		}

		return ret;
	}

	/**
	 * 更新持久层中的数据表对象
	 * 
	 * @param obj
	 *            DBObject 更新的对旬
	 * @return boolean 是否更新成功
	 */
	public boolean update(DBObject obj) {
		// 修改一个对象

		logger.debug("更新持久层中的数据表对象");
		DatabaseDAO dba = null; // 引入数据库操作工具类
		String sql = sqlQuery.getUpdateSql(obj);
		if (sql.equals("")) {
			logger.error("空的sql语句无法执行!");
			return false;
		}