mysql jdbc批处理_JDBC批处理 数据库连接池

关于JDBC

Jdbc是java database connectivity的简称,java数据库连接，专门用来通过一段java代码连接数据库的一门技术。

使用方法大致为一下六个步骤：

一、注册驱动

注册驱动有两种方式：

1.  Class.forName("com.mysql.jdbc.Driver");

这种方式不会对具体的驱动类产生依赖(即不用import驱动类)。Class类的forName方法中对参数指定的类进行了装载操作。在这里将com.mysql.jdbc.Driver类装载到jvm。众所周知，类装载时，将执行被装载类的静态代码块，而Driver类有一个静态代码块如下：

static{try{

java.sql.DriverManager.registerDriver(newDriver());

}catch(SQLExceptione){

thrownew RuntimeException("can't register driver!");

}

}

所以在装载过程中即完成了driver的注册。这也是使用最多的一种注册驱动方式。

2.    DriverManager.registerDriver(newcom.mysql.jdbc.Driver());

这种方式会造成DriverManager中产生两个一样的驱动，并会对具体的驱动类产生依赖。

具体来说就是：

1.    装载Driver类时注册一次驱动(有关类装载，请参考http://www.yanwushu.com/post/54.html)，执行此代码时，又注册一次。

2.    由于实例化了com.mysql.jdbc.Driver.class，导致必须import该类，从而具体驱动产生了依赖。

3.    System.setProperty("jdbc.drivers","com.mysql.jdbc.Driver");

通过系统的属性设置注册驱动,如果要注册多个驱动，则System.setProperty("jdbc.drivers","com.mysql.jdbc.Driver:com.oracle.jdbc.Driver");

这种驱动注册方式很少使用。

二、获取数据库连接对象(java.sql.Connection)

Connection conn =DriverManager.getConnection("jdbc:mysql://localhost:3306/jtdb","root","root")；

三、获取传输器

connection对象提供了两种传输器，Statement和PreparedStatement

两种传输器的区别与关系：

关系：PreparedStatement继承自Statement,都是接口

区别：PreparedStatement可以使用占位符，是预编译的，批处理比Statement效率高

四、执行sql语句，接收结果

如果是查询结果则用ResultSet 接收，如果是增删改的话，用int类型接收

如:

Statement st =(Statement) conn.createStatement();

String sql= "select * from at_school where owner ='"+user_id+"'";

ResultSet rs=st.executeQuery(sql);

sql= "UPDATE at_school SET state='1' WHERE id='"+id+"'";int rs2 = st.executeUpdate(sq);

五、遍历结果集(java.sql.ResultSet)

ResultSet对象维护指向结果集中当前行的游标。 术语“结果集”是指包含在ResultSet对象中的行和列数据。

ResultSet rs=st.executeQuery(sql);

ResultSet接口中有几种涉及移动光标的方法，其中常用的包括：public boolean next() throwsSQLException 将光标移动到下一行。 如果结果集中没有更多行，则此方法返回false。public boolean absolute(int row) throwsSQLException 将光标移动到指定的行。public void last() throwsSQLException 将光标移动到最后一行。while(rs.next()){//根据列的索引获取第一列的数据

String id = rs.getString(1);//根据列的索引获取第二列的数据

String username = rs.getString(2);//根据列的索引获取第三列的数据

String password = rs.getString(3);

}

六、释放资源

rs.close(); //释放结果集资源st.close();//释放传输器资源conn.close();//释放连接资源

demo

importjava.sql.Connection;importjava.sql.DriverManager;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.sql.Statement;importorg.junit.Test;importcom.mysql.jdbc.Driver;public classHelloJDBC {//单元测试方法：@Test + void

@Testpublic voidhello() throwsSQLException{//1，注册驱动com.mysql.jdbc.Driver

DriverManager.registerDriver(newDriver());//2，获取数据库连接java.sql.Connection

Connection conn =DriverManager.getConnection("jdbc:mysql://localhost:3306/jtdb","root","root");//3，获取传输器java.sql.Statement

Statement st =conn.createStatement();//4，执行SQL。java.sql.ResultSet

String sql ="select * from user";

ResultSet rs=st.executeQuery(sql);//5，遍历结果集

while(rs.next()){//根据列的索引获取第一列的数据

String i = rs.getString(1);//根据列的索引获取第二列的数据

String username = rs.getString(2);//根据列的索引获取第三列的数据

String password = rs.getString(3);

System.out.println(id+username+password);

}//6，释放资源

rs.close();//释放结果集资源

st.close();//释放传输器资源

conn.close();//释放连接资源

}

}

JDBC工具类

importjava.sql.Connection;importjava.sql.DriverManager;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.sql.Statement;importjava.util.ResourceBundle;/*** 这个类用来提供jdcb的工具类

* 构造方法私有化

* 该类提供一个getConnetion()方法，提供connection对象

* 提供close()方法，释放资源

*@authorwjx

**/

public classJDBCUtils {

​//私有化构造函数

privateJDBCUtils(){

}//加载配置文件

static ResourceBundle rb = null;//只加载一次属性文件

static{

rb= ResourceBundle.getBundle("jdbc");

}//提供一个数据库连接对象

public static Connection getConn() throwsClassNotFoundException {try{//注册驱动

Class.forName(rb.getString("driverClass"));//数据库名，所在地址和端口号

String url = rb.getString("jdbcUrl");//用户名

String user = rb.getString("user");//密码

String password = rb.getString("password");//获取数据库连接对象

Connection conn =DriverManager.getConnection(url, user, password);returnconn;

}catch(SQLException e) {//TODO Auto-generated catch block

e.printStackTrace();

}return null;

}public static voidclose(Connection conn,Statement st,ResultSet rs){//从结果集开始释放，依次是：ResultSet-->Statement-->Connection//非空判断，防止空指针异常

if(rs!=null){try{

rs.close();

}catch(SQLException e) {

e.printStackTrace();

}finally{

rs=null;//手动置空

}

}//释放传输器资源//非空判断，防止空指针异常

if(st!=null){try{

st.close();

}catch(SQLException e) {

e.printStackTrace();

}finally{

st=null;//手动置空

}

}//释放数据库连接资源//非空判断，防止空指针异常

if(conn!=null){try{

conn.close();

}catch(SQLException e) {

e.printStackTrace();

}finally{

conn=null;//手动置空

}

}

}public static voidclose(Connection conn,Statement st){//释放传输器资源//非空判断，防止空指针异常

if(st!=null){try{

st.close();

}catch(SQLException e) {

e.printStackTrace();

}finally{

st=null;//手动置空

}

}//释放数据库连接资源//非空判断，防止空指针异常

if(conn!=null){try{

conn.close();

}catch(SQLException e) {

e.printStackTrace();

}finally{

conn=null;//手动置空

}

}

}

}

配置文件(jdbc.properties)

driverClass=com.mysql.jdbc.Driver

jdbcUrl=jdbc:mysql:///test

user=root

password=123456

关于批处理

当我们需要向数据库中插入大量数据时，批处理会将这些数据打成多个批次addBatch()，统一发送给数据库服务器执行executeBatch()，减少与数据库的交互次数提高程序的执行效率。

如果有一个功能需求，是向数据库中插入50000条数据，这种需求如果不用批处理的话，会非常非常的耗时和资源。

不用批处理的情况下

用statement传输器

demo：

//不用批处理，Statement传输器下 用时： 1456秒

@Testpublic voidtest01(){try{//获取数据库连接

Connection conn =JDBCUtill.getConn();//创建传输器(Statement)

Statement st =conn.createStatement();//将开始插入的时间记录下来

Long begin =System.currentTimeMillis();//执行sql语句

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

st.executeUpdate("insert into user (id,username,password) values ("+i+",'user "+i+"','paw "+i+"')");

}

System.out.println("用时： "+(System.currentTimeMillis()-begin)/1000+"秒");

st.close();

conn.close();

}catch(Exception e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

用PreparedStatement传输器

demo：

//不用批处理，PreparedStatement传输器下 用时： 1391秒

@Testpublic voidtest02(){try{//获取数据库连接

Connection conn =JDBCUtill.getConn();//创建传输器(PreparedStatement)

String sql ="insert into user (id,username,password) values (?,?,?)";

PreparedStatement pst=conn.prepareStatement(sql);//将开始插入的时间记录下来

Long begin =System.currentTimeMillis();//执行sql语句

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

pst.setInt(1, i);

pst.setString(2, "username "+i);

pst.setString(3, "psw "+i);

pst.executeUpdate();

}

System.out.println("用时： "+(System.currentTimeMillis()-begin)/1000+"秒");

pst.close();

conn.close();

}catch(Exception e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

用批处理

JDBC实现批处理有两种方式：statement和preparedstatement

statement实现批处理：

demo：

//向test数据库中的user表中插入50000条数据//用批处理，Statement传输器下 用时： 12秒

@Testpublic void test05() throwsSQLException{try{

Connection conn=JDBCUtill.getConn();//将自动提交设为false

conn.setAutoCommit(false);//创建一个 PreparedStatement传输器

Statement st =conn.createStatement();//将开始插入的时间记录下来

Long begin =System.currentTimeMillis();//设置需要插入语句的总数和每一批提交的数量

int count = 50000;int batchsize = 5000;for(int i = 9 ; i < count;i++){//添加一条sql语句

String sql = "insert into user (id,username,password) values ('"+i+"','"+i+"','"+i+"')";

st.addBatch(sql);//每5000条为一批

if(i%batchsize==0){//执行一次批处理

st.executeBatch();//提交

conn.commit();

}

}//如果还有剩余，则再执行一次批处理

if ((count+1) % batchsize != 0) {

st.executeBatch();

conn.commit();

}

System.out.println("用时： "+(System.currentTimeMillis()-begin)/1000+"秒");

st.close();

conn.close();

}catch(ClassNotFoundException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

采用Statement.addBatch(sql)方式实现批处理：

优点：可以向数据库发送多条不同的ＳＱＬ语句。

缺点：SQL语句没有预编译。

当向数据库发送多条语句相同，但仅参数不同的SQL语句时，需重复写上很多条SQL语句。

preparedstatement实现批处理：

demo:

//用批处理，PreparedStatement传输器下(不加rewriteBatchedStatements=true 参数) 用时： 12秒

@Testpublic void test03() throwsSQLException {try{

Connection conn=JDBCUtill.getConn();//将自动提交设为false

conn.setAutoCommit(false);

String sql= "insert into user (id,username,password) values (?,?,?)";//创建一个 PreparedStatement传输器

PreparedStatement pst =conn.prepareStatement(sql);//将开始插入的时间记录下来

Long begin =System.currentTimeMillis();//设置需要插入语句的总数和每一批提交的数量

int count = 50000;int batchsize = 5000;for(int i = 1 ; i < count;i++){

pst.setLong(1, i);

pst.setString(2, "batch test"+i);

pst.setString(3, "test psw"+i);//添加一条sql语句

pst.addBatch();//每5000条为一批

if(i%batchsize==0){//执行一次批处理

pst.executeBatch();//提交

conn.commit();

}

}//如果还有剩余，则再执行一次批处理

if ((count+1) % batchsize != 0) {

pst.executeBatch();

conn.commit();

}

System.out.println("用时： "+(System.currentTimeMillis()-begin)/1000+"秒");

pst.close();

conn.close();

}catch(ClassNotFoundException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

采用PreparedStatement.addBatch()实现批处理

优点：发送的是预编译后的SQL语句，执行效率高。

缺点：只能应用在SQL语句相同，但参数不同的批处理中。因此此种形式的批处理经常用于在同一个表中批量插入数据，或批量更新表的数据。

如果数据库连接对象没有设置rewriteBatchedStatements=true参数的话，效率会低一些

demo：

//用批处理，PreparedStatement传输器下(加上rewriteBatchedStatements=true 参数) 用时： 2秒

@Testpublic void test04() throwsSQLException {try{

Connection conn=JDBCUtill.getConn_batch();//将自动提交设为false

conn.setAutoCommit(false);

String sql= "insert into user (id,username,password) values (?,?,?)";//创建一个 PreparedStatement传输器

PreparedStatement pst =conn.prepareStatement(sql);//将开始插入的时间记录下来

Long begin =System.currentTimeMillis();//设置需要插入语句的总数和每一批提交的数量

int count = 50000;int batchsize = 5000;for(int i = 1 ; i < count;i++){

pst.setLong(1, i);

pst.setString(2, "batch test"+i);

pst.setString(3, "test psw"+i);//添加一条sql语句

pst.addBatch();//每5000条为一批

if(i%batchsize==0){//执行一次批处理

pst.executeBatch();//提交

conn.commit();

}

}//如果还有剩余，则再执行一次批处理

if ((count+1) % batchsize != 0) {

pst.executeBatch();

conn.commit();

}

System.out.println("用时： "+(System.currentTimeMillis()-begin)/1000+"秒");

pst.close();

conn.close();

}catch(ClassNotFoundException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

关于数据库连接池

什么是数据库连接池？

用来存放数据库连接的一个容器，这个容器在整个程序中共享。提高程序的执行效率降低与数据库的交互次数。

主要有两个优点：实现数据库连接对象的复用，降低与数据库的交互次数。

自定义一个简易的数据库连接池

主要有以下几个步骤：

1、创建pool类，继承自DataSource

2、创建容器，用来存放数据库连接对象(LinkedList)

3、在静态代码块中完成容器初始化

4、提供getConnection方法，对外提供获取数据库连接对象(Connection)的方法

5、提供returnConnection方法，用来把用了的数据库连接对象放回池中。

demo：

importjava.io.PrintWriter;importjava.sql.Connection;importjava.sql.SQLException;importjava.sql.SQLFeatureNotSupportedException;importjava.util.LinkedList;importjava.util.List;importjava.util.logging.Logger;importjdbc.JDBCUtill;

​importjavax.sql.DataSource;

​/*** 自定义一个数据库连接池

* 步骤：

* 1、创建pool类，继承自DataSource

* 2、创建容器，用来存放数据库连接对象(LinkedList)

* 3、在静态代码块中完成容器初始化

* 4、提供getConnection方法，对外提供获取数据库连接对象(Connection)的方法

* 5、提供returnConnection方法，用来把用了的数据库连接对象放回池中。

*@authorwjx

**/​public class Pool implementsDataSource{

​static int total = 5;//创建容器，用来存放数据库连接对象(LinkedList)

static List pool = new LinkedList();//在静态代码块中完成容器初始化

static{for(int i = 0; i < total;i++){try{

Connection conn=JDBCUtill.getConn();

pool.add(conn);

}catch(ClassNotFoundException e) {

e.printStackTrace();

}

}

}//提供getConnection方法，对外提供获取数据库连接对象(Connection)的方法

@Overridepublic Connection getConnection() throwsSQLException {

Connection conn= null;//remove(Object o)//从列表中删除指定元素的第一个出现(如果存在)。

conn = pool.remove(0);

System.out.println("已从池中取走一个conn对象，还剩"+pool.size()+"个conn对象");returnconn;

}//提供returnConnection方法，用来把用了的数据库连接对象放回池中。

public void returnConnection(Connection conn) throwsSQLException{if(conn!=null && !conn.isClosed()){

pool.add(conn);

System.out.println("已成功还回对象");

}else{

System.out.println("这是一个空对象！");

}

}

@Overridepublic PrintWriter getLogWriter() throwsSQLException {//TODO Auto-generated method stub

return null;

}

​

@Overridepublic void setLogWriter(PrintWriter out) throwsSQLException {//TODO Auto-generated method stub

}

​

@Overridepublic void setLoginTimeout(int seconds) throwsSQLException {//TODO Auto-generated method stub

}

​

@Overridepublic int getLoginTimeout() throwsSQLException {//TODO Auto-generated method stub

return 0;

}

​

@Overridepublic Logger getParentLogger() throwsSQLFeatureNotSupportedException {//TODO Auto-generated method stub

return null;

}

​

@Overridepublic T unwrap(Class iface) throwsSQLException {//TODO Auto-generated method stub

return null;

}

​

@Overridepublic boolean isWrapperFor(Class> iface) throwsSQLException {//TODO Auto-generated method stub

return false;

}

​

​

​

@Overridepublic Connection getConnection(String username, String password) throwsSQLException {//TODO Auto-generated method stub

return null;

}

​

}

测试一下：

importjava.sql.Connection;importjava.sql.PreparedStatement;importjava.sql.ResultSet;importjava.sql.SQLException;

​importorg.junit.Test;

​/*** 这个类用来测试自定义的连接池

*@authorwjx

**/

public classtest {

​

@Testpublic voidtest_pool(){//声明数据库连接对象

Connection conn = null;//声明传输器对象

PreparedStatement pst = null;//声明结果集对象

ResultSet rs = null;//创建连接池对象

Pool pl = newPool();try{//获取连接器

conn =pl.getConnection();//创建传输器

String sql = "select * from user";

pst=conn.prepareStatement(sql);//获取结果集

rs =pst.executeQuery();//遍历结果集

while(rs.next()){

System.out.println("id="+rs.getInt(1)+" userName="+rs.getString(2)+" password=d"+rs.getString(3));

}

}catch(SQLException e) {//TODO Auto-generated catch block

e.printStackTrace();

}finally{//释放资源

try{

rs.close();

pst.close();

pl.returnConnection(conn);

}catch(SQLException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

结果为：

已从池中取走一个conn对象，还剩4个conn对象

id=1 userName=u1 password=dp1

id=2 userName=u2 password=dp2

id=3 userName=u3 password=dp3

已成功还回对象