发表于： 2017-09-26 22:20:27
1 814
今天完成的事情：
一、学习DBCP连接池对比不使用连接池对数据库执行插入数据的执行效率
（1）首先是建数据表，为了简便操作，只创建一个字段，循环插入数字来测试，每次操作前清空数据表。项目目录
（2）在idea2017中新建maven项目，添加依赖包,pom表如下
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lhq</groupId>
<artifactId>jdbc01</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.24</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.1.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.0.0</version>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>6.11</version>
</dependency>
</dependencies>
</project>
（3）在src/main/java 下建两个两个工具类，其中DBConn不使用连接池，DBCPUtil使用连接池
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DBConn {
//1.JDBC基本方法来获取数据库的连接并返回一个连接
private static final String url="jdbc:mysql://localhost/test";
private static final String user="root";
private static final String password="1234";
private static Connection conn =null;
public static Connection getConnection() {
//1.注册驱动 2.建立连接
try {
Class.forName("com.mysql.jdbc.Driver");
conn=DriverManager.getConnection(url, user, password);
System.out.println("---------------数据库连接成功----------------");
} catch (Exception e) {
e.printStackTrace();
System.out.println("---------------数据库连接失败----------------");
}
return conn;
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
public class DBCPUtil {
private static Properties properties = new Properties();
private static DataSource dataSource;
//加载DBCP配置文件
static{
try{
FileInputStream is = new FileInputStream("src/main/resources/dbcp.properties");
properties.load(is);
}catch(IOException e){
e.printStackTrace();
}
try{
dataSource = BasicDataSourceFactory.createDataSource(properties);
}catch(Exception e){
e.printStackTrace();
}
}
//从连接池中获取一个连接
public static Connection getConnection(){
Connection connection = null;
try{
connection = dataSource.getConnection();
}catch(SQLException e){
e.printStackTrace();
}
try {
connection.setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
}
（3）建立测试类DBCPTest，三种测试对比
---1.不采用连接池，每次插入数据都建立一个连接，然后关闭。
---2.不采用连接池，只建立一个连接，插入所有数据，然后关闭连接。
---3.采用连接池，自动获取连接，插入数据，然后连接收回连接池。
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import org.testng.annotations.Test;
public class DBCPTest {
//测试,每写一条数据前,就新建一个连接,插入完后关闭连接
@Test
public void testWriteDBByEveryConn() throws Exception{
for(int i = 1; i < =2000; i++){
writeDBByEveryConn(i);
}
System.out.println("DONE");
}
//测试,使用连接池,每写一条数据前,从连接池中获取一个连接
@Test
public void testWriteDBByDBCP() throws Exception{
for(int i = 1; i <=2000; i++){
writeDBByDBCP(i);
}
System.out.println("DONE");
}
//测试,不适用连接池，只建一条连接,写入所有数据
@Test
public void testWriteDBByOneConn() throws Exception{
Connection conn = DBConn.getConnection();
Statement stat = conn.createStatement();
for(int i = 1; i <= 2000; i++){
writeDBByOneConn(i, stat);
}
conn.close();
System.out.println("DONE");
}
//不使用连接池写数据库,每写一条数据创建一个连接
public void writeDBByEveryConn(int data){
String sql = "insert into demo values (" + data + ")";
Connection conn = DBConn.getConnection();
try{
Statement stat = conn.createStatement();
stat.executeUpdate(sql);
System.out.println("------插入数据-----");
}catch(Exception e){
e.printStackTrace() ;
}finally{
if(conn!=null) {
try {
conn.close();
System.out.println("------------------连接关闭------------------");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
//不使用连接池写数据库,只用一个连接,写所有数据
public void writeDBByOneConn(int data, Statement stat){
String sql = "insert into demo values (" + data + ")";
try{
stat.executeUpdate(sql);
}catch(Exception e){
e.printStackTrace() ;
}
}
//通过DBCP连接池写数据库
public void writeDBByDBCP(int data){
String sql = "insert into demo values (" + data + ")";
try {
Connection conn = DBCPUtil.getConnection();
Statement stat = conn.createStatement();
stat.executeUpdate(sql);
conn.commit();
conn.close();//手动关闭连接，把连接交给连接池管理
} catch (SQLException e) {
e.printStackTrace();
}
}
}
（4）测试插入2000条数据，根据完成后的时间来对比效率，从结果来看测试2.3的结果接近，对比测试1来说时间上领先很多。这只是插入简单数字，若是插入更过的字段值，结果应该相差很大。
明天的计划：
1.继续整合之前学习的spring，mybaits，单元测试
遇到的问题：
暂无
收获：
1.在使用的连接池的效率确实有很大的提升，连接池也有很多中，本例中是用DBCP的，还有C3P0，druid等比较主流的连接池技术，在以后的学习中在继续研究使用。
返回列表
评论