内外连接数据库相比,使用连接池前后连接数据库的对照

先是,为何使用JDBC?

率先,为何使用JDBC?

运用连接池前后连接数据库的对待,前后连接数据库相比较

第二,为啥采用JDBC?

       
JDBC是指java数据库连接,是面向关系型数据库的,它事实上便是2个JAVA封装的API,大家使用Java语言实践sql语句,对(种种)数据库操作,具备跨平台性。不管是哪些关
        周到据库,大家都足以通过jdbc达成数据库的连接和操作。

下一场,为何使用连接池?

         
大家不但须求连接到数据库,更供给一而再的功效。那就需求连接池了。也便是说,作者提前连接好n个延续,要求的时候,小编在池里取就行,不用再次出现创现用了,速度快了,效
         
 率高了。连接池有c3p0,dbcp等,有成文专门介绍过三种连接池的区分。结论正是c三p0是利用最广泛的。

上边相比使用连接池前后的频率

1 建一个pool管理类 Mpool

package com.db;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class Mpool {
private static Mpool mPool;
private ComboPooledDataSource dataSource;

static {
mPool = new Mpool();
}
//构造方法
public Mpool() {
try {
dataSource = new ComboPooledDataSource(“mysql”);
dataSource.setUser(“root”);
dataSource.setPassword(“root123”);
dataSource.setJdbcUrl(“jdbc:mysql://localhost:3306/test02”);
dataSource.setDriverClass(“com.mysql.jdbc.Driver”);
dataSource.setInitialPoolSize(2);
dataSource.setMinPoolSize(1);
dataSource.setMaxPoolSize(10);
dataSource.setMaxStatements(50);
dataSource.setMaxIdleTime(60);
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}

public final static Mpool getInstance() {
return mPool;
}

public final Connection getConnection() {
try {
return dataSource.getConnection();
} catch (SQLException e) {
throw new RuntimeException(“无法从数据源获取连接 “, e);
}
}

}

2 测试类 main

import java.sql.*;
import com.db.Mpool;;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(“使用连接池…………………..”);
for (int i = 0; i < 20; i++) {
long beginTime = System.currentTimeMillis();

//一 获取2个接连
Connection conn = Mpool.getInstance().getConnection();
try {

//二那几个一连要干嘛,封装在PreparedStatement筹算对象中.不能使用拼接的情势了,采纳占位符。
/* PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password)
value(“+i+”,111)”);
*/
PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password) values(?,?)”);
pstmt.setInt(1, i);
pstmt.setInt(2, i);
//叁 策画好之后,试行准备对象

/* 叁-一奉行查询对象 ResultSet rs = pstmt.executeQuery();*/

//三-二 执行插入 更新等的预备对象
//Boolean a= pstmt.execute(); //假设第第二个结实是结果集 重回true。
//提出使用executeUpadate() 施行结果能够看看,0表示没有进行
int a= pstmt.executeUpdate();
System.out.println(a);

/* 假如是查询语句,则re存在再次来到结果。
while (rs.next()) {
re.get内容

}*/
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println(“第” + (i + 壹) + “次进行耗时为:”

  • (endTime – beginTime));
    }

}

}

 

 

3 只是用jdbc测试

import java.sql.*;

public class Test1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(“不选择连接池…………………………..”);
for (int i = 0; i < 20; i++) {
long beginTime = System.currentTimeMillis();
try {
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
} catch (Exception e1) {
e1.printStackTrace();
}
String url = “jdbc:mysql://localhost:3306/test02”;
String user = “root”;
String password = “root123”;
Connection conn=null;
try {
//直接利用jdbc获取conn
conn = DriverManager.getConnection(url, user, password);
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password) values(?,?)”);
pstmt.setInt(1, i);
pstmt.setInt(2, i);

int a =pstmt.executeUpdate();
System.out.println(a);
/* while (rs.next()) {
// get content
}*/
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println(“第” + (i + 一) + “次进行耗费时间为:”

  • (endTime – beginTime));
    }
    }
    }

 能够窥见:
使用jdbc直接连接数据库,每回延续需求的时日都大致,40秒左右。而利用连接池的话,第贰回再而三必要的日子比较长,因为要做一些开端化操作吧,第2遍获得连接的时光大致是1秒,异常的快的。

