首页 > 数据库技术 > 详细

数据库连接池

时间:2019-06-21 23:44:47      阅读:198      评论:0      收藏:0      [点我收藏+]

今日知识

1. c3p0和Druid使用
2. DBUtils使用
3. SpringJDBC轻量级框架
4. 总结

c3p0和Druid使用

1. *概念:其实是一个容器(集合),存放数据库的容器。用户访问完在放回池子中
2. *好处:
1.节约资源
2. 用户访问高效

3. 实现:
1. 标准接口:DataSource javax.sql包下的
1.方法:
*获取连接 Connection()
*归还连接:Connection.close()如果连接对象connection是连接池获取的,此时应该是归还连接,不是直接关闭连接。
2.
* c3p0连接池技术
* Druid连接技术,由阿里巴巴实现的。
4. C3P0的使用:
*步骤:
1. 导入jar(两个),c3p0的包,和mchange-commons-java-0.2.12 jar包,+数据库连接的包
2. 定义配置文件:
*名称:c3p0.properties 或者 c3p0-config.xml
*路径:直接放在src目录下即可
3. 创建核心对象 获取数据库连接池对象 :combopooledDataSource(mchange-commons-java-0.2.12 jar包)
4. 获取连接:getConnection
*核心代码:
//获取dataSource,使用的默认配置
1.DataSource ds=new ComboPooledDataSource();//自动获取配置文件c3p0-config.xml
//使用其他配置,带参的使用
2.DataSource ds=new ComboPooledDataSource("otherc3p0");
3. 通过DataSource调用getConnection方法
4. 剩下的操作和原来一样

* 注意:C3p0只是一个管理连接池的一个容器,其他操作还和原来一样,先获取sql执行对象,在执行sql,最后处理结果。

