JDBC高级
施炎生
1.用连接池来管理Connection,可以重复使用Connection，每次使用完Connection后，可以返回给连接池，不用一直创建。  
2.连接池的配置文件：
driverClassName：数据库驱动名称
url：数据库的地址
username：用户名
password：密码
注意：配置文件中每行后面不能加逗号，分号，空格等。
3.C3P0连接池的开发步骤：
第一步：引入DBCP连接池的jar包.
第二步：编写DBCP代码：
    * 手动设置参数:
    * 配置文件设置参数:
4.DUBtils完成增删改的操作:
创建核心类---QueryRunner
利用核心类进行增删改---queryRunner.update
  

常小天
今天继续学习JDBC的内容。首先学习的是JDBC的事务管理。事务管理的三个方法：setAutoCommit(Boolean AutoCommit)、commit()、rollBack()。需要注意的点有两个，一是在一个事务中三个方法要用同一个连接对象调用，二是rollBack()要放在捕获异常结构的catch{}。接下来学习的是连接池。所谓连接池，就是一个存放连接对象的容器，它内部已经创建了多个连接，当外部用户访问的时候，它就把内部的连接以remove()的形式取出来给用户使用，当用户使用结束后再以add()的方式归还给连接池。以此方式节约资源，提升效率。第三方连接池种类多样，今天重点学习的是C3P0连接池。使用C3P0连接池大步骤分3步，第一是导包，要将C3P0的jar包导入项目。第二步是添加配置文件。这一步很关键，稍有差错就会导致无法正常使用C3P0连接池。这里要注意三点，一是配置文件的存放路径必须是当前项目的SRC文件夹下，不能存放到其他文件夹，也不能存放到SRC文件夹的子文件夹中，二是配置文件的名称只能是C3P0-config.xml，三是配置文件中的格式和key的名称都只能使用C3P0所规定的内容，只有value值可以自行修改，所以这里建议直接拷贝现成的配置文件再加以修改来使用。这三点其实都只有一个目的，就是保证C3P0的底层代码能够顺利找到配置文件并加载。因为其底层代码是将配置文件路径写死的，所以一旦没有按照它的规定来添加配置文件，就会导致它找不到配置文件，找不到配置文件就无法连接数据库，之后的操作也就无从谈起。使用C3P0的第三步就是编写代码使用C3P0。根据构造创建C3P0连接池的对象即可，再拿链接库对象调用方法获取连接，后面的步骤与之前学习的内容相同。今天学习的最后一部分内容是DBUtils工具类，它就是一个简化JDBC代码的工具类，它将JDBC编码中的众多重复部分进行封装，让开发者可以以极其简洁的语句进行开发。首先创建核心类QueryRunner对象，其构造方法中传入一个C3P0链接库，第二步调用update方法进行数据库的增删改操作。

陈叶隆
I.事务管理:conn.setAutoSumit(false);sumit();rollback();
II.C3P0连接池:1,开发步骤: a：引入DBCP连接池的jar包;b: 编写DBCP代码：配置文件设置参数.
                        2,C3P0改造工具类:
private static final ComboPooledDataSource dsPool =new ComboPooledDataSource();
public static Connection getConnection(){
                conn = dsPool.getConnection();
                        return conn;
        }
III. DBUtils工具的使用: QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
                queryRunner.update("update account set name=?,money=? where id =?", "eee",20000,4);

侯玉林
今天我们学习了连接池,以及和各种工具类.

陈世彪:
今天学习了JDBC
连接池是事先创建连接的一个容器,如果遇到许多需要用到连接时
普通的连接,一个连接才创造一个,时间太慢了,而连接池事先创建好,
即调即用,用完再还给连接池,节省空间
Druid的使用:
配置方式设置参数
Druid配置方式可以使用属性文件配置的。
文件名称没有规定但是属性文件中的key要一定的。

