• Home
• org.voovan
• voovan-database
• 4.2.5
• source code
• JdbcOperate.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.voovan.db.JdbcOperate Maven / Gradle / Ivy

package org.voovan.db;

import org.voovan.db.exception.UpdateCountException;
import org.voovan.tools.TObject;
import org.voovan.tools.TSQL;
import org.voovan.tools.json.JSON;
import org.voovan.tools.log.Logger;
import org.voovan.tools.reflect.TReflect;

import javax.sql.DataSource;
import java.io.Closeable;
import java.io.IOException;
import java.sql.*;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
 * jdbc 操作类
 * 		每个数据库操作函数 开启关闭一次连接. 使用:开始来标识参数,例如: Map 和对象形式用:":arg", List 和 Array 形式用":1"
 * 		所有行为均为非线程安全
 *
 * @author helyho
 *
 * Voovan Framework.
 * WebSite: https://github.com/helyho/Voovan
 * Licence: Apache v2 License
 */
public class JdbcOperate implements Closeable {
	private static Map JDBC_OPERATE_THREAD_LIST = new ConcurrentHashMap();

	private DataSource	dataSource;
	private Connection	connection;
	private TranscationType transcationType;
	private Savepoint savepoint = null;
	private Statement statement;
	private ResultSet resultSet;

	private DataBaseType dataBaseType;

	private List bindedJdbcOperate = new ArrayList();
	private boolean isTransactionFinished = false;

	/**
	 * 构造函数
	 * @param dataSource	数据源
	 */
	public JdbcOperate(DataSource dataSource) {
		this.dataSource = dataSource;
		this.dataBaseType = TSQL.getDataBaseType(dataSource);
		this.transcationType = TranscationType.NONE;
	}

	/**
	 * 构造函数
	 * @param dataSource	数据源
	 * @param isTrancation   是否启用事物支持, 默认使用的`NEST`(嵌套事务)的事物方式
	 */
	public JdbcOperate(DataSource dataSource, boolean isTrancation){
		this.dataSource = dataSource;
		this.dataBaseType = TSQL.getDataBaseType(dataSource);
		this.transcationType = (isTrancation? TranscationType.ALONE : TranscationType.NONE);
	}

	/**
	 * 构造函数
	 * @param dataSource	数据源
	 * @param transcationType    是否启用事务支持, 设置事务模式
	 */
	public JdbcOperate(DataSource dataSource, TranscationType transcationType){
		this.dataSource = dataSource;
		this.dataBaseType = TSQL.getDataBaseType(dataSource);
		this.transcationType = transcationType;
	}

	/**
	 * 获取数据库类型g
	 * @return DataBaseType数据库类型
	 */
	public DataBaseType getDataBaseType() {
		return dataBaseType;
	}

	/**
	 * 增加连接事务关联绑定
	 * 		只能绑定 TranscationType 为 NEST 的事务
	 * @param subJdbcOperate 连接操作对象
	 * @param bothway true: 双向绑定, false: 单向绑定,只建立当前连接和目标连接的绑定关系
	 *                双向绑定意味这任意一个节点的 commit 或者 rollback 操作都会直接联动所有的事物同时操作(提交/回滚), 如果是单向绑定,只会联动下级事物同时操作(提交/回滚)
	 * @return true: 增加连接事务绑定成功, false: 增加连接事务绑定失败
	 */
	public synchronized boolean addBind(JdbcOperate subJdbcOperate, boolean bothway){
		if(subJdbcOperate.transcationType == TranscationType.NEST) {
			if(!bindedJdbcOperate.contains(subJdbcOperate)) {
				if(bothway) {
					subJdbcOperate.bindedJdbcOperate.add(this);
				}
				return bindedJdbcOperate.add(subJdbcOperate);
			}
		}

		return false;
	}

	/**
	 * 移除连接事务绑定
	 * @param subJdbcOperate 连接操作对象
	 * @param bothway true: 双向绑定, 解除当前连接和目标连接两个连接相互的绑定关系, : 单向绑定, 只解除当前连接和目标连接的绑定关系
	 * @return true: 移除连接事务绑定成功, false: 移除连接事务绑定失败
	 */
	public synchronized boolean removeBind(JdbcOperate subJdbcOperate, boolean bothway){
		if(bothway) {
			subJdbcOperate.bindedJdbcOperate.remove(this);
		}
		return bindedJdbcOperate.remove(subJdbcOperate);
	}

