public class ConnectionManager {
private static ConnectionManager instance;
private ComboPooledDataSource ds;
public static Connection connection;
private ConnectionManager() throws Exception{
String path=ConnectionManager.class.getClassLoader().getResource("").getFile();
InputStream is = new FileInputStream(path+"/database.properties");
Properties prop = new Properties();
prop.load(is);
ds=new ComboPooledDataSource();
ds.setDriverClass(prop.getProperty("drive").trim());
ds.setJdbcUrl(prop.getProperty("url").trim());
ds.setUser(prop.getProperty("username").trim().toString());
ds.setPassword(prop.getProperty("password").trim().toString());
ds.setInitialPoolSize(Integer.parseInt(prop.getProperty("initPoolSize").trim()));
ds.setMaxPoolSize(Integer.parseInt(prop.getProperty("initPoolSize").trim()));
ds.setMinPoolSize(Integer.parseInt(prop.getProperty("minPoolSize").trim()));
ds.setAcquireIncrement(Integer.parseInt(prop.getProperty("acquireIncrement").trim()));
ds.setAutoCommitOnClose(true);//启动事物管理
ds.setTestConnectionOnCheckin(true);//
ds.setIdleConnectionTestPeriod(Integer.parseInt(prop.getProperty("testPoolTime").trim()));
ds.setMaxIdleTime(Integer.parseInt(prop.getProperty("maxTimePool").trim()));
ds.setAutoCommitOnClose(Boolean.parseBoolean(prop.getProperty("autoCommitOnClose").trim()));
ds.setAcquireRetryDelay(Integer.parseInt(prop.getProperty("acquireRetryDelay").trim()));
}
public static final ConnectionManager getInstance() {
if (instance == null) {
try {
instance = new ConnectionManager();
} catch (Exception e) {
e.printStackTrace();
}
}
return instance;
}
public synchronized final Connection getConnection() {
try {
return ds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
protected void finalize() throws Throwable {
DataSources.destroy(ds); //
super.finalize();
}
}
public class DatabaseHandle {
private Connection connection;
private PreparedStatement preparedStatement;
private ResultSet result;
private CallableStatement call;
private DatabaseHandle() {
ConnectionManager connectionManger = ConnectionManager.getInstance();
connection = connectionManger.getConnection();
}
public static DatabaseHandle getDatabaseHandle(){
return new DatabaseHandle();
}
public List findList(String sql) throws SQLException{
return findList(sql,null);
}
public List findList(String sql, Object[] values) throws SQLException {
List list=new ArrayList();
try{
preparedStatement = connection.prepareStatement(sql);
setAttribute(preparedStatement, values);
result= preparedStatement.executeQuery();
ResultSetMetaData metadata=result.getMetaData();
int mapSize=metadata.getColumnCount();
while(result.next()){
Map map=new HashMap(mapSize);
for(int i=0;i<mapSize;i++){
map.put(metadata.getColumnLabel(i+1), result.getObject(metadata.getColumnLabel(i+1)));
}
list.add(map);
}
}catch(SQLException e){
throw e;
}
return list;
}
public void executeList(List<String> sqls,List<Object[]> objs) throws SQLException{
try{
if(sqls.size()!=objs.size()){return;}
connection.setAutoCommit(false);
for(int i=0,j=sqls.size();i<j;i++){
preparedStatement = connection.prepareStatement(sqls.get(i));
setAttribute(preparedStatement, objs.get(i));
preparedStatement.execute();
}
connection.commit();
connection.setAutoCommit(true);
}catch(SQLException e){
connection.rollback();
throw e;
}
}
public boolean insertData(String sql,Object values[]) throws SQLException{
boolean b;
try{
connection.setAutoCommit(false);
preparedStatement = connection.prepareStatement(sql);;
setAttribute(preparedStatement, values);
b=preparedStatement.execute();
connection.commit();
connection.setAutoCommit(true);
}catch(SQLException e){
connection.rollback();
throw e;
}
return b;
}
public boolean insertData(String sql) throws SQLException{
return insertData(sql,null);
}
public int updateData(String sql,Object values[]) throws SQLException{
int size;
connection.setAutoCommit(false);
try{
preparedStatement = connection.prepareStatement(sql);;
setAttribute(preparedStatement, values);
size=preparedStatement.executeUpdate();
connection.commit(); //
connection.setAutoCommit(true);
}catch(SQLException e){
connection.rollback();
throw e;
}
return size;
}
public void close(){
try{
if (result != null) {
result.close();
}
}catch(Exception e){}
try{
if (preparedStatement != null) {
preparedStatement.close();
}
}catch (Exception e){}
try{
if (call != null) {
call.close();
}
}catch (Exception e){}
try{
if (connection != null){
connection.close();
}
}catch (Exception e){}
}
public int updateData(String sql) throws SQLException{
return updateData(sql,null);
}
/**
* LIST
* @param callName
* @param list
* @return
* @throws SQLException
*/
public int[] callProcedureList(String callName,List<List> list) throws SQLException{
CallableStatement call=connection.prepareCall(callName);
int i[]=null;
try{
addList(call, list);
i=call.executeBatch();
}catch(SQLException e){
throw e;
}
return i;
}
/**
* 批处理 触发器
* @param callName
* @param list
* @return
* @throws SQLException
*/
public int[] callProcedureArray(String callName,List<Object[]> list) throws SQLException{
CallableStatement call=connection.prepareCall(callName);
int i[]=null;
try{
addArray(call, list);
i=call.executeBatch();
}catch(SQLException e){
throw e;
}
return i;
}
/**
* 集合参数批处理
* @param sql
* @param list
* @return
* @throws SQLException
*/
public int[] addBatchList(String sql,List<List> list) throws SQLException{
PreparedStatement preparedStatement=null;
int i[]=null;
try{
connection.setAutoCommit(false);
preparedStatement = connection.prepareStatement(sql);
addList(preparedStatement, list);
i=preparedStatement.executeBatch();
connection.commit(); //
connection.setAutoCommit(true);
}catch(SQLException e){
connection.rollback();
throw e;
}
return i;
}
/**
* 数组参数批处理
* @param sql
* @param list
* @return
* @throws SQLException
*/
public int[] addBatchArray(String sql,List<Object[]> list) throws SQLException{
PreparedStatement preparedStatement=null;
int i[]=null;
try{
preparedStatement = connection.prepareStatement(sql);
addArray(preparedStatement, list);
i=preparedStatement.executeBatch();
}catch(SQLException e){
connection.rollback();
throw e;
}
return i;
}
private void addArray(PreparedStatement preparedStatement,List<Object[]> list) throws SQLException{
for(Object[] objs:list){
for(int size=0;size<objs.length;size++){
preparedStatement.setObject(size+1, objs[size]);
}
preparedStatement.addBatch();
}
}
private void addList(PreparedStatement preparedStatement,List<List> list) throws SQLException{
for(List lists:list){
for(int size=0;size<lists.size();size++){
preparedStatement.setObject(size+1, lists.get(size));
}
preparedStatement.addBatch();
}
}
/**
* 设置属性
* @param preparedStatement
* @param values
* @throws SQLException
*/
private void setAttribute(PreparedStatement preparedStatement,
Object[] values) throws SQLException {
if (values != null) {
for (int i = 0; i < values.length; i++) {
System.out.println(values[i]);
preparedStatement.setObject(i+1, values[i]);
}
}
}
}
配置文件
databaseName=mysql ##oracle
url=....
username=root
password=dcbicc
drive=com.mysql.jdbc.Driver
initPoolSize=10
maxPoolSize=100
minPoolSize=10
acquireIncrement=20
testPoolTime=60
maxTimePool=2500
autoCommitOnClose=true
acquireRetryDelay=1000
分享到:
相关推荐
JDBC封装的工具类,将所有共同的代码提取过来,形成工具类
Java JDBC封装类,带增删改查例子,支持oracle,MySql,hsqldb 等,支持事务,返回数据格式 支持二维数组,MAP格式,以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类,可以作为项目共通类使用。
标题:JDBC封装类 描述:此文章将详细介绍一个用于简化Java中JDBC操作的封装类,该类通过提供一系列方法来加速数据库编程任务,包括建立数据库连接、执行查询、处理结果集以及执行更新操作。 ### 一、JDBC封装类...
现在的数据层的开发,大多会使用如MyBatis或...由于部分场景下MyBatis或JPA之类无法满足我的需求,所以我打算自己封装一套查数据库的工具类。 文章地址: https://blog.csdn.net/lxyoucan/article/details/124042295
Java JDBC封装类升级版,带增删改查例子,支持oracle,MySql,hsqldb 等,支持事务,返回数据格式 支持二维数组,MAP格式,以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类,可以作为项目共通类...
jdbc封装工具类,此类事封装成list,Object>>格式,可直接把转换为jsonArray格式传输数据。
**标题:“自己写个JDBC封装”** 在Java开发中,JDBC(Java Database Connectivity)是连接Java应用程序和关系数据库的标准接口。然而,原始的JDBC API使用起来相对繁琐,需要编写大量的重复代码,例如建立数据库...
"java增删改查JDBC封装类(泛型封装)"这个主题是关于如何利用泛型来优化JDBC操作,以提高代码的可读性、安全性和复用性。以下将详细讲解这个主题涉及的知识点。 1. **JDBC基础**: - JDBC是Java中连接数据库的标准...
本资源是对JDBC的封装,方便在项目中使用,其中BaseDao.java是对JDBC操作的封装,使用时让自己的Dao类继承即可,然后调用其中的executeQuery和executeOthe分别执行DQL和DML操作。dbinfo.properties属性文件存储基本...
jdbc的封装类,便于在开发时候方便,实现了数据库的加载,连接,增、删、查、改。
给学生讲课课上写的jdbc封装类,对基本的增删改查和事务做了封装。例子中用的是oracle 11g数据库,如果换其他数据库直接改连库字符串就行,其他的不用动,适合初学者学习。查询的时候会省掉很多工作量,不需要一个一...
在"JDBC简单封装类"中,这些步骤可能会被封装到单独的方法里,比如`connect()`用于建立连接,`executeQuery(String sql)`和`executeUpdate(String sql)`分别用于执行查询和更新,`getResultSet()`用于获取结果集,...
文档脉络清楚的详述了实现JDBC封装所需要进行的步骤。
"JDBC封装"是指将常见的数据库操作,如增删改查(CRUD:Create, Read, Update, Delete),进行模块化和抽象化的过程,以便于在代码中重复使用和简化数据库交互。下面将详细介绍JDBC封装的原理、步骤以及它带来的好处...
java用于jdbc的连接的实现类,在数据库连接的时候直接new出来就OK了!DAO层自己加写...
【标题】:JDBC封装包 【描述】:JDBC(Java Database Connectivity)是Java语言中用来规范客户端程序如何访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法。这个封装包是我个人制作的,旨在简化...
关于java对SQLite和sql的封装类,可以实现增删改,查,事务操作
自己封装好的,基于commons的DBBase,DBCP的数据库工具。支持线程池,支持直接对象化操作。即无需任何映射,只要是java标准类,属性带标准set、get,属性名称与查询结果集中字段名称相同,就可以直接查询出对象链表...
jdbc封装(实现对实体的增删改查[分页]),辅助学习Hibernate 包含三个文件夹,分别是: code-access实现 是用access实现的,本意是access方便,就一个文件,方便部署。但access有好多不支持,就写成这样.主要是可参考Dao...