优化一段java代码考虑不用PreparedStatement

java方面1.使用Statement对象2.预编译PreparedStatement3.使用PreparedStatement + 批处理为了区分出这三者之间的效率，下面的事例执行过程都是在数据库表t1中插入1万条记录，并记录出所需的时间(此时间与电脑硬件有关)1.使用Statement对象使用范围：当执行相似SQL(结构相同，具体值不同)语句的次数比较少优点：语法简单缺点:采用硬编码效率低，安全性较差。原理：硬编码，每次执行时相似SQL都会进行编译           事例执行过程:   public void exec(Connection conn){           try {                     Long beginTime = System.currentTimeMillis();                           conn.setAutoCommit(false);//设置手动提交                    Statement st = conn.createStatement();                            for(int i=0;i<10000;i++){                       String sql="insert into t1(id) values ("+i+")";                       st.executeUpdate(sql);                     }                           Long endTime = System.currentTimeMillis();                   System.out.println("Statement用时："+(endTime-beginTime)/1000+"秒");//计算时间                   st.close();                  conn.close();                } catch (SQLException e) {                                 e.printStackTrace();          }    } 执行时间：Statement用时：31秒 2.预编译PreparedStatement使用范围：当执行相似sql语句的次数比较多（例如用户登陆，对表频繁操作..）语句一样，只是具体的值不一样，被称为动态SQL优点：语句只编译一次，减少编译次数。提高了安全性（阻止了SQL注入）缺点: 执行非相似SQL语句时，速度较慢。原理：相似SQL只编译一次，减少编译次数名词解释：SQL注入:select * from user where username="张三" and password="123" or 1=1;前面这条语句红色部分就是利用sql注入，使得这条词句使终都会返回一条记录，从而降低了安全性。事例执行过程:      public void exec2(Connection conn){         try {                   Long beginTime = System.currentTimeMillis();                    conn.setAutoCommit(false);//手动提交                    PreparedStatement pst = conn.prepareStatement("insert into t1(id) values (?)");                    for(int i=0;i<10000;i++){                       pst.setInt(1, i);                       pst.execute();                       }                      conn.commit();                      Long endTime = System.currentTimeMillis();                      System.out.println("Pst用时:"+(endTime-beginTime)+"秒");//计算时间                      pst.close();                      conn.close();          } catch (SQLException e) {                                      e.printStackTrace();          }    }执行时间：Pst用时:14秒 3.使用PreparedStatement + 批处理使用范围：一次需要更新数据库表多条记录优点：减少和SQL引擎交互的次数，再次提高效率,相似语句只编译一次，减少编译次数。提高了安全性（阻止了SQL注入）缺点:原理：批处理: 减少和SQL引擎交互的次数，一次传递给SQL引擎多条SQL。名词解释：PL/SQL引擎：在oracle中执行pl/sql代码的引擎，在执行中发现标准的sql会交给sql引擎进行处理。SQL引擎：执行标准sql的引擎。事例执行过程:public void exec3(Connection conn){                     try {                      conn.setAutoCommit(false);                      Long beginTime = System.currentTimeMillis();                      PreparedStatement pst = conn.prepareStatement("insert into t1(id) values (?)");                                           for(int i=1;i<=10000;i++){                          pst.setInt(1, i);                       pst.addBatch();//加入批处理，进行打包                       if(i%1000==0){//可以设置不同的大小；如50，100，500，1000等等                        pst.executeBatch();                        conn.commit();                        pst.clearBatch();                       }                      }                     pst.executeBatch();                      Long endTime = System.currentTimeMillis();                      System.out.println("pst+batch用时："+(endTime-beginTime)+"毫秒");                      pst.close();                      conn.close();                     } catch (SQLException e) {                      // TODO Auto-generated catch block                      e.printStackTrace();                     } }执行时间：pst+batch用时：485毫秒 @数据库方面1 静态SQL使用范围：优点：每次执行相似sql都会进行编译。缺点:效率低,占用破费cpu资源，耗费SGA 资源。原理：(检查SQL 语句在SGA 中的共享池中是否存在, 如果不存在，则编译、解析后执行：硬解析,     如果已存在，则取出编译结果执行：软解析)事例执行过程:DECLARE
time1 NUMBER;
time2 NUMBER;
BEGIN
  time1 := dbms_utility.get_time;
  EXECUTE IMMEDIATE 'truncate table t_demo';
  FOR i IN 1..10000
  LOOP
     EXECUTE IMMEDIATE
       'insert into t_demo(u_id) values('||i||')';
  END LOOP;
  time2 := dbms_utility.get_time;
  dbms_output.put_line((time2-time1)/100||'秒');
END执行时间：pst+batch用时：20.93秒2 动态SQL使用范围：优点：语句只编译一次，减少编译次数，提高效率。缺点:原理：减少编译次数(检查SQL 语句在SGA 中的共享池中是否存在, 如果不存在，则编译、解析后执行：硬解析,     如果已存在，则取出编译结果执行：软解析)事例执行过程:DECLARE
time1 NUMBER;
time2 NUMBER;
BEGIN
  time1 := dbms_utility.get_time;
  EXECUTE IMMEDIATE 'truncate table t_demo';
  FOR i IN 1..10000
  LOOP
     EXECUTE IMMEDIATE
       'insert into t1(u_id) values(:x)' USING i;
  END LOOP;
  time2 := dbms_utility.get_time;
  dbms_output.put_line((time2-time1)/100||'秒');
END;        执行时间：pst+batch用时：10.55秒 3 利用forall进行批处理<相似java中的批处理>使用范围：当执行相似sql语句的次数比较多（例如用户登陆，对表频繁操作..）FORALL只能运行一条sql语句。优点：减少与SQL引擎转替次数，提交效率。缺点:循环时从开始到结束，一次性读完，不能取其中的某些循环进行操作。原理：使用ForAll语句可以让PL/SQL引擎一次将多条SQL转发给SQL引擎，从而减少转发次数，提高系统性能。事例执行过程:CREATE  OR  REPLACE  PROCEDURE  p_test
AS   --定义新的类型(不是定义变量！)
   TYPE id_table_type IS TABLE OF NUMBER(6) INDEX BY BINARY_INTEGER;
   --用新的类型来定义变量
   id_table id_table_type;
   time1 NUMBER;
time2 NUMBER;
BEGIN
    FOR i IN 1..10000
    LOOP
       --往两个数组中存放数据
       id_table(i) := i;
    END LOOP;
   --★：一次性向SQL引擎传递了多条数据而不是一条
    time1 := dbms_utility.get_time;
    FORALL i IN 1..id_table.COUNT
        INSERT INTO t_demo(u_id) VALUES(id_table(i));
  time2 := dbms_utility.get_time;
  dbms_output.put_line((time2-time1)*10||'毫秒');end p_test; call p_test();执行时间：pst+batch用时：170毫秒 4 利用BULK COLLECT使用范围：处理数据量比较少时。优点：一次读取多行数据，提高效率。缺点: 需要较大的内存开销原理：将多个行引入一个或多个集合中。事例执行过程:DECLARE   TYPE books_aat       IS TABLE OF book%ROWTYPE      INDEX BY PLS_INTEGER;   book books_aat;BEGIN   SELECT *     BULK COLLECT INTO book     FROM books    WHERE title LIKE '%PL/SQL%';   ...END;

其实用PreparedStatement除了预编译，还有一个好处就是防止注入式攻击。

对，这个在单纯的JSP开发中尤为重要！

在JDBC应用中,如果你已经是稍有水平开发者,你就应该始终以PreparedStatement代替Statement.也就是说,在任何时候都不要使用Statement一.代码的可读性和可维护性.
虽然用PreparedStatement来代替Statement会使代码多出几行,但这样的代码无论从可读性还是可维护性上来说.都比直接用Statement的代码高很多档次:stmt.executeUpdate("insert into tb_name (col1,col2,col2,col4) values ('"+var1+"','"+var2+"',"+var3+",'"+var4+"')");perstmt = con.prepareStatement("insert into tb_name (col1,col2,col2,col4) values (?,?,?,?)");
perstmt.setString(1,var1);
perstmt.setString(2,var2);
perstmt.setString(3,var3);
perstmt.setString(4,var4);
perstmt.executeUpdate();不用我多说,对于第一种方法.别说其他人去读你的代码,就是你自己过一段时间再去读,都会觉得伤心.二.PreparedStatement尽最大可能提高性能.
每一种数据库都会尽最大努力对预编译语句提供最大的性能优化.因为预编译语句有可能被重复调用.所以语句在被DB的编译器编译后的执行代码被缓存下来,那么下次调用时只要是相同的预编译语句就不需要编译,只要将参数直接传入编译过的语句执行代码中(相当于一个涵数)就会得到执行.这并不是说只有一个Connection中多次执行的预编译语句被缓存,而是对于整个DB中,只要预编译的语句语法和缓存中匹配.那么在任何时候就可以不需要再次编译而可以直接执行.而statement的语句中,即使是相同一操作,而由于每次操作的数据不同所以使整个语句相匹配的机会极小,几乎不太可能匹配.比如:
insert into tb_name (col1,col2) values ('11','22');
insert into tb_name (col1,col2) values ('11','23');
即使是相同操作但因为数据内容不一样,所以整个个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存.这样每执行一次都要对传入的语句编译一次.当然并不是所以预编译语句都一定会被缓存,数据库本身会用一种策略,比如使用频度等因素来决定什么时候不再缓存已有的预编译结果.以保存有更多的空间存储新的预编译语句.三.最重要的一点是极大地提高了安全性.即使到目前为止,仍有一些人连基本的恶义SQL语法都不知道.
String sql = "select * from tb_name where name= '"+varname+"' and passwd='"+varpasswd+"'";
如果我们把[' or '1' = '1]作为varpasswd传入进来.用户名随意,看看会成为什么?select * from tb_name = '随意' and passwd = '' or '1' = '1';
因为'1'='1'肯定成立,所以可以任何通过验证.更有甚者:
把[';drop table tb_name;]作为varpasswd传入进来,则:
select * from tb_name = '随意' and passwd = '';drop table tb_name;有些数据库是不会让你成功的,但也有很多数据库就可以使这些语句得到执行.而如果你使用预编译语句.你传入的任何内容就不会和原来的语句发生任何匹配的关系.(前提是数据库本身支持预编译,但上前可能没有什么服务端数据库不支持编译了,只有少数的桌面数据库,就是直接文件访问的那些)只要全使用预编译语句,你就用不着对传入的数据做任何过虑.而如果使用普通的statement,有可能要对drop,;等做费尽心机的判断和过虑.上面的几个原因,还不足让你在任何时候都使用PreparedStatement吗?

还有一个好处是写SQL语句不容易出错，特别是一大堆引号的时候

你可以考虑一下在数据库层的优化，而不是更换一个类，我不认为你这样就能解决问题select * from (select * from test where xx = ?)8个这样的语句你不认为你的数据库设计有问题或是SQL语句需要优化吗？

－－在JDBC应用中,如果你已经是稍有水平开发者,你就应该始终以PreparedStatement代替Statement.也就是说,在任何时候都不要使用Statement 回楼上这个问题必须讨论    任何事务都是相对的，不能武端的
我今天受到一个开发人员的问题
他用的是预编译
最后
insert into a  value (),(),()......     大概有50来条，结果java编译器提示诉多太慢失败后来检查就是预编译出错误了。 prestatement。后来将insert into a  value (),(),()......   裁开成了单条的insert语句
如inser （），
insert（）
insert（），最后成功。
这里到不是什么效率问题。  而是程序要跑起来

调试易

优化一段java代码考虑不用PreparedStatement

解决方案 »