	/**
	 * 获取连接
	 *
	 * @return 获取数据库连接
	 * @throws SQLException SQL 异常
	 */
	public synchronized Connection getConnection() throws SQLException {
		long threadId = Thread.currentThread().getId();
		//如果连接不存在,或者连接已关闭则重取一个连接
		if (connection == null || connection.isClosed()) {
			//事务嵌套模式
			if (transcationType == TranscationType.NEST) {
				//判断是否有上层事务
				if (JDBC_OPERATE_THREAD_LIST.containsKey(threadId)) {
					connection = JDBC_OPERATE_THREAD_LIST.get(threadId).connection;
					savepoint = connection.setSavepoint();
				} else {
					connection = dataSource.getConnection();
					connection.setAutoCommit(false);
					JDBC_OPERATE_THREAD_LIST.put(threadId, this);
				}
			}
			//孤立事务模式
			else if (transcationType == TranscationType.ALONE){
				connection = dataSource.getConnection();
				connection.setAutoCommit(false);
			}
			//非事务模式
			else if (transcationType == TranscationType.NONE){
				connection = dataSource.getConnection();
				connection.setAutoCommit(true);
			}
		}
		return connection;
	}

	/**
	 * 返回当前事务形式
	 * @return 事务类型
	 */
	public TranscationType getTranscationType() {
		return transcationType;
	}

	/**
	 * 设置当前事务类型
	 * @param transcationType TranscationType 对象事务类型
	 * @return JdbcOperate 对象
	 */
	public JdbcOperate setTranscationType(TranscationType transcationType) {
		this.transcationType = transcationType;
		return this;
	}

	/**
	 * 提交事务
	 * @param isClose 是否关闭数据库连接
	 * @throws SQLException SQL 异常
	 */
	public synchronized void commit(boolean isClose) throws SQLException {
		if(connection==null){
			return ;
		}

		//关联事务提交
		for(JdbcOperate bindJdbcOperate : bindedJdbcOperate){
			if(this.equals(bindJdbcOperate)) {
				if(!bindJdbcOperate.isTransactionFinished) {
					bindJdbcOperate.commit(isClose);
				}
			}
		}

		if(!connection.isClosed()) {
			connection.commit();

			if (isClose) {
				try {
					close();
				} catch (IOException e) {
					throw new SQLException(e);
				}
			}
		}
		isTransactionFinished = true;
	}

	/**
	 * 回滚事务
	 * @param isClose 是否关闭数据库连接
	 * @throws SQLException SQL 异常
	 */
	public synchronized void rollback(boolean isClose) throws SQLException {
		if(connection==null){
			return ;
		}

		//有事务点则为: 子事务, 无事务点则为: 主事务
		//主事务回滚并可关闭连接
		//子事务回滚事务点, 并不可关闭连接
		if(savepoint!=null) {
			connection.rollback(savepoint);
		} else {
			//关联事务回滚
			for(JdbcOperate bindJdbcOperate : bindedJdbcOperate){
				if(this.equals(bindJdbcOperate)) {
					if(!bindJdbcOperate.isTransactionFinished) {
						bindJdbcOperate.rollback(isClose);
					}
				}
			}

			if(!connection.isClosed()) {
				connection.rollback();

				if (isClose) {
					try {
						close();
					} catch (IOException e) {
						throw new SQLException(e);
					}
				}
			}
			isTransactionFinished = true;
		}
	}

	/**
	 * 提交事务不关闭连接
	 * @throws SQLException SQL 异常
	 */
	public void commit() throws SQLException {
		commit(true);
	}

	/**
	 * 回滚事务不关闭连接
	 * @throws SQLException SQL 异常
	 */
	public void rollback() throws SQLException {
		rollback(true);
	}

	/**
	 *
	 * @param sqlText
	 *            sql字符串
	 * @param mapArg
	 *            参数
	 * @return 结果集信息
	 * @throws SQLException SQL 异常
	 */
	private ResultInfo baseQuery(String sqlText, Map mapArg) throws SQLException {
		Connection conn = getConnection();
		SQLException exception = null;
		try {
			//构造PreparedStatement
			PreparedStatement preparedStatement = TSQL.createPreparedStatement(conn, sqlText, mapArg);
			//执行查询
			resultSet = preparedStatement.executeQuery();
			return new ResultInfo(resultSet,this);
		} catch (SQLException e) {
			closeConnection(conn);
			Logger.error("Query execution SQL Error! \n SQL is : \n\t" + sqlText + ": \n\t " ,e);
			exception = e;
		}

		if(exception!=null){
			throw exception;
		}

		return null;
	}