使用才c3p0时要先配置连接池,这样就可以省去手动创建参数 c3p0-config.xml
采用配置文件时,配置文件里的NAME不能更改
创建连接地
ComboPooledDataSource dataSource = new ComboPooledDataSource();
再获得连接
conn = dataSource.getConnection();
使用DBUtils时
先要创建核心类
QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
后面直接使用核心类里的方法,增删改是使用update
queryRunner.update("insert into account values (null,?,?)", "ddd",10000);
几个?就往后面按顺序添加几个
JDBC是java用来和Sql数据库连接的桥梁
JDBCUtils是工具类用来简便和数据库之间的代码
C3p0是连接池,可以事先创建号连接,节省连接的时间
Druid开源池,使用属性文件进行配置
DBUtils可以创建核心类,减少开发时间,和代码

张育辉
七:JDBC工具类的概述:
                        增删改查,重复代码过多,加载驱动,关闭资源一直在重复,需要抽取,
                        把属性(加载驱动的架包,协议,用户名,密码)写到properties配置文件中,类加载的时候开始赋值;
                        获取连接对象时候调用加载驱动,在使用工具类的时候调用connection连接对象时候,加载驱动并且获取连接;
                       
                       
        八:连接池
                概述:连接池是装有连接的容器，使用连接的话，可以从连接池中进行获取，使用完成之后将连接归还给连接池
                为什么使用连接池:连接对象创建和销毁是需要耗费时间的，在服务器初始化的时候就初始化一些连接。
                把这些连接放入到内存中，使用的时候可以从内存中获取，使用完成之后将连接放入连接池中。
                从内存中获取和归还的效率要远远高于创建和销毁的效率。（提升性能）。
                连接池的原理:先创建几个连接放入池中,当需要连接的时候从池中获取那一个连接(底层是拿到了连接,删除拿到了连接),结束时候归还连接(也就是添加一个连接)
                重写close方法,把销毁方法改成添加方法
               
        九:装饰则设计模式两个前提
                一、增强的类和被增强的类实现相同的接口
                二、在增强的类中获得被增强的类的引用
                        io的缓冲流也是使用了装饰着设计模式,把字符流传进去,就可以使用读取一行的功能;
                原理:1:增强类生成有参构造和私有的接口类型的成员属性;
                         2:被增强类传过来赋值给自己私有成员属性;
                         3:实现接口方法,增加自己的增强的方法,调用被增强的方法;
        十:连接池两个jar包
                        1:druit,可以通过new DruidDataSource()使用连接池;可以通过DruidDataSourceFactory.createDataSource(properties)方法读取配置文件;
                               
                        2:c3p0,可以通过new ComboPooledDataSource()方法使用连接池,是通过xml文件来读取属性的,格式是固定的c3p0-config.xml;
        十一:dbUtils数据库工具类;因为JDBC手写比较麻烦，而且有非常多的代码是类似的。
                        比如获得连接，预编译SQL，释放资源等..那么可以将这些代码抽取出来放到工具类中。将类似的代码进行抽取。大大简化JDBC的编程;
                        通过new QueryRunner(连接池对象)获取连接        ;
                        int update(参数1,参数2);增删改用update方法,参数1是数据库语句,参数2,是给?号赋值
                        query(String sql,ResultSetHandler rsh,Object… args);用来查询,

苏海斌
今天主要讲了三点,事务,连接池,DBUtils;
其中事务的话主要是通过connection连接对象来管理事务;
分为三步:开启提交回滚;
连接池的话了解什么是连接池及其作用,自定义连接池了解就行,重点掌握c3p0,
最后学了DBUtils,掌握DBUtils的增删改方法!

批处理(了解)
问题:内存溢出

一:事务
connection连接对象
管理事务:
1.开启事务:setAutoCommit(false)设置不自动提交
2.提交事务:commit()
3.回滚事务:rollback()

二.连接池:
实现DataSource接口就是连接池
相当于共享单车,创建好了连接,需要时用,用完再归还;
开源连接池:
druid
C3P0(重点!!!)
步骤:1.导包 2.引入c3p0配置文件 3.编写代码

