数据库连接池
package org.dave.common.database;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ResourceBundle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.jolbox.bonecp.BoneCP;
import com.jolbox.bonecp.BoneCPConfig;
/**
* 数据库连接池
* @author David Day
*/
public final class DatabaseConnectionPool {
private static final Logger LOG = LoggerFactory.getLogger(DatabaseConnectionPool.class);
private static final ResourceBundle BUNDLE = ResourceBundle.getBundle("connection");
private static final String DRIVER = "driver";
private static final String URL = "url";
private static final String USERNAME = "username";
private static final String PASSWORD = "password";
private static final String MAX_CONNECTION = "max_connection";
private static BoneCP pool;
/**
* 开启连接池
*/
public static void startup() {
try {
Class.forName(BUNDLE.getString(DRIVER));
BoneCPConfig config = new BoneCPConfig();
config.setJdbcUrl(BUNDLE.getString(URL));
config.setUsername(BUNDLE.getString(USERNAME));
config.setPassword(BUNDLE.getString(PASSWORD));
config.setMaxConnectionsPerPartition(Integer.parseInt(BUNDLE.getString(MAX_CONNECTION)));
pool = new BoneCP(config);
} catch (Exception e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 关闭连接池
*/
public static void shutdown() {
pool.shutdown();
}
/**
* @return 数据库连接
*/
public static Connection getConnection() {
try {
return pool.getConnection();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
}
数据库异常
package org.dave.common.database;
/**
* 数据库异常
* @author David Day
*/
@SuppressWarnings("serial")
public class DatabaseException extends RuntimeException {
public DatabaseException(Throwable cause) {
super(cause);
}
}
事务控制
package org.dave.common.database;
import java.sql.Connection;
import java.sql.SQLException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 数据库事务
* @author David Day
*/
public class DatabaseTransaction {
/**
* 日志工具
*/
private static final Logger LOG = LoggerFactory.getLogger(DatabaseTransaction.class);
/**
* 数据库连接
*/
private Connection conn;
/**
* 实例化一个默认连接的事务
*/
private DatabaseTransaction() {
this(DatabaseConnectionPool.getConnection());
}
/**
* 实例化一个默认连接的事务
*/
private DatabaseTransaction(boolean openTransaction) throws DatabaseException {
this(DatabaseConnectionPool.getConnection(), openTransaction);
}
/**
* @param conn 数据库连接
*/
private DatabaseTransaction(Connection conn) {
this.conn = conn;
}
/**
* @param conn 数据库连接
*/
private DatabaseTransaction(Connection conn, boolean openTransaction) throws DatabaseException {
this.conn = conn;
setAutoCommit(!openTransaction);
}
/**
* @return 数据库连接
*/
public Connection getConnection() {
return conn;
}
/**
* 设置是否自动提交
* @param autoCommit 自动提交
* @throws DatabaseException
*/
private void setAutoCommit(boolean autoCommit) throws DatabaseException {
try {
conn.setAutoCommit(autoCommit);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 开始事务
* @throws DatabaseException
*/
public void begin() throws DatabaseException {
setAutoCommit(false);
}
/**
* @return 是否打开事务
* @throws DatabaseException
*/
public boolean isBegin() throws DatabaseException {
try {
return !conn.getAutoCommit();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 提交
* @throws DatabaseException
*/
public void commit() throws DatabaseException {
try {
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 回滚
* @throws DatabaseException
*/
public void rollback() throws DatabaseException {
try {
conn.rollback();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* 关闭连接
* @throws DatabaseException
*/
public void close() throws DatabaseException {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
/**
* @return 连接是否关闭
* @throws DatabaseException
*/
public boolean isClose() throws DatabaseException {
try {
return conn.isClosed();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DatabaseException(e);
}
}
}
通用数据模型
package org.dave.common.database;
import java.io.Serializable;
@SuppressWarnings("serial")
public abstract class DataModel implements Serializable { }
结果转换器
package org.dave.common.database.convert;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 结果映射器
* @author David Day
*/
public interface ResultConverter<T> {
/**
* 映射
* @param rs 结果集
* @return 映射结果
* @throws SQLException
*/
public T convert(ResultSet rs) throws SQLException ;
}
把结果转换为整型
package org.dave.common.database.convert;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 整型映射工具
* @author David Day
*/
public class IntegerConverter implements ResultConverter<Integer> {
@Override
public Integer convert(ResultSet rs) throws SQLException {
return rs.getInt(1);
}
}
通用dao
package org.dave.common.database.access;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.dave.common.database.convert.ResultConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 数据存取类
* @author David Day
*/
public abstract class DataAccess {
/**
* 日志工具
*/
private static final Logger LOG = LoggerFactory.getLogger(DataAccess.class);
/**
* 数据库连接
*/
private Connection conn;
/**
* @param conn 数据库连接
*/
private DataAccess(Connection conn) {
this.conn = conn;
}
/**
* 插入数据
* @param sql
* @param generatedKeysConverter 主键映射
* @param params
* @return 主键
* @throws DataAccessException
*/
protected <T> T insert(String sql, ResultConverter<T> generatedKeysConverter, Object... params) throws DataAccessException {
try {
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
setParameters(pstmt, params);
executeUpdate(pstmt);
ResultSet rs = pstmt.getGeneratedKeys();
nextResult(rs);
return convertResult(rs, generatedKeysConverter);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 更新数据
* @param sql
* @param params
* @return 影响行数
* @throws DataAccessException
*/
protected int update(String sql, Object... params) throws DataAccessException {
return executeUpdate(getPreparedStatement(sql, params));
}
/**
* 查询单个结果
* @param <T>
* @param sql
* @param converter
* @param params
* @return
*/
protected <T> T queryForObject(String sql, ResultConverter<T> converter, Object... params) {
ResultSet rs = executeQuery(sql, params);
if (nextResult(rs)) {
return convertResult(rs, converter);
} else {
return null;
}
}
/**
* 查询结果列表
* @param <T>
* @param sql
* @param converter
* @param params
* @return
*/
protected <T> List<T> queryForList(String sql, ResultConverter<T> converter, Object... params) {
ResultSet rs = executeQuery(sql, params);
List<T> list = new ArrayList<T>();
while (nextResult(rs)) {
list.add(convertResult(rs, converter));
}
return list;
}
/**
* @param sql SQL语句
* @return 预编译声明
*/
private PreparedStatement getPreparedStatement(String sql, Object... params) throws DataAccessException {
PreparedStatement pstmt = getPreparedStatement(sql);
setParameters(pstmt, params);
return pstmt;
}
/**
* @param sql SQL语句
* @return 预编译声明
*/
private PreparedStatement getPreparedStatement(String sql) throws DataAccessException {
try {
return conn.prepareStatement(sql);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 为预编译声明传入参数
* @param pstmt 预编译声明
* @param params 参数
* @throws DataAccessException
*/
private void setParameters(PreparedStatement pstmt, Object... params) throws DataAccessException {
try {
for (int i = 0; i < params.length; i++) {
pstmt.setObject(i + 1, params[i]);
}
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 执行更新操作
* @param pstmt
* @return 影响行数
* @throws DataAccessException
*/
private int executeUpdate(PreparedStatement pstmt) throws DataAccessException {
try {
return pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 执行查询操作
* @param pstmt 预编译声明
* @return 结果集
* @throws DataAccessException
*/
private ResultSet executeQuery(PreparedStatement pstmt) throws DataAccessException {
try {
return pstmt.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 执行查询操作
* @param sql SQL语句
* @param params 参数
* @return 结果集
* @throws DataAccessException
*/
private ResultSet executeQuery(String sql, Object... params) throws DataAccessException {
return executeQuery(getPreparedStatement(sql, params));
}
/**
* 移动到下一行记录
* @param rs 结果集
* @return 是否有下一行记录
* @throws DataAccessException
*/
private boolean nextResult(ResultSet rs) throws DataAccessException {
try {
return rs.next();
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
/**
* 映射
* @param rs 结果集
* @return 映射结果
* @throws DataAccessException
*/
private <T> T convertResult(ResultSet rs, ResultConverter<T> converter) throws DataAccessException {
try {
return converter.convert(rs);
} catch (SQLException e) {
e.printStackTrace();
LOG.error(e.getMessage(), e);
throw new DataAccessException(e);
}
}
}
数据库存取异常
package org.dave.common.database.access;
/**
* 数据库存取异常
* @author David Day
*/
@SuppressWarnings("serial")
public class DataAccessException extends RuntimeException {
public DataAccessException(Throwable cause) {
super(cause);
}
}