	/**
	 * 执行数据库更新
	 *
	 * @param sqlText
	 *            sql字符串
	 * @param mapArg
	 *            参数
	 * @return 更新记录数
	 * @throws SQLException SQL 异常
	 */
	private int baseUpdate(String sqlText, Map mapArg) throws SQLException {
		Connection conn = getConnection();
		PreparedStatement preparedStatement = null;
		SQLException exception = null;
		try {
			preparedStatement = TSQL.createPreparedStatement(conn, sqlText, mapArg);
			statement = preparedStatement;
			return preparedStatement.executeUpdate();
		} catch (SQLException e) {
			Logger.error("Update execution SQL Error! \n SQL is :\n\t " + sqlText + "\nError is: \n\t" ,e);
			exception = e;
		} finally {
			// 非事务模式执行
			if (transcationType == TranscationType.NONE) {
				closeConnection(preparedStatement);
			}else{
				if(exception!=null) {
					rollback();
				}
				closeStatement(preparedStatement);
			}
		}

		if(exception!=null){
			throw exception;
		}

		return -1;
	}

	/**
	 * 执行数据库批量更新
	 *
	 * @param sqlTexts
	 *            sql字符串
	 * @return 每条 SQL 更新记录数
	 * @throws SQLException SQL 异常
	 */
	private int[] baseBatch(String[] sqlTexts) throws SQLException {
		if(sqlTexts.length == 0) {
			return new int[0];
		}

		Connection conn = getConnection();
		Statement statement = null;
		SQLException exception = null;
		try {

			statement = (Statement) conn.createStatement();

			for(String sqlText : sqlTexts) {
				statement.addBatch(sqlText);

				if (Logger.isLogLevel("DEBUG")) {
					Logger.sql("[SQL_Executed]: " + sqlText);
				}
			}

			int[] result = statement.executeBatch();

			return result;
		} catch (SQLException e) {
			Logger.error("Batch execution SQL Error! \n SQL is : \n\t" + JSON.toJSON(sqlTexts) + ":\n\t" ,e);
			exception = e;
		} finally {
			// 非事务模式执行
			if (transcationType == TranscationType.NONE) {
				closeConnection(statement);
			}else{
				if(exception!=null) {
					rollback();
				}
				closeStatement(statement);
			}
		}

		if(exception!=null){
			throw exception;
		}

		return new int[0];
	}

	/**
	 * 执行数据库批量更新
	 *
	 * @param sqlText
	 *            sql字符串
	 * @param mapArgs
	 *            参数
	 * @return 每条 SQL 更新记录数
	 * @throws SQLException SQL 异常
	 */
	private int[] baseBatch(String sqlText, Collection> mapArgs) throws SQLException {
		if(mapArgs.size() == 0) {
			return new int[0];
		}

		Connection conn = getConnection();
		PreparedStatement preparedStatement = null;
		SQLException exception = null;
		try {

			// 获取 SQL 中的参数列表
			List sqlParams = TSQL.getSqlParamNames(sqlText);
			preparedStatement = (PreparedStatement) conn.prepareStatement(TSQL.preparedSql(sqlText));
			if (mapArgs != null) {
				for (Map magArg : mapArgs) {
					// 用 sqlParams 对照 给 preparestatement 填充参数
					TSQL.setPreparedParams(preparedStatement, sqlParams, magArg);
					preparedStatement.addBatch();
				}
			}

			if(Logger.isLogLevel("DEBUG")) {
				Logger.sql("[SQL_Executed]: " + sqlText);
			}

			statement = preparedStatement;
			int[] result = preparedStatement.executeBatch();

			return result;
		} catch (SQLException e) {
			Logger.error("Batch execution SQL Error! \n SQL is : \n\t" + sqlText + ":\n\t" ,e);
			exception = e;
		} finally {
			// 非事务模式执行
			if (transcationType == TranscationType.NONE) {
				closeConnection(preparedStatement);
			}else{
				if(exception!=null) {
					rollback();
				}
				closeStatement(preparedStatement);
			}
		}

		if(exception!=null){
			throw exception;
		}

		return new int[0];
	}


	private List