Java基础知识学习总结---(java连接Oracle数据库)

JDBCJDBC全称"Java DataBase Connectivity"，它是一套面向对象的应用程序接口（API），并且制定了统一的访问各类关系数据库的标准接口，为各个数据库厂商提供了标准的接口实现。通过使用JDBC技术，开发人员可以用纯Java语言和标准的SQL语句编写完整的数据库应用程序，真正地实现软件的跨平台。

       

        本文地址：http://blog.youkuaiyun.com/chen_zw/article/details/18514723

       JDBC对多种关系型数据库的驱动和操作都进行了封装，因此，开发者不需要编写额外的程序来兼容不同的数据库连接，只需要通过加载不同的数据库驱动程序即可完成连接，我们首先简单地封装JDBC连接类：

[java]  view plain  copy

 

1. import java.sql.Connection;  
2. import java.sql.DatabaseMetaData;  
3. import java.sql.DriverManager;  
4. import java.sql.ResultSet;  
5. import java.sql.SQLException;  
6. import java.sql.Statement;  
7.   
8. import oracle.jdbc.driver.OracleConnection;  
9.   
10. /** 
11.  * @Description: JDBC连接类(示例连接Oralce) 
12.  * @CreateTime: 2014-1-19 下午9:46:44 
13.  * @author: chenzw  
14.  * @version V1.0 
15.  */  
16. public class JdbcUtil {  
17.     //驱动名    
18.     private static String DRIVER = "oracle.jdbc.driver.OracleDriver";    
19.     //获得url    
20.     private static String USER= "admin";    
21.     //获得连接数据库的用户名    
22.     private static String URL  = "jdbc:oracle:thin:@localhost:7001:test";    
23.     //获得连接数据库的密码    
24.     private static String PASS = "";    
25.   
26.     static {    
27.         try {     
28.             //1.初始化JDBC驱动并让驱动加载到jvm中,加载JDBC驱动后,会将加载的驱动类注册给DriverManager类。  
29.             Class.forName(DRIVER);    
30.         } catch (ClassNotFoundException e) {    
31.             e.printStackTrace();    
32.         }    
33.     }    
34.       
35.      public static Connection getConnection(){    
36.         Connection conn = null;    
37.         try {     
38.             //2.取得连接数据库    
39.             conn = DriverManager.getConnection(URL,USER,PASS);    
40.             //3.开启自动提交  
41.             conn.setAutoCommit(true);  
42.         } catch (SQLException e) {    
43.             e.printStackTrace();    
44.         }    
45.         return conn;    
46.      }    
47.   
48.     //开启事务  
49.     public static void beginTransaction(Connection conn) {    
50.         if (conn != null) {    
51.             try {    
52.                 if (conn.getAutoCommit()) {    
53.                     conn.setAutoCommit(false);    
54.                 }    
55.             } catch (SQLException e) {    
56.                 e.printStackTrace();    
57.             }    
58.         }    
59.     }    
60.     
61.     //提交事务  
62.     public static void commitTransaction(Connection conn) {    
63.         if (conn != null) {    
64.             try {    
65.                 if (!conn.getAutoCommit()) {    
66.                     conn.commit();    
67.                 }    
68.             } catch (SQLException e) {    
69.                 e.printStackTrace();    
70.             }    
71.         }    
72.     }    
73.     
74.     //回滚事务  
75.     public static void rollBackTransaction(Connection conn) {    
76.         if (conn != null) {    
77.             try {    
78.                 if (!conn.getAutoCommit()) {    
79.                     conn.rollback();    
80.                 }    
81.             } catch (SQLException e) {    
82.                 e.printStackTrace();    
83.             }    
84.         }    
85.     }    
86.       
87.      //关闭连接  
88.      public static void close(Object o){    
89.         if (o == null){    
90.             return;    
91.         }    
92.         if (o instanceof ResultSet){    
93.             try {    
94.                 ((ResultSet)o).close();    
95.             } catch (SQLException e) {    
96.                 e.printStackTrace();    
97.             }    
98.         } else if(o instanceof Statement){    
99.             try {    
100.                 ((Statement)o).close();    
101.             } catch (SQLException e) {    
102.                 e.printStackTrace();    
103.             }    
104.         } else if (o instanceof Connection){    
105.             Connection c = (Connection)o;    
106.             try {    
107.                 if (!c.isClosed()){    
108.                     c.close();    
109.                 }    
110.             } catch (SQLException e) {    
111.                 e.printStackTrace();    
112.             }    
113.         }      
114.     }    
115.   
116.     //重载关闭连接  
117.     public static void close(ResultSet rs, Statement stmt,     
118.             Connection conn){    
119.         close(rs);    
120.         close(stmt);    
121.         close(conn);    
122.     }    
123.     //重载关闭连接  
124.     public static void close(ResultSet rs,     
125.             Connection conn){    
126.         close(rs);     
127.         close(conn);    
128.     }   
129.     //重载关闭连接  
130.     public static void close(ResultSet rs, PreparedStatement ps,     
131.             Connection conn){    
132.         close(rs);    
133.         close(ps);    
134.         close(conn);    
135.     }    
136. }  

        JDBC数据库连接的查询主要通过Statement对象来执行各种SQL语句。Statement对象主要分为以下3种类型：

      1. Statement ：执行静态SQL语句的对象。

             Statement接口常用的2个方法：

             (1) executeUpdate(String sql) ：执行insert / update / delete 等SQL语句，成功返回影响数据库记录行数的int整数型。

             (2) executeQuery(String sql) ： 执行查询语句，成功返回一个ResultSet类型的结果集对象。

