Go语言视频零基础入门到精通

javalearner

在一般的开发过程中，往往要遇到从数据库中取出数据组成值对象（通常叫做VO），然后放在列表集中，并传回调用端的情况。在还没有接触到clone的时候，程序往往要在while块中构造VO实例，但这样做并不推荐，甚至应该极力避免，因为会造成程序效率的低下。在使用clone技术以后，程序运行效率有所改善，以下是常用写法，希望对大家有所帮助。 支持clone的VO看起来像这样： package com.XXX; import java.util.*; public class TempJob implements Cloneable { //声明其可被clone
  
   
   
     
   

   
   
  
   private String Jbnr=null;
   private String Jbdw=null;     public Object clone() {
       try {
           return super.clone();                               //返回clone以后的对象
           }
           catch (CloneNotSupportedException e) {
               System.out.println(e.toString());
           }   public void setJbnr(String Jbnr){
       this.Jbnr=Jbnr;
   }   public String getJbnr(){
       return Jbnr;
   }   public void setJbdw(String Jbdw){
       this.Jbdw=Jbdw;
   }
   
   public String getJbdw(){
       return Jbdw;
   }
}
对于调用VO的类，像这样： package com.XXX;
import java.sql.*;
import java.util.*; public class DoJob{   private Connection con;
   private Statement stmt;
   private ResultSet rs;
   private ArrayList lis=new ArrayList();   public ArrayList query(String a){                              
       String sql="";
       sql="select a.*,b.name from temp_job a, user_basic b "
           +"where a.userid = b.userid order by a.wcqk";
       try{
           stmt=con.createStatement();
           rs=stmt.executeQuery(sql);   
           TempJob job=new TempJob();                //只要一个实例
           while (rs.next()){
               job.setJbnr(rs.getString(1));
               job.setJbdw(rs.getString(2));
               lis.add(job.clone());                         //返回被clone对象
           }
     }
     catch(SQLException e){
       System.out.println(e.toString());
     }
     finally {                           
       this.rs=null;
       this.stmt=null;
       con.close();
     }   
     return lis;
   }
}
  下面是作者对运行效率的说明：

1. 现在有一典型的 VO 类 Auto(LightWeight)：
   
2. package com.test;
   
3. public class Auto implements Cloneable{
   
4. 
   
5.     private String No;
   
6.     private String Addr;
   
7. 
   
8.     public Object clone() throws CloneNotSupportedException{
   
9. return super.clone();
   
10.     }
    
11.     public String setNo(String no){
    
12.         return this.No=no;
    
13.     }  
    
14.     public String getNo(){
    
15.         return this.No;
    
16.     }  
    
17.    
    
18.     public String setAddr(String addr){
    
19.         return this.Addr=addr;
    
20.     }  
    
21.     public String getAddr(){
    
22.         return this.Addr;
    
23.     }
    
24. }
    
25. 
    
26.     接着分别通过使用克隆和不使用克隆的 Bean 来构造 Auto 实例。
    
27. 使用克隆的 Bean：
    
28. package com.test;
    
29. import java.io.*;
    
30. import java.util.*;
    
31. import org.dom4j.*;
    
32. import org.dom4j.io.*;
    
33. public class MyXMLReader {
    
34.     Auto auto=new Auto();                                 //请比较不同
    
35.     ArrayList al=new ArrayList();
36. 
    
37. public ArrayList go() {
    
38.     long lasting = System.currentTimeMillis();
    
39.     try {
    
40.      File f = new File("data_100k.xml");
    
41.      SAXReader reader = new SAXReader();
    
42.      Document doc = reader.read(f);
    
43.      Element root = doc.getRootElement();
    
44.      Element foo;
    
45.      for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
    
46.          foo = (Element) i.next();
    
47.          auto.setNo(foo.elementText("NO"));
    
48.          auto.setAddr(foo.elementText("ADDR"));
    
49.                 al.add(auto.clone());                    //请比较不同
    
50.      }
    
51.    } catch (Exception e) {
    
52.      e.printStackTrace();
    
53.   }
    
54.   System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
    
55.   return al;
    
56.     }
    
57. }
    
58. 
    
59.     取八次运行时间
    
60.     运行时间：172 毫秒
    
61.     运行时间：93 毫秒
    
