黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】JDBC高级 [打印本页]
作者: 厦门校区 时间: 2018-5-28 17:29
标题: 【厦门JavaEE就业1期-每日总结】JDBC高级
同学们，今天继续学习了JDBC，重点就是对连接池的理解，C3P0连接池和DBUtils的使用
今日需要掌握的有：
- 能够用自己的话阐述什么是连接池，有什么好处？
- 会使用Druid和C3P0连接池改写工具类
- 会使用DBUtils对数据进行增删改查
- 能够用自己的话解释几个易混淆的概念：JDBC、JDBCUtils、C3P0、Druid、DBUtils
请同学们按照如上要求，总结今日所学。
作者: 磬辰 时间: 2018-5-28 20:10
JDBC的事务管理：
setAutoCommit(false); 打开事务，并且关掉自动提交事务。
将comit()放在try里面的最后，rollback放到catch中，保证事务的一致性。
连接池：之所以用连接池，是因为频繁的创建和销毁连接对象是很浪费时间和消耗
资源的。把连接放入内存中，需要的时候再从内存中去获取，使用完之后再归还到
内存中，效率远远高于前者。
装饰者模式：
可以在不添加新方法的基础上，通过获取被增强类的引用，对增强类的方法进行增强
好比如去买一杯咖啡，获取咖啡的引用，然后我可以选择加糖，或者加牛奶，它本身还是
一杯咖啡，只是在这基础上我对它进行了一下修饰或者变化。
Druid连接池和C3P0的连接池使用方式差不太多，区别在于文件的配置，Druid文件
命名没有限制，C3P0的文件则固定为 c3p0-config.xml
DBUtils使用：
ResultSetHandler<List<User>>()查询多条记录存入对象的list集合中
List<User> list = queryRunner.query(sql,new ResultSetHandler<List<User>>())
ResultSetHandler<User>()查询单条记录存入对象中
User user = queryRunner.query(sql,new ResultSetHandler<User>())
ArrayHandler()将单条记录存入Object[]中
Object[] object = queryRunner.query(sql,new ArrayHandler())
ArrayListHandler()将多条记录存入Obejct[]的List集合中
List<Object[]> list= queryRunner.query(sql,new ArrayListHandler())
BeanHandler<User>((User.class));)将一条记录封装到一个JavaBean中
User user = queryRunner.query(sql, new BeanHandler<User>(User.class));
BeanListHandler<User>将多条记录封装到一个装有JavaBean的List集合中
List<User> list = queryRunner.query(sql, new BeanListHandler<User>(User.class));
MapHandler() 将一条记录存入Map集合中,key为列名
Map<String,Object> map = queryRunner.query(sql, new MapHandler())
MapListHandler() 将多条记录存入装有Map的List集合中
List<Map<String,Object>> list = queryRunner.query(sql, new MapListHandler());
ColumnListHandler()将数据中的某列的值存入List中
List<Object> list = queryRunner.query(sql,new ColumnListHandler("name"));
ScalarHandler()将单个值进行封装
Object object = queryRunner.query(sql,new ScalarHandler());
作者: 渣.. 时间: 2018-5-28 20:20
柯威龙
今天首先学习了事务,事务的话有三个步骤开始事务,提交事务,回滚事务这三点.
其次学习了连接池,连接池的作用在于一次创建多个连接,将连接放入内存中,获得连接的时候从内存
取出,使用完归还回去.之前我们是释放资源把连接销毁掉,现在我们需要归还就不能销毁,所以学习了
增强close的方法,这样子就把销毁改成归还.方法有三种,继承,装饰者,动态代理.正常来说我们都是用装饰者
然后学了了DBCP但是有个比DBCP更简便的方法叫在做C3P0.然后还可以使用C3P0来修改工具类.C3P0就是今天的一个重点,
需要掌握.最后学习了DBUtils,这是一个相当于工具类的意思.使用DBUtils完成CRUD的操作.
作者: 许大炮 时间: 2018-5-28 21:36
许剑鸿 webDay11
连接池: 用于存放connection对象 在连接池中预先放入connection对象 使用的时候取出用完之后放回
节省内存和创建connection的时间
C3P0使用步骤:1 导包 2 设置参数(手动set参数或配置文件设置参数 配置文件名必须为c3p0-config.xml且只能放在src下)........
DBUtils增删改: 创建核心类对象QueryRunner 参数中传入连接池 使用核心类对象QueryRunner中的update()方法对数据库表数据的增删改操作
JDBC、 java 数据库连接 为多种数据库提供统一访问
JDBCUtils、自定义工具类 主要有注册驱动 获得连接 释放资源等方法
C3P0、开源连接池
Druid、开源连接池
DBUtils、工具类简化代码
作者: 厦门陈强 时间: 2018-5-28 21:39
陈强
JDBC高级的一天
事务管理的API---三个操作
-开启事务---setAutoCommit
-提交事务---Commit
-回滚事务---rollback
连接池---就是一个容器,里面装有一定量的连接,供使用的时候直接从连接池获取,使用完成后再将连接归还给连接池.提高了效率.
C3P0---采用配置文件方式的使用
前提---src下有c3p0配置的XML文件,并build path c3p0的jar包
注意 : c3p0的XML配置文件中的名称不能改变,文件也必须要放在src目录下
New一个CombopooledDataSource 的对象,获得连接池 ( 此时该连接池对象里面已经有存在一定数量的连接 ),然后根据对象去获取连接,然后再进行sql语句的编写,预编译等操作.
DUBtils完成增删改的操作
创建核心类---QueryRunner
利用核心类进行增删改---queryRunner.update ( sql语句,参数 ( n个,与问号数一致 ) )
作者: 小故事 时间: 2018-5-28 21:43
谢洪彬:
今天学习了JDBC高级
Connection操作事务的三个操作
由连接对象开启事务
由连接对象提交事务
由连接对象回滚事务
C3p0连接池(其中存放了很多连接,用的时候拿出来,不用的时候归还)
1.导入jar包
2.配置文件
3.修改配置文件
注:文件名和文件的内容需要按固定格式定义
注:连接池中获取的connection连接调用close()方法是用于归还连接的
DBUtils工具类
减少代码的复用性,提高效率
核心类:QueryRunner
使用核心类调用update()方法可以完成增删改操作.
使用核心类调用Query()方法可以完成查询操作.
作者: conan75 时间: 2018-5-28 21:44
陈昆明:
今天对连接池进行了初步的学习
1.对一个类进行增强的方法: a.通过继承重写,但该方法只能是被增强类可以被继承的情况下才能使用;b.通过修饰者模式(也就是包装类),创建一个类实现接口(要被增强的类需要也实现这个接口),然后创建的类中需要引入
被增强类的对象,至于为什么要引入被增强类的方法,个人理解是因为,当我们只要对其中某写方法进行增强时,才需要引入,要不然其实直接来一个实现类就行了,全部实现方法就行.
2.druid连接池与c3p0连接池,连接池,顾名思义就是存放连接对象的池子(容器),之所以使用连接池的目的是为了提高执行效率.使用连接池的基本步骤:引入jar包,添加配置文件,配置文件包括文件名,路径,key值等都需要按照
别人的游戏规则来,不能随意修改;
3.DBUtils工具类(doubi工具类),使用极为简单,需要知道里面的两个类:QueryRunner与DBUtils,可以使用QueryRunner中的update方法与query方法进行增删改查
*DBUtils与C3p0连接池的结合使用时,可以通过第三方工具类来提供一个C3p0的连接池,避免连接池的重复创建,对资源造成浪费
作者: 咸鱼coder 时间: 2018-5-28 21:53
万冕
今天学了事物，只要是用conn去调用setAutoCommit(false)开启事务 ，commit提交事务 rollback回滚到未提交前的状态
连接池是一个存放连接对象的容器，它能在容器里预先产生几个连接对象，供用户使用，并且在用完后不是销毁，而是归还
因为连接池底层重写了close方法。
c3po是一个开源的连接池，先创建c3po的ComboPooledDataSource对象，直接调用getConnection获取连接对象，要在之前先导包
其他的增删改查步骤都一致，改变的地方只有获取连接的那一步
DButils是别人已经定义好了的工具类，大大的优化了代码量，只需要两行的代码，首先创建核心类QueryRunner 然后在调用里面的API就可以
更简化的完成增删改查
作者: seilye 时间: 2018-5-28 21:54
叶身辉:
事务三个步骤(逻辑上的一组操作，组成这组操作的各个逻辑单元，要么全都成功，要么全都失败。)
开启事务:start transaction;
提交事务:commit;
回滚事务:rollback;
test注解:
注意不要全部执行,点击方法名执行,
jdbc(用于执行sql的java语句):
五个步骤:贾琏欲执事,加载驱动,创建连接,输入SQL,执行SQL,释放资源
C3P0(工具类):
导入jar包:要导入mysql的连接包和c3p0的jar包
配置一个文件参数文件名固定,注意不能改原本的内容,只能更改值
Connection 连接
PreparedStatement 解决了sql注入的问题,执行sql语句
ResultSet 结果集
ComboPooledDataSource datasource = new ComboPooledDataSource();创建连接池的对象
datasource 连接池
注意connection的释放资源时,将连接返回到连接池
DBUtils:
要导入mysql的连接包和c3p0的jar包还有一个dbutils包
QueryRunner queryrunner = new QueryRunner(dataSource); 传入一个连接池对象
例句queryrunner.update("insert into user values(null,?,?,?,?)", "aaa", "246", "大白", 15);
如果是查询就用query
作者: 滴滴eclipse启动 时间: 2018-5-28 21:54
江某人:
JDBC高级:
jdbc管理事务的API 有三步:
setAutoCommit();开启事务
commit();提交事务
rollback();回滚事务
C3P0连接池的使用:
引入DBCP连接池的jar包
将文件名命名为 c3p0-config.xml(不能改,固定这名字(暂时我只知道不能改))
拷贝模版配置文件到SRC下,并修改
DBUtils（阿帕奇）:
DBUtils是java编程中的数据库操作实用工具，小巧简单实用。
DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。
Dbutils今天学习了:QueryRunner; QueryRunner中提供对sql语句操作的API.
update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作(今天还没有教查的)
作者: 13163997058 时间: 2018-5-28 21:54
本帖最后由 13163997058 于 2018-5-29 11:49 编辑
王刘锁
看着写过的代码才能想起来今天学习了什么!首先是事务的处理,主要就是一个Connection接口,它有两个作用一是创建连接二是管理事务! 这个接口中有一些方法用来管理事务.事务就是一组操作,这组操作的各个步骤要么全部成功要么全部失败.事务的管理方法:
开启事务:conn.setAutoCommit(false);括号内写false意思是不自动提交事务
提交事务:conn.commit();回滚事务:conn.rollback();
然后学习了连接池的工作原理,主要学习的是怎么自定义一个连接池当然这不是今天的重点,所以不多记录,能做到理解会用就可以!接下来学习的是一些开源的连接池像阿里巴巴的Druid,阿帕奇的C3PO,老师说重点掌握C3PO,那今天就多练习一下C3PO好了.敲了好多遍的代码结果做作业的时候又是一脸懵的去翻笔记,这真的很愁人!下面是凭记忆记录的,不知道能有多少错误!那种很麻烦的手动连接的方式就不写了,直接记配置文件的方式.
首先配置文件的注意事项:文件名字不能乱改,是固定的 c3po-config.xml
然后是里面的属性也不能改,都是系统认定的!那我们能改的只有具体的值classname,url,user,password,这些内容.
那c3po的创建连接池的方式是:ComboPooledDataSource dataSource = new ComboPooledDataSource();其它的好像就没有什么变化的了!
还有就是DBUtils工具类.不过今天没来得及练习.就不记录了,明天练习完了再添加!!
来补充一下昨天没写完的DBUtils,今天上午在敲完日常作业后准备去练习一下
DBUtils的CURD操作,结果创建好Java文件不知道怎么去写代码,后来去翻了笔记发现
笔记中也没有什么信息,最后去了百度百科去查了一下,大概有了一些理解,又去代码
中写了几遍,在这里记录一下自己的理解,首先DBUtils是一个工具类库,
它主要是封装了我们的JDBC代码,以前我们用JDBC来和数据库建立连接并做一些CRUD
的操作,那时候我们的代码会很繁琐而且重复性太高.后来我们可以自定义工具类把注
册驱动和建立连接的方法还有释放资源的方法放到工具类中,这样很大程度上简化我
们的代码,而且复用性提高很多,可是即便有了工具类还是代码还是不够完美,那么
DBUtils的作用就凸显出来了,它对JDBC的封装极大程度简化我们的代码,让我们可以
用两行代码就完成CRUD的操作,那我们去使用它就需要记住它的主要核心类
QueryRunner,首先我们需要通过构造方法来获取到QueryRunner对象,一种是无参
QueryRunner()创建的是一个没有连接的对象,操作数据库的时候还要创建连接比较麻
烦,但是可以手动管理事务,第二种是有参QueryRunner(DataaSource ds),这个构造参
数是一个连接池对象,在这里我们可以用我们之前定义的JDBCUtils2这个工具类来获
取C3PO的连接池,这个构造出来的对象不用我们再获取连接,而且是自动管理事务,
那重要的是要记住CRUD操作的方法,一个增删改,一个查询,查询还没学先不记录,
有参增删改:update(String sql,object...param);
无参增删改:update(Connection conn,String sql,object...param);
这里面直接写sql语句,后面的参数是解决sql注入问题的那个?对应的值,sql语句中有
多少?后面就有多少个值!而且顺序和类型必须对应!无参的不过是多给一个连接对象,
练习的时候我尝试用一个QueryRunner对象去同时执行多条sql语句结果没有报错,但
是这好像也没什么用!!
作者: 李志勇 时间: 2018-5-28 21:54
李志勇:
JDBC高级:
事务管理 三步骤:
Connection.setAutoCommit(boolean autocommit) 开启事务
.commit(); 提交事务
.rollback();回滚事务;
连接池:
连接池是装有连接的容器，使用连接的话，可以从连接池中进行获取，使用完成之后将连接归还给连接池。
c3p0开源连接池的使用,采用配置文件的方式:
导包
mysql-connector-java-5.0.8-bin.jar
c3p0-0.9.1.2.jar
配置文件在src文件下c3p0-config.xml;
然后通过创建连接池ComboPooledDataSource dataSource = new ComboPooledDataSource();
从连接池获得连接 conn = dataSource.getConnection();
编写sql语句
预编译sql pstmt = conn.prepareStatement(sql);
执行sql pstmt.executeUpdate();或 rs = pstmt.executeQuery();
工具类的标准:{
private static final ComboPooledDataSource dataSource=new ComboPooledDataSource();
public static Connection getConnection() throws SQLException{
return dataSource.getConnection();
}
public static DataSource getDataSource(){
return dataSource;
}
}
DBUtils的使用:
QueryRunner qr=new QueryRunner(JDBCUtils.getDataSource());
qr.update("sql语句", sql语句中的问号赋值);
作者: 李思贤126 时间: 2018-5-28 21:55
李思贤:今天首先学了事务的三个方法:
1:开始事务 setAutoCommit(Boolean)
2:提交事务 commit();
3:回滚事务 rollback(); 这三个方法都有conn调用. 回滚事务放在catch中
连接池,就是存放连接对象的容器.
我们要求掌握c3p0连接池.需要做下面几个步骤,
第一步：引入c3p0连接池的jar包.
第二步:配置文件,文件的名字一定要是c3p0-config.xml,里面的key不能随便乱改.
最后学习了DBUtils,可以非常简洁的书写代码,本来是十来行的代码,现在2行完成.
QueryRunner(DataSource ds);
方法：QueryRunner queryRunner = new QueryRunner(JDBCUtilsC3P0.getDataSource());
queryRunner.update(“sql语句””...”);
作者: lnongge 时间: 2018-5-28 21:55
16weisong
今天学了JDBC高级,主要包括JDBC事务管理,连接池,Druid连接池,c3p0连接池和DBUtils工具类,主要掌握C3P0连接池和DBUtils工具类的使用即可,事务管理就三个方法.今天只需要把c3p0的使用多写几遍,和DBUtils一起,即可掌握
作者: 5119 时间: 2018-5-28 21:56
游荣辉
总结
今天首先学了事务的三个方法
.setAutoCommit(Boolean)
.commit();
.rollback();有异常(捕获)
还有连接池,什么是连接池呢?
就是存放连接对象的容器
还学习了一个很重要的连接池:c3p0连接池.
第一步：引入DBCP连接池的jar包.
第二步：编写DBCP代码：
手动设置参数:这个我就不多说了
配置文件设置参数:这个要创建一个配置文件,文件的名字一定要是c3p0-config.xml,
里头的名字不能随便乱改
dbutils,是可以非常简洁的书写代码,本来是十来行的代码,用dbutils两行就写好了,
构造：
QueryRunner(DataSource ds);
方法：
int update(String sql,Object… args);
T query(String sql,ResultSetHandler rsh,Object… args);
作者: 偏离X 时间: 2018-5-28 21:57
郭明杰
[事务] 事务指的是逻辑上的一组操作,组成这组操作的各个逻辑但愿要么全都成功,
要么全都失败.
1 开启事务,
2 提交事务 : 没有问题的时候-->数据生效,事务结束
3 回滚事务:有问题的时候-->数据回到开启事务时的状态,事务结束
注意:链接事务管理必须是用
开启:conn.setAutoCommit(false);
提交:conn.commit();
回滚:conn.rollback();
连接池 相当于存放连接的容器
c3po是一个开源的连接池，先创建c3po的ComboPooledDataSource对象，直接调用getConnection获取连接对象，要在之前先导包
作者: w849027724 时间: 2018-5-28 21:58
吴利君
今天学习了SQL的一些进阶的知识，其实关键的还是开源的连接池的使用以及DButils的使用。
首先是事务的管理，这个主要有三个，一个是开启事务，setAutecommit，提交事务commit以及回滚事务rollback这三个，使用方式也顾名思义。
然后是两个连接池，第一个是Druid连接池，这个连接池是阿里云开发的，优点是可以和Spring框架很好的整合，还可以对sql语句的执行效率进行统计，优点挺多不过没用过，所以不大了解，然后是c3p0连接池，这个连接池有用过，挺好用的，比原始的连接代码好用很多，代码简略了很多！而且据我了解，现在很多项目都在使用这个，比如我们的要学习的框架SSH，SSM等都可以使用这个来连接数据库，方便很多。
最后是DButils这个工具类，这个超级好用，它可以简化查询代码，提高开发效率，主要的增删改可以通过QueryRunner这个类的update方法使用，查询可以通过query这个方法使用，通过这个方法可以返回几个固定属性的值，然后接收即可。
作者: 名字被人注册了 时间: 2018-5-28 21:58
刘文峰
连接池是存放连接对象的容器,连接池在创建时会在里面创建出n个连接对象,当需要使用连接时可以直接从连接池里获取连接对象,使用完成后在归还连接对象.而不是即时创建连接对象然后在销毁.
c3p0的使用步骤,首先要先导入c3p0的jar包并创建路径和c3p0_config.xml 配置文件,要注意配置文件必须放在项目的src文件夹的根目录下,而且文件名不能改变,配置文件里的属性名也是固定的,可以对属性值修改但不能修改属性名.
c3p0有使用配置文件来设置参数和手动设置参数两种:
手动设置参数的使用步骤:
创建连接池 ComboPoolDataSource datasource = new ComboPoolDataSource();
配置属性 datasource.setDriverClass(); 加载驱动
datasource.setJdbcUrl(); 连接数据库
datasource.setUser(); 用户名
datasource.setPassword(); 密码
获得连接对象
Connection conn = datasource.getConnection(); 一个操作只需要一个连接对象
编写sql语句 :String sql = “sql语句”;
预编译sql语句 PreparedStatement pst = conn.PreparedStatement(sql);
如果sql语句有?号,则需为?号赋值,否则跳过这步;
执行sql语句: pst.executeUpdate(); 增删改 pst.executeQuery(); 查询
最后是归还资源,连接池里的.close()方法不是销毁连接,而是归还连接.
配置文件的步骤和手动设置一样,只是跳过了配置属性的步骤.
Dbutils是工具类,极大程度简化了代码;它的增删改步骤很简单,只有两步:
第一步 :创建核心类
QueryRunner queryrunner = new QueryRunner(传入连接对象);
第二步,执行sql语句
Queryrunner.update(“sql语句”,后面的参数是可变参数,根据sql语句里的问号数量来传入,有几个就要写几个);
作者: Eclipse启动 时间: 2018-5-28 21:58
郑阳阳
什么是连接池:
就是个装着连接对象的容器,使用的时候拿出来,使用完后还回去.
好处:
销毁和使用对象需要时间,连接池创建时就会初始化一些连接,连接存放于内存中,
使用的时候从内存中获得,使用完毕再归还,效率远高于创建于销毁.
JDBC是sun公司提供的一套统一的规范的接口.
JDBCUtils是JDBC的工具类
C3P0是阿里旗下开源的JDBC连接池
Druid也是开源的JDBC连接池
DBUtils是阿帕奇组织编写的工具类,能够极大的减少编写代码
事务:
就三行代码. 连接对象.setAutoCommit(false) 开启事务
连接对象.commit() 提交事务
连接对象.rollback() 回滚事务
作者: rkko 时间: 2018-5-28 22:01
杜石苇
今日总结
连接池是用来创建储存多个连接到数据库的链接的,这样就方便用户拿去放;当用户需要时从数据库中拿就行了;用完后不销毁 放回连接池;
Druid ,C3P0改写的工具类就是创建个数据源的链接对象
这个工具类利用Druid和C3P0的对象能直接从配置文件中加载驱动; 其他的基本一样 这个创建的链接对象 colse后不会销毁 回自动回连接池;
DBUtils 对数据增删改就两行代码
QueryRunner qr=new QueryRunner(JDBCUtils.getDataSoures()); 创建个 QueryRunner的对象从C3P0中获取连接池对象
qr.update("insert into account values (?,?,?)", 5,"ddd",10000); update增删改 里面底层代码自动有PreparedStatement这个防止注入的对象
作者: doudou0606 时间: 2018-5-28 22:01
JDBC高级
施炎生
1.用连接池来管理Connection,可以重复使用Connection，每次使用完Connection后，可以返回给连接池，不用一直创建。
2.连接池的配置文件：
driverClassName：数据库驱动名称
url：数据库的地址
username：用户名
password：密码
注意：配置文件中每行后面不能加逗号，分号，空格等。
3.C3P0连接池的开发步骤：
第一步：引入DBCP连接池的jar包.
第二步：编写DBCP代码：
* 手动设置参数:
* 配置文件设置参数:
4.DUBtils完成增删改的操作:
创建核心类---QueryRunner
利用核心类进行增删改---queryRunner.update
作者: LittleSky 时间: 2018-5-28 22:02
常小天
今天继续学习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方法进行数据库的增删改操作。
作者: chenyelong 时间: 2018-5-28 22:02
陈叶隆
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);
作者: 光宇 时间: 2018-5-28 22:25
侯玉林
今天我们学习了连接池,以及和各种工具类.
作者: 一梦 时间: 2018-5-28 22:53
陈世彪:
今天学习了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可以创建核心类,减少开发时间,和代码
作者: finfin12 时间: 2018-5-28 23:08
张育辉
七: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);用来查询,
作者: sts 时间: 2018-5-28 23:20
苏海斌
今天主要讲了三点,事务,连接池,DBUtils;
其中事务的话主要是通过connection连接对象来管理事务;
分为三步:开启提交回滚;
连接池的话了解什么是连接池及其作用,自定义连接池了解就行,重点掌握c3p0,
最后学了DBUtils,掌握DBUtils的增删改方法!
批处理(了解)
问题:内存溢出
一:事务
connection连接对象
管理事务:
1.开启事务:setAutoCommit(false)设置不自动提交
2.提交事务:commit()
3.回滚事务:rollback()
二.连接池:
实现DataSource接口就是连接池
相当于共享单车,创建好了连接,需要时用,用完再归还;
开源连接池:
druid
C3P0(重点!!!)
步骤:1.导包 2.引入c3p0配置文件 3.编写代码
三:DBUtils工具类:
使用DBUtils增删改
作者: Yanmo_ 时间: 2018-5-28 23:20
颜琳琳:
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核心操作类来操作.
作者: 追风筝的人哇 时间: 2018-5-28 23:39
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
作者: Nevermo 时间: 2018-5-28 23:39
许煜
每日总结
连接池:可以把连接池看作为一个容器,容器里面装的是已经创建好的连接对象.
用更通俗的话说就是连接池就像是一个工具箱,里面装着各种各样的工具.你需要工具时你可以从工具箱里面拿一个出来,但你用完不能乱丢,必须还回去.
连接池的优势:传统方式每次要访问数据库就得创建一个连接对象,使用完还得销毁连接对象.十分浪费计算机的计算能力.连接池就是提前创好连接对象,调用的时候直接拿走,用完归还.省下了程序每次创建连接和销毁链接,节约了计算机的计算能力,从而提高了程序的效率.而提高效率的代价是提前创建好的连接对象会多占用一些内存空间.
C3P0通过对配置文件的路径 文件名 格式 的严格限制,并将加载配置文件这一过程高度封装,即通过构造方法就将配置文件各种属性传入,底层代码更复杂,但是上层代码比起Druid更为简单.
DBUtils高度封装的数据库操作的工具类 用起来十分简单粗暴
QueryRunner qr =new QueryRunner(连接池对象);
qr.update/query(底层为preparedstatement对象执行sql语言);
QueryRunner是被高度封装过的 执行完语句会自动将连接对象回收进连接池
作者: COLDER 时间: 2018-5-28 23:48
本帖最后由 COLDER 于 2018-10-18 19:15 编辑
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语句,参数)
作者: hpb199567 时间: 2018-5-28 23:52
何平波
通过这两天的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构造方法
作者: 郑学馨 时间: 2018-5-28 23:56
郑学馨
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对数据库的增删改!
作者: AsusCoder 时间: 2018-5-29 00:16
本帖最后由 AsusCoder 于 2018-5-29 12:03 编辑
曾耀峰
一、初步学习事务
事务在代码中的作用是当执行更新操作后，如果代码后面的代码存在异常，那么被更新的数据会返回原来的状态，确保数据不会因为代码异常而更新丢失。
掌握事务的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个经典设计模式之一。算是第一次接触到，所以用了大幅总结去学自定义设计类。
作者: 黄志彬 时间: 2018-5-29 01:20
黄志彬
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核心类对象的时候，传进去的是连接池.因为要归还所以要传连接池。
作者: 丶犯二 时间: 2018-5-29 01:20
任佳锋
今天学习了JDBC高级
JDBC事务的三个操作步骤:
开启事务--setAutoCommit
提交事务--Commit
回滚事务--rollback
这三个方法用conn调用 回滚事务则放在catch中
C3p0连接池(存放连接的容器,用于存放连接,使用时取出,不用归还):
c3po是一个开源的连接池使用前要先导包,
然后创建c3po的ComboPooledDataSource对象，直接调用getConnection获取连接对象
DBUtils工具类(增删改):
降低代码的复用性,从而提高效率
创建核心类---QueryRunner,并将参数传入连接池,
利用核心类进行增删改等操作---queryRunner.update()
作者: 张述明 时间: 2018-5-29 01:43
张述明
今天学习的主要内容
JDBC的事务环境准备:SetAutoCommit(boolean) 设置true 为自动提交,反之
Commit() 提交
Rollback() 回滚
获得连接时候,开启事务.
连接管理事务必须一个事务有同一个连接对象完成操作.
连接池:
是储存连接的容器
自定义连接池出现的问题分析
解决思路
增强一个类方法
两种方式
1. 采用继承的方法 条件:必须能控制这个类的构造
2. 采用装饰者模式
条件: 1.增强的类和被增强的类实现相同接口
2.在增强的类中获得被增强的类的引用.
开源连接池主要掌握C3P0连接池
CombopooledDataSource dataSurce=new CombopooledDataSource();
导包
配置文件
直接使用
代码实现
Dbutils QueryRunner对象 核心运行类
增删改 用update()
查询 用 query()
作者: 林荣彬 时间: 2018-5-29 01:48
林荣彬
今天学习了事务管理的三步骤,重点学习连接池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);
作者: ...ylq 时间: 2018-5-29 09:16
叶凌青
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) ，用来完成表数据的查询操作
作者: zzx835387607 时间: 2018-5-29 09:23
郑志祥 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那边的内容（固定不可更改）
作者: wpwing 时间: 2018-5-29 09:58
吴鹏
总结
------------------------------------------------------------------
一 连接池:
顾名思义,用来放连接的池子,在程序加载的时候,预先将一些连接放在一个"池子"里,在使用的时候调用,用完再放回池子里;
以往使用连接的做法是,使用的时候创建连接对象,用完了以后再进行销毁,而当使用的连接很多时,创建和销毁连接需要的时间
会非常多,因此使用连接池,使用的时候调用连接,用完了后再放回连接池,大大节省了时间,提高了程序执行的效率;
-----------------------------------------------------------------------
二 C3P0:
1 使用之前,需先把c3p0的jar包导入到项目中;
2 创建C3P0的对象,通过手动或读取配置文件信息,都可以加载驱动,读取库文件和输入用户名及密码:
ComboPooledDataSource dataSource = new ComboPooledDataSource();
若使用手动加载信息的方法:
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setjdbcUrl("数据库所在的位置");
dataSource.setUser("数据库的用户名");
dataSource.setPasswore("数据库的密码");
而加载配置文件来加载信息的话,在创建ComboPooledDataSource()对象的时候,程序就会在src目录下寻找
默认的加载文件,c3p0-config.xml,需要注意的是,配置文件里面的内容的键是固定的,不能自己乱取名,否则
无法识别,
<?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">wp</property>
//数据库的密码;
<property name="initialPoolSize">5</property>
//连接库初始的连接数目;
<property name="minPoolSize">5</property>
//默认最小的连接数目;
<property name="maxPoolSize">20</property>
//连接库中最多有几个连接;
</default-config>
以上为配置文件的范本,必须按以上格式;
-----------------------------------
Druid:
是一个连接池,使用方法与C3P0类似,也分为手动输入信息和读取配置文件信息;
同样的,需要导入druid的jar包;
创建对象:
DriudDataSource dataSource = new DruidDataSource();
手动输入调用的方法与c3p0类似:
dataSource.setDriverClassName("驱动的全类名");
dataSource.setUrl("数据库地址");
dataSource.setUsername("用户名");
dataSource.setPassword("密码");
读取文件,是通过创建Preperties对象,调用其方法,通过字节输入流读取配置文件:
Properties properties = new Properties();
properties.load(new FileInputStream("src/配置文件"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
后面可以直接获得连接对象,执行操作等;
----------------------------------------------------------
三 DBUtils:
是一个工具类,封装了JDBC的代码,大大简化了代码的输入,增强了开发的效率;
它是由阿帕奇提供的一个工具类库,在使用之前,也需要导入DBUtils的jar包;
核心运行类:QueryRunner()
构造方法:
无参:QueryRunner()
有参:QueryRunner(DataSource ds)
方法:
int update(String sql,Object...params);
传入一个sql语句,和若干个可变参数的值,返回值是int类型,代表了改变(增,删,改)的行数;
int update(Connection conn,String sql,Object...params);
传入一个连接对象,一个sql语句,和若干个的可变参数的值,返回值是int类型,代表了改变(增,删,改)的行数;
T query(String sql,ResultSetHandler<T> rsh,Object...params);
传入一个sql语句,一个rsh集合,若干个可变参数的值;
T query(Connection conn,String sql,ResultSetHandler<T> rsh,Object...params);
传入一个连接对象,一个sql语句,一个rsh集合,若干个可变参数的值;
在一般情况下,如果执行增删改查操作:
构造:
有参:QueryRunner(DataSource ds)
方法:
int update(String sql,Object...params);
传入一个sql语句,和若干个可变参数的值,返回值是int类型,代表了改变(增,删,改)的行数;
T query(String sql,ResultSetHandler<T> rsh,Object...params);
传入一个sql语句,一个rsh集合,若干个可变参数的值;
如果有事务管理的话:
构造:
无参:QueryRunner()
方法:
int update(Connection conn,String sql,Object...params);
传入一个连接对象,一个sql语句,和若干个的可变参数的值,返回值是int类型,代表了改变(增,删,改)的行数;
T query(Connection conn,String sql,ResultSetHandler<T> rsh,Object...params);
传入一个连接对象,一个sql语句,一个rsh集合,若干个可变参数的值;
----------------------------------------------------------
四 JDBC、JDBCUtils、C3P0、Druid、DBUtils:
JDBC是一套完整的接口规范的API,规范了java与数据库的连接;
JDBCUtils是把JDBC中重复的代码抽取出来的一个工具类;
C3P0是一个连接池;
Druid是一个连接池;
DBUtils是一个封装了JDBC的工具类,由阿帕奇组织提供的,旨在简化代码,提高编程的效率;
作者: 2902 时间: 2018-5-29 10:12
今天学习了事务,连接池,dubt;
事务有三个步骤,开启事务,就是不让系统自动提交,通过connection对象setAutoCommit(flase);来设置手动提交
操作多条sql语句;全部执行为出错,则通过connection对象.commit来结束事务 保存数据,如果执行sql语句过程
中有错误发生则通过捕获异常,在catch中回滚事务,让数据库回到开始事务的状态,结束事务;这三个方法都要用同一
个connection对象;
连接池,为了不让每次访问数据库都创建一个新的连接池,使用完后就销毁,我们学习了连接池,提高了运行效率,连接池
在数据加载时就初始化好多个连接对象,访问者访问直接在连接池取一个连接对象,实现数据访问,完成后将连接对象归
还到连接池,这样避免了大量创建和销毁连接对象的情况发生.主要我们学习c3p0连接池.
作者: 1748341437 时间: 2018-5-29 10:25
本帖最后由 1748341437 于 2018-5-29 10:28 编辑
2018/5/28 林玮
今天学了三个知识,一是事务,二是连接池,三是DBUtils工具类,最后还拓展了一个知识--开源连接池C3P0(据说以后工作会经常用到);
事务呢是逻辑上的一组操作,而这组操作要么全部成功要么全部失败,他有三个方法都是
通过connection对象创建出来的,而添加了这三个方法的代码就是一组事务了.
第一个方法:conn.setAutoCommit(false);--开启事务,顾名思义主要用于开启事务,
要注意的一点是括号里加false是只开启不自动提交,反之则是开启并自动提交;
第二个方法:conn.commit();--提交事务,如果开启事务自动提交了事务了的话就
不用写这个方法了,但这样写不好,所以我们还是用手动提交事务的方法.
的三个方法:conn.rollback();--回滚事务,如果代码里有错误,他就可以回滚到开始的
一个状态.由于他本身就有异常,所以要用try--catch()封装一下;
注意事项:1.事务的连接对象必须是同一个连接对象;2.不能不写提交事务;
连接池是一个类,可以储存连接到内存内存中.我们可以自定义连接池类但是不够完善,所以就了解了一个开源连接池.在没学连接池的时候,我们如果要用到连接池了,就创建连接池,然后销毁(释放资源),这是一个很浪费资源的方法,如果有100万个用户我们就要创建100万个连接对象了.学完连接池就不一样了,当用户使用到连接的时候从连接池中去拿,用完归还回去,供其他用户使用.这样就会形成一个循环不用再我们自己一直创建那么多的连接对象,再销毁;我们在用它的时候,它创建的连接池对象有一个下限和一个上限,都是我们自己给定的,这个不重要,有多少个同时使用连接的用户就设置多少个...
DBUtils工具类呢,好像没什么好讲的,顾名思义嘛.就是jdbc的一个工具类用于简化代码的;
主要就是后面的那个开源连接池C3P0了,其实除了C3P0还有一个Druid开源连接池,这个不重要了解一下就好,因为以后主要就用C3P0的.由于开发项目啥的都要用到C3P0,所以这个还是蛮重要的;当然是用C3P0之前肯定是有准备工作的,在使用它之前得先导jar包,还要导一个后缀民为.xml的配置文件(注意文件名不能改,我们现在导的是c3p0-config.xml就是这个"c3p0-config"不能改导进去是什么就是什么),然后就可以开始使用了;
今天讲的东西不多但是逻辑比较强,不同以往傻瓜式记忆,所以以后写代码时也要多加思考了;
作者: 376091692 时间: 2018-5-29 10:57
凌辉:
今天主要要掌握C3P0的用法和DBUtils的使用
为了不浪费资源我们要先创建连接池的工具类,
在C3P0调用连接池的连接,
在DBUtils核心类调用连接池,
要多使用几次,记熟练
作者: it小白001 时间: 2018-5-29 11:34
吴俊斌
一.事务管理的三个方法: 一个事务开启,setAutoCommit(Boolean AutoCommit)也就是在开头把自动提交改为手动提交
第二个是提交commit()在代码没有异常的情况下执行 第三个是回滚rollBack()在代码报错的时候执行,退回事务开启时候的状态
二.自定义常量池
1.一个类实现DataSource接口,重写获得连接的方法,思路先创建一个不能被修改的集合泛型是连接对象,在构造方法里给它添加
几个连接,在获得连接方法里通过集合的remove()得到连接对象,不用get()的原因是因为不方便归还
2.还要添加一个归还的方法,就是用户在调这个方法的时候传一个连接对象过来,在添加到集合中.但是这样用户就要多记很多
方法,我们可将连接.close的方法改为归还的方法,因为connection是接口,我们要使用装饰者模式就是创建一个类去实现connection
接口,在创建一个包装类,在构造方法把connection对象传过来,这样我们的包装类就有了.close方法,在将里面的方法替换成归还就好了
三.Druid和c3p0开源连接池
这两个使用方法差不多,都有两种方式.都是先要导包,创建对象,但是C3P0更为简单,第一种方式都一样都有手动设置通过对象加载驱动,
路径,账号,密码 第二种方式就不同了,druid配置环境变量的内容不能乱改,文件名可以随意写,路劲也可随便放.C3P0的文件名,路径,还有
文件内容都是固定的不能乱改.使用上也不同,Druid需要通过对象.load(输入流找到配置文件),而C3P0直接创建对象就搞定了
四.DBUtils
这是一个工具类库,使用的时候的需要创建queryrunner对象需传一个连接池对象,使用update的增删改,使用query查询
作者: 六道的骸6 时间: 2018-5-29 11:39
JDBC高级
批处理操作
可以将一批SQL语句一起执行
基本使用
添加批处理
addBatch();
执行批处理
executeBatch();
清空批处理
clearBatch();
为了防止批处理时产生内存溢出 应设置条件每隔一个时间段执行批处理 并清空批处理
JAVA操作事务
管理事务
1 开启事务 setAutoCommit(false) 关闭事务自动提交功能
2 提交事务: 没有问题的时候→数据生效,事务结束 commit()
3 回滚事务: 有问题的时候→数据不生效,回滚事务 rollback();
连接事务的对象必须为同一对象
连接池
概述
相当于一个装有连接的容器,使用连接的话,可以从连接池中进行获取,使用完成之后将连接归还给连接池.
在服务器初始化时就初始化一些连接.把连接放入内存中,使用的时候从内存中获取,使用完成后归还给连接池.
作用
提升性能 减少连接对象的创建和销毁
自定义连接池
接口 DataSource
1 实现接口 DataSource
2 初始化多个连接
创建list集合存储连接对象
在空参构造中给集合添加连接对象
3 重写getConnection方法
删除集合中第0个元素 return删除的元素对象(防止同一个连接对象重复被调用)
4 编写归还连接方法
给集合添加传入的连接对象
问题及解决
问题
创建连接池对象 不方便程序的扩展
额外提供自定义方法提高了使用难度
解决
将close方法重写为归还方法(增强一个类中的方法)
1 采用继承的方式 重写父类的方法(使用条件:必须能够创建父类对象)
2 装饰者模式
使用条件 1 包装类和实现类要实现相同的接口
2 包装类中获得实现类的引用(包装类中使用了实现类的对象)
为了简化编程 提供一个模版类(模版类继承接口的所有方法 需要全部重写)
让包装类继承模版类 包装类有参构造 传入接口子对象和集合对象 将close方法改为归还方法
改写工具类的获得连接对象方法
创建包装类对象 传入连接对象和集合 增强close方法 返回增强后的连接对象
Druid连接池
概述
阿里旗下的开源连接池产品,可以与Spring框架进行快速整合.
引入jar包和连接池驱动
使用1(手动方式)
获取连接池对象 new DruidDataSource
手动设置参数 dataSource.set
使用2(配置方式)
属性文件中的key不可改变
创建配置文件对象 new Properties
读取配置文件 p.load(new ReaderFile)
创建连接对象 DruidDataSourceFactory.create(P)
C3P0开源连接池
引入jar包
使用1(手动方式)
创建连接池 new ComboPooledDataSource
设置参数 cbo.set
使用2(配置文件)
在src路径下创建配置XML文件 文件名必须为(c3p0-config.xml) 配置连接池
创建连接池 new ComboPooledDataSource 会默认去查找c3p0-config文件 之后即可直接使用
改写工具类
创建 private final连接池对象
创建 获取连接对象方法
创建 获取连接池方法
DbUtils
概念
对JDBC进行了简单封装的开源工具类库 简化了JDBC的编程
QueryRunner 核心运行类
方法
update(sql,可变参数) 增删改
query(sql,可变参数) 查询
增删改操作
创建QueryRunner运行类对象
使用update传入SQL语句进行操作
查询操作
创建QueryRunner运行类对象
使用query传入SQl语句 匿名ResultSetHandler对象 泛型java类
查询一条记录 获取数据赋值给java类中的成员变量
查询多条数据 创建集合 泛型java类 创建java类对象 赋值 添加到集合中
遍历集合 打印所有java类对象(需要重写toString方法)
作者: 凉面要趁热吃 时间: 2018-5-29 15:22
本帖最后由 凉面要趁热吃 于 2018-5-30 09:01 编辑
黄进安:
1. 事务的批量处理
l 使用了voidaddBatch(String sql) 执行SQL命令
l 使用了int[]executeBatch() 对这些执行命令进行批量处理,全部执行成功返回更新计数组成的数组
2. JDBC的连接对象进行事务管理
通过连接对象获取:事务的开启,提交和回滚
开启: 连接对象.setAutoCommit(false); false部让事务自动提交
提交: 连接对象.commit();
回滚: 连接.rollback(); 置于catch语句中,即事务出现异常时回滚事务
3. 自定义连接池用到了一种设计模式: 装饰者模式
--->装饰模式是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能
l 装饰对象和真实对象有相同的接口
l 将真实对象传递到装饰对象的构造方法中,实现对真实对象的引用
l 在装饰对象中对需求的方法进行重写操作,完成我们需要的功能需求
4. 对c3p0连接池的使用:
l 如果使用配置文件的方式,配置文件名c3p0-config.xml 不可随意更改且必须放在当前项目的src文件夹下,因为在连接池对象ComboPooledDataSource的底层源代码中已经设置好了文件的指定路径及其文件名,同理里面定义的一些变量名也不能更改.
l 优化工具类:在工具类中创建连接池对象ComboPooledDataSource,使用静态修饰,使其仅随工具类的加载而创建一次;抽取创建获取连接池和连接的方法
5. 使用DBUtils工具类:
l 获取核心类: QueryRunner(连接池对象);
l 通过核心类对数据库进行CRUD操作的方法: intupdate(“SQL执行语句?,?”,Object… args);即底层代码使用的是PrepareStatement预编译的 SQL 语句的对象
作者: 望蜀 时间: 2018-5-29 16:10
邵倩
Connection 有两个作用:创建连接和管理事务.
事务是一组操作,这组操作的各个组成部分 要么全成功,要么全失败.
conn.setAutoCommit(false); 开启事务,false确保事务不能自动提交----获取连接后
conn.commit(); 提交事务---sql语句执行完后
conn.rollback(); 回滚事务---catch到异常后
连接池
装连接对象的容器.
创建和销毁连接对象需要耗费时间,而连接池可以实现在服务器初始化的时候就初始化一些连接,并放入内存中,要用的时候从内存中获取,使用完成后放回连接池,从内存获取和归还的效率远高于创建和销毁.
连接池对象被创建的时候 连接也会创建 而且是多个.
自定义连接池 emmmm...不重要,因为以后也不用自己写连接池,而是借用一些开源连接池产品如Druid或C3P0等.
Druid
手动设置参数的方式不用掌握,主要学习配置文件方式设置参数
Druid配置方式可以使用属性文件配置
文件名没有规定但是属性文件中的key是一定的,如driverClassName=... ,url=...
C3P0
一个开源的JDBC连接池,目前使用最多的连接池
配置文件的路径/名称/name属性都不能随意写,大小写都要严格按照要求写,只能放在src下,文件名c3p0-config.xml
开发步骤:
1.导入mysql驱动包和c3p0的jar包
2.配置文件 修改值
3.工具类,这个工具类中创建了一个c3p0连接池,还有3个方法 获得连接池,从连接池中获得连接和释放资源.
4.建表
5.写一个测试类 贾琏欲执事
Dbutils
Apache组织提供的一个对JDBC进行简单封装的开源工具类库,简化开发,不影响程序性能
增删改的操作除了sql语句外一模一样
QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());//创建核心类
queryRunner.update("insert into account values (null,?,?)", "ddd",10000);
注意:凡是使用JDBC操作数据库 都要导mysql的驱动包
配置文件只能放在src下
作者: q55w66 时间: 2018-5-29 16:48
王清松
连接池:存放连接对象的内存区域，让资源稀少的连接对象可以被重复使用，减少了连接创建和销毁的次数，提高程序的效率
JDBC：Java Data Base Connectivity Java数据库连接
JDBCUtils: 我们自己定义的JDBC工具类
C3P0:封装好的连接池工具
Druid:阿里封装好的连接池工具
DBUtils:阿帕奇封装好的JDBC工具类
用Java的IDE管理事务
1.事务开启(Connection对象).setAutoCommit(false);区别于SQL语句starttransaction
2.事务回滚(Connection对象).rollback;
3.事务提交(Connection对象).commit;
编写自定义连接池：
1.编写实现DataSource接口的类
2.创建集合List<Connection>存放连接
3.在构造函数中构造连接
4.编写获取连接的方法
5.编写归还连接的方法
问题：
1.使用接口实现类完成构造，不方便程序扩展
2.需要用户记住额外的归还方法，不方便使用
解决：
1.继承conn对象所属类，重写其close()方法，因为不知道类名，无法控制其构造函数,所以不可行
2.动态绑定代理(为学习)
3.使用装饰者类（如同字符高效流对字符流进行包装） Connectivity Java数据库连接
JDBCUtils: 我们自己定义的JDBC工具类
C3P0:封装好的连接池工具
Druid:阿里封装好的连接池工具
DBUtils:阿帕奇封装好的JDBC工具类
用Java的IDE管理事务
1.事务开启(Connection对象).setAutoCommit(false);区别于SQL语句starttransaction
2.事务回滚(Connection对象).rollback;
3.事务提交(Connection对象).commit;
编写自定义连接池：
1.实现
作者: wahahaha 时间: 2018-5-30 08:28
林恒山
添加事务的代码:调用Connection里面的getAutoCommit()开启事务;commit()提交事务;rollback()回滚事务.
因为连接资源宝贵,不断的创建和销毁效率并不高,因此有了连接池,连接池是一个存放连接的容器,需要使用的时候可以从连接池拿取连接,不需要的时候存放到连接池里面.放在连接池的连接并不会在用完之后就直接销毁掉.
2种连接池:
1.阿里的druid,直接创建druid,手动设置连接数据库的参数,另外一种则是将参数写在properties配置文件里面.
2.阿帕奇的C3P0,第一种也是创建C3P0对象,手动设置参数,第二种则是把参数写在名字为c3p0-config.xml中.
DUBtils完成增删改的操作
创建QueryRunner对象,调用QueryRunner对象的update进行增删改,调用QueryRunner对象的query进行查.
作者: Do1 时间: 2018-5-30 18:48
本帖最后由 Do1 于 2018-5-30 21:50 编辑
郑泽珑
mysql数据库默认是自动提交事务的,我们可以通过3个方法来设置事务的回滚 提交,防止在处理SQL时期间发生错误而导致数据传输的错误,
第一个是 setAutoCommit(false); 这个方法设置了将默认的提交改为false.
然后再通过 commit();方法手动提交结果
如果处理的过程中报错了就可以通过rollback();方法进行回滚回到设置默认提交时的值
连接池是因为普通的连接每次都要创建一个连接给一个用户,用户使用完毕后释放资源,会造成性能及内存上的影响,通过连接池可以预先建立好n个连接,用户从连接池中获取连接,使用完毕后归还,这里的归还需要重写工具类Connection中的close方法.
重写工具类Connection中的close方法需要先将它的其它方法实现,然后重写close,将close改为归还,即将用户使用完毕后的Connection接口 加入连接池接口List集合 conn.add(List).
Druid是阿里旗下的一个开源连接池,使用方法和c3p0基本一致,不过c3p0有方便直接配置的xml文件
这类开源连接池方法中直接帮你提供了连接池,我们不需要再去手动创建连接加入集合,非常方便用户使用
JDBCUtils工具类的改写,直接引用c3p0工具类中的创建连接池方法,留几个close方法即可
DBUtils是将sql编译语句进一步的简化,只需2句话即可完成编译操作,
一是创建QuerRunner对象需要传入一个连接池
二是通过不同的参数将数据传递,给一个javabean对象,这个对象里面有setget方法保存和取值
作者: avip0000 时间: 2018-6-4 17:30
白有旺
JDBC 今天学了 自定义工具类连接数据库 比较复杂 了解就好
重点掌握 C3P0 DBUtils
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |