连接池 DBCP c3p0以及分页的案例

1. 连接池

思考：

程序中连接如何管理？

1. 连接资源宝贵；需要对连接管理
2. 连接：

a) 操作数据库，创建连接

b) 操作结束，  关闭！

分析：

涉及频繁的连接的打开、关闭，影响程序的运行效率！

连接管理：

预先创建一组连接，有的时候每次取出一个； 用完后，放回；

学习连接池：

1. 自定义一个连接池
2. 学习优秀的连接池组件

a) DBCP

b) C3P0

自定义连接池

代理：

如果对某个接口中的某个指定的方法的功能进行扩展，而不想实现接口里所有方法，可以使用(动态)代理模式!

Java中代理模式：静态/动态/Cglib代理(spring)

使用动态代理，可以监测接口中方法的执行！

如何对Connection对象，生成一个代理对象：

|--Proxy

static Object newProxyInstance(

ClassLoader loader,    当前使用的类加载器

Class<?>[] interfaces,   目标对象(Connection)实现的接口类型

InvocationHandler h    事件处理器：当执行上面接口中的方法的时候，就会自动触发事件处理器代码，把当前执行的方法(method)作为参数传入。

)  想要什么就努力的去得到，去想方设法，去行动，最终得到之。

说说代理Proxy这里到底干了什么，这里就是什么呢，可以使用pool.releaseConnection(conn)释放链接，也可以链接本身直接conn.close()释放链接，自身直接释放链接的，不会改变pool中的属性。Proxy的作用就是一种代理，是一种基于时间的机制，代理完成一些业务逻辑，当你执行某个方法，比如这里执行close方法的时候，我就要让你顺带做一些改变pool属性的一些逻辑。

/**

* 自定义连接池, 管理连接

* 代码实现：

1.  MyPool.java  连接池类，

2.  指定全局参数：  初始化数目、最大连接数、当前连接、   连接池集合

3.  构造函数：循环创建3个连接

4.  写一个创建连接的方法

5.  获取连接

------>  判断： 池中有连接， 直接拿

------>                池中没有连接，

------>                 判断，是否达到最大连接数； 达到，抛出异常；没有达到最大连接数，

创建新的连接

6. 释放连接

------->  连接放回集合中(..)

*

*/

public class MyPool {

private int init_count = 3; // 初始化连接数目

private int max_count = 6; // 最大连接数

private int current_count = 0;  // 记录当前使用连接数

// 连接池 （存放所有的初始化连接）

private LinkedList<Connection> pool = new LinkedList<Connection>();

//1.  构造函数中，初始化连接放入连接池

public MyPool() {

// 初始化连接

for (int i=0; i<init_count; i++){

// 记录当前连接数目

current_count++;

// 创建原始的连接对象

Connection con = createConnection();

// 把连接加入连接池

pool.addLast(con);

}

}

//2. 创建一个新的连接的方法

private Connection createConnection(){

try {

Class.forName("com.mysql.jdbc.Driver");

// 原始的目标对象

final Connection con = DriverManager.getConnection("jdbc:mysql:///jdbc_demo", "root", "root");

/**********对con对象代理**************/

// 对con创建其代理对象

Connection proxy = (Connection) Proxy.newProxyInstance(

con.getClass().getClassLoader(),    // 类加载器

//con.getClass().getInterfaces(),   // 当目标对象是一个具体的类的时候

new Class[]{Connection.class},      // 目标对象实现的接口

new InvocationHandler() { // 当调用con对象方法的时候， 自动触发事务处理器

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

// 方法返回值

Object result = null;

// 当前执行的方法的方法名

String methodName = method.getName();

// 判断当执行了close方法的时候，把连接放入连接池

if ("close".equals(methodName)) {

System.out.println("begin:当前执行close方法开始！");

// 连接放入连接池

pool.addLast(con);

System.out.println("end: 当前连接已经放入连接池了！");

} else {

// 调用目标对象方法

result = method.invoke(con, args);

}

return result;

}

}

);

return proxy;// 就是上面定义的 final Connection

} catch (Exception e) {

throw new RuntimeException(e);

}

}

//3. 获取连接