除此以外注意,对数据库的操作也是有影响的,例如查询和写入操作,时间就差别等。

 

首先,为何使用JDBC?
JDBC是指java数据库连接,是面向关系型数据库的,它实际…

JDBC

今日职分

  • 行使JDBC实现对分类表的CRUD的操作(JDBC的回看)
  • 接纳DBCP,C3P0连接池实现主旨数据库的操作(收取工具类)
  • 可见选取DBUtils完结CRUD的操作

 

教学导航

教学目标

掌握DBCP和C3P0连接池的使用并掌握连接池的原理.

能够使用DBUtils完成基本的CRUD的操作

教学方法

案例驱动法

       
JDBC是指java数据库连接,是面向关系型数据库的,它实质上正是2个JAVA封装的API,大家运用Java语言推行sql语句,对(种种)数据库操作,具有跨平台性。不管是如何关
        周密据库,大家都得以经过jdbc达成数据库的连天和操作。

       
JDBC是指java数据库连接,是面向关系型数据库的,它实际就是二个JAVA封装的API,大家选取Java语言施行sql语句,对(各样)数据库操作,具有跨平台性。不管是怎么关
        系数据库,大家都足以因而jdbc落成数据库的总是和操作。

1.1 利用JDBC完结对于分类的CRUD的操作-回想JDBC

然后,为何采纳连接池?

接下来,为什么采纳连接池?

1.1.1 需求:

互连网商场中对分类增加,修改,删除,查询的操作.使用JDBC实现对分类的CRUD的操作.

         
大家不光须要连接到数据库,更须求连接的频率。那就供给连接池了。也正是说,小编提前连接好n个一而再,要求的时候,作者在池里取就行,不用再次出现创现用了,速度快了,效
         
 率高了。连接池有c叁p0,dbcp等,有小说尤其介绍过两种连接池的界别。结论正是c三p0是利用最普及的。

         
大家不但须要连接到数据库,更亟待延续的效能。那就须求连接池了。也便是说,作者提前连接好n个接二连三,必要的时候,作者在池里取就行,不用重现创现用了,速度快了,效
         
 率高了。连接池有c三p0,dbcp等,有成文专门介绍过二种连接池的区分。结论就是c三p0是利用最广大的。

1.1.2 分析:

上边相比使用连接池前后的频率

上边相比较使用连接池前后的效用

1.1.2.1 才干分析

【JDBC的回顾】

  • JDBC的概念:

JDBC:Java Data Base
Connectivity.

  • 驱动:

 

  • JDBC的费用步骤:

手续一:注册驱动.

手续二:获得连接.
手续3:创建试行SQL语句对象.

手续4:释放财富.

  • JDBC的API的详解:

DriverManager:

    * 注册驱动:

    * 得到三番五次:

Connection:

    * 获得实施SQL语句对象.

        * Statement createStatement();

        * PreparedStatement prepareStatement(String sql);

        * CallableStatement prepareCall(String sql);

    * 举办事务管理:

        * setAutoCommit(boolean flag);

        * commit();

        * rollback();

Statement:

    * 执行SQL语句:

        * int executeUpate(String sql); –执行insert update
delete语句.

        * ResultSet executeQuery(String sql); –执行select语句.

        * boolean execute(String sql); –实行select再次回到true 实行其余的言辞重临false.

  

ResultSet:

    * 遍历结果集:next();

    * 得到结果聚焦的数据.getXXX(int c);
getXXX(String name);

1 建一个pool管理类 Mpool

1 建一个pool管理类 Mpool

1.1.2.2 手续分析

  • 步骤壹:成立Java项目,引进mysql的驱动包.
  • 手续二:编写程序
  • 手续3:注册驱动
  • 手续4:得到再三再四
  • 步骤五:执行SQL
  • 步骤陆:释放能源

package com.db;

package com.db;

1.1.3 代码达成:

收取工具类:

package com.itheima.jdbc.utils;

 

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Properties;

 

/**

 * JDBC的工具类

 * @author apple

 *

 */