三:DBUtils工具类:
使用DBUtils增删改

颜琳琳:
  JDBC高级总结:
  今日主要学习了三个方面1.事务,2.连接池,3.DBUTils.
一.事务主要说了Conncetion中的三个管理事务的方法:1. setAutoCommint(false)  false代表不自动开启事务; 2. commint() 开启事务; 3.rollback() 回滚
二.连接池:
连接池是一个用来装连接的容器,主要的作用在使用了连接池可以将用户使用的完的连接归还给连接池,来提高性能.
主要学了:1. 自定义连接池; 2.Druid连接池; 3.c3p0连接池; 其中主要掌握c3p0连接池,其他两个了解即可. c3p0的使用步骤:1.添加c3p0和JDBC的jar包; 2.创建连接池的配置文件(注意:在配置文件的文件名必须是”c3p0-config.xml”,然后配置文件中的键名不能随意更改)
3.进行创建连接池(连接池中需要创建ComboPooledDataSource 连接对象,然后再写三个方法分别是1.创建连接方法, 2.获取连接池, 3.释放资源) 4.创建连接池的测试类进行测试.
三.DBUTils(工具类):
    使用该工具类也需要导入其jar包,然后再进行编写DBUTils工具类,该工具类的作用可以使对JDBC中的sql数据库的增删改操作代码简化,操作更容易,主要用到了QureyRunner核心操作类来操作.

  1 jdbc 事务
  事务的概念
  事务的环境准备
  案例 一: 连接对象管理事务 : 开启事务 --提交事务(没问题时候--数据生效,事务结束)
                            --回滚事务:有问题时候数据回滚到开启事务的状态,结束事务
  给这转钱案例添加事务;这样可以解决转账中的问题
  Connection中 的方法  SetAutoCommit(flase)设置事务不自动提交
                      rollback / commit
  注意点: 连接对象要一致
  2  连接池 :可以看成装连接对象的容器,有用有还 ,用户使用完连接池中的一个练级
            后 会归还 到连接池中
    连接对象创建和销毁时需要耗费时间的(如访问量)
    原理: 连接放在连接池中连接池放在内存中
  
***   自定义连接池 (模糊)
      一个普通java 类 实现一个DataSource 接口 ;
     
  3 使用C3P0连接池完成对数据库的CURD操作
     使用步骤: 导包c3p0-0.9.1.2.jar
               导入c3p0-config.xml (不能修改xml文件名和文件内部定义好的"键")
  4 DBUtils工具类来进行数据库的CRUd     

许煜
每日总结
连接池:可以把连接池看作为一个容器,容器里面装的是已经创建好的连接对象.
用更通俗的话说就是连接池就像是一个工具箱,里面装着各种各样的工具.你需要工具时你可以从工具箱里面拿一个出来,但你用完不能乱丢,必须还回去.
连接池的优势:传统方式每次要访问数据库就得创建一个连接对象,使用完还得销毁连接对象.十分浪费计算机的计算能力.连接池就是提前创好连接对象,调用的时候直接拿走,用完归还.省下了程序每次创建连接和销毁链接,节约了计算机的计算能力,从而提高了程序的效率.而提高效率的代价是提前创建好的连接对象会多占用一些内存空间.
C3P0通过对配置文件的路径 文件名 格式 的严格限制,并将加载配置文件这一过程高度封装,即通过构造方法就将配置文件各种属性传入,底层代码更复杂,但是上层代码比起Druid更为简单.
DBUtils高度封装的数据库操作的工具类 用起来十分简单粗暴
QueryRunner qr =new QueryRunner(连接池对象);
qr.update/query(底层为preparedstatement对象执行sql语言);
QueryRunner是被高度封装过的 执行完语句会自动将连接对象回收进连接池

Day11