public Connection getConnection(){

// 3.1 判断连接池中是否有连接, 如果有连接，就直接从连接池取出

if (pool.size() > 0){

return pool.removeFirst();

}

// 3.2 连接池中没有连接： 判断，如果没有达到最大连接数，创建；

if (current_count < max_count) {

// 记录当前使用的连接数

current_count++;

// 创建连接

return createConnection();

}

// 3.3 如果当前已经达到最大连接数，抛出异常

throw new RuntimeException("当前连接已经达到最大连接数目 ！");

}

//4. 释放连接

public void realeaseConnection(Connection con) {

// 4.1 判断： 池的数目如果小于初始化连接，就放入池中

if (pool.size() < init_count){

pool.addLast(con);

} else {

try {

// 4.2 关闭

current_count--;

con.close();

} catch (SQLException e) {

throw new RuntimeException(e);

}

}

}

public static void main(String[] args) throws SQLException {

MyPool pool = new MyPool();

System.out.println("当前连接: " + pool.current_count);  // 3

// 使用连接

pool.getConnection();

pool.getConnection();

Connection con4 = pool.getConnection();

Connection con3 = pool.getConnection();

Connection con2 = pool.getConnection();

Connection con1 = pool.getConnection();

// 释放连接, 连接放回连接池

// pool.realeaseConnection(con1);

/*

* 希望：当关闭连接的时候，要把连接放入连接池！【当调用Connection接口的close方法时候，希望触发pool.addLast(con);操作】

* 把连接放入连接池

* 解决1：实现Connection接口，重写close方法

* 解决2：动态代理

*/

con1.close();

// 再获取

pool.getConnection();

System.out.println("连接池：" + pool.pool.size());      // 0

System.out.println("当前连接: " + pool.current_count);  // 3

}

}

代理的总结：(了解会用)

使用代理，可以在不实现接口的情况，对接口的方法进行扩展，添加额外的用户需要的业务逻辑！

2.开源的连接池技术

概述：

Sun公司约定： 如果是连接池技术，需要实现一个接口！

javax.sql.DataSource;

连接池：

DBCP

C3P0

2.1 DBCP连接池：

l DBCP 是 Apache 软件基金组织下的开源连接池实现，使用DBCP数据源，应用程序应在系统中增加如下两个 jar 文件：

• Commons-dbcp.jar：连接池的实现
• Commons-pool.jar：连接池实现的依赖库

l Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

l 核心类：BasicDataSource、BasicDataSourceFactory

l 使用步骤

• 引入jar文件

l commons-dbcp-1.4.jar

l commons-pool-1.5.6.jar

public class App_DBCP {

// 1. 硬编码方式实现连接池

@Test

public void testDbcp() throws Exception {

// DBCP连接池核心类

BasicDataSource dataSouce = new BasicDataSource();

// 连接池参数配置：初始化连接数、最大连接数 / 连接字符串、驱动、用户、密码

dataSouce.setUrl("jdbc:mysql:///jdbc_demo"); //数据库连接字符串

dataSouce.setDriverClassName("com.mysql.jdbc.Driver");  //数据库驱动

dataSouce.setUsername("root"); //数据库连接用户

dataSouce.setPassword("root"); //数据库连接密码

dataSouce.setInitialSize(3);  // 初始化连接

dataSouce.setMaxActive(6);   // 最大连接

dataSouce.setMaxIdle(3000);   // 最大空闲时间

// 获取连接

Connection con = dataSouce.getConnection();

con.prepareStatement("delete from admin where id=3").executeUpdate();

// 关闭

con.close();

}

@Test

// 2. 【推荐】配置方式实现连接池  ,  便于维护

public void testProp() throws Exception {

// 加载prop配置文件

Properties prop = new Properties();

// 获取文件流

InputStream inStream = App_DBCP.class.getResourceAsStream("db.properties");

// 加载属性配置文件

prop.load(inStream);

// 根据prop配置，直接创建数据源对象

DataSource dataSouce = BasicDataSourceFactory.createDataSource(prop);

// 获取连接

Connection con = dataSouce.getConnection();

con.prepareStatement("delete from admin where id=4").executeUpdate();

// 关闭

con.close();

}

}

配置方式实现DBCP连接池，  配置文件中的key与BaseDataSouce中的属性一样：