[java]  view plain  copy

 

1. ResultSet rs = null;  
2. Statement stmt = null;  
3. try {  
4.     stmt = conn.createStatement();  
5.     int num = stmt.executeUpdate("insert into company values('No.1','优快云')");  
6.     rs = stmt.executeQuery("select * from company");  
7. } catch (SQLException e) {  
8.     // TODO Auto-generated catch block  
9.     e.printStackTrace();  
10.         conn.rollback();  
11. }finally{  
12.     JdbcUtil.close(rs, stmt, conn);  
13. }  

         1.1 Statement批量处理函数：

               (1) addBatch(String sql) ：添加批量处理的数据；

               (2) executeBatch()：提交批量数据；

               (3) clearBatch()：清空已添加的批量数据；

[java]  view plain  copy

 

1. /** 
2.   * 实验一：Statement.executeBatch(); 
3.   */  
4. ResultSet rs = null;  
5. Statement stmt = null;  
6. try {  
7.     conn.setAutoCommit(false); //切记:必须设置成手动提交模式,否则每次addBatch都会提交一次,而不是批量提交  
8.     stmt = conn.createStatement();  
9.     Long startMemory  = Runtime.getRuntime().freeMemory();  
10.     Long startTime = System.currentTimeMillis();   
11.     for(int i = 0; i < 10000; i++){  
12.         stmt.addBatch("insert into t_dept values('No.1','优快云')");  
13.         //stmt.executeUpdate("insert into t_dept values('No.1','优快云')");  
14.     }  
15.     stmt.executeBatch();  
16.     conn.commit();  
17.     Long endMemory = Runtime.getRuntime().freeMemory();  
18.     Long endTime = System.currentTimeMillis();   
19.     System.out.println("使用内存大小:"+ (startMemory-endMemory)/1024 + "KB");  
20.     System.out.println("用时:"+ (endTime-startTime)/1000 + "s");  
21. } catch (SQLException e) {  
22.     e.printStackTrace();  
23.     conn.rollback();  
24. }finally{  
25.     JdbcUtil.close(rs, stmt, conn);  
26. }  
27.   
28. //执行结果：  
29. 使用内存大小:488KB  
30. 用时:116s   --汗，原谅我的电脑龟速。  