今天学习内容为JDBC的事务管理,自定义连接池,Druid/C3P0连接池,DBUtil工具类
JDBC的事务管理:开启事务,提交事务,回滚事务
开启事务:conn.setAutoCommmit(false);//禁用自动提交模式,默认为自动提交,禁用该功能,再需要时再手动提交.
提交事务:conn.commit();
回滚事务:conn.rollback();
注意:JDBC的事务都是通过连接对象来调用.
具体案例:转账案例,重点理解是开启事务,提交事务,回滚事务的语句的使用位置

连接池:存放连接的容器,作用:使用连接池与创建连接和销毁连接的方式相比,降低了时间耗费,提高效率.
自定义连接池+Druid连接池:这部分还未能全部理解,暂无总结.

C3P0连接池:开源的JDBC的连接池.
配置文件方式:导入jar包---修改配置文件---创建连接池---获得连接对象---编写SQL...增删改查
创建连接池:ComboPooledDataSource cpds = new ComboPooledDataSource();
获得连接对象:conn = cpds.getConnection();

DBUtil:由JDBC封装的工具类,作用:简化JDBC编程
QueryRunner对象---update方法
QueryRunner:核心运行类,QueryRunner qr = new QueryRunner(连接池);
update方法:update(sql语句,参数)

何平波
通过这两天的JDBC的学习,发现其实想要操控数据库的数据,用了很多的代码,在今天的学习中,这些复杂且重复性多的代码都被封装成了工具,这样使用java语言来操控数据库就变得更加灵活简便.
在这里,通过这两天的学习,课程的目的想要我们了解这些工具类的底层源码是什么样,以及为什么会出现如此简便的工具类.
这里分析了下如何使用工具类c3p0,druid 和Dbutils来操控数据库的数据.
一.
1.首先得有数据库,有表,而且表中还要有数据.
2.在java中引包,引入的包分别是c3p0-0.9.1.2.jar  和commons-dbutils-1.4.jar  以及最为基本的sql包 mysql-connector-java-5.0.8-bin.jar
3.引包需要添加 Build Path 到运行环境中
4.编写c3p0的连接池    以及  c3p0.config.xml配置文件(这个文件必须创建,这个文件是c3p0根据里面的内容来找到你的数据库驱动,数据库和表的路径,用户名,密码);
5.使用Dbutils里方法将原本复杂重复的方法简写成为两行
                                @Test
                        public void add() throws Exception {
                                //druid
                                QueryRunner rq=new QueryRunner(Druid.getDataSource());
                                rq.update("insert into user values(null,?,?)", "黑风鬼","船长");
                                System.out.println("添加成功!");
                        }
这里比较多的公司企业大多次采用c3p0和Dbutils工具类来开发,所以今天着重研究c3p0的文件配置方式操控数据库
c3p0配置文件的连接池正确步骤
1.在src文件夹下创建一个c3p0-config.xml的文件
2.正确格式:<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
        <default-config>
                <property name="driverClass">com.mysql.jdbc.Driver </property>//驱动位置
                <property name="jdbcUrl"> jdbc:mysql:///test</property>//数据库表位置
                <property name="user">root</property>//数据库用户名
                <property name="password">root </property>//数据库密码
                <property name="initialPoolSize">5 </property>初始化的连接数量
                <property name="minPoolSize">5 </property>最大默认值
                <property name="maxPoolSize">20 </property>最小默认值

        </default-config>
</c3p0-config>
3.使用连接池
(1)声明3个变量名为null;
(2)调用c3p0里的对象方法 ComboPooledDataSource
(3)设置连接参数  采用 setDescription()  setJdbcUrl() setPassword() setUser()  这里可以见名知意分别传入什么样的字符串
(4)获取c3p0的构造方法 getConnection()
(5)sql语句
(6)预编译prepareStatement
(7)结果集
(8)遍历结果集
(9)释放资源      注意(1-7)要捕获异常放在try{},catch(异常类){异常原因及信息} finally{ 释放资源 }

二.
一的方法不规范,如果经常需要修改数据库的位置或表的话,需要在源代码里修改,这里的c3p0-config.xml文件就是为了解决这类问题的
使用配置文件的方法就可以省略3.使用连接池的步骤,这种方式会比较灵活,且更加规范.