db.properties

url=jdbc:mysql:///jdbc_demo

driverClassName=com.mysql.jdbc.Driver

username=root

password=root

initialSize=3

maxActive=6

maxIdle=3000

注意：这里App_DBCP.class.getResourceAsInputstrem(“/db.properties”);路径的写法

带 / 表示工程的根目录

不带/ 表示该类所在的目录

都是这样的，/都是表示根

配置文件，一般使用xml和properties文件存储，前者使用的更为广泛，后者这是做一些简单的数据存储。凡是有关系的尤其是包含关系的，一定是使用xml文件存储。Properties本事就是一个map影视而已，当然存储的都是键值对。

2.2 C3P0连接池：

C3P0连接池：

最常用的连接池技术！Spring框架，默认支持C3P0连接池技术！

C3P0连接池，核心类：

CombopooledDataSource ds;通过查看源码，可以发现这个类，也是实现了sun定义DataSource接口的。

使用：

1. 下载，引入jar文件:  c3p0-0.9.1.2.jar
2. 使用连接池，创建连接

a) 硬编码方式

b) 配置方式(xml)，这个xml的模板必须从c3p0的源码包中拷贝出来，不用更改xml文件的名称，只需要修改xml文件中的内容即可。创建ComboPooleDataSource对象的时候将会自动加载这个xml配置文件。

Ctrl + shift + \取消注释，只需要保留<default-config>即可，别的都可以删除

public class App {

@Test

//1. 硬编码方式，使用C3P0连接池管理连接

public void testCode() throws Exception {

// 创建连接池核心工具类

ComboPooledDataSource dataSource = new ComboPooledDataSource();

// 设置连接参数：url、驱动、用户密码、初始连接数、最大连接数

dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc_demo");

dataSource.setDriverClass("com.mysql.jdbc.Driver");

dataSource.setUser("root");

dataSource.setPassword("root");

dataSource.setInitialPoolSize(3);

dataSource.setMaxPoolSize(6);

dataSource.setMaxIdleTime(1000);

// ---> 从连接池对象中，获取连接对象

Connection con = dataSource.getConnection();

// 执行更新

con.prepareStatement("delete from admin where id=7").executeUpdate();

// 关闭

con.close();

}

@Test

//2. XML配置方式，使用C3P0连接池管理连接

public void testXML() throws Exception {

// 创建c3p0连接池核心工具类

// 自动加载src下c3p0的配置文件【c3p0-config.xml】

ComboPooledDataSource dataSource = new ComboPooledDataSource();// 使用默认的配置

// 获取连接

Connection con = dataSource.getConnection();

// 执行更新

con.prepareStatement("delete from admin where id=5").executeUpdate();

// 关闭

con.close();

}

}

2.3 优化

项目，连接的管理，交给连接池！

还是之前的项目：

public class JdbcUtil {

private static ComboPooledDataSource dataSource = null;

/**

* 静态代码块准备需要的一些数据

*/

static

{

dataSource = new ComboPooledDataSource();

}

/**

* 建立数据库链接的操作

*/

public static Connection getConnection()

{

try {

return dataSource.getConnection();

} catch (SQLException e) {

throw new RuntimeException(e);

}

}

/**

* 关闭数据库链接

* @param conn

* @param stmt

* @param rs

*/

public static void closeAll(Connection conn, Statement stmt, ResultSet rs)

{

if(rs!=null)

{

try {

rs.close();

rs = null;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

if(stmt!=null)

{

try {

stmt.close();

stmt = null;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

if(conn!=null)

{

try {

conn.close();

conn = null;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

}

}

3. 分页技术

分页技术：

JSP页面，用来显示数据！ 如果数据有1000条，分页显示，每页显示10条，共100页;   好处:  利于页面布局，且显示的效率高！

分页关键点：

1. 分页SQL语句；
2. 后台处理： dao/service/servlet/JSP

分页的sql语句：

第一个参数：当前页的其实索引行 = (当前页数 - 1)*每页显示的条目数

第二个参数：每页显示的条目数

Select * from employee limit 0, 4;

实现步骤：

1. 环境准备

a) 引入jar文件及引入配置文件

1. 数据库驱动包
2. C3P0连接池jar文件 及 配置文件
3. DbUtis组件:    QueryRunner qr = new QueryRuner(dataSouce);

qr.update(sql);

b) 公用类: JdbcUtils.java

1. 先设计：PageBean.java
2. Dao接口设计/实现：   2个方法
3. Service/servlet
4. JSP

作业：

需求：自拟

要求功能：

1. 列表展示、分页 【必须有】
2. 注册、登陆

a) 登陆后，进入第1步骤的列表页面（分页）

b) 注册成功，跳转到登陆页面，让用户登陆

1. 扩展

a) 对列表数据修改

b) 对列表数据删除

