JDBC技术总结（一）

1. JDBC简介

        SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范，称之为JDBC，JDBC不能直接操作数据库，JDBC通过接口加载数据库的驱动，然后操作数据库。JDBC：Java Data Base Connectivity，它主要由接口组成。组成JDBC的2个包为java.sql和javax.sql。开发JDBC应用需要这2个包的支持外，还需要导入相应JDBC的数据库实现（即数据库驱动）。

2. JDBC快速入门

        编程从user表中读取数据，并打印在控制台窗口中。

2.1 搭建实验环境

[sql] view plain copy

 

1. create database test Character set utf8 collate utf8_general_ci;  
2. use test  
3. create table user  
4. (  
5.     id int primary Key,  
6.     name varchar(20),  
7.     password varchar(20),  
8.     email varchar(20),  
9.     birthday Date  
10. );  
11.   
12. insert into user(id,name,password,email,birthday) values(1,'zw','123','[e-mail]','1990-09-19');  
13. insert into user(id,name,password,email,birthday) values(2,'ls','123','[e-mail]','1991-04-19');  
14. insert into user(id,name,password,email,birthday) values(3,'ww','123','[e-mail]','1992-06-19');        

2.2 编写java程序

        新建一个java工程，并导入数据库驱动 MySQL-connector-java-5.1.20-bin.jar。

[java] view plain copy

 

1. public class Demo1 {  
2.   
3.     public static void main(String[] args) throws Exception {  
4.           
5.         String url = "jdbc:mysql://localhost:3306/day14";  
6.         String username = "root";  
7.         String password = "root";  
8.           
9.         try{  
10.             //1.加载驱动  
11.             //DriverManager.registerDriver(new Driver());  
12.             Class.forName("com.mysql.jdbc.Driver");  
13.               
14.             //2.获取数据库的连接  
15.             Connection conn = DriverManager.getConnection(url, username, password);  
16.               
17.             //3.获得用于向数据库发送sql语句的statement对象  
18.             Statement st = conn.createStatement();  
19.               
20.             //4.向数据库发sql,并获取代表结果集的resultset  
21.             String sql = "select id,name,password,email,birthday from user";  
22.             ResultSet rs = st.executeQuery(sql);  
23.               
24.             //取出结果集的数据  
25.             while(rs.next()){  
26.                 int id = (Integer) rs.getObject("id");  
27.                 String name = (String)rs.getObject("name");  
28.                 String pd = (String)rs.getObject("password");  
29.                 String email = (String)rs.getObject("email");  
30.                 Date birthday = (Date)rs.getObject("birthday");  
31.                 System.out.println(id+","+name+","+pd+","+email+","+birthday);  
32.             }  
33.         }  
34.         //关闭连接  
35.         finally{  
36.             if(rs != null){  
37.                 try{  
38.                     rs.close();  
39.                 }catch(Exception e) {  
40.                     e.printStackTrace();  
41.                 }  
42.                 rs = null;  
43.             }  
44.             if(st != null){  
45.                 try{  
46.                     st.close();  
47.                 }catch(Exception e) {  
48.                     e.printStackTrace();  
49.                 }  
50.                 st = null;  
51.             }  
52.               
53.             if(conn != null){  
54.                 try{  
55.                     conn.close();  
56.                 }catch(Exception e) {  
57.                     e.printStackTrace();  
58.                 }  
59.                 conn = null;  
60.             }  
61.         }  
62.     }  
63. }  

        JDBC程序中的DriverManager用于加载驱动，并创建与数据库的连接，这个类的常用方法有：

[java] view plain copy

 

1. DriverManager.registerDriver(new Driver());  
2. DriverManager.getConnection(URL, user, password);  

        注意：在实际开发中不推荐采用registerDriver方法注册驱动，原因有二：
        a. 查看Driver的源代码可以看到，如果采用此种方式，会导致驱动程序注册两次，也就是在内存中会有两个Driver对象；
        b. 程序依赖mysql的api，脱离mysql的jar包，程序将无法编译，将来程序切换底层数据库将会非常麻烦。
        推荐方式：Class.forName("com.mysql.jdbc.Driver");
        采用此种方式不会导致驱动对象在内存中重复出现，并且采用此种方式，程序仅仅只需要一个字符串，不需要依赖具体的驱动，使程序的灵活性更高。同样，在开发中也不建议采用具体的驱动类型指向getConnection方法返回的Connection对象。

3. JDBC常用API

        JDBC程序中的Connection对象用于代表数据库的连接，Connection是数据库编程中最重要的一个对象，客户端与数据库所有交互都是通过Connection对象完成的。这个对象常用的方法有：

[java] view plain copy

 

1. createStatement();    //创建向数据库发送sql的statement对象  
2. prepareStatement(sql); //创建向数据库发送预编译sql的prepareStatement对象。这个更常用  
3. prepareCall(sql); //创建执行存储过程中的callableStatement对象  
4. setAutoCommit(boolean autoCommit); //设置事物是否自动提交  
5. commit(); //在链接上提交事物  
6. rollback(); //在此链接上回滚事物  

        JDBC程序中的Statement对象用于向数据库发送sql语句，Statement对象常用方法有：

[java] view plain copy

 

1. <span style="font-family:Microsoft YaHei;">executeQuery(String sql);   //用于向数据库发送查询语句  
2. executeUpdate(String sql);  //用于向数据库发送insert，update或delete语句  
3. execute(String sql);  //用于向数据库发送任意sql语句  
4. addBatch(String sql);  //把多条sql语句放到一个批处理中  
5. executeBath();  //向数据库发送一批sql语句执行  
6. </span>  

        JDBC程序中的ResultSet对象用于代表sql语句的执行结果。ResultSet封装执行结果时，采用的类似于表格的方式。ResultSet对象维护了一个指向表格数据行的游标，初始的时候，游标在第一行之前，调用该对象的next()方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。由于ResultSet用于封装执行结果，所以该对象提供的都是用于获取数据的get方法：

[java] view plain copy

 

1. <span style="font-family:Microsoft YaHei;">//获取任意类型的数据  
2. getObject(int index);  //index表示列号  
3. getObject(String columnName);  //columnName表示列名，建议用这种方法，更好维护  
4. //获取指定类型的数据(int,String,Date等)  
5. getString(int index);  
6. getString(String columnName);  
7. </span>  

        ResultSet除了提供get方法以外，还提供了对结果集进行滚动的方法：

[java] view plain copy

 

1. <span style="font-family:Microsoft YaHei;">next();   //移动到下一行  
2. previous();  //移动到前一行  
3. absolute(int row);  //移动到指定行  
4. beforeFirst();  //移动到resultSet的最前面  
5. afterLast(); //移动到resultSet的最后面  
6. </span>  

        为了确保资源释放代码能运行，资源释放代码一定要写在finally语句中。

4. JDBC实现增删改查

        JDBC技术主要是同数据库打交道，那么免不了增删改查，由上面的代码可以看出，在对数据库进行操作之前需要先建立连接，在操作之后都需要释放资源，所以我们可以把这两部分内容抽取出来，写到JDBCUtils类中来实现：

[java] view plain copy

 

1. public class JDBCUtils {  
2.       
3.     private static String driver = null;  
4.     private static String url = null;  
5.     private static String username = null;  
6.     private static String password = null;  
7.       
8.     //加载驱动  
9.     static{  
10.         try {  
11.                         //db.properties是一个配置文件，里面有连接数据库所需要的信息  
12.             InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");  
13.             Properties prop = new Properties();   
14.             prop.load(in);//加载配置文件  
15.             driver = prop.getProperty("driver");  
16.             url = prop.getProperty("url");  
17.             username = prop.getProperty("username");  
18.             password = prop.getProperty("password");  
19.               
20.             Class.forName(driver);//加载驱动  
21.               
22.         } catch (Exception e) {  
23.             throw new ExceptionInInitializerError(e);  
24.         }  
25.     }  
26.       
27.     public static Connection getConnection() throws SQLException{  
28.                   
29.         return DriverManager.getConnection(url, username, password);//获得connection  
30.     }  
31.       
32.     public static void release(Connection conn, Statement st, ResultSet rs){ //释放资源  
33.           
34.         if(rs != null){  
35.             try{  
36.                 rs.close();  
37.             }catch(Exception e) {  
38.                 e.printStackTrace();  
39.             }  
40.             rs = null;  
41.         }  
42.         if(st != null){  
43.             try{  
44.                 st.close();  
45.             }catch(Exception e) {  
46.                 e.printStackTrace();  
47.             }  
48.             st = null;  
49.         }  
50.           
51.         if(conn != null){  
52.             try{  
53.                 conn.close();  
54.             }catch(Exception e) {  
55.                 e.printStackTrace();  
56.             }  
57.             conn = null;  
58.         }     
59.     }  
60.   
61. }  

        db.properties文件：

[plain] view plain copy

 

1. driver=com.mysql.jdbc.Driver  
2. url=jdbc:mysql://localhost:3306/day14  
3. username=root  
4. password=root  

        这样我们就完成了数据库的连接和资源的释放工具类。下面我们开始编写对数据库的增删改查：

[java] view plain copy

 

1. //使用JDBC对数据库的增删改查  
2. public class Demo2 {  
3.       
4.     private Connection conn = null;  
5.     private Statement st = null;  
6.     private ResultSet rs = null;  
7.       
8.     @Test  
9.     public void insert(){  
10.       
11.         try {  
12.             conn = JDBCUtils.getConnection();  
13.             st = conn.createStatement();  
14.             String sql = "insert into user(id,name,password,email,birthday) values(3,'ww','123','[e-mail]','1982-06-14');";  
15.             int num = st.executeUpdate(sql);//返回的是该sql语句会影响数据库的几行  
16.             if(num > 0){  
17.                 System.out.println(num);  
18.                 System.out.println("插入成功");  
19.             }  
20.         } catch (Exception e) {  
21.             e.printStackTrace();  
22.         }finally {  
23.             JDBCUtils.release(conn, st, rs);  
24.         }  
25.           
26.     }  
27.       
28.     @Test  
29.     public void delete(){  
30.               
31.         try {  
32.             conn = JDBCUtils.getConnection();  
33.             st = conn.createStatement();  
34.             String sql = "delete from user where password='123'";  
35.             int num = st.executeUpdate(sql);  
36.             if(num > 0){  
37.                 System.out.println(num);  
38.                 System.out.println("删除成功");  
39.             }  
40.         } catch (Exception e) {  
41.   
42.             e.printStackTrace();  
43.         }finally {  
44.             JDBCUtils.release(conn, st, rs);  
45.         }  
46.           
47.     }  
48.       
49.     @Test  
50.     public void update(){  
51.                   
52.         try {  
53.             conn = JDBCUtils.getConnection();  
54.             st = conn.createStatement();  
55.             String sql = "update user set password='456' where name='ww'";  
56.             int num = st.executeUpdate(sql);  
57.             if(num > 0) {  
58.                 System.out.println(num);  
59.                 System.out.println("修改成功");  
60.             }  
61.         } catch (Exception e) {  
62.             e.printStackTrace();  
63.         }finally {  
64.             JDBCUtils.release(conn, st, rs);  
65.         }  
66.           
67.     }  
68.       
69.     @Test  
70.     public void find(){  
71.                   
72.         try {  
73.             conn = JDBCUtils.getConnection();  
74.             st = conn.createStatement();  
75.             String sql = "select id,name,password,email,birthday from user";  
76.             rs = st.executeQuery(sql);  
77.             while(rs.next()){  
78.                 int id = (Integer)rs.getObject("id");  
79.                 String name = (String)rs.getObject("name");  
80.                 String password = (String)rs.getObject("password");  
81.                 String email = (String)rs.getObject("email");  
82.                 Date birthday = (Date)rs.getObject("birthday");  
83.                 System.out.println(id+","+name+","+password+","+email+","+birthday);  
84.             }  
85.         } catch (Exception e) {  
86.             e.printStackTrace();  
87.         }finally {  
88.             JDBCUtils.release(conn, st, rs);  
89.         }  
90.           
91.     }  
92.   
93. }  

        JDBC基本知识点就介绍到这，后面再介绍一些高级点的应用，如有错误之处，欢迎留言指正~

 上一节主要讲了JDBC的基本操作，这一节主要总结一下JDBC如何处理大文本、如何处理图片以及进行批处理。

1.JDBC处理大文本

        在MySQL中，大文本是text类型，使用Java操作数据库中的大文本需要两个方法setCharacterStream和getCharacterStream，一个是写入数据库的字符流，一个是从数据库中读取的字符流。setCharacterStream(index,Reader,length)有三个参数，Reader表示获取文件的流，length表示文件的长度，index表示参数的索引。那么获取文件的流Reader如何获得呢？我们可以通过下面方法获取：

[java] view plain copy

 

1. String path = Demo1.class.getClassLoader().getResource("1.txt").getPath(); //获取指定文件的Path  
2. File file = new File(path); //以这个path为参数构建一个file对象  
3. Reader reader = new FileReader(file); //以这个file对象为参数构建Reader流，这个流与这个文件就关联了  

        下面我们来看一下如何向数据库中存入大文本以及如何从数据库中取出大文本。先建立一个数据库：

[sql] view plain copy

 

1. create database tes<span style="font-family:Microsoft YaHei;">t</span>;  
2. use test;  
3. create table testclob  
4. (  
5.    id int primary key auto_increment,  
6.    resume text  
7. );  

        下面看Demo1.java：

[java] view plain copy

 

1. public class Demo1 {  
2.       
3.     @Test//向数据库中插入一个文本  
4.     public void add() throws FileNotFoundException {  
5.         Connection conn = null;  
6.         PreparedStatement st = null;  
7.         ResultSet rs = null;  
8.           
9.         try {  
10.             conn = JDBCUtils.getConnection();  //使用上一节中的JDBCUtils  
11.             String sql = "insert into testclob(resume) values(?)";  
12.             st = conn.prepareStatement(sql); //预处理sql语句  
13.   
14.             String path = Demo1.class.getClassLoader().getResource("1.txt").getPath();//在工程src目录下存放一个1.txt文件  
15.             File file = new File(path);   
16.             st.setCharacterStream(1, new FileReader(file), file.length());  
17.             int num = st.executeUpdate(); //执行向数据库中插入  
18.             if(num > 0) {  
19.                 System.out.println("插入成功");  
20.             }   
21.         } catch (SQLException e) {        
22.             e.printStackTrace();  
23.         } finally {  
24.             JdbcUtils.release(conn, st, rs);  
25.         }  
26.     }  
27.       
28.     @Test //从数据库中读取文本  
29.     public void read() throws IOException {  
30.         Connection conn = null;  
31.         PreparedStatement st = null;  
32.         ResultSet rs = null;  
33.         try {  
34.             conn = JDBCUtils.getConnection();  
35.             String sql = "select resume from testclob where id=?";  
36.             st = conn.prepareStatement(sql);  
37.             st.setInt(1, 1);  
38.             rs = st.executeQuery(); //执行sql语句  
39.             if(rs.next()){  
40.                 Reader reader = rs.getCharacterStream("resume"); //获取字段未resume的项，也就是我们刚刚存到数据库的1.txt文件  
41.                 char buffer[] = new char[1024];  
42.                 int len = 0;  
43.                 FileWriter out = new FileWriter("D:\\1.txt"); //写到D盘下  
44.                 while((len = reader.read(buffer)) > 0){  
45.                     out.write(buffer, 0, len);  
46.                 }  
47.                 out.close();  
48.                 reader.close();  
49.             }  
50.         } catch (SQLException e) {        
51.             e.printStackTrace();  
52.         } finally {  
53.             JdbcUtils.release(conn, st, rs);  
54.         }  
55.     }  
56.   
57. }  

        以上就是处理大文本的方法，比较简单，下面我们来看看如何处理图片。

2. JDBC处理图片

         在MySQL中，大文本是image类型，我们现在数据库中建立新的表：

[sql] view plain copy

 

1. create table testblob  
2.  (  
3.     id int primary key auto_increment,  
4.     image longblob  
5.  );  

        然后我们直接看处理图片的java程序Demo2.java：

[java] view plain copy

 

1. public class Demo2 {  
2.     @Test //向数据库中写入图片  
3.     public void add() throws FileNotFoundException {  
4.         Connection conn = null;  
5.         PreparedStatement st = null;  
6.         ResultSet rs = null;  
7.           
8.         try {  
9.             conn = JdbcUtils.getConnection();  
10.             String sql = "insert into testblob(image) values(?)";  
11.             st = conn.prepareStatement(sql);  
12.             String path = Demo2.class.getClassLoader().getResource("honey.jpg").getPath(); //图片存在src目录下  
13.             st.setBinaryStream(1, new FileInputStream(path), new File(path).length());//这里用的是setBinaryStream，字节流  
14.             //这种方法也行，FileInputStream方法重载了，既可以传递路径，也可以传递具体文件  
15.             //st.setBinaryStream(1, new FileInputStream(new File(path)), new File(path).length());    
16.             int num = st.executeUpdate();  
17.             /*这里会有这个错误： 
18.              * Packet for query is too large (4531349 > 1048576).  
19.              * You can change this value on the server by setting the max_allowed_packet' variable. 
20.              * 原因：MySQL的一个系统参数：max_allowed_packet，其默认值为1048576(1M)，即允许传递的最大packet为1M，如果照片超过1M无法导入 
21.              * 查询：show VARIABLES like '%max_allowed_packet%';修改此变量的值：set global max_allowed_packet = 1024*1024*10;(10M) 
22.              * */  
23.             if(num > 0){  
24.                 System.out.println("插入成功");  
25.             }  
26.         } catch (SQLException e) {        
27.             e.printStackTrace();  
28.         } finally {  
29.             JdbcUtils.release(conn, st, rs);  
30.         }  
31.     }  
32.       
33.     @Test //从数据库中读取图片  
34.     public void read() throws IOException {  
35.         Connection conn = null;  
36.         PreparedStatement st = null;  
37.         ResultSet rs = null;  
38.           
39.         try {  
40.             conn = JdbcUtils.getConnection();  
41.             String sql = "select image from testblob where id=?";  
42.             st = conn.prepareStatement(sql);  
43.             st.setInt(1, 1);  
44.             rs = st.executeQuery();  
45.             while(rs.next()){  
46.                 InputStream in = rs.getBinaryStream("image");//获取用getBinaryStream，也是字节流  
47.                 int len = 0;  
48.                 byte buffer[] = new byte[1024];  
49.                 FileOutputStream out = new FileOutputStream("D:\\honey.jpg"); //写到D盘下  
50.                 while((len = in.read(buffer)) > 0){  
51.                     out.write(buffer, 0, len);  
52.                 }  
53.                 out.close();  
54.                 in.close();  
55.             }  
56.         } catch (SQLException e) {        
57.             e.printStackTrace();  
58.         } finally {  
59.             JdbcUtils.release(conn, st, rs);  
60.         }  
61.     }  
62.   
63. }  

        JDBC操作图片也比较简单，跟操作大文本差不多。下面看看JDBC如何进行批处理。

3. JDBC进行批处理

首先我们还是先建立一个表：

[sql] view plain copy

 

1. create table testbatch  
2. (  
3.     id int primary key,  
4.     name varchar(20)  
5. );  

然后我们看看JDBC进行批处理的具体代码：

[java] view plain copy

 

1. //jdbc进行批处理  
2. public class Demo3 {  
3.   
4.     @Test  
5.     public void testBatch() {  
6.         Connection conn = null;  
7.         Statement st = null;  
8.         ResultSet rs = null;  
9.           
10.         try {  
11.             conn = JdbcUtils.getConnection();  
12.             String sql1 = "insert into testbatch(id,name) values(1,'aaa')";  
13.             String sql2 = "insert into testbatch(id,name) values(2,'bbb')";  
14.             String sql3 = "insert into testbatch(id,name) values(3,'ccc')";  
15.             String sql4 = "delete from testbatch where id=1";  
16.               
17.             st = conn.createStatement();  
18.             st.addBatch(sql1);  
19.             st.addBatch(sql2);  
20.             st.addBatch(sql3);  
21.             st.addBatch(sql4); //将四条sql语句加入Batch  
22.               
23.             st.executeBatch(); //然后依次执行这四条sql语句  
24.             st.clearBatch();//执行完后清除batch  
25.         } catch (Exception e) {       
26.             e.printStackTrace();  
27.         } finally {  
28.             JdbcUtils.release(conn, st, rs);  
29.         }  
30.     }  
31.       
32.     @Test //大量插入  
33.     public void testBatch2() {  
34.         Connection conn = null;  
35.         PreparedStatement st = null;  
36.         ResultSet rs = null;  
37.           
38.         try {  
39.             conn = J<span style="font-family:Microsoft YaHei;">DBC</span>Utils.getConnection();  
40.             String sql = "insert into testbatch(id,name) values(?,?)";    
41.             st = conn.prepareStatement(sql);  
42.               
43.             for(int i = 0; i < 10000000; i++){  
44.                 st.setInt(1, i);  
45.                 st.setString(2, "aa"+i);  
46.                 st.addBatch();  
47.                 if(i % 1000 == 0){//每1000条向数据库中添加一次  
48.                     st.executeBatch();  
49.                     st.clearBatch();  
50.                 }  
51.             }  
52.             st.executeBatch();//防止还剩一些零头的数据，这里刚好是1000的倍数  
53.             st.clearBatch();  
54.         } catch (Exception e) {       
55.             e.printStackTrace();  
56.         } finally {  
57.             JdbcUtils.release(conn, st, rs);  
58.         }  
59.     }  
60. }  

JDBC大文本、图片的操作以及批处理其实很简单，掌握几个关键的API就可以了，不再赘述，如有错误之处，欢迎留言指正~