三.Dbutils和c3p0的工具包的使用将会是代码更加精简和灵活
第一步,只需将c3p0写成一个自定义的工具类,且工具类方法与之前的学的jdbc获取数据库对象的方法类似,
第二步,将c3p0的核心类ComboPooledDataSource  使用私有常量修饰
第三步,写一个方法返回获取c3p0的getConnection构造方法
第四步,获得连接池  返回核心类对象
第五步,释放资源

四.Dbutils的使用
第一步,QueryRunner qr=new QueryRunner(c3p0Utils.getDatasource()); 调用核心类,括号里传入的是c3p0的自定义工具类的连接池方法
第二部,qr.update("sql语句","值","值")   值的类型要看表格的类型
这里无论是增删改的方法,都使用update构造方法

郑学馨
JDBC事物管理三要素:
        //创建同一个要使用的连接对象:connection conn:
                开启事物:conn.setautocommit(false);
                提交事物:conn.commit;
                回滚事物:conn.rollback;

什么是连接池:系统创建一个连接池(相当一个容器),连接词里面

存在了一些提前创建好的连接对象,当我们要创建连接时,直接连

接到这些池子中的连接对象,完成工作后,再将连接对象归还给连

接词,供别人继续连接使用.

如何自定义连接池:
注意:1:连接池是java一个类:它实现了datasourse接口
     2:连接池是一个容器:所以创建一个list集合,用来存放对

象
     3:在使用完连接池内的连接对象后需要归还改对象到list

集合中
如何增强连接池:
C3P0:连接池:
配置文件的三个要求:
使用C3P0的三步骤:导包---创建连接池对象---创建方法
*导包:将C3P0文件导入项目中,创建c3p0-config.xml文件:
(c3p0-config.xml文件的三要求:一:不能修改该文件名;二:必须

将该文件放置在项目的src文件夹下;三:不能修改文件内名称)
*创建连接池对象:为了简化代码,将该步骤提取至工具类中,优点

:简化代码,无需多次创建多个连接池对象占用资源\代码如下:
connection conn=JDBC.Utiles.getconnection();
*创建方法:按照"贾琏欲执事"步骤继续

DBUtiles工具类的使用:DBUtiles是连接池的工具类
一:导包:
二:创建queryrunner对象
三:利用queryrunner对象实现update对数据库的增删改!

曾耀峰
一、初步学习事务   
事务在代码中的作用是当执行更新操作后，如果代码后面的代码存在异常，那么被更新的数据会返回原来的状态，确保数据不会因为代码异常而更新丢失。
掌握事务的3个方法:
开启事务:conn.setAutoCommit(false):在conn链接对象获取完后，就可以开启事务
提交事务:conn.commmit():当所有sql执行完毕后，可以提交事务
回滚事务:conn.rollback();写在catch代码块中，如果出现代码异常，会执行catch代码块中的回滚事务。
二、连接池      
1.理解:池在编程中通常理解为装某种数据的容器。   
   在JDBC中，如果每个用户的请求都是创建一个连接对象，使用完毕后销毁。这样在大规模用户的请求中，对内存是一种很沉重的负担。所以提出连接池的概念，连接池是装有连接对象的容器，使用连接的话，可以从连接池中进行获取，使用完成之后将连接还给连接池。连接池从内存中获取和归还的效率要远远高于创建连接对象和销毁的效率