c) 新增数据

PageBean的设计

public class PageBean <T> {

private int currentPage = 1; //当前显示的页面 默认显示第一页

private int pageCount = 4; //查询返回的条数 默认 每页4条数据

private int totalCount; //总记录数

private int totalPage; //总页数

private List<T> pageData; //分页查询到的数据

public int getCurrentPage() {

return currentPage;

}

public void setCurrentPage(int currentPage) {

this.currentPage = currentPage;

}

public int getPageCount() {

return pageCount;

}

public void setPageCount(int pageCount) {

this.pageCount = pageCount;

}

public int getTotalCount() {

return totalCount;

}

public void setTotalCount(int totalCount) {

this.totalCount = totalCount;

}

public int getTotalPage() {

if(totalCount % pageCount == 0)

{

totalPage = totalCount / pageCount;

}

else

{

totalPage = totalCount / pageCount + 1;

}

return totalPage;

}

public void setTotalPage(int totalPage) {

this.totalPage = totalPage;

}

public List<T> getPageData() {

return pageData;

}

public void setPageData(List<T> pageData) {

this.pageData = pageData;

}

}

分页项目总的jdbcutil使用了c3p0包和DbUtils包

C3p0是干啥的：创立连接池，从连接池中获取链接的。

DbUtils是干啥的：dbutils下面主要是有两个类，一个DbUtils类主要是用来实现数据库的连接的，QueryRunner主要是用来实现执行sql语句的(往往这是我们使用DBUtils的主要内容)

通常是c3p0和DbUtil搭配使用，前者用来获取连接，后者用来放回一个QueryRunner用来执行sql语句。

public class JdbcUtil {

private static ComboPooledDataSource dataSource = null;

// 初始化

static {

// 一旦创建 建辉默认的加载 c3p0文件

dataSource = new ComboPooledDataSource();

}

// 创建DbUtils核心工具类对象

public static QueryRunner getQueryRunner()

{

// 创建 QueryRunner的时候 可以传入一个参数 datasource 这样在 执行 qr.executeUpdate()的

//时候 尅不传入链接，这样最终也不需要 手动的 conn.close()

return new QueryRunner(dataSource);// 看到没有这里都不需要getConnection的操作，所以我们后面也不需要自己师范conn,stmt,rs等资源

}

// 当然有可能有某些函数中还需要使用connection所以可以写一个getConnection

// 获取连接 一遍那些需要使用 数据库链接的地方使用

public static Connection getConnection()

{

try {

return dataSource.getConnection();// 从连接池中 拿出一个链接来

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

throw new RuntimeException(e);

}

}

}

<a href="${pageContext.request.contextPath }/index?currentPage=1">首页</a>这里再说一下，pageContext是jsp中的内置对象，失眠是在EL表达式中使用了内置对象。EL表达式中，使用get方法时只写get后面的名字就可以了。

一般jsp、html等资源都是给浏览器使用。如果使用转发时，应当写上完整的路径，如下：

String uri = “/error/error.jsp”; //这个时候第一个/表示的就是项目根目录和request.getContextPath()是一样的。

reqeust.getRequestDispacher(uri).forward(request, response);

如果使用重定向的话如下：

response.sendRedirect(request.getContextPath() + “/error/error.jsp”);

Servlet动态资源，编译之后，request.getContextPath/class里面,一般servlet资源找给服务器使用，这个时候一般使用的都是重定向request.getRequestDispacher(“/IndexServlet”),直接重定向过去，这个时候，IndexServlet前面的 / 就相当于request.getContextPath