62.     运行时间：94 毫秒
    
63.     运行时间：141 毫秒
    
64.     运行时间：125 毫秒
    
65.     运行时间：78 毫秒
    
66.     运行时间：203 毫秒
    
67.     运行时间：63 毫秒
    
68. 没有使用克隆的 Bean：
    
69. package com.test;
    
70. import java.io.*;
    
71. import java.util.*;
    
72. import org.dom4j.*;
    
73. import org.dom4j.io.*;
    
74. public class MyXMLReader {
    
75.     ArrayList al=new ArrayList();
    
76.     public ArrayList go() {
    
77.         long lasting = System.currentTimeMillis();
    
78.     try {
    
79.      File f = new File("data_100k.xml");
    
80.      SAXReader reader = new SAXReader();
    
81.      Document doc = reader.read(f);
    
82.      Element root = doc.getRootElement();
    
83.      Element foo;
    
84.      for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
    
85.      foo = (Element) i.next();
    
86.      Auto auto=new Auto();                     //请比较不同
    
87.          auto.setNo(foo.elementText("NO"));
    
88.          auto.setAddr(foo.elementText("ADDR"));
    
89.                 al.add(auto);                             //请比较不同
    
90.      }
    
91.     } catch (Exception e) {
    
92.      e.printStackTrace();
    
93.   }
    
94.   System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
    
95.   return al;
    
96.     }
    
97. }
    
98. 
    
99.     取八次运行时间
    
100.     运行时间：187 毫秒
     
101.     运行时间：93 毫秒
     
102.     运行时间：172 毫秒
     
103.     运行时间：78 毫秒
     
104.     运行时间：204 毫秒
     
105.     运行时间：79 毫秒
     
106.     运行时间：204 毫秒
     
107.     运行时间：78 毫秒
     
108.     通过比较，克隆与非克隆，在构造 Auto 上花的时间是差不多的。
     
109.     且慢，让我们再看下面的 Auto 类。
     
110. 修改一下 Auto 类的构造函数，像这样(HeavyWeight)：
     
111. package com.test;
     
112. import java.io.*;
     
113. public class Auto implements Cloneable{
     
114. 
     
115.     private String No;
     
116.     private String Addr;
     
117.     private String str;
     
118.     private File f = new File("data_10k.xml");
     
119.     private StringBuffer sb=new StringBuffer();
     
120. 
     
121.     public Object clone() throws CloneNotSupportedException{
     
122.        return super.clone();
     
123.     }
     
124.     //以下方法仅仅为了构造一个 HeavyWeight 对象。
     
125.     public Auto(){
     
126.         try{
     
127.             BufferedReader inbuffer=new BufferedReader(new FileReader(f));
     
128.             while ((str=inbuffer.readLine())!=null){
     
129.             sb.append(str);
     
130.         }
     
131.         }catch(Exception e){
     
132.            System.out.println(e.toString());
     
133.     }
     
134.   }
     
135.     public String setNo(String no){
     
136.         return this.No=no;
     
137.     }  
     
138.     public String getNo(){
     
139.         return this.No;
     
140.     }  
     
141.    
     
142.     public String setAddr(String addr){
     
143.         return this.Addr=addr;
     
144.     }  
     
145.     public String getAddr(){
     
146.         return this.Addr;
     
147.     }
     
148. }
     
149. 
     
150.     再看看测试数据呢？
     
151.     使用克隆构造 Auto 实例：     不使用克隆构造 Auto 实例：
     
152.     运行时间：188 毫秒           运行时间：2219 毫秒
     
153.     运行时间：78 毫秒            运行时间：2266 毫秒
     
154.     运行时间：109 毫秒           运行时间：2156 毫秒
     
155.     运行时间：219 毫秒           运行时间：2093 毫秒
     
156.     运行时间：110 毫秒           运行时间：2266 毫秒
     
157.     运行时间：78 毫秒            运行时间：2141 毫秒
     
158.     运行时间：157 毫秒           运行时间：2078 毫秒
     
159.     运行时间：78 毫秒            运行时间：2172 毫秒
     
160.     好了，让我们查看一下 Auto 类。可以看见只是在其构造函数中加入读取10K XML文件的代码，
161. 而克隆与非克隆运行时间却有近 10 倍的差距！
     
162.    
     

复制代码