2.自定义连接池
      在javax包中提供了一个连接池类DataSource,里面的getConnction()方法可以获得连接对象。编写自定义的连接池要有以下功能:1.连接池中预先存放一些定义好的连接对象 2.需要使用的时候，从连接池中获取;使用完毕后归还到连接池。
      编写步骤:
      1).实现接口:
          新建MyDataSource类，实现DataSource()接口。载入要实现的所有方法
      2).建立连接池:
          新建一个List<Connection>容器，代表一个连接池
      3).编写获取连接的方法:
          将接口方法getConnection() 提到前面，其他接口方法不必管。在里面添加:return list.remove(0);
      4).初始化连接对象
          在默认构造函数MyDataSource()中初始化N个连接对象，存放到集合List中。注意，在这里的建立的连接对象从JDBCUtils中获取。
          connList.add(JDBCUtils.getConnection());
      5).使用完毕归还:
          添加一个归还方法，void addBack(Connection conn) 里面写connList.add(conn);
     测试使用:
       (1)定义MyDataSource dataSource = new MyDataSource();
       (2)从链接池中获取连接:Connction conn = dataSource.getConnection();
       (3)使用完毕后，归还。dataSource.addBack(conn);
3.自定义连接池出现的问题与解决:
       1).问题:
         (1)使用接口的实现完成的构造:这种写法不方便程序的扩展
        （2)额外提供了方法归还连接:这种方式增加使用连接池的难度。
      2).解决方法:
          原来在Connction中式有一个close方法的，close方法完成了连接的销毁。做一个事情，将原有的连接的close方法改为归还。
          -(1).现在要做的事情是如何将原有的close方法的逻辑改为归还(增强一个类中的方法)
          -(2).如何增强一个类中的方法，有3种方式
           [1].使用继承的方式:
              继承这种方式是最为简单的，但是有条件是，必须控制这个类的构造
           [2].采用装饰者模式:
              装饰该类，使该类功能变得强大。比如，一个美女去整双眼皮，人还是这个人，只是比原来更漂亮，眼睛更大。
              -使用条件:
               一、增强的类和被增强的类实现相同的接口
               二、在增强的类中获得被增强的类的引用
           [3].动态代理(后面学习)
        3)装饰者模式增强自定义连接池类_实现步骤:
          [1].定义一个MyConnectionWrapper 实现Connction接口
          [2].初始化构造函数，Connction conn对象。
          [3].载入接口需要实现的方法，出现问题了:Connction中有40+个方法，而我们只需要一个close()方法
          [4].解决步骤3的问题,应该简化编程。提供一个模板类(模板类原封不动的将接口中的所有方法实现，但没有增强)
           编写一个装饰类继承模板类，在装饰类中只需要增强其中某一个方法既可。
             -ConnectionWrappter 原封不动实现 Connction接口
             -MyConnctionWrappter 继承 Connection方法，重写其中的close方法，改为归还.
          [5].改写自定义连接池工具类:
                      public Connection getConnection() throws SQLException {
                Connection conn = connList.remove(0);
                // 增强连接
                MyConnctionWrapper connWrapper = new MyConnctionWrapper(conn, connList);

                return connWrapper;
        }
          [6].去掉归还方法
     了解一下装饰者设计模式
三、c3p0——数据库连接池   
   c3p0是来自Apache提供的数据库连接池的工具类。
   从上面自定义连接池可以看出，自己写一个完美的连接池还是比较费劲的。使用有人写好的工具类就比较简便了。
  1.c3p0使用步骤:   
    (1)步骤1:建立c3p0-config.xml,在里面的默认配置标签<defalut-config>中，设置属性driverClass驱动器、jdbcUrl数据库地址、user数据库用户名、password密码。注意，属性名是固定的写法是固定的，不能改变。当创建数据库连接池对象ComboPooledDataSource datasource = new ComboPooledDataSource()时，会在src路径下查找c3p0-config.xml，自动读取里面的属性配置信息，完成要对连接的数据库基本信息的配置。         
  (2)步骤2:从连接池中获取连接对象。Connection conn = datasource.getConnection();   
   (3)步骤3:获取语句，执行语句，处理结果       (4)步骤4:归还连接。当调用conn.close()时，c3p0里面重写了close()方法，重写的功能是将连接对象放回到数据池容器中。         2.改写工具类:           
  从上面使用c3p0可以发现，每次使用一次就得创建一个连接池，是一种比创建连接还浪费内存的情况。这时候应该将工具类进行改写，把创建连接池做成一个全局静态常量:  
