JDBC-（连接池框架）
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JDBC-（连接池框架）相关的知识，希望对你有一定的参考价值。
JDBC
一、数据库连接池
1.数据库连接池的概念
- 数据库连接背景
- 数据库连接是一种关键的、有限的、昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。
- 数据库连接池
- 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。这项技术能明显提高对数据库操作的性能。
- 数据库连接池原理
2.自定义连接池
- java.sql.DataSource接口：数据源(数据库连接池)。java官方提供的数据库连接池规范(接口)
- 获取数据库连接对象：Connection getConnection();
- 自定义连接池
/*
自定义连接池类
*/
public class MyDataSource implements DataSource
//定义集合容器，用于保存多个数据库连接对象
private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());
//静态代码块，生成10个数据库连接保存到集合中
static
for (int i = 0; i < 10; i++)
Connection con = JDBCUtils.getConnection();
pool.add(con);
//返回连接池的大小
public int getSize()
return pool.size();
//从池中返回一个数据库连接
@Override
public Connection getConnection()
if(pool.size() > 0)
//从池中获取数据库连接
return pool.remove(0);
else
throw new RuntimeException("连接数量已用尽");
@Override
public Connection getConnection(String username, String password) throws SQLException
return null;
@Override
public <T> T unwrap(Class<T> iface) throws SQLException
return null;
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException
return false;
@Override
public PrintWriter getLogWriter() throws SQLException
return null;
@Override
public void setLogWriter(PrintWriter out) throws SQLException
@Override
public void setLoginTimeout(int seconds) throws SQLException
@Override
public int getLoginTimeout() throws SQLException
return 0;
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException
return null;
3.自定义连接池测试
public class MyDataSourceTest
public static void main(String[] args) throws Exception
//创建数据库连接池对象
MyDataSource dataSource = new MyDataSource();
System.out.println("使用之前连接池数量：" + dataSource.getSize());
//获取数据库连接对象
Connection con = dataSource.getConnection();
System.out.println(con.getClass());// JDBC4Connection
//查询学生表全部信息
String sql = "SELECT * FROM student";
PreparedStatement pst = con.prepareStatement(sql);
ResultSet rs = pst.executeQuery();
while(rs.next())
System.out.println(rs.getInt("sid") + "\\t" + rs.getString("name") + "\\t" + rs.getInt("age") + "\\t" + rs.getDate("birthday"));
//释放资源
rs.close();
pst.close();
//目前的连接对象close方法，是直接关闭连接，而不是将连接归还池中
con.close();
System.out.println("使用之后连接池数量：" + dataSource.getSize());
4.归还连接
- 继承(无法解决)
- 通过打印连接对象，发现DriverManager获取的连接实现类是JDBC4Connection。
- 自定义一个类，继承JDBC4Connection这个类，重写close()方法。
/*
自定义Connection类
*/
public class MyConnection1 extends JDBC4Connection
//声明连接对象和连接池集合对象
private Connection con;
private List<Connection> pool;
//通过构造方法给成员变量赋值
public MyConnection1(String hostToConnectTo, int portToConnectTo, Properties info, String databaseToConnectTo, String url,Connection con,List<Connection> pool) throws SQLException
super(hostToConnectTo, portToConnectTo, info, databaseToConnectTo, url);
this.con = con;
this.pool = pool;
//重写close()方法，将连接归还给池中
@Override
public void close() throws SQLException
pool.add(con);
- 但是这种方式行不通，通过查看JDBC工具类获取连接的方法我们发现：我们虽然自定义了一个子类，完成了归还连接的操作。但是DriverManager获取的还是JDBC4Connection这个对象，并不是我们的子类对象。而我们又不能整体去修改驱动包中类的功能！
//将之前的连接对象换成自定义的子类对象
private static MyConnection1 con;
//4.获取数据库连接的方法
public static Connection getConnection()
try
//等效于：MyConnection1 con = new JDBC4Connection(); 语法错误！
con = DriverManager.getConnection(url,username,password);
catch (SQLException e)
e.printStackTrace();
return con;
- 装饰设计模式
- 自定义连接类
/*
自定义Connection类。通过装饰设计模式，实现和mysql驱动包中的Connection实现类相同的功能！
实现步骤：
1.定义一个类，实现Connection接口
2.定义Connection连接对象和连接池容器对象的变量
3.提供有参构造方法，接收连接对象和连接池对象，对变量赋值
4.在close()方法中，完成连接的归还
5.剩余方法，只需要调用mysql驱动包的连接对象完成即可
*/
public class MyConnection2 implements Connection
//2.定义Connection连接对象和连接池容器对象的变量
private Connection con;
private List<Connection> pool;
//3.提供有参构造方法，接收连接对象和连接池对象，对变量赋值
public MyConnection2(Connection con,List<Connection> pool)
this.con = con;
this.pool = pool;
//4.在close()方法中，完成连接的归还
@Override
public void close() throws SQLException
pool.add(con);
@Override
public Statement createStatement() throws SQLException
return con.createStatement();
@Override
public PreparedStatement prepareStatement(String sql) throws SQLException
return con.prepareStatement(sql);
@Override
public CallableStatement prepareCall(String sql) throws SQLException
return con.prepareCall(sql);
@Override
public String nativeSQL(String sql) throws SQLException
return con.nativeSQL(sql);
@Override
public void setAutoCommit(boolean autoCommit) throws SQLException
con.setAutoCommit(autoCommit);
@Override
public boolean getAutoCommit() throws SQLException
return con.getAutoCommit();
@Override
public void commit() throws SQLException
con.commit();
@Override
public void rollback() throws SQLException
con.rollback();
@Override
public boolean isClosed() throws SQLException
return con.isClosed();
@Override
public DatabaseMetaData getMetaData() throws SQLException
return con.getMetaData();
@Override
public void setReadOnly(boolean readOnly) throws SQLException
con.setReadOnly(readOnly);
@Override
public boolean isReadOnly() throws SQLException
return con.isReadOnly();
@Override
public void setCatalog(String catalog) throws SQLException
con.setCatalog(catalog);
@Override
public String getCatalog() throws SQLException
return con.getCatalog();
@Override
public void setTransactionIsolation(int level) throws SQLException
con.setTransactionIsolation(level);
@Override
public int getTransactionIsolation() throws SQLException
return con.getTransactionIsolation();
@Override
public SQLWarning getWarnings() throws SQLException
return con.getWarnings();
@Override
public void clearWarnings() throws SQLException
con.clearWarnings();
@Override
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException
return con.createStatement(resultSetType,resultSetConcurrency);
@Override
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
return con.prepareStatement(sql,resultSetType,resultSetConcurrency);
@Override
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
return con.prepareCall(sql,resultSetType,resultSetConcurrency);
@Override
public Map<String, Class<?>> getTypeMap() throws SQLException
return con.getTypeMap();
@Override
public void setTypeMap(Map<String, Class<?>> map) throws SQLException
con.setTypeMap(map);
@Override
public void setHoldability(int holdability) throws SQLException
con.setHoldability(holdability);
@Override
public int getHoldability() throws SQLException
return con.getHoldability();
@Override
public Savepoint setSavepoint() throws SQLException
return con.setSavepoint();
@Override
public Savepoint setSavepoint(String name) throws SQLException
return con.setSavepoint(name);
@Override
public void rollback(Savepoint savepoint) throws SQLException
con.rollback(savepoint);
@Override
public void releaseSavepoint(Savepoint savepoint) throws SQLException
con.releaseSavepoint(savepoint);
@Override
public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
return con.createStatement(resultSetType,resultSetConcurrency,resultSetHoldability);
@Override
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
return con.prepareStatement(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
@Override
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
return con.prepareCall(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
@Override
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException
return con.prepareStatement(sql,autoGeneratedKeys);
@Override
public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
return con.prepareStatement(sql,columnIndexes);
@Override
public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
return con.prepareStatement(sql,columnNames);
@Override
public Clob createClob() throws SQLException
return con.createClob();
@Override
public Blob createBlob() throws SQLException
return con.createBlob();
@Override
public NClob createNClob() throws SQLException
return con.createNClob();
@Override
public SQLXML createSQLXML() throws SQLException
return con.createSQLXML();
@Override
public boolean isValid(int timeout) throws SQLException
return con.isValid(timeout);
@Override
public void setClientInfo(String name, String value) throws SQLClientInfoException
con.setClientInfo(name,value);
@Override
public void setClientInfo(Properties properties) throws SQLClientInfoException
con.setClientInfo(properties);
@Override
public String getClientInfo(String name) throws SQLException
return con.getClientInfo(name);
@Override
public Properties getClientInfo() throws SQLException
return con.getClientInfo();
@Override
public Array createArrayOf(String typeName, Object[] elements) throws SQLException
return con.createArrayOf(typeName,elements);
@Override
public Struct createStruct(String typeName, Object[] attributes) throws SQLException
return con.createStruct(typeName,attributes);
@Override
public void setSchema(String schema) throws SQLException
con.setSchema(schema);
@Override
public String getSchema() throws SQLException
return con.getSchema();
@Override
public void abort(Executor executor) throws SQLException
con.abort(executor);
@Override
public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException
con.setNetworkTimeout(executor,milliseconds);
@Override
public int getNetworkTimeout() throws SQLException
return con.getNetworkTimeout();
@Override
public <T> T unwrap(Class<T> iface) throws SQLException
return con.unwrap(iface);
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException
return con.isWrapperFor(iface);
- 自定义连接池类
public class MyDataSource implements DataSource
//定义集合容器，用于保存多个数据库连接对象
private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());
//静态代码块，生成10个数据库连接保存到集合中
static
for (int i = 0; i < 10; i++)
Connection con = JDBCUtils.getConnection();
pool.add(con);
//返回连接池的大小
public int getSize()
return pool.size();
//从池中返回一个数据库连接
@Override
public Connection getConnection()
if(pool.size() > 0)
//从池中获取数据库连接
Connection con = pool.remove(0);
//通过自定义连接对象进行包装
MyConnection2 mycon = new MyConnection2(con,pool);
//返回包装后的连接对象
return mycon;
else
throw new RuntimeException("连接数量已用尽");
- 适配器设计模式
- 通过之前MyConnection2连接类我们发现，有很多个需要实现的方法。这个时候我们就可以使用适配器设计模式了。提供一个适配器类，实现Connection接口，将所有功能进行实现(除了close方法)。自定义连接类只需要继承这个适配器类，重写需要改进的close()方法即可！
- 适配器类
/*
适配器抽象类。实现Connection接口。
实现所有的方法，调用mysql驱动包中Connection连接对象的方法
*/
public abstract class MyAdapter implements Connection
// 定义数据库连接对象的变量
private Connection con;
// 通过构造方法赋值
public MyAdapter(Connection con)
this.con = con;
// 所有的方法，均调用mysql的连接对象实现
@Override
public Statement createStatement() throws SQLException
return con.createStatement();
@Override
public PreparedStatement prepareStatement(String sql) throws SQLException
return con.prepareStatement(sql);
@Override
public CallableStatement prepareCall(String sql) throws SQLException
return con.prepareCall(sql);
@Override
public String nativeSQL(String sql) throws SQLException
return con.nativeSQL(sql);
@Override
public void setAutoCommit(boolean autoCommit) throws SQLException
con.setAutoCommit(autoCommit);
@Override
public boolean getAutoCommit() throws SQLException
return con.getAutoCommit();
@Override
public void commit() throws SQLException
con.commit();
@Override
public void rollback() throws SQLException
con.rollback();
@Override
public boolean isClosed() throws SQLException
return con.isClosed();
@Override
public DatabaseMetaData getMetaData() throws SQLException
return con.getMetaData();
@Override
public void setReadOnly(boolean readOnly) throws SQLException
con.setReadOnly(readOnly);
@Override
public boolean isReadOnly() throws SQLException
return con.isReadOnly();
@Override
public void setCatalog(String catalog) throws SQLException
con.setCatalog(catalog);
@Override
public String getCatalog() throws SQLException
return con.getCatalog();
@Override
public void setTransactionIsolation(int level) throws SQLException
con.setTransactionIsolation(level);
@Override
public int getTransactionIsolation() throws SQLException
return con.getTransactionIsolation();
@Override
public SQLWarning getWarnings() throws SQLException
return con.getWarnings();
@Override
public void clearWarnings() throws SQLException
con.clearWarnings();
@Override
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException
return con.createStatement(resultSetType,resultSetConcurrency);
@Override
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
return con.prepareStatement(sql,resultSetType,resultSetConcurrency);
@Override
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
return con.prepareCall(sql,resultSetType,resultSetConcurrency);
@Override
public Map<String, Class<?>> getTypeMap() throws SQLException
return con.getTypeMap();
@Override
public void setTypeMap(Map<String, Class<?>> map) throws SQLException
con.setTypeMap(map);
@Override
public void setHoldability(int holdability) throws SQLException
con.setHoldability(holdability);
@Override
public int getHoldability() throws SQLException
return con.getHoldability();
@Override
public Savepoint setSavepoint() throws SQLException
return con.setSavepoint();
@Override
public Savepoint setSavepoint(String name) throws SQLException
return con.setSavepoint(name);
@Override
public void rollback(Savepoint savepoint) throws SQLException
con.rollback(savepoint);
@Override
public void releaseSavepoint(Savepoint savepoint) throws SQLException
con.releaseSavepoint(savepoint);
@Override
public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
return con.createStatement(resultSetType,resultSetConcurrency,resultSetHoldability);
@Override
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
return con.prepareStatement(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
@Override
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
return con.prepareCall(sql,resultSetType,resultSetConcurrency,resultSetHoldability);
@Override
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException
return con.prepareStatement(sql,autoGeneratedKeys);
@Override
public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
return con.prepareStatement(sql,columnIndexes);
@Override
public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
return con.prepareStatement(sql,columnNames);
@Override
public Clob createClob() throws SQLException
return con.createClob();
@Override
public Blob createBlob() throws SQLException
return con.createBlob();
@Override
public NClob createNClob() throws SQLException
return con.createNClob();
@Override
public SQLXML createSQLXML() throws SQLException
return con.createSQLXML();
@Override
public boolean isValid(int timeout) throws SQLException
return con.isValid(timeout);
@Override
public void setClientInfo(String name, String value) throws SQLClientInfoException
con.setClientInfo(name,value);
@Override
public void setClientInfo(Properties properties) throws SQLClientInfoException
con.setClientInfo(properties);
@Override
public String getClientInfo(String name) throws SQLException
return con.getClientInfo(name);
@Override
public Properties getClientInfo() throws SQLException
return con.getClientInfo();
@Override
public Array createArrayOf(String typeName, Object[] elements) throws SQLException
return con.createArrayOf(typeName,elements);
@Override
public Struct createStruct(String typeName, Object[] attributes) throws SQLException
return con.createStruct(typeName,attributes);
@Override
public void setSchema(String schema) throws SQLException
con.setSchema(schema);
@Override
public String getSchema() throws SQLException
return con.getSchema();
@Override
public void abort(Executor executor) throws SQLException
con.abort(executor);
@Override
public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException
con.setNetworkTimeout(executor,milliseconds);
@Override
public int getNetworkTimeout() throws SQLException
return con.getNetworkTimeout();
@Override
public <T> T unwrap(Class<T> iface) throws SQLException
return con.unwrap(iface);
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException
return con.isWrapperFor(iface);
- 自定义连接类
/*
自定义Connection连接类。通过适配器设计模式。完成close()方法的重写
1.定义一个类，继承适配器父类
2.定义Connection连接对象和连接池容器对象的变量
3.提供有参构造方法，接收连接对象和连接池对象，对变量赋值
4.在close()方法中，完成连接的归还
*/
public class MyConnection3 extends MyAdapter
//2.定义Connection连接对象和连接池容器对象的变量
private Connection con;
private List<Connection> pool;
//3.提供有参构造方法，接收连接对象和连接池对象，对变量赋值
public MyConnection3(Connection con,List<Connection> pool)
super(con); // 将接收的数据库连接对象给适配器父类传递
this.con = con;
this.pool = pool;
//4.在close()方法中，完成连接的归还
@Override
public void close() throws SQLException
pool.add(con);
- 自定义连接池类
public class MyDataSource implements DataSource
//定义集合容器，用于保存多个数据库连接对象
private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());
//静态代码块，生成10个数据库连接保存到集合中
static
for (int i = 0; i < 10; i++)
Connection con = JDBCUtils.getConnection();
pool.add(con);
//返回连接池的大小
public int getSize()
return pool.size();
//从池中返回一个数据库连接
@Override
public Connection getConnection()
if(pool.size() > 0)
//从池中获取数据库连接
Connection con = pool.remove(0);
//通过自定义连接对象进行包装
//MyConnection2 mycon = new MyConnection2(con,pool);
MyConnection3 mycon = new MyConnection3(con,pool);
//返回包装后的连接对象
return mycon;
else
throw new RuntimeException("连接数量已用尽");
- 动态代理
- 经过我们适配器模式的改进，自定义连接类中的方法已经很简洁了。剩余所有的方法已经抽取到了适配器类中。但是适配器这个类还是我们自己编写的，也比较麻烦！所以可以使用动态代理的方式来改进。
- 自定义数据库连接池类
public class MyDataSource implements DataSource
//定义集合容器，用于保存多个数据库连接对象
private static List<Connection> pool = Collections.synchronizedList(new ArrayList<Connection>());
//静态代码块，生成10个数据库连接保存到集合中
static
for (int i = 0; i < 10; i++)
Connection con = JDBCUtils.getConnection();
pool.add(con);
//返回连接池的大小
public int getSize()
return pool.size();
//动态代理方式
@Override
public Connection getConnection()
if(pool.size() > 0)
//从池中获取数据库连接
Connection con = pool.remove(0);
Connection proxyCon = (Connection)Proxy.newProxyInstance(con.getClass().getClassLoader(), new Class[]Connection.class, new InvocationHandler()
/*
执行Connection实现类所有方法都会经过invoke
如果是close方法，则将连接还回池中
如果不是，直接执行实现类的原有方法
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
if(method.getName().equals("close"))
pool.add(con);
return null;
else
return method.invoke(con,args);
);
return proxyCon;
else
throw new RuntimeException("连接数量已用尽");
//从池中返回一个数据库连接
/*@Override
public Connection getConnection()
if(pool.size() > 0)
//从池中获取数据库连接
Connection con = pool.remove(0);
//通过自定义连接对象进行包装
//MyConnection2 mycon = new MyConnection2(con,pool);
MyConnection3 mycon = new MyConnection3(con,pool);
//返回包装后的连接对象
return mycon;
else
throw new RuntimeException("连接数量已用尽");
*/
5.开源连接池的使用
- C3P0
- 基本使用
/*
使用C3P0连接池
1.导入jar包
2.导入配置文件到src目录下
3.创建c3p0连接池对象
4.获取数据库连接进行使用
*/
public class C3P0Demo1
public static void main(String[] args) throws Exception
//创建c3p0连接池对象
DataSource dataSource = new ComboPooledDataSource();
//获取数据库连接进行使用
Connection con = dataSource.getConnection();
//查询全部学生信息
String sql = "SELECT * FROM student";
PreparedStatement pst = con.prepareStatement(sql);
ResultSet rs = pst.executeQuery();
while(rs.next())
System.out.println(rs.getInt("sid") + "\\t" + rs.getString("name") + "\\t" + rs.getInt("age") + "\\t" + rs.getDate("birthday"));
//释放资源
rs.close();
pst.close();
con.close(); // 将连接对象归还池中
- 配置演示
public class C3P0Demo2
public static void main(String[] args) throws Exception
//创建c3p0连接池对象
DataSource dataSource = new ComboPooledDataSource();
//获取数据库连接进行使用
for(int i = 1; i <= 11; i++)
Connection con = dataSource.getConnection();
System.out.println(i + ":" + con);
if(i == 5)
con.close();
- Druid
- 基本使用
/*
Druid连接池
1.导入jar包
2.编写配置文件，放在src目录下
3.通过Properties集合加载配置文件
4.通过Druid连接池工厂类获取数据库连接池对象
5.获取数据库连接，进行使用
*/
public class DruidDemo1
public static void main(String[] args) throws Exception
//通过Properties集合加载配置文件
InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
Properties prop = new Properties();
prop.load(is);
//通过Druid连接池工厂类获取数据库连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//获取数据库连接，进行使用
Connection con = dataSource.getConnection();
//查询全部学生信息
String sql = "SELECT * FROM student";
PreparedStatement pst = con.prepareStatement(sql);
ResultSet rs = pst.executeQuery();
while(rs.next())
System.out.println(rs.getInt("sid") + "\\t" + rs.getString("name") + "\\t" + rs.getInt("age") + "\\t" + rs.getDate("birthday"));
//释放资源
rs.close();
pst.close();
con.close(); // 将连接对象归还池中
- 抽取工具类
/*
数据库连接池工具类
*/
public class DataSourceUtils
//1.私有构造方法
private DataSourceUtils()
//2.定义DataSource数据源变量
private static DataSource dataSource;
//3.提供静态代码块，完成配置文件的加载和获取连接池对象
static
try
//加载配置文件
InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
Properties prop = new Properties();
prop.load(is);
//获取数据库连接池对象
dataSource = DruidDataSourceFactory.createDataSource(prop);
catch(Exception e)
e.printStackTrace();
//4.提供获取数据库连接的方法
public static Connection getConnection()
Connection con = null;
try
con = dataSource.getConnection();
catch (SQLException e)
e.printStackTrace();
return con;
//5.提供获取数据库连接池的方法
public static DataSource getDataSource()
return dataSource;
//6.提供释放资源的方法
public static void close(Connection con, Statement stat, ResultSet rs)
if(con != null)
try
con.close();
catch (SQLException e)
e.printStackTrace();
if(stat != null)
try
stat.close();
catch (SQLException e)
e.printStackTrace();
if(rs != null)
try
rs.close();
catch (SQLException e)
e.printStackTrace();
public static void close(Connection con, Statement stat)
close(con,stat,null);
二、JDBC框架(JDBCTemplate)
1.分析前一天案例中的重复代码
- dao层的重复代码
- 定义必要的信息、获取数据库的连接、释放资源都是重复的代码！
- 而我们最终的核心功能仅仅只是执行一条sql语句而已啊！
- 所以我们可以抽取出一个JDBC模板类，来封装一些方法(update、query)，专门帮我们执行增删改查的sql语句！
- 将之前那些重复的操作，都抽取到模板类中的方法里。就能大大简化我们的使用步骤！
2.自定义JDBC框架
2.1数据库的源信息
- DataBaseMetaData(了解)：数据库的源信息
- java.sql.DataBaseMetaData：封装了整个数据库的综合信息
- 例如：
- String getDatabaseProductName()：获取数据库产品的名称
- int getDatabaseProductVersion()：获取数据库产品的版本号
- ParameterMetaData：参数的源信息
- java.sql.ParameterMetaData：封装的是预编译执行者对象中每个参数的类型和属性
- 这个对象可以通过预编译执行者对象中的getParameterMetaData()方法来获取
- 核心功能：
- int getParameterCount()：获取sql语句中参数的个数
- ResultSetMetaData：结果集的源信息
- java.sql.ResultSetMetaData：封装的是结果集对象中列的类型和属性
- 这个对象可以通过结果集对象中的getMetaData()方法来获取
- 核心功能：
- int getColumnCount()：获取列的总数
- String getColumnName(int i)：获取列名
2.2JDBCTemplate类增删改功能的编写
public class JDBCTemplate
private DataSource dataSource;
private Connection con;
private PreparedStatement pst;
private ResultSet rs;
public JDBCTemplate(DataSource dataSource)
this.dataSource = dataSource;
//专用于执行增删改sql语句的方法
public int update(String sql,Object...objs)
int result = 0;
try
con = dataSource.getConnection();
pst = con.prepareStatement(sql);
//获取sql语句中的参数源信息
ParameterMetaData pData = pst.getParameterMetaData();
//获取sql语句中参数的个数
int parameterCount = pData.getParameterCount();
//判断参数个数是否一致
if(parameterCount != objs.length)
throw new RuntimeException("参数个数不匹配");
//为sql语句中的?占位符赋值
for (int i = 0; i < objs.length; i++)
pst.setObject(i+1,objs[i]);
//执行sql语句
result = pst.executeUpdate();
catch(Exception e)
e.printStackTrace();
finally
//释放资源
DataSourceUtils.close(con,pst);
//返回结果
return result;
2.3JDBCTemplate类查询功能的编写
- 实体类
/*
学生实体类
*/
public class Student
private Integer sid;
private String name;
private Integer age;
private Date birthday;
public Student()
public Student(Integer sid, String name, Integer age, Date birthday)
this.sid = sid;
this.name = name;
this.age = age;
this.birthday = birthday;
public Integer getSid()
return sid;
public void setSid(Integer sid)
this.sid = sid;
public String getName()
return name;
public void setName(String name)
this.name = name;
public Integer getAge()
return age;
public void setAge(Integer age)
this.age = age;
public Date getBirthday()
return birthday;
public void setBirthday(Date birthday)
this.birthday = birthday;
@Override
public String toString()
return "Student" +
"sid=" + sid +
", name=" + name + \\ +
", age=" + age +
", birthday=" + birthday +
;
- ResultSetHandler接口
/*
用于处理结果集的接口
*/
public interface ResultSetHandler<T>
//处理结果集的抽象方法。
<T> T handler(ResultSet rs);
- BeanHandler实现类
/*
实现类1：用于完成将查询出来的一条记录，封装到Student对象中
*/
public class BeanHandler<T> implements ResultSetHandler<T>
//1.声明对象类型变量
private Class<T> beanClass;
//2.有参构造对变量赋值
public BeanHandler(Class<T> beanClass)
this.beanClass = beanClass;
/*
将ResultSet结果集中的数据封装到beanClass类型对象中
*/
@Override
public T handler(ResultSet rs)
//3.声明对象
T bean = null;
try
//4.创建传递参数的对象
bean = beanClass.newInstance();
//5.判断是否有结果集
if(rs.next())
//6.得到所有的列名
//6.1先得到结果集的源信息
ResultSetMetaData rsmd = rs.getMetaData();
//6.2还要得到有多少列
int columnCount = rsmd.getColumnCount();
//6.3遍历列数
for(int i = 1; i <= columnCount; i++)
//6.4得到每列的列名
String columnName = rsmd.getColumnName(i);
//6.5通过列名获取数据
Object columnValue = rs.getObject(columnName);
//6.6列名其实就是对象中成员变量的名称。于是就可以使用列名得到对象中属性的描述器(get和set方法)
PropertyDescriptor pd = new PropertyDescriptor(columnName.toLowerCase(),beanClass);
//6.7获取set方法
Method writeMethod = pd.getWriteMethod();
//6.8执行set方法，给成员变量赋值
writeMethod.invoke(bean,columnValue);
catch (Exception e)
e.printStackTrace();
//7.将对象返回
return bean;
- BeanListHandler实现类
/*
实现类2：用于将结果集封装到集合中
*/
public class BeanListHandler<T> implements ResultSetHandler<T>
//1.声明对象变量
private Class<T> beanClass;
//2.有参构造为变量赋值
public BeanListHandler(Class<T> beanClass)
this.beanClass = beanClass;
@Override
public List<T> handler(ResultSet rs)
//3.创建集合对象
List<T> list = new ArrayList<>();
try
//4.遍历结果集对象
while(rs.next())
//5.创建传递参数的对象
T bean = beanClass.newInstance();
//6.得到所有的列名
//6.1先得到结果集的源信息
ResultSetMetaData rsmd = rs.getMetaData();
//6.2还要得到有多少列
int columnCount = rsmd.getColumnCount();
//6.3遍历列数
for(int i = 1; i <= columnCount; i++)
//6.4得到每列的列名
String columnName = rsmd.getColumnName(i);
//6.5通过列名获取数据
Object columnValue = rs.getObject(columnName);
//6.6列名其实就是对象中成员变量的名称。于是就可以使用列名得到对象中属性的描述器(get和set方法)
PropertyDescriptor pd = new PropertyDescriptor(columnName.toLowerCase(),beanClass);
//6.7获取set方法
Method writeMethod = pd.getWriteMethod();
//6.8执行set方法，给成员变量赋值
writeMethod.invoke(bean,columnValue);
//7.将对象保存到集合中
list.add(bean);
catch (Exception e)
e.printStackTrace();
//8.返回结果
return list;
- ScalarHandler实现类
/*
实现类3：用于返回一个聚合函数的查询结果
*/
public class ScalarHandler<T> implements ResultSetHandler<T>
@Override
public Long handler(ResultSet rs)
//1.声明一个变量
Long value = null;
try
//2.判断是否有结果
if(rs.next())
//3.获取结果集的源信息
ResultSetMetaData rsmd = rs.getMetaData();
//4.获取第一列的列名
String columnName = rsmd.getColumnName(1);
//5.根据列名获取值
value = rs.getLong(columnName);
catch(Exception e)
e.printStackTrace();
//6.将结果返回
return value;
- JDBCTemplate类
public class JDBCTemplate
private DataSource dataSource;
private Connection con;
private PreparedStatement pst;
private ResultSet rs;
public JDBCTemplate(DataSource dataSource)
this.dataSource = dataSource;
/*
专用于执行聚合函数sql语句的方法
*/
public Long queryForScalar(String sql, ResultSetHandler<Long> rsh, Object...objs)
Long result = null;
try
con = dataSource.getConnection();
pst = con.prepareStatement(sql);
//获取sql语句中的参数源信息
ParameterMetaData pData = pst.getParameterMetaData();
int parameterCount = pData.getParameterCount();
//判断参数个数是否一致
if(parameterCount != objs.length)
throw new RuntimeException("参数个数不匹配");
//为sql语句中的?占位符赋值
for (int i = 0; i < objs.length; i++)
pst.setObject(i+1,objs[i]);
//执行sql语句
rs = pst.executeQuery();
//通过ScalarHandler方式对结果进行处理
result = rsh.handler(rs);
catch(Exception e)
e.printStackTrace();
finally
//释放资源
DataSourceUtils.close(con,pst,rs);
//将结果返回
return result;
/*
专用于查询所有记录sql语句的方法
*/
public <T> List<T> queryForList(String sql, ResultSetHandler<T> rsh, Object...objs)
List<T> list = new ArrayList<>();
try
con = dataSource.getConnection();
pst = con.prepareStatement(sql);
//获取sql语句中的参数源信息
ParameterMetaData pData = pst.getParameterMetaData();
int parameterCount = pData.getParameterCount();
//判断参数个数是否一致
if(parameterCount != objs.length)
throw new RuntimeException("参数个数不匹配");
//为sql语句中的?占位符赋值
for (int i = 0; i < objs.length; i++)
pst.setObject(i+1,objs[i]);
//执行sql语句
rs = pst.executeQuery();
//通过BeanListHandler方式对结果进行处理
list = rsh.handler(rs);
catch(Exception e)
e.printStackTrace();
finally
//释放资源
DataSourceUtils.close(con,pst,rs);
//将结果返回
return list;
/*
专用于执行查询一条记录sql语句的方法
*/
public <T> T queryForObject(String sql, ResultSetHandler<T> rsh, Object...objs)
T obj = null;
try
con = dataSource.getConnection();
pst = con.prepareStatement(sql);
//获取sql语句中的参数源信息
ParameterMetaData pData = pst.getParameterMetaData();
int parameterCount = pData.getParameterCount();
//判断参数个数是否一致
if(parameterCount != objs.length)
throw new RuntimeException("参数个数不匹配");
//为sql语句中的?占位符赋值
for (int i = 0; i < objs.length; i++)
pst.setObject(i+1,objs[i]);
//执行sql语句
rs = pst.executeQuery();
//通过BeanHandler方式对结果进行处理
obj = rsh.handler(rs);
catch(Exception e)
e.printStackTrace();
finally
//释放资源
DataSourceUtils.close(con,pst,rs);
//将结果返回
return obj;
2.4测试自定义JDBC框架的使用
public class JDBCTemplateTest
//创建JDBCTemplate对象
JDBCTemplate template = new JDBCTemplate(DataSourceUtils.getDataSource());
@Test
public void selectScalar()
//查询student表的记录条数
String sql = "SELECT COUNT(*) FROM student";
Long count = template.queryForScalar(sql, new ScalarHandler<Long>());
System.out.println(count);
@Test
public void selectAll()
//查询所有学生信息
String sql = "SELECT * FROM student";
List<Student> list = template.queryForList(sql, new BeanListHandler<Student>(Student.class));
for(Student stu : list)
System.out.println(stu);
@Test
public void selectOne()
//查询张三这条记录
String sql = "SELECT * FROM student WHERE sid=?";
//通过BeanHandler将结果封装成一个Student对象
Student stu = template.queryForObject(sql, new BeanHandler<Student>(Student.class), 1);
System.out.println(stu);
@Test
public void insert()
//新增周七记录
String sql = "INSERT INTO student VALUES (?,?,?,?)";
Object[] params = 5,"周七",27,"2007-07-07";
int result = template.update(sql, params);
System.out.println(result);
@Test
public void delete()
//删除周七这条记录
String sql = "DELETE FROM student WHERE sid=?";
int result = template.update(sql, 5);
System.out.println(result);
@Test
public void update()
//修改张三的年龄为33
String sql = "UPDATE student SET age=? WHERE name=?";
Object[] params = 33,"张三";
int result = template.update(sql,params);
System.out.println(result);
Java Web JDBC的增删改查，C3P0等连接池，dbutils框架的使用
前面做了一个非常垃圾的小demo，真的无法直面它，菜的抠脚啊，真的菜，好好努力把。菜鸡。
--WZY
一、JDBC是什么？
Java Data Base Connectivity，java数据库连接，在需要存储一些数据，或者拿到一些数据的时候，就需要往数据库里存取数据，那么java如何连接数据库呢？需要哪些步骤？
1、注册驱动
什么是驱动？
驱动就是JDBC实现类，通俗点讲，就是能够连接到数据库功能的东西就是驱动，由于市面上有很多数据库，Oracle、MySql等等，所以java就有一个连接数据库的实现规范接口，定义一系列的连接数据库接口(java.sql.Driver接口)，但是不提供实现，而每个数据库厂家来提供这些接口的具体实现，这样一来，不管使用的是什么数据库，我们开发者写的代码都是相同的，就不必因为数据库的不同，而写法不同，唯一的不同就是数据库驱动不一样，使用mysql，那么就必须使用mysql的驱动，使用Oracle就必须使用oracle的驱动实现类。 看下面mysql连接数据的原理图，看看驱动是在哪里，起什么作用。就明白了什么是驱动了。
DriverManager，一个工具类，是用于操作管理JDBC实现类的，
原始写法：DriverManager.register(new Driver()); //因为使用的是MySql，所以在导包时就需要导入com.mysql.jdbc.Driver
现在写法：Class.forName("com.mysql.jdbc.Driver"); //不用导包，会执行com.mysql.jdbc.Driver类中的静态代码块，其静态代码块的内容为
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can\'t register driver!");
}
}
会发现第二种加载驱动的方法的底层其实就是第一种加载驱动。为什么要这样呢？原因很简单， 第一种是硬编程，直接将数据库驱动给写死了，无法扩展，如果使用第一种，那么连接的数据库只能是mysql，因为导包导的是mysql的驱动包，如果换成Oracle，就会报错，需要在代码中将Oracle的驱动包导入，这样很麻烦，而第二种写法就不一样了，第二种是使用的字符串方法注册驱动的，我们只需要将该字符串提取到一个配置文件中，以后想换成oracle数据库，只需要将该字符串换成oracle驱动的类全名即可，而不需要到代码中去修改什么东西。
2、获得连接
使用DriverManage来获得连接，因为DriverManager是驱动实现类的管理者
Connection conn = DriverManager.getConnection(url,user,password);
url:确定数据库服务器的位置，端口号，数据库名
jdbc:mysql://localhost:3306/db
user:登录名称，默认root
password:密码，默认root
这里只是说mysql，别的数据库，url格式就不同了。
MySQL jdbc:mysql://localhost:3306/db 默认端口是3306，粗体为连接时使用的数据库名
Oracle jdbc:oracle:thin:@localhost:1521:db 默认端口号1521
DB2 jdbc:db2://localhost:6789/db 默认端口号6789
SQLServer jdbc:microsoft:sqlserver://localhost:1433;databaseName=db 默认端口号1433
SQLServer 2005 jdbc:sqlserver://localhost:1433;databaseName=db 默认端口号1433
3、获取执行sql语句对象，PraparedStament对象
通过Connection对象获取Statement或者PraparedStament对象(使用它)处理sql
Statement
Statement st = conn.createStatement(); //获取sql语句执行对象
st.excuteUpdate(sql); //执行增删改语句
st.excuteQuery(sql); //执行查询语句
sql语句必须是完整的。
PraparedStatment
sql语句可以不是完整的，可以将参数用?替代，然后在预编译后加入未知参数
PraparedStatment ps = conn.prapareStatement(sql); //获取sql语句执行对象praparedStatment
赋值
ps.setInt(Index,value); ps.setString(index,value); //可以设置很多中类型，index从1开始，代表sql语句中的第几个未知参数，
ps.excuteUpdate(); //执行增删改语句
ps.excuteQuery(sql); //执行查询语句
这两个的区别，常使用的是PraparedStatment对象，因为它可以预编译，效率高，可以设置参数等等优点
4、获得结果集对象
int count = ps.excuteUpdate(); //执行增删改的sql语句时，返回一个int类型的整数，代表数据库表影响的行数，
Result result = ps.excuteQuery(); //执行查询sql语句时，返回一个结果集对象，该对象装着所有查询到的数据信息，一行一行的存储数据库表信息。
5、处理结果
对查询到的Result结果进行处理，拿到所有数据，并封装成对象。
while(rs.next()){
获取行数据的第一种方式
rs.getString(index);//index代表第几列，从1开始
获取行数据的第二中方式
rs.getString(string); //string：代表字段名称。
}
总结：java的JDBC就分为5步，4个属性
属性：driver、url、user、password
五步：
注册驱动、获取连接、获取执行sql语句对象、获取结果集对象、处理结果。
二、JDBC的CURD操作
创建（Create）、更新（Update）、读取（Retrieve）和删除（Delete）操作
查询所有(读取Retrieve)
findAll()
1 @Test 2 public void findAll() throws Exception{ 3 //1 注册驱动 4 Class.forName("com.mysql.jdbc.Driver"); 5 //2 获得连接 6 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root"); 7 //3语句执行者，sql语句 8 Statement st = conn.praparedStatement("select * from t_user"); 9 //4 执行查询语句 10 ResultSet rs = st.executeQuery(); 11 //5处理数据 12 // * 如果查询多个使用，使用while循环进行所有数据获取 13 // * 技巧：如果查询结果最多1条，使用 if(rs.next()) { 查询到了 } else { 没有数据 } 14 while(rs.next()){ 15 int id = rs.getInt(1); 16 String username = rs.getString(2); 17 String password =rs.getString(3); 18 System.out.print(id + ", "); 19 System.out.print(username + ", "); 20 System.out.println(password); 21 } 22 //6释放资源 23 rs.close(); 24 st.close(); 25 conn.close(); 26 27 }
save(),增加操作(创建Create)
1 @Test 2 public void save() throws Exception{ 3 //1 注册驱动 4 Class.forName("com.mysql.jdbc.Driver"); 5 //2 获得连接 6 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root"); 7 //3语句执行者 8 Statement st = conn.praparedStatement("insert into t_user(username,password) values(?,?)"); 9 //3.1赋值 10 st.setString(1,"xiaoming"); 11 st.setString(2,"123"); 12 //4 执行DML语句 13 int r = st.executeUpdate(); 14 15 //5处理数据 16 System.out.println(r); 17 18 //6释放资源 19 //rs.close(); 20 st.close(); 21 conn.close(); 22 }
update(),更新
1 @Test 2 public void update() throws Exception{ 3 //1 注册驱动 4 Class.forName("com.mysql.jdbc.Driver"); 5 //2 获得连接 6 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root"); 7 //3语句执行者 8 Statement st = conn.praparedStatement("update t_user set username = ？ where id = ？ "); 9 //3.1赋值参数 10 st.setString(1,"xiaoye"); 11 st.setInt(2,2); 12 //4 执行DML语句 13 int r = st.executeUpdate(); 14 15 //5处理数据 16 System.out.println(r); 17 18 //6释放资源 19 //rs.close(); 20 st.close(); 21 conn.close(); 22 }
delete(),删除
1 @Test 2 public void delete() throws Exception{ 3 //1 注册驱动 4 Class.forName("com.mysql.jdbc.Driver"); 5 //2 获得连接 6 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root"); 7 //3语句执行者 8 Statement st = conn.praparedStatement("delete from t_user where id = ?"); 9 //3.1赋值参数 10 st.setInt(1,2); 11 //4 执行DML语句 12 int r = st.executeUpdate(); 13 14 //5处理数据 15 System.out.println(r); 16 17 //6释放资源 18 //rs.close(); 19 st.close(); 20 conn.close(); 21 }
上面重复代码过多，所以使用一个获得连接的工具类，来帮我们获得连接，并且把四个属性提取出来，放在配置文件中
使用jdbcInfo.properties(放在src下面即可)保存四个属性。以方便修改
jdbcInfo.properties
1 driver = com.mysql.jdbc.Driver 2 url = jdbc:mysql://localhost:3306/myums 3 user = root 4 password =root
写一个工具类，注册驱动，提供连接，就不必每次都重复写注册驱动，连接代码了
JdbcUtils.java
1 public class JdbcUtils { 2 3 private static String url; 4 private static String user; 5 private static String password; 6 static{ 7 try { 8 9 // 将具体参数存放配置文件中， xml，properties（key=value） 10 // 1 加载 properties 文件 src （类路径） --> WEB-INF/classes 11 // 方式1： 使用类加载ClassLoader的方式加载资源 12 InputStream is = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbcInfo.properties"); 13 // 方式2：使用Class对象加载，必须添加/，表示src 14 // InputStream is = JdbcUtils.class.getResourceAsStream("/jdbcInfo.properties"); 15 // * 如果不使用/表示，从当前类所在的包下加载资源 16 //InputStream is = JdbcUtils.class.getResourceAsStream("/com/itheima/d_utils/jdbcInfo2.properties"); 17 // 2 解析 18 Properties props = new Properties(); 19 props.load(is); 20 21 // 3 获得配置文件中数据 22 String driver = props.getProperty("driver"); 23 url = props.getProperty("url"); 24 user = props.getProperty("user"); 25 password = props.getProperty("password");; 26 27 // 4 注册驱动 28 Class.forName(driver); 29 } catch (Exception e) { 30 throw new RuntimeException(e); 31 } 32 } 33 34 35 /** 36 * 获得连接 37 * @return 38 */ 39 public static Connection getConnection(){ 40 try { 41 42 Connection conn = DriverManager.getConnection(url, user, password); 43 return conn; //获得连接 44 } catch (Exception e) { 45 //将编译时异常 转换 运行时 ， 以后开发中 运行时异常使用比较多的。 46 } 47 } 48 49 /** 50 * 释放资源 51 * @param conn 52 * @param st 53 * @param rs 54 */ 55 public static void closeResource(Connection conn,Statement st,ResultSet rs){ 56 try { 57 if (rs != null) { 58 rs.close(); 59 } 60 } catch (Exception e) { 61 throw new RuntimeException(e); 62 } finally{ 63 try { 64 if (st != null) { 65 st.close(); 66 } 67 } catch (Exception e) { 68 throw new RuntimeException(e); 69 } finally{ 70 try { 71 if (conn != null) { 72 conn.close(); 73 } 74 } catch (Exception e) { 75 throw new RuntimeException(e); 76 } 77 } 78 } 79 }
模版代码
1 //模板代码 2 public void demo01(){ 3 // 0 提供变量 4 Connection conn = null; 5 Statement st = null; 6 ResultSet rs = null; 7 8 try { 9 //1 获得连接 10 conn = JdbcUtils.getConnection(); 11 12 13 //2 获得语句执行者 14 //3执行sql语句 15 //4处理结果 16 17 } catch (Exception e) { 18 throw new RuntimeException(e); 19 } finally{ 20 //end 释放资源 21 JdbcUtils.closeResource(conn, st, rs); 22 } 23 }
三、连接池
在上面，我们在进行CRUD时，一直重复性的写一些代码，比如最开始的注册驱动，获取连接代码，一直重复写，通过编写一个获取连接的工具类后，解决了这个问题，但是又会出现新的问题，每进行一次操作，就会获取一个连接，用完之后，就销毁，就这样一直新建连接，销毁连接，新建，销毁，连接Connection 创建与销毁 比较耗时的。所以应该要想办法解决这个问题。
连接池就是为了解决这个问题而出现的一个方法，为了提高性能，开发连接池，连接池中一直保持有n个连接，供调用者使用，调用者用完返还给连接池，继续给别的调用者使用，比如连接池中一开始就有10个连接，当有5个用户拿走了5个连接后，池中还剩5个，当第6个用户在去池中拿连接而前面5个连接还没归还时，连接池就会新建一个连接给第六个用户，让池中一直能够保存最少5个连接，而当这样新建了很多连接后，用户归还连接回来时，会比原先连接池中的10个连接更多，连接池就会设置一个池中最大空闲的连接数，如果超过了这个数，就会将超过的连接给释放掉，连接池就是这样工作的。
现在介绍几款连接池，DBCP、C3P0、tomcat内置连接池(JNDI)(这个不讲)
DBCP连接池，
两种方式获得连接，使用配置文件，不使用配置文件
1、不使用配置文件，自己手动设置参数
导包
核心类BasicDataSource，通过new出BasicDataSource对象，设置参数 然后获得连接
1 //创建核心类 2 BasicDataSource bds = new BasicDataSource(); 3 //配置4个基本参数 4 bds.setDriverClassName("com.mysql.jdbc.Driver"); 5 bds.setUrl("jdbc:mysql:///myums"); 6 bds.setUsername("root"); 7 bds.setPassword("root"); 8 9 //管理连接配置 10 bds.setMaxActive(50); //最大活动数 11 bds.setMaxIdle(20); //最大空闲数 12 bds.setMinIdle(5); //最小空闲数 13 bds.setInitialSize(10);//初始化个数 14 15 //获取连接 16 try { 17 Connection conn = bds.getConnection(); 18 System.out.println(conn); 19 20 } catch (SQLException e) { 21 throw new RuntimeException(e); 22 }
2、使用配置文件，参数写入配置文件中即可，也就是通过配置文件来配置驱动、用户名、密码、等信息
导包
导入配置文件dbcpconfig.properties
1 #连接设置 2 driverClassName=com.mysql.jdbc.Driver 3 url=jdbc:mysql://localhost:3306/test 4 username=root 5 password=root 6 7 #<!-- 初始化连接 --> 8 initialSize=10 9 10 #最大连接数量 11 maxActive=50 12 13 #<!-- 最大空闲连接 --> 14 maxIdle=20 15 16 #<!-- 最小空闲连接 --> 17 minIdle=5 18 19 #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 --> 20 maxWait=60000 21 22 23 #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 24 #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。 25 connectionProperties=useUnicode=true;characterEncoding=gbk 26 27 #指定由连接池所创建的连接的自动提交（auto-commit）状态。 28 defaultAutoCommit=true 29 30 #driver default 指定由连接池所创建的连接的只读（read-only）状态。 31 #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix） 32 defaultReadOnly= 33 34 #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。 35 #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE 36 defaultTransactionIsolation=READ_UNCOMMITTED
获取连接
1 //通过类加载器获取指定配置文件的输入流，Dbcp1是一个类名， 2 InputStream is = Dbcp1.class.getClassLoader().getResourceAsStream("dbcpconfig.properties"); 3 Properties properties = new Properties(); 4 properties.load(is); 5 //加载配置文件，获得配置信息 6 DataSource ds = BasicDataSourceFactory.createDataSource(properties); 7 Connection conn = ds.getConnection(); 8 System.out.println(conn);
C3P0连接池
导包
从配置信息中获取 配置文件必须为xml
c3p0-config.xml
1 <c3p0-config> 2 <!-- 默认配置，如果没有指定则使用这个配置 --> 3 <default-config> 4 <property name="driverClass">com.mysql.jdbc.Driver</property> 5 <property name="jdbcUrl">jdbc:mysql://localhost:3306/myums</property> 6 <property name="user">root</property> 7 <property name="password">root</property> 8 9 <property name="checkoutTimeout">30000</property> 10 <property name="idleConnectionTestPeriod">30</property> 11 <property name="initialPoolSize">10</property> 12 <property name="maxIdleTime">30</property> 13 <property name="maxPoolSize">100</property> 14 <property name="minPoolSize">10</property> 15 <property name="maxStatements">200</property> 16 <user-overrides user="test-user"> 17 <property name="maxPoolSize">10</property> 18 <property name="minPoolSize">1</property> 19 <property name="maxStatements">0</property> 20 </user-overrides> 21 </default-config> 22 <!-- 命名的配置 --> 23 <named-config name="jxpx"> 24 <property name="driverClass">com.mysql.jdbc.Driver</property> 25 <property name="jdbcUrl">jdbc:mysql://localhost:3306/myums</property> 26 <property name="user">root</property> 27 <property name="password">root</property> 28 <!-- 如果池中数据连接不够时一次增长多少个 --> 29 <property name="acquireIncrement">5</property> 30 <property name="initialPoolSize">20</property> 31 <property name="minPoolSize">10</property> 32 <property name="maxPoolSize">40</property> 33 <property name="maxStatements">0</property> 34 <property name="maxStatementsPerConnection">5</property> 35 </named-config> 36 </c3p0-config>
从配置文件中看，需要注意一个地方，一个是default-config，一个是name-config，两者都区别在于创建核心类对象时，如果将name-config作为参数传进去，那么将会调用name-config下的配置信息，否则将调用default-config下的配置信息，
两种方式使用c3p0，加参数，使用named-config 的配置信息，不加参数，自动加载配置信息，加载的是default-config中的信息
获得连接，使用核心类