[java]  view plain  copy

 

1. /** 
2.   * 实验二：Statement.executeUpdate(); 
3.   */  
4. //而如果直接使用executeUpdate更新（其实一样是批量提交），竟然比executeBatch速度更快，效率更高，这个真的百思不得其解，留待以后解决。。  
5. ResultSet rs = null;  
6. Statement stmt = null;  
7. try {  
8.     conn.setAutoCommit(false); //切记:必须设置成手动提交模式,否则每次addBatch都会提交一次,而不是批量提交  
9.     stmt = conn.createStatement();  
10.     Long startMemory  = Runtime.getRuntime().freeMemory();  
11.     Long startTime = System.currentTimeMillis();   
12.     for(int i = 0; i < 10000; i++){  
13.             //stmt.addBatch("insert into t_dept values('No.1','优快云')");  
14.         stmt.executeUpdate("insert into t_dept values('No.1','优快云')");  
15.     }  
16.     //stmt.executeBatch();  
17.     conn.commit();  
18.     Long endMemory = Runtime.getRuntime().freeMemory();  
19.     Long endTime = System.currentTimeMillis();   
20.     System.out.println("使用内存大小:"+ (startMemory-endMemory)/1024 + "KB");  
21.     System.out.println("用时:"+ (endTime-startTime)/1000 + "s");  
22. } catch (SQLException e) {  
23.     e.printStackTrace();  
24.     conn.rollback();  
25. }finally{  
26.     JdbcUtil.close(rs, stmt, conn);  
27. }  
28. //执行结果：  
29. <span style="font-family: Arial, Helvetica, sans-serif;">使用内存大小:329KB</span>  
30. 用时:98s  

Note： 本次实验得出的结论是使用executeUpdate的批量提交法比executeBatch效率高，速度更快，占用内存更小，如果有朋友有不同结论的话，欢迎留言交流。

       1.3 Statement可滚动ResultSet配置：

              (1) java.sql.Connection.creatStatement(int resultSetType,int resultSetConcurrency);

              (2) java.sql.Connection.creatStatement(int resultSetType,int resultSetConcurrency,int resultSetHoldability);

              参数：

              [1] resultSetType： -- 生成的ResultSet的类型

                   ResultSet.TYPE_FORWARD_ONLY  -- 结果集只允许向前滚动，默认缺省值

                   ResultSet.TYPE_SCROLL_INSENSITIVE  --  结果集对数据库中的的数据变动是不敏感的

                   ResultSet.TYPE_SCROLL_SENSITIVE  --  结果集对数据库中的的数据变动是敏感的（实际上只对Update的数据敏感）

                  Note：ResultSet为TYPE_SCROLL_INSENSITIVE时，我们取出的是数据库中真实数据，并且保存在内存中，一旦取出后，数据库中数据进行变动将不能及时更新到ResultSet中； 而ResultSet为TYPE_SCROLL_SENSITIVE时，我们取出的是数据库中数据的索引值（类似于rowid），每次rs.next()时将根据该索引时重新从数据库中取出数据，所以说是敏感的，但是如果数据库中进行的是添加或是删除操作，那敏感性也将无效。（自己思考，索引值）

              [2] resultSetConcurrency： -- 生成的ResultSet的并发性（指定是否可修改ResultSet结果集）

                    ResultSet.CONCUR_READ_ONLY  -- 结果集不可修改(只读)，默认缺省值

                    ResultSet.CONCUR_UPDATABLE  -- 结果集可修改

[java]  view plain  copy

 

