Statement及PreparedStatement执行多个sql

    这两个对象的区别： 1.Statement它更适合执行不同sql的批处理，它没有提供预处理功能，性能比较低。 2.PreparedStatement它适合执行相同的批处理，它提供了预处理功能，属性比较高。            /**       *  @param args       *  @throws SQLException       *  @throws ClassNotFoundException       */       public  static  void main(String[] args)  throws ClassNotFoundException,                 SQLException {             // 定义sql 语句            String sql1 = "create table person(id int,name varchar(20))";            String sql2 = "insert into person values(1,‘tom‘)";            String sql3 = "insert into person values(2,‘fox‘)";            String sql4 = "insert into person values(3,‘tony‘)";            String sql5 = "update person set name=‘张三‘ where id=1";            String sql6 = "delete from person where id=3";              Connection conn = jdbcUtils. getConnection();            Statement st = conn.createStatement();               // 添加批处理sql            st.addBatch(sql1);            st.addBatch(sql2);            st.addBatch(sql3);            st.addBatch(sql4);            st.addBatch(sql5);            st.addBatch(sql6);               // 执行批处理sql            st.executeBatch();            st.clearBatch();            st.close();             conn.close();        }     使用版本高一点的 jdbc的jar包时加入参数可开启缓存在url中加参数： ?useServerPrepStmts=true&cachePrepStmts=true&rewriteBatchedStatements=true      /**       *  @param args       *  @throws SQLException       *  @throws ClassNotFoundException       */       public  static  void main(String[] args)  throws ClassNotFoundException,                 SQLException {            String sqlString = "insert into person values(?,?)";            Connection conn = jdbcUtils.  getConnection();            PreparedStatement pst = conn.prepareStatement(sqlString);              long l = System.  currentTimeMillis();              for (  int i = 0; i < 10000; i ) {                 pst.setInt(1, i);                 pst.setString(2, "name"  i);                 pst.addBatch();                   if (i % 1000 == 0) {                      pst.executeBatch();                      pst.clearBatch(); // 清空缓存                 }            }            pst.executeBatch();            pst.close();            conn.close();            System.  out.println(System.  currentTimeMillis() - l);      }    

方法：

1.   public static Connection getConnection(){
2.   try {
3.   Class.forName( "com.mysql.jdbc.Driver");
4.   ct = DriverManager.getConnection( "jdbc:mysql://127.0.0.1:3306/test","squirrel","xiaoyang");
5.   } catch (Exception e) {
6.   e.printStackTrace();
7.   }
8.   return ct;
9.   }
10.    
11.   /**释放数据库链接资源：注意数据库资源关闭的顺序*/
12.   public static void closeConnection(){
13.    
14.   try { //注意关闭数据库资源的先后顺序
15.   if(rs!=null){
16.   rs.close();
17.   } if(ps!=null){
18.   ps.close();
19.   } if(ct!=null){
20.   ct.close();
21.   }
22.   } catch (SQLException e) {
23.   e.printStackTrace();
24.   }
25.   }
26.    

测试方法：

1.   /**
2.   * PreparedStatement批量执行sql
3.   */
4.   public static void excuteBatchInsertDatabase(){
5.    
6.   ct=getConnection();
7.    
8.   try {
9.   ct.setAutoCommit( false);
10.   ps=ct.prepareStatement( "insert into user(name,passwd,age,gender) values(?,?,?,?)");
11.    
12.   ps.setString( 1, "BBBB");
13.   ps.setString( 2, "BBBB");
14.   ps.setInt( 3, 20);
15.   ps.setString( 4, "F");
16.   ps.addBatch();
17.    
18.   ps.setString( 1, "BBBB");
19.   ps.setString( 2, "BBBB");
20.   ps.setInt( 3, 20);
21.   ps.setString( 4, "F");
22.   ps.addBatch();
23.    
24.   /**
25.   * 等价于sql语句：
26.   * insert into user(name,passwd,age,gender) values
27.   * ("BBBB","BBBB",20,‘F‘),
28.   * ("BBBB","BBBB",20,‘F‘);
29.   */
30.   ps.executeBatch(); //批量执行sql，避免因此单次的insert操作建立多个Connection浪费资源
31.   ct.commit();
32.   } catch (Exception e) {
33.   e.printStackTrace();
34.   try {
35.   ct.rollback();
36.   } catch (SQLException e1) {
37.   e1.printStackTrace();
38.   }
39.   } finally{
40.   closeConnection();
41.   }
42.   }

执行excuteBatchInsertDatabase（）方法数据库记录：

数据库数据记录表明：sql语句批量执行成功

注意：

批量查询最好交由一个事务组控制，如果出现操作异常可以进行事务回滚，不至于造成部分数据更新部分数据更新失败的尴尬局面，避免你脏数据污染数据库

 

• 由于 PreparedStatement 对象已预编译过，所以其执行速度要快于 Statement 对象。因此，多次执行的 SQL 语句经常创建为 PreparedStatement 对象，以提高效率
• Statement用于执行静态的sql语句

• 由于PreparedStatement创建对象消耗资源比较高,所以只执行 一次的sql语句,不使用PreparedStatement

• 主要目的减少执行计划次数，防止sql注入
• jdbc 元数据 meta  ,ResultSet.xxx
• Mysql jdbc 关闭自动提交事务 可提升性能 conn.setAutoCommit(false) ,
• 归还conn时 须提前设置为.setAutoCommit(true)
• rollback()回滚 
• 批量处理：一次向数据库发送多个SQL语句时，可以减少通信开销，从而提高性能。