private static final ComboPooledDataSource datasource = new ComboPooledDataSource();  
  这样实例化的对象，就能全局使用。   
   3.总结c3p0作用:      
   1)创建连接池     
2)从连接池中获得连接对象  
   3)连接对象关闭后，自动归还到连接池。
四、DBUtils:   
    来自Apache提供的一个对JDBC进行简单封装的开源工具类库，使它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。   
原理:JDBC手写代码步骤繁多，并且很多代码是类似的，如获取代码中的链接，预编译SQL，释放资源等。因此将类似的代码进行抽取，制作成工具类。
五、今天和昨天总结:   
    因为JDBC原生代码操作的麻烦，我们制作了一个工具类JDBCUtils,封装了JDBC的代码中注册驱动，获取连接，释放资源的方法。很快我们在数据库连接中，发现使用连接对象创建销毁不符合实际开发情况，又学了连接池的概念，学习了两个开源连接池库druid（德鲁伊），c3p0。把原来获取连接变成获取连接池，修改了工具类，变成C3P0Utils。最后学习了DBUtils。完全简化代码，原来的十来行变成两行代码。   
   这就是面向对象封装的特性。
    装饰者模式属于编程设计模式中27个经典设计模式之一。算是第一次接触到，所以用了大幅总结去学自定义设计类。

黄志彬

JDBC管理事务的方法：setAutoCommit设置事务，commit提交事务,rollback回滚事务(捕获到异常catch里面，保证事务的一致性)。。。都是连接对象调用的，连接对象必须是同一个

连接池是用来装连接的，负责连接的创建和销毁。提升性能。
连接池是java类创建的对象
conn不是DriverManager获得的conn（conn.close 销毁）,而是增强后的连接对象，增强了close() 归还

C3P0 是用来管理连接对象的
工具类直接从连接池拿的连接对象，连接池只需要创建一次。
导包：mysql的驱动包,C3P0的jar包.
配置文件有3个要求，路径要在src里面，文件名固定，name属性不能乱写。要与C3P0规定的一致。
导包----》配置文件---》new 得到的连接池就是带有数据的连接池对象---》归还


DBUtils:简化代码。
创建核心类：QueryRunner
添加，修改，删除就只有update里面的参数不一样；第一个参数是SQL语句，后面的就要看SQL语句中有几个问号就有几个参数。
new核心类对象的时候，传进去的是连接池.因为要归还所以要传连接池。

任佳锋
今天学习了JDBC高级

JDBC事务的三个操作步骤:
开启事务--setAutoCommit
提交事务--Commit
回滚事务--rollback
这三个方法用conn调用  回滚事务则放在catch中

C3p0连接池(存放连接的容器,用于存放连接,使用时取出,不用归还):
c3po是一个开源的连接池使用前要先导包,
然后创建c3po的ComboPooledDataSource对象，直接调用getConnection获取连接对象


DBUtils工具类(增删改):
降低代码的复用性,从而提高效率
创建核心类---QueryRunner,并将参数传入连接池,
利用核心类进行增删改等操作---queryRunner.update()

张述明
今天学习的主要内容
JDBC的事务环境准备:SetAutoCommit(boolean) 设置true 为自动提交,反之
Commit() 提交
Rollback() 回滚

获得连接时候,开启事务.
连接管理事务必须一个事务有同一个连接对象完成操作.
连接池:
是储存连接的容器
自定义连接池出现的问题分析
解决思路
增强一个类方法
两种方式
1.        采用继承的方法  条件:必须能控制这个类的构造
2.        采用装饰者模式
条件: 1.增强的类和被增强的类实现相同接口
2.在增强的类中获得被增强的类的引用.

开源连接池主要掌握C3P0连接池
CombopooledDataSource dataSurce=new CombopooledDataSource();
导包
配置文件
直接使用
代码实现

Dbutils    QueryRunner对象  核心运行类

增删改 用update()
查询   用 query()

林荣彬
       今天学习了事务管理的三步骤,重点学习连接池C3P0和DBUtils