1. ResultSet rs = null;  
2. Statement stmt = null;  
3. try {  
4.     stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);  //可滚动，  
5.         rs = stmt.executeQuery("select * from staff");  
6.         System.out.println(rs.isBeforeFirst()); //true,判断指针是否在结果集的开头  
7.     rs.beforeFirst(); //指针定位到开头,该行取不到数据  
8.     rs.next(); //必须先把指针移到数据上,才算是结果集的第一行  
9.         System.out.println(rs.isFirst()); //true,判断指针是否在结果集的第一行  
10.     rs.first();   //指针重新定位到结果集的第一行  
11.     rs.absolute(20);  //指针定位到结果集的第20行  
12.     rs.previous();  //指针移动到上一行  
13.     System.out.println(rs.getString(1));  
14.     rs.last(); //指针定位到结果集的最后一行  
15.     System.out.println(rs.isLast());  //true,判断指针是否在结果集最后一行  
16.     rs.afterLast(); //指针定位到末尾,该行取不到数据  
17.         System.out.println(rs.isAfterLast()); //true,判断指针是否在结果集的末尾  
18. } catch (SQLException e) {  
19.     e.printStackTrace();  
20.     conn.rollback();  
21. }finally{  
22.     JdbcUtil.close(rs, stmt, conn);  
23. }   <span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">             </span>  

      2. PrepareStatement： 执行预编译SQL语句对象。

             PrepareStatement接口常用的2个方法：

             (1) executeUpdate(String sql) ：执行insert / update / delete 等SQL语句，成功返回影响数据库记录行数的int整数型。

             (2) executeQuery(String sql) ： 执行查询语句，成功返回一个ResultSet类型的结果集对象。

[java]  view plain  copy

 

1. ResultSet rs = null;  
2. PreparedStatement ps;  
3. try {  
4.     ps = conn.prepareStatement("insert into company values(?,?)");  
5.     ps.setString(1, "No1.");  
6.     ps.setString(2, "csdn");  
7.     int num = ps.executeUpdate();  
8. } catch (SQLException e) {  
9.     // TODO Auto-generated catch block  
10.     e.printStackTrace();  
11.         conn.rollback();  
12. }finally{  
13.     JdbcUtil.close(rs, stmt, conn);  
14. }  
15.           
16. try {  
17.     ps = conn.prepareStatement("select * from company");  
18.     ps.setString(1, "No1.");  
19.     ps.setString(2, "csdn");  
20.     rs = ps.executeQuery();  
21. } catch (SQLException e) {  
22.     // TODO Auto-generated catch block  
23.     e.printStackTrace();  
24.         conn.rollback();  
25. }finally{  
26.     JdbcUtil.close(rs, stmt, conn);  
27. }  

              优点：（1）可以有效SQL注入式攻击，提高安全性。（2）使用预处理语句在性能上提升很多。

         2.1 PrepareStatement批量处理函数：

               (1) addBatch(String sql) ：添加批量处理的数据；

               (2) executeBatch()：提交批量数据；

               (3) clearBatch()：清空已添加的批量数据；

[java]  view plain  copy

 

1. /** 
2.   * 实验三：PreparedStatement.executeBatch(); 
3.   */  
4. ResultSet rs = null;  
5. PreparedStatement ps = null;  
6. try {  
7.     conn.setAutoCommit(false); //切记:必须设置成手动提交模式,否则每次addBatch都会提交一次,而不是批量提交  
8.     Long startMemory  = Runtime.getRuntime().freeMemory();  
9.     Long startTime = System.currentTimeMillis();   
10.     ps = conn.prepareStatement("insert into t_dept values(?,?)");  
11.     for(int i = 0 ; i < 10000; i++){  
12.         ps.setString(1, "No1.");  
13.         ps.setString(2, "csdn");  
14.         ps.addBatch();  
15.         //ps.executeUpdate();  
16.     }  
17.     ps.executeBatch();  
18.     conn.commit();  
19.     Long endMemory = Runtime.getRuntime().freeMemory();  
20.     Long endTime = System.currentTimeMillis();   
21.     System.out.println("使用内存大小:"+ (startMemory-endMemory)/1024 + "KB");  
22.     System.out.println("用时:"+ (endTime-startTime)/1000 + "s");  
23. } catch (SQLException e) {  
24.     // TODO Auto-generated catch block  
25.     e.printStackTrace();  
26. }finally{  
27.     JdbcUtil.close(rs, ps, conn);  
28. }  
29.   
30. //执行结果：  
31. 使用内存大小:2110KB  
32. 用时:0s  --无语了，实在太快了，10000条。。。  