5. Druid连接池
* 步骤
1.导入 druid-1.0.9jar包和数据库连接jar包
2. 定义配置文件:druid.properties
*可以叫任意名称,放在任意目录下
3. 获取数据库连接池对象 :DruidDataSourceFactory.createDataSource(pro);
4. 获取连接:getConnection
* 创建Utils工具使用:
1. 创建成员变量DataSource
2. 用静态代码块获取DataSource对象,
3. 创建getConnection方法
4.创建释放资源的方法
例如:
public class DruidUtils {
private static DataSource ds;
//获取连接池对象
static {
Properties pro=new Properties();
//获取配置文件,并返回流
InputStream is = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
try {
pro.load(is);
ds= DruidDataSourceFactory.createDataSource(pro);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
//获取连接对象
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
//释放资源
public static void close(Connection con,Statement statement){
close(con,statement,null);
}
public static void close(Connection con, Statement statement, ResultSet rs){
if (rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (con!=null){
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (statement!=null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//获取连接池的方法
public static DataSource getDatasource(){
return ds;
}
}

DBUtils使用

* DBUtils框架 它是对JDBC的简单封装,学习成本极低,并且使用dbutils能极大简化jdbc编码的工作量
* 步骤:
1. 导包:commons-dbutils-jar
2. 创建QueryRunner对象,依赖数据源DataSource
*QueryRunner runner=new QueryRunner(DruidUtils.getDatasource());
3. 调用QueryRunner的方法来完成数据库操
1. update:用来执行一个更新(插入、更新或删除)操作。
2. batch:用来执行批量更新(插入、更新或删除)操作。
3. query(sql,new ArrayHandler()):把结果集中的第一行数据转成对象数组。
4. query(sql,new ArrayListHandler()):把结果集中的每一行数据都转成一个数组,再存放到List中。
5. query(sql,new BeanHandler()):将结果集中的第一行数据封装到一个对应的JavaBean实例中。
6. query(sql,new BeanListHandler()):将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。
7. query(sql,new ColumnListHandler("name")):将结果集中某一列的数据存放到List中
8. query(sql,new KeyedHandler("name")):将结果集中的每一行数据都封装到一个Map<列名,列值>里,再把这些map再存到一个map里,其key为指定的key。
9. query(sql,new MapHandler()):将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。
10. query(sql,new MapListHandler()):将结果集中的每一行数据都封装到一个Map里,然后再存放到List.
11. query(sql,new ScalarHandler()):将单个值封装,用来统计聚合函数返回值.如count,avg,max,min

*代码:
package com.rqy.datasource.dbutils;

import com.rqy.datasource.Utils.DruidUtils;
import com.rqy.datasource.bean.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;
import java.sql.SQLException;
import java.util.*;

/**
* @author 任清阳
* @Email 1277409109@qq.com
* @date 2019/6/18 21:16
*/

public class DButilsDemo2 {
//1.导入jar包
private QueryRunner runner=new QueryRunner(DruidUtils.getDatasource());
//使用单元测试

/**
* batch:用来执行批量更新(插入、更新或删除)操作。
*/

@Test
public void testBatch() throws SQLException {
String sql="delete from account where name=? and balance=? ";
Object[] [] params=new Object[10][];
for (int i = 0; i < 10; i++) {
//为每一行给两列值,第一列对应第一个问号,第二列对应第二个问号
params[i]=new Object[]{i+"",3};
}
int[] query = runner.batch(sql,params);
System.out.println(Arrays.toString(query));

}
/**
* update:用来执行一个更新(插入、更新或删除)操作。
*/

@Test
public void test() throws SQLException {
String sql="insert into account values(null,?,?) ";
int query = runner.update(sql,"ren",5200);
System.out.println(query);

}

/**
*query: ArrayHandler:把结果集中的第一行数据转成对象数组。
*/

@Test
public void test1() throws SQLException {
String sql="select * from account ";
Object[] query = runner.query(sql, new ArrayHandler());
System.out.println(Arrays.toString(query));

}
/**
* query:ArrayListHandler:把结果集中的每一行数据都转成一个数组,再存放到List中。
*/

@Test
public void test2() throws SQLException {
String sql="select * from account ";
List<Object[]> query = runner.query(sql, new ArrayListHandler());
for (Object[] objects:query) {
System.out.println(Arrays.toString(objects));
}
}
/**
* BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中。
*/

@Test
public void test3() throws SQLException {
String sql="select * from account ";
Account query = runner.query(sql, new BeanHandler<Account>(Account.class));
System.out.println(query);
}
/**
* BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。
*/

@Test
public void test4() throws SQLException {
String sql="select * from account ";
List<Account> query = runner.query(sql, new BeanListHandler<Account>(Account.class));
for(Account account:query) {
System.out.println(account);
}
}
/**
* ColumnListHandler:将结果集中某一列的数据存放到List中
*/

@Test
public void test5() throws SQLException {
String sql="select * from account ";
List<Object> query = runner.query(sql, new ColumnListHandler("name"));
for(Object obj:query) {
System.out.println(obj);
}
}
/**
* KeyedHandler(name):将结果集中的每一行数据都封装到一个Map<列名,列值>里
* 再把这些map再存到一个map里,其key为指定的key。
*/

@Test
public void test6() throws SQLException {
String sql="select * from account ";
Map<Object, Map<String, Object>> name = runner.query(sql, new KeyedHandler("name"));
Set<Object> objects=name.keySet();
for(Object key:objects) {
Map<String, Object> value=name.get(key);
System.out.println(value);
}
}
/**
* MapHandler:将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。
*/

@Test
public void test7() throws SQLException {
String sql="select * from account ";
Map<String, Object> query = runner.query(sql, new MapHandler());
System.out.println(query);
}
/**
* MapListHandler:将结果集中的每一行数据都封装到一个Map里,然后再存放到List
*/

@Test
public void test8() throws SQLException {
String sql="select * from emp ";
List<Map<String, Object>> list = runner.query(sql, new MapListHandler());
for (Map<String,Object> s:list ){
System.out.println(s);
}
}
/**
* 测试ScalarHandler:将单个值封装,用来统计聚合函数返回值
*
* */

@Test
public void test9() throws SQLException {
Object query = runner.query("select count(*) from account",
new ScalarHandler());
System.out.println(query);

}
}

Spring JDBC

* Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
* 步骤:
1. 导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource
* JdbcTemplate template = new JdbcTemplate(ds);

3. 调用JdbcTemplate的方法来完成CRUD的操作
1. update():执行DML语句。增、删、改语句
2. queryForMap():查询结果将结果集封装为map集合,将列名作为key,将值作为value 将这条记录封装为一个map集合
* 注意:这个方法查询的结果集长度只能是1
3. queryForList():查询结果将结果集封装为list集合
* 注意:将每一条记录封装为一个Map集合,再将Map集合装载到List集合中
4. query():查询结果,将结果封装为JavaBean对象
* query的参数:RowMapper
* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
* new BeanPropertyRowMapper<类型>(类型.class)
5. queryForObject:查询结果,将结果封装为对象
* 一般用于聚合函数的查询

4. 练习:
* 需求:
1. 修改1号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1的记录,将其封装为Map集合
5. 查询所有记录,将其封装为List
6. 查询所有记录,将其封装为Emp对象的List集合
7. 查询总记录数

*代码:
package com.rqy.datasource.jdbctemplate;
import com.rqy.datasource.Utils.DruidUtils;
import com.rqy.datasource.bean.Account;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
import java.util.Map;

/**
* @author 任清阳
* @Email 1277409109@qq.com
* @date 2019/6/18 15:36
*/

public class JdbcTemplateDemo {
//导入jar包
//创建JDBCTemplate对象
private JdbcTemplate template = new JdbcTemplate(DruidUtils.getDatasource());

//junit单元测试,可以让方法独立运行
/**
* 1.修改1号数据的 salary 为 10000
*
*/

@Test
public void test1(){
String sql="update emp set sal=5000 where empno=?";
int i=template.update(sql,01);
System.out.println(i);
}
/**
* 2.添加一条记录
*
*/

@Test
public void test2(){
String sql="insert into emp (empno,ename,deptno)VALUES (?,?,?)";
int i=template.update(sql,"08","nihao","3");
System.out.println(i);
}
/**
* 3.删除刚才添加的记录
*
*/

@Test
public void test3(){
String sql="delete from emp where empno=?";
int i=template.update(sql,"08");
System.out.println(i);
}
/**
*
* 4.查询id为1的记录,将其封装为Map集合
* /注意:这个方法查询的结果集长度只能是1
*/

@Test
public void test4(){
String sql="select * from emp where empno=?";
Map<String, Object> map = template.queryForMap(sql, "01");
System.out.println(map);
}
/**
* 5.查询所有记录,将其封装为List
* 实际操作:将每一条记录封装为一个Map集合,再将Map集合装载到List集合中
*/

@Test
public void test5(){
String sql="select * from emp ";
List<Map<String, Object>> list = template.queryForList(sql);
for (Map<String,Object> s:list ){
System.out.println(s);
}
}
/**
* 6.查询所有记录,将其封装为Emp对象的List集合
*/

@Test
public void test6(){
String sql="select * from account ";
List<Account> accounts = template.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
for (Account s:accounts){
System.out.println(s);
}
}
/**
* 7. 查询总记录数
*/

@Test
public void test7(){
String sql="select count(id) from account ";
Long i=template.queryForObject(sql,Long.class);
System.out.println(i);
}
}


数据库连接池

原文:https://www.cnblogs.com/rqy0526/p/11067285.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!