public class JDBCUtils {

public static final String DRIVERCLASS;

内外连接数据库相比,使用连接池前后连接数据库的对照。public static final String URL;

public static final String USERNAME;

public static final String PASSWORD;

 

static{

// 得到属性文件中的数据.

Properties properties = new Properties();

try {

properties.load(new FileInputStream(“src/db.properties”));

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

 

DRIVERCLASS = properties.getProperty(“jdbc.driverClass”);

URL = properties.getProperty(“jdbc.url”);

USERNAME = properties.getProperty(“jdbc.username”);

PASSWORD = properties.getProperty(“jdbc.password”);

}

 

// 加载驱动:

public static void loadDriver(){

try {

Class.forName(DRIVERCLASS);

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

 

// 获得一而再:

public static Connection getConnection(){

loadDriver();

Connection conn = null;

try {

conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return conn;

}

 

// 释放能源:

public static void release(Statement stmt,Connection conn){

if(stmt != null){

try {

stmt.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

stmt = null;

}

 

if(conn != null){

try {

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

conn = null;

}

}

 

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

if(rs!= null){

try {

rs.close();

} catch (SQLException e) {

e.printStackTrace();

}

rs = null;

}

if(stmt != null){

try {

stmt.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

stmt = null;

}

 

if(conn != null){

try {

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

conn = null;

}

}

}

 

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;

1.2 动用连接池改变JDBC的先后:

import com.mchange.v2.c3p0.ComboPooledDataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

1.2.1 需求:

晋升程序运转的频率,选拔连接池对JDBC的有个别的作用张开升高.

public class Mpool {
private static Mpool mPool;
private ComboPooledDataSource dataSource;

public class Mpool {
private static Mpool mPool;
private ComboPooledDataSource dataSource;

1.2.2 分析:

static {
mPool = new Mpool();
}
//构造方法
public Mpool() {
try {
dataSource = new ComboPooledDataSource(“mysql”);
dataSource.setUser(“root”);
997755.com澳门葡京,dataSource.setPassword(“root123”);
dataSource.setJdbcUrl(“jdbc:mysql://localhost:3306/test02”);
dataSource.setDriverClass(“com.mysql.jdbc.Driver”);
dataSource.setInitialPoolSize(2);
dataSource.setMinPoolSize(1);
dataSource.setMaxPoolSize(10);
dataSource.setMaxStatements(50);
dataSource.setMaxIdleTime(60);
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}

static {
mPool = new Mpool();
}
//构造方法
public Mpool() {
try {
dataSource = new ComboPooledDataSource(“mysql”);
dataSource.setUser(“root”);
dataSource.setPassword(“root123”);
dataSource.setJdbcUrl(“jdbc:mysql://localhost:3306/test02”);
dataSource.setDriverClass(“com.mysql.jdbc.Driver”);
dataSource.setInitialPoolSize(2);
dataSource.setMinPoolSize(1);
dataSource.setMaxPoolSize(10);
dataSource.setMaxStatements(50);
dataSource.setMaxIdleTime(60);
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}

1.2.2.1 技能分析:

【连接池的概述】

  • 何以选择连接池

Connection对象在JDBC使用的时候.使用的时候就会去成立3个目的,使用达成现在就会将那一个目标给销毁了.每一趟成立和销毁对象都以耗费时间操作.要求使用连接池对其开始展览优化.程序伊始化的时候,初叶化两个三番五次,将三个一而再放入到池中(内存中).每一回获得的时候,都能够一向从连接池中进行获取.使用完成未来,将连接归还到池中.

  • 大规模连接池:

DBCP :Apache.

C3P0 :

【连接池的规律】

在javax.sql.DataSource接口–连接池的接口

* 功用:开头化三个连接.把五个两次三番放入到内部存款和储蓄器中.

* 归还:将连接对象放回到内部存款和储蓄器中.

【自定义连接池–明白】

public class MyDataSource implements DataSource{

 

// 创制叁个集结List集结.

List<Connection> list = new ArrayList<Connection>();

 

// 早先化连接池的时候,伊始化几个连接.

public  MyDataSource() {

for (int i = 1; i <= 5; i++) {

Connection conn = JDBCUtils.getConnection();

list.add(conn);

}

}

 

@Override

// 从连接池中拿走接二连三

public Connection getConnection() throws SQLException {

if(list.size()==0){

for (int i = 1; i <= 3; i++) {

Connection conn = JDBCUtils.getConnection();

list.add(conn);

}

}

Connection conn = list.remove(0);

return conn;

}

 

// 归还连接:

public void addBack(Connection conn){

list.add(conn);

}

}

 

【自定义连接池中难点】

壹.开立连接池的时候能或不可能面向接口编程.

二.额外扩展连接池的措施,那么程序员必要记住这几个方法.能否不额外去提供一些方法.

***** 消除:就是要去加强Connection的close方法.

       一.一连的办法:

            * 承接的施用标准:能够支配这么些类的构造.

       二.装饰者形式:(*****)

            * 装饰者形式的应用口径:

                * 二.1增高的类和被增加的类完结平等的接口.

                * 贰.二在拉长的类中能够拿走被拉长的类的引用.

            * 接口中方法过多,只提升个中的多个方法.别的方法都亟待原样调用原有方法.

       3.动态代理:(*****)

            * JDK的动态代理使用规范:

                 * 被代理的目的必须兑现接口.

【使用开源连接池优化程序】

  • DBCP连接池:

 

核心API:

 

 

@Test

/**

 * DBCP的三个入门:手动设置参数

 */

public void demo1(){

Connection conn = null;

PreparedStatement pstmt = null;

 

// 创制连接池:

BasicDataSource dataSource = new BasicDataSource();

dataSource.setDriverClassName(“com.mysql.jdbc.Driver”);

dataSource.setUrl(“jdbc:mysql:///web07”);

dataSource.setUsername(“root”);

dataSource.setPassword(“1234”);

try{

// 获得接二连三:

conn = dataSource.getConnection();

// 编写SQL语句.

String sql = “insert into category values (null,?)”;

// 预编译SQL:

pstmt = conn.prepareStatement(sql);

// 设置参数:

pstmt.setString(一, “鞋靴箱包”);

//执行SQL

pstmt.executeUpdate();

}catch(Exception e){

e.printStackTrace();

}finally{

JDBCUtils.release(pstmt, conn);

}

}

 

@Test

/**

 * DBCP的含有配置文件的措施

 */

public void demo2(){

Connection conn = null;

PreparedStatement pstmt = null;

 

// 创立连接池:

try{

Properties properties = new Properties();

properties.load(new FileInputStream(“src/dbcp.properties”));

DataSource dataSource =
BasicDataSourceFactory.createDataSource(properties);

// 得到接二连三:

conn = dataSource.getConnection();

// 编写SQL语句.

String sql = “insert into category values (null,?)”;

// 预编译SQL:

pstmt = conn.prepareStatement(sql);

// 设置参数:

pstmt.setString(一, “生活用品”);

//执行SQL

pstmt.executeUpdate();

}catch(Exception e){

e.printStackTrace();

}finally{

JDBCUtils.release(pstmt, conn);

}

}

 

DBCP的参数的安装:

#连接装置

driverClassName=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:3306/jdbc

username=root

password=1234

 

#<!– 初步化连接 –>

initialSize=10

 

#最洛桑接数量

maxActive=50

 

#<!– 最大空闲连接 –>

maxIdle=20

 

#<!– 最小空闲连接 –>

minIdle=5

 

#<!– 超时等待时间以飞秒为单位
伍仟飞秒/一千等于60秒 –>

maxWait=60000

  • C叁P0连接池的采用:

 

 

代码达成:

@Test

/**

 * 手动设置参数的法子:

 */

public void demo1(){

Connection conn = null;

PreparedStatement stmt = null;

// System.err.println(“”);

try{

// 创造连接池:

ComboPooledDataSource dataSource = new ComboPooledDataSource();

// 设置参数:

dataSource.setDriverClass(“com.mysql.jdbc.Driver”);

dataSource.setJdbcUrl(“jdbc:mysql:///web07”);

dataSource.setUser(“root”);

dataSource.setPassword(“1234”);

 

conn = dataSource.getConnection();

// 编写SQL

String sql = “insert into category values (null,?)”;

// 预编译SQL:

stmt = conn.prepareStatement(sql);

// 设置参数:

stmt.setString(一, “食物饮料”);

stmt.executeUpdate();

}catch(Exception e){

e.printStackTrace();

}finally{

JDBCUtils.release(stmt, conn);

}

}

 

@Test

/**

 * 配置文件的不二等秘书技:

 */

public void demo2(){

Connection conn = null;

PreparedStatement stmt = null;

// System.err.println(“”);

try{

// 创设连接池:

ComboPooledDataSource dataSource = new
ComboPooledDataSource(“mysql11111”);

 

conn = dataSource.getConnection();

// 编写SQL

String sql = “insert into category values (null,?)”;

// 预编译SQL:

stmt = conn.prepareStatement(sql);

// 设置参数:

stmt.setString(一, “食品饮料22二”);

stmt.executeUpdate();

}catch(Exception e){

e.printStackTrace();

}finally{

JDBCUtils.release(stmt, conn);

}

}

【使用C三P0改写了工具类】

public class JDBCUtils2 {

 

private static final ComboPooledDataSource DATASOURCE =new
ComboPooledDataSource();

 

public Connection getConnection(){

Connection conn = null;

try {

conn = DATASOURCE.getConnection();

} catch (SQLException e) {

e.printStackTrace();

}

return conn;

}

     …

}

public final static Mpool getInstance() {
return mPool;
}

public final static Mpool getInstance() {
return mPool;
}

1.3 DBUtils完成CRUD的操作

public final Connection getConnection() {
try {
return dataSource.getConnection();
} catch (SQLException e) {
throw new RuntimeException(“无法从数据源获取连接 “, e);
}
}

public final Connection getConnection() {
try {
return dataSource.getConnection();
} catch (SQLException e) {
throw new RuntimeException(“一点都不大概从数据源获取连接 “, e);
}
}

1.3.1 需求:

简化DAO的开发.

}

}

1.3.2 分析:

2 测试类 main

2 测试类 main

1.3.2.1 才具分析:

DBUtils

【概述】

DBUtils是java编制程序中的数据库操作实用工具,小巧轻便实用。

DBUtils封装了对JDBC的操作,简化了JDBC操作,能够少写代码。

Dbutils多个为主职能介绍

l QueryRunner中提供对sql语句操作的API.

l ResultSetHandler接口,用于定义select操作后,怎么着封装结果集.

l DbUtils类,它正是二个工具类,定义了关闭财富与事务管理的不2秘诀

 

【QueryRunner核心类】

l QueryRunner(DataSource ds) ,提供数据源(连接池),DBUtils底层自动爱抚连接connection

l update(String sql, Object… params) ,实施更新数据

l query(String sql, ResultSetHandler<T> rsh, Object… params)
,推行查询

 

【ResultSetHandler结果集管理类】

ArrayHandler

将结果集中的第一条记录封装到一个Object[]数组中,数组中的每一个元素就是这条记录中的每一个字段的值

ArrayListHandler

将结果集中的每一条记录都封装到一个Object[]数组中,将这些数组在封装到List集合中。

BeanHandler

将结果集中第一条记录封装到一个指定的javaBean中。

BeanListHandler

将结果集中每一条记录封装到指定的javaBean中,将这些javaBean在封装到List集合中

ColumnListHandler

将结果集中指定的列的字段值,封装到一个List集合中

KeyedHandler

将结果集中每一条记录封装到Map<String,Object>,在将这个map集合做为另一个Map的value,另一个Map集合的key是指定的字段的值。

MapHandler

将结果集中第一条记录封装到了Map<String,Object>集合中,key就是字段名称,value就是字段值

 

MapListHandler

将结果集中每一条记录封装到了Map<String,Object>集合中,key就是字段名称,value就是字段值,在将这些Map封装到List集合中。

ScalarHandler

它是用于单数据。例如select count(*) from 表操作。

 

【DbUtils】

closeQuietly(Connection conn) 关闭连接,假诺有特别try后不抛。

commitAndCloseQuietly(Connection conn) 提交并关闭连接

rollbackAndCloseQuietly(Connection conn) 回滚并关闭连接

 

import java.sql.*;
import com.db.Mpool;;

import java.sql.*;
import com.db.Mpool;;

public class Test {

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(“使用连接池…………………..”);
for (int i = 0; i < 20; i++) {
long beginTime = System.currentTimeMillis();

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(“使用连接池…………………..”);
for (int i = 0; i < 20; i++) {
long beginTime = System.currentTimeMillis();

//1 获取三个老是
Connection conn = Mpool.getInstance().getConnection();
try {

//1 获取八个接连
Connection conn = Mpool.getInstance().getConnection();
try {

//2那一个延续要干嘛,封装在PreparedStatement希图对象中.不得以选拔拼接的方式了,选取占位符。
/* PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password)
value(“+i+”,111)”);
*/
PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password) values(?,?)”);
pstmt.setInt(1, i);
pstmt.setInt(2, i);
//三 绸缪好以往,实行计划对象

//2这些一而再要干嘛,封装在PreparedStatement筹算对象中.不可能利用拼接的款型了,选用占位符。
/* PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password)
value(“+i+”,111)”);
*/
PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password) values(?,?)”);
pstmt.setInt(1, i);
pstmt.setInt(2, i);
//三 希图好之后,试行希图对象

/* 3-一试行查询对象 ResultSet rs = pstmt.executeQuery();*/

/* 3-1实践查询对象 ResultSet rs = pstmt.executeQuery();*/

//叁-2 推行插入 更新等的筹算对象
//Boolean a= pstmt.execute(); //假诺第第3个结果是结果集 再次来到true。
//提出使用executeUpadate() 施行结果能够见到,0表示并没有进行
int a= pstmt.executeUpdate();
System.out.println(a);

//3-2 实行插入 更新等的预备对象
//Boolean a= pstmt.execute(); //如若第第③个结实是结果集 重返true。
//提出使用executeUpadate() 实践结果能够看来,0表示一直不施行
int a= pstmt.executeUpdate();
System.out.println(a);

/* 假诺是询问语句,则re存在重临结果。
while (rs.next()) {
re.get内容

/* 倘使是询问语句,则re存在重返结果。
while (rs.next()) {
re.get内容

}*/
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println(“第” + (i + 1) + “次举办开销时间为:”

}*/
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println(“第” + (i + 壹) + “次实施开销时间为:”

  • (endTime – beginTime));
    }
  • (endTime – beginTime));
    }

}

}

}

}

 

 

 

 

3 只是用jdbc测试

3 只是用jdbc测试

import java.sql.*;

import java.sql.*;

public class Test1 {

public class Test1 {

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(“不选取连接池…………………………..”);
for (int i = 0; i < 20; i++) {
long beginTime = System.currentTimeMillis();
try {
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
} catch (Exception e1) {
e1.printStackTrace();
}
String url = “jdbc:mysql://localhost:3306/test02”;
String user = “root”;
String password = “root123”;
Connection conn=null;
try {
//间接利用jdbc获取conn
conn = DriverManager.getConnection(url, user, password);
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password) values(?,?)”);
pstmt.setInt(1, i);
pstmt.setInt(2, i);

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(“不选用连接池…………………………..”);
for (int i = 0; i < 20; i++) {
long beginTime = System.currentTimeMillis();
try {
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
} catch (Exception e1) {
e1.printStackTrace();
}
String url = “jdbc:mysql://localhost:3306/test02”;
String user = “root”;
String password = “root123”;
Connection conn=null;
try {
//直接使用jdbc获取conn
conn = DriverManager.getConnection(url, user, password);
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
PreparedStatement pstmt = conn
.prepareStatement(“insert into user(userName,password) values(?,?)”);
pstmt.setInt(1, i);
pstmt.setInt(2, i);

int a =pstmt.executeUpdate();
System.out.println(a);
/* while (rs.next()) {
// get content
}*/
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println(“第” + (i + 一) + “次施行耗时为:”

int a =pstmt.executeUpdate();
System.out.println(a);
/* while (rs.next()) {
// get content
}*/
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println(“第” + (i + 壹) + “次实施费用时间为:”

  • (endTime – beginTime));
    }
    }
    }
  • (endTime – beginTime));
    }
    }
    }

 能够窥见:
使用jdbc直接连接数据库,每一次再三再四要求的时辰都差不离,40秒左右。而利用连接池的话,第一回三番五次需求的时刻相比较长,因为要做一些开端化操作吧,第三回获得连接的时日差不多是一秒,相当慢的。

 能够窥见:
使用jdbc直接连接数据库,每回三番五次需求的岁月都大概,40秒左右。而选拔连接池的话,第三遍一而再须求的时间相比长,因为要做一些开端化操作吧,第四回获得连接的时刻轮廓是一秒,非常快的。

除此以外注意,对数据库的操作也是有影响的,比方查询和写入操作,时间就不壹致。

其它注意,对数据库的操作也是有震慑的,比方查询和写入操作,时间就不相同。

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website