[java]  view plain  copy

 

1. /** 
2.   * 实验四：PreparedStatement.executeUpdate(); 
3.   */  
4. //直接使用executeUpdate批量提交，速度慢的可怕。。  
5. ResultSet rs = null;  
6. PreparedStatement ps = null;  
7. try {  
8.      conn.setAutoCommit(false); //切记:必须设置成手动提交模式,否则每次addBatch都会提交一次,而不是批量提交  
9.      Long startMemory  = Runtime.getRuntime().freeMemory();  
10.      Long startTime = System.currentTimeMillis();   
11.      ps = conn.prepareStatement("insert into t_dept values(?,?)");  
12.      for(int i = 0 ; i < 10000; i++){  
13.          ps.setString(1, "No1.");  
14.          ps.setString(2, "csdn");  
15.          //ps.addBatch();  
16.          ps.executeUpdate();  
17.      }  
18.      //ps.executeBatch();  
19.      conn.commit();  
20.      Long endMemory = Runtime.getRuntime().freeMemory();  
21.      Long endTime = System.currentTimeMillis();   
22.      System.out.println("使用内存大小:"+ (startMemory-endMemory)/1024 + "KB");  
23.      System.out.println("用时:"+ (endTime-startTime)/1000 + "s");  
24. } catch (SQLException e) {  
25. // TODO Auto-generated catch block  
26.      e.printStackTrace();  
27. }finally{  
28.      JdbcUtil.close(rs, ps, conn);  
29. }  
30.   
31. //执行结果：  
32. 使用内存大小:1617KB  
33. 用时:190s  --内存占用少了点，但是时间嘛，我只能说呵呵。。  

总结： 使用批量提交数据一定要选用预编译的executeBatch()方法，虽然内存占用多了点，但是速度快才是王道。

         2.2 PrepareStatement可滚动ResultSet配置：

              (1) java.sql.Connection.PreparedStatement prepareStatement(String sql,int resultSetType,int resultSetConcurrency);

              (2) java.sql.Connection.PreparedStatement prepareStatement(String sql,int resultSetType,int resultSetConcurrency,int resultSetHoldability);

              参数及其用法详见上面1.3。

      3. CallableStatement接口常用的2个方法：

             (1) executeUpdate(String sql) ：执行insert / update / delete 等SQL语句，成功返回影响数据库记录行数的int整数型。

             (2) executeQuery(String sql) ： 执行查询语句，成功返回一个ResultSet类型的结果集对象。

[java]  view plain  copy

 

1. ResultSet rs = null;  
2. CallableStatement cs;  
3. try {  
4.     cs = conn.prepareCall("{call p_insert(?,?)}");  
5.     cs.setString(1, "No1.");  
6.     cs.setString(2, "csdn");  
7.     int num = cs.executeUpdate();  
8. } catch (SQLException e) {  
9.     // TODO Auto-generated catch block  
10.     e.printStackTrace();  
11.         conn.rollback();  
12. }finally{  
13.     JdbcUtil.close(rs, stmt, conn);  
14. }  
15.   
16. try {  
17.     cs = conn.prepareCall("{call p_select(?)}");  
18.     cs.setString(1,  "No1.");  
19.     rs = cs.executeQuery();  
20. } catch (SQLException e) {  
21.     // TODO Auto-generated catch block  
22.     e.printStackTrace();  
23.         conn.rollback();  
24. }finally{  
25.     JdbcUtil.close(rs, stmt, conn);  
26. }