1.事务
connection:连接对象
1.获得语句对象
2.管理事务

1.connection.setAutoCommit(false)开启事务://设置事务不自动提交
2. connection.commit 提交事务:没有问题的时候---数据生效,----事务结束
3.connection.rollback 回滚事务:有问题的时候----数据回到开启事务时的状态,----事务结束

2.连接池(装连接对象的容器)(提升运行性能)
接口:DataSource

Druid连接池:配置方式可以使用属性文件配置的,文件名称没有规定但是属性文件中的key要一定的

C3P0连接池:配置文件只能放在src下面.文件的名字只能是c3p0-config.xml
使用步骤:
第一:导包
第二:配置文件
第三:使用

3.DBUTIS工具类
DBUtils:对JDBC进行简单的封装的开源工具类库简化了JDBC操作，可以少写代码.

QueryRunner对象:核心运行类,
QueryRunner
构造:QueryRunner(DataSource ds);
方法:int update(String sql,Object… args);
T query(String sql,ResultSetHandler rsh,Object… args);

叶凌青
C3P0
是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
第一步：引入DBCP连接池的jar包.
第二步：编写DBCP代码：
    * 手动设置参数:
    * 配置文件设置参数:
public class JDBCUtils2 {
        private static final ComboPooledDataSource DATA_SOURCE =new ComboPooledDataSource();
        /**
         * 获得连接的方法
         */
        public static Connection getConnection(){
                Connection conn = null;
                try {
                        conn = DATA_SOURCE.getConnection();
                } catch (SQLException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return conn;
        }
...
}DBUtils（阿帕奇）
DBUtils是java编程中的数据库操作实用工具，小巧简单实用。
DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。
Dbutils三个核心功能介绍
1、QueryRunner中提供对sql语句操作的API.
2、ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
3、DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法
update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作

郑志祥   day11JDBC(高级）
事物的三个方法
1.开启事物 conn.setAutoCommit(false) 括号里面的false是令开启事物不自动提交
2.提交事物conn.commit
3.回滚事物conn.rollback

连接池的概述；
连接池是一个装连接的容器，连接对象的创建与销毁是需要时间的，连接池就犹如一个中转站，已经在内存创建好了，使用时从内存中借出来，使用结束后还回内存（连接池）。

创建连接池
1.创建一个普通类实现接口Datesoure
（接口里面的方法需要全部重写）
2.创建connList集合
3.通过工具类.getConnection来创建连接
4.for循环创建多个连接，再将这些连接add添加到集合
5.用户通过 getConnection，使用连接
5.用户通过addback还回连接
注意；不要释放资源，（释放资源相当于销毁）


增强类的方法的三种方式
1.采用继承的方法（重写里面的方法） 条件；这个类可以进行构造
（由于找不到connection的父类，所以无法使用继承进行）
2.采用装饰者模方式（包装）

条件；·增强类和被增强类同时实现一个接口
      ·在被增强类获得增强类的引用
       （1.传入参数  集合list   接口nonn
          2.重写close里面的方法，将销毁更改为归还）
3.动态代理的方式














druid是阿里旗下的连接池产品，使用非常简单，可以与后期的Spring框架进行整合。

1.导包（）c3p0-0.9.1.2.jar
2.创建连接池 combopooledDataSource
3.
谷歌浏览器可以右键翻译成中文
因为JDBC 手写比较复杂，
OBUtil是对JDBC进行封装，而且没有影响性能

DBUtils（是阿帕奇给我提供的工具类，可以大大帮我简化代码）
使用就2步骤
1.创建核心类QueryRunner对象（传入连接池）
2.利用对象调用   增删改update 查query 还可以进行批处理
（sql语句{底层用的是preparedStatement}）

C3P0的要点
1.导包C3P0-0.9.jar
2.在src相对路径下的c3p0-config.xml配置文件的名字（固定不可修改）
2.c3p0-config.xml里面的内容key那边的内容（固定不可更改）