ReactOS爬虫之再改版

元始天尊

http://www.0xaa55.com/thread-285-1-1.html
上次给大家留了2个问题，现在揭晓
问题1：上面代码是栈实现的，请自己写出队列版代码
堆栈版：

1. import java.io.File;
   
2. import java.io.FileInputStream;
   
3. import java.io.FileOutputStream;
   
4. import java.io.IOException;
   
5. import java.io.InputStream;
   
6. import java.io.ObjectInputStream;
   
7. import java.io.ObjectOutputStream;
   
8. import java.io.Serializable;
   
9. import java.net.URL;
   
10. import java.net.URLConnection;
    
11. import java.util.Stack;
    
12. 
    
13. import org.jsoup.Jsoup;
    
14. import org.jsoup.nodes.Document;
    
15. import org.jsoup.nodes.Element;
    
16. import org.jsoup.parser.Tag;
    
17. import org.jsoup.select.Elements;
    
18. 
    
19. public class ReactOSDownloaderStack
    
20. {
    
21.     public static String url="http://svn.reactos.org/";
    
22.     public static String path="k:/reactos/";
    
23.     public static int filethreadnum=0;
    
24.      
    
25.     public static boolean setinit=false;//是否强制初始化
    
26.     public static String[] initstring={};//初始化目录位要开始更新的目录，按深度顺序
    
27.     public static int curdepth=0;//当前初始化深度
    
28.     public static Stack<FolderClass> folders=new Stack<FolderClass>();
    
29. 
    
30.     public static class SerialElement implements Serializable
    
31.     {
    
32.         /**
    
33.          *
    
34.          */
    
35.         public String attrhref="";
    
36.         private static final long serialVersionUID = 1L;
    
37.         
    
38.         public SerialElement(Element ele)
    
39.         {
    
40.             attrhref=ele.attr("href");
    
41.         }
    
42.     }
    
43.    
    
44.     public static class SerialData implements Serializable
    
45.     {
    
46.         /**
    
47.          *
    
48.          */
    
49.         public Stack<FolderClass> inner=new Stack<FolderClass>();
    
50.         private static final long serialVersionUID = 1L;
    
51.         public SerialData(Stack<FolderClass> data)
    
52.         {
    
53.             inner.clear();
    
54.             inner.addAll(data);
    
55.         }
    
56.         public void ReadFromData(Stack<FolderClass> data)
    
57.         {
    
58.             data.clear();
    
59.             data.addAll(inner);
    
60.         }
    
61.     }
    
62.    
    
63.     public static class FileThread extends Thread
    
64.     {
    
65.         String filepath;
    
66.         String curnode;
    
67.          
    
68.         FileThread(String filepath,String curnode)
    
69.         {
    
70.             this.filepath=filepath;
    
71.             this.curnode=curnode;
    
72.         }
    
73.         
    
74.         @Override
    
75.         public void run()
    
76.         {
    
77.             try
    
78.             {
    
79.                 while(filethreadnum>30)
    
80.                 {
    
81.                     sleep(1000);
    
82.                 }
    
83.                 filethreadnum++;
    
84.                 int byteread=0;
    
85.                 int bytesum=0;
    
86.                 URL weburl=new URL(url+filepath+curnode);
    
87.                 URLConnection con=weburl.openConnection();
    
88.                 InputStream instream=con.getInputStream();
    
89.                 FileOutputStream fs=new FileOutputStream(escape((path+filepath+curnode).replace("%20"," ")));
    
90.                 byte[] buffer=new byte[65536];
    
91.                 while((byteread=instream.read(buffer)) != -1)
    
92.                 {
    
93.                     bytesum+=byteread;
    
94.                     fs.write(buffer,0,byteread);
    
95.                     System.out.println("\t\t当前下载文件："+filepath+curnode+"\t当前大小："+bytesum);
    
96.                 }
    
97.                 fs.close();
    
98.                 instream.close();
    
99.                 filethreadnum--;
    
100.             }
     
101.             catch(Exception e)
     
102.             {
     
103.                 System.out.println("error");
     
104.                 filethreadnum--;
     
105.                 new File(path+filepath+curnode).deleteOnExit();;
     
106.             }
     
107.         }
     
108.     }
     
109.      
     
110.     public static String escape(String src)
     
111.     {
     
112.         StringBuffer sbuf=new StringBuffer();
     
113.         int len=src.length();
     
114. 
     
115.         for(int i=3;i<len;i++)
     
116.         {
     
117.             char ch=src.charAt(i);
     
118.             if(ch == '\\' || ch == ':' || ch == '*' || ch == '?' || ch == '"' || ch == '<' || ch == '>' || ch == '|')
     
119.                 ;
     
120.             else
     
121.                 sbuf.append(ch);
     
122.         }
     
123.         return src.substring(0,3)+formatpath(sbuf.toString());
     
124.     }
     
125.      
     
126.     public static String formatpath(String src)
     
127.     {
     
128.         if(!src.contains("http"))
     
129.             return src;
     
130.         String newstr=src.substring(0,10)+src.substring(10).replaceAll("/{2,}", "/");
     
131.         return newstr;
     
132.     }
     
133.      
     
134.     public static String createFolder(String folderPath)
     
135.     {
     
136.         String txt = folderPath;
     
137.         try
     
138.         {
     
139.             File myFilePath = new File(txt);
     
140.             txt = folderPath;
     
141.             if (!myFilePath.exists())
     
142.             {
     
143.                 myFilePath.mkdir();
     
144.         }
     
145.     }
     
146.     catch (Exception e)
     
147.     {
     
148.         System.out.println("错误!");
     
149.     }
     
150.         return txt;
     
151.     }
     
152. 
     
153.     public static class FolderClass implements Serializable
     
154.     {
     
155.         String filepath;
     
156.         SerialElement e;
     
157.         
     
158.         public FolderClass(SerialElement e,String filepath)
     
159.         {
     
160.             this.filepath=filepath;
     
161.             this.e=e;
     
162.         }
     
163.          
     
164.         public void ResolveFolder()
     
165.         {
     
166.             try
     
167.             {            
     
168.                 String curnode=e.attrhref;
     
169.                 if(curnode.indexOf(';') != -1 || curnode.charAt(0) == '/' || curnode.equals("../") || curnode.equals("svn/"))
     
170.                     return;
     
171.                 System.out.println(curnode+"\t"+filepath);
     
172.                 if(setinit)
     
173.                 {
     
174.                     if(!curnode.equals(initstring[curdepth]))
     
175.                         return;
     
176.                     else
     
177.                         curdepth++;
     
178.                     if(curdepth >= initstring.length)
     
179.                         setinit=false;
     
180.                 }
     
181.                   
     
182.                 if(curnode.charAt(curnode.length()-1) == '/')
     
183.                 {//目录
     
184.                     createFolder(escape((path+filepath+curnode).replace("%20"," ")));
     
185.                     Document doc=Jsoup.connect(formatpath(url+filepath+curnode)).timeout(0).get();
     
186.                     System.out.println("当前目录："+url+formatpath(filepath)+curnode);
     
187.                     Elements items=doc.select("tbody tr a");
     
188.                     for(Element ele1:items)
     
189.                     {
     
190.                         folders.push(new FolderClass(new SerialElement(ele1),filepath+curnode));
     
191.                     }
     
192.                     items.clear();
     
193.                     items=doc.select("ul li a");
     
194.                     for(Element ele2:items)
     
195.                     {
     
196.                         folders.push(new FolderClass(new SerialElement(ele2),filepath+curnode));
     
197.                     }
     
198.                 }
     
199.                 else
     
200.                 {//文件
     
201.                     File curfile=new File((path+filepath+curnode).replace("%20"," "));
     
202.                     if(curfile.exists())
     
203.                         return;
     
204.                     (new FileThread(filepath,curnode)).start();
     
205.                 }
     
206.             }
     
207.             catch(Exception e)
     
208.             {
     
209.                 System.out.println("error");
     
210.             }
     
211.         }
     
212.     }
     
213.    
     
214.     public static void main(String[] args) throws IOException
     
215.     {
     
216.         try
     
217.         {
     
218.             if(new File("savedata").exists())
     
219.             {
     
220.                 FileInputStream fis=new FileInputStream("savedata");
     
221.                 ObjectInputStream ois=new ObjectInputStream(fis);
     
222.                 SerialData data=(SerialData) ois.readObject();
     
223.                 data.ReadFromData(folders);
     
224.                 ois.close();
     
225.                 fis.close();
     
226.             }
     
227.             else
     
228.             {
     
229.                 Document doc = Jsoup.connect(url).timeout(0).get();
     
230.                 Elements items=doc.select("tbody tr a");
     
231.                 createFolder(path);
     
232.                 for(Element e1:items)
     
233.                 {
     
234.                     folders.push(new FolderClass(new SerialElement(e1),""));
     
235.                 }
     
236.                 items=doc.select("ul li a");
     
237.                 for(Element e2:items)
     
238.                 {
     
239.                     folders.push(new FolderClass(new SerialElement(e2),""));
     
240.                 }
     
241.                 new File("savedata").createNewFile();
     
242.             }
     
243.             
     
244.             new Thread()
     
245.             {
     
246.                 @Override
     
247.                 public void run()
     
248.                 {
     
249.                     while(true)
     
250.                     {
     
251.                         try
     
252.                         {
     
253.                             sleep(1000);
     
254.                             FileOutputStream fos=new FileOutputStream("savedata");
     
255.                             ObjectOutputStream oos=new ObjectOutputStream(fos);
     
256.                             SerialData data=new SerialData(folders);
     
257.                             oos.writeObject(data);
     
258.                             oos.close();
     
259.                             fos.close();
     
260.                         }
     
261.                         catch(Exception e)
     
262.                         {
     
263.                         }
     
264.                     }
     
265.                 }
     
266.             }.start();
     
267.             
     
268.             new Thread()
     
269.             {
     
270.                 @Override
     
271.                 public void run()
     
272.                 {
     
273.                     while(!folders.empty())
     
274.                     {
     
275.                         int searchonce=30;
     
276.                         while(searchonce-- > 0 && !folders.isEmpty())
     
277.                         {
     
278.                             folders.pop().ResolveFolder();
     
279.                         }
     
280.                     }
     
281.                 }
     
282.             }.start();
     
283.                
     
284.             while(filethreadnum != 0 || folders.size() != 0)
     
285.             {
     
286.                 Thread.sleep(1000);
     
287.             }
     
288.         }
     
289.         catch(Exception exc)
     
290.         {
     
291.             System.out.println("错误!"+exc.getMessage());
     
292.         }
     
293.     }
     
294. }

复制代码

队列版：

1. import java.io.File;
   
2. import java.io.FileOutputStream;
   
3. import java.io.IOException;
   
4. import java.io.InputStream;
   
5. import java.net.URL;
   
6. import java.net.URLConnection;
   
7. import java.util.LinkedList;
   
8. import java.util.Queue;
   
9. import java.util.Stack;
   
10. import org.jsoup.Jsoup;
    
11. import org.jsoup.nodes.Document;
    
12. import org.jsoup.nodes.Element;
    
13. import org.jsoup.select.Elements;
    
14. public class ReactOSDownloaderQueue
    
15. {
    
16.     public static String url="[url=http://svn.reactos.org/]http://svn.reactos.org/[/url]";
    
17.     public static String path="k:/reactos/";
    
18.     public static int filethreadnum=0;
    
19.         
    
20.     public static boolean setinit=false;//是否强制初始化
    
21.     public static String[] initstring={};//初始化目录位要开始更新的目录，按深度顺序
    
22.     public static int curdepth=0;//当前初始化深度
    
23.     public static Queue<FolderClass> folders=new LinkedList<FolderClass>();
    
24.     public static class FileThread extends Thread
    
25.     {
    
26.         String filepath;
    
27.         String curnode;
    
28.                
    
29.         FileThread(String filepath,String curnode)
    
30.         {
    
31.             this.filepath=filepath;
    
32.             this.curnode=curnode;
    
33.         }
    
34.         
    
35.         @Override
    
36.         public void run()
    
37.         {
    
38.             try
    
39.             {
    
40.                 while(filethreadnum>100)
    
41.                 {
    
42.                     sleep(1000);
    
43.                 }
    
44.                 filethreadnum++;
    
45.                 int byteread=0;
    
46.                 int bytesum=0;
    
47.                 URL weburl=new URL(url+filepath+curnode);
    
48.                 URLConnection con=weburl.openConnection();
    
49.                 InputStream instream=con.getInputStream();
    
50.                 FileOutputStream fs=new FileOutputStream(escape((path+filepath+curnode).replace("%20"," ")));
    
51.                 byte[] buffer=new byte[65536];
    
52.                 while((byteread=instream.read(buffer)) != -1)
    
53.                 {
    
54.                     bytesum+=byteread;
    
55.                     fs.write(buffer,0,byteread);
    
56.                     System.out.println("\t\t当前下载文件："+filepath+curnode+"\t当前大小："+bytesum);
    
57.                 }
    
58.                 fs.close();
    
59.                 instream.close();
    
60.                 filethreadnum--;
    
61.             }
    
62.             catch(Exception e)
    
63.             {
    
64.                 System.out.println("error");
    
65.                 filethreadnum--;
    
66.                 new File(path+filepath+curnode).deleteOnExit();;
    
67.             }
    
68.         }
    
69.     }
    
70.         
    
71.     public static String escape(String src)
    
72.     {
    
73.         StringBuffer sbuf=new StringBuffer();
    
74.         int len=src.length();
    
75.         for(int i=3;i<len;i++)
    
76.         {
    
77.             char ch=src.charAt(i);
    
78.             if(ch == '\\' || ch == ':' || ch == '*' || ch == '?' || ch == '"' || ch == '<' || ch == '>' || ch == '|')
    
79.                 ;
    
80.             else
    
81.                 sbuf.append(ch);
    
82.         }
    
83.         return src.substring(0,3)+formatpath(sbuf.toString());
    
84.     }
    
85.         
    
86.     public static String formatpath(String src)
    
87.     {
    
88.         if(!src.contains("http"))
    
89.             return src;
    
90.         String newstr=src.substring(0,10)+src.substring(10).replaceAll("/{2,}", "/");
    
91.         return newstr;
    
92.     }
    
93.         
    
94.     public static String createFolder(String folderPath)
    
95.     {
    
96.         String txt = folderPath;
    
97.         try
    
98.         {
    
99.             File myFilePath = new File(txt);
    
100.             txt = folderPath;
     
101.             if (!myFilePath.exists())
     
102.             {
     
103.                 myFilePath.mkdir();
     
104.             }
     
105.         }
     
106.         catch (Exception e)
     
107.         {
     
108.             System.out.println("错误!");
     
109.         }
     
110.         return txt;
     
111.     }
     
112.     public static class FolderClass
     
113.     {
     
114.         String filepath;
     
115.         Element e;
     
116.                
     
117.         FolderClass(Element e,String filepath)
     
118.         {
     
119.             this.filepath=filepath;
     
120.             this.e=e;
     
121.         }
     
122.                
     
123.         public void ResolveFolder()
     
124.         {
     
125.             try
     
126.             {      
     
127.                 String curnode=e.attr("href");
     
128.                 if(curnode.indexOf(';') != -1 || curnode.charAt(0) == '/' || curnode.equals("../") || curnode.equals("svn/"))
     
129.                     return;
     
130.                 System.out.println(curnode+"\t"+filepath);
     
131.                 if(setinit)
     
132.                 {
     
133.                     if(!curnode.equals(initstring[curdepth]))
     
134.                         return;
     
135.                     else
     
136.                         curdepth++;
     
137.                     if(curdepth >= initstring.length)
     
138.                         setinit=false;
     
139.                 }
     
140.                         
     
141.                 if(curnode.charAt(curnode.length()-1) == '/')
     
142.                 {//目录
     
143.                     createFolder(escape((path+filepath+curnode).replace("%20"," ")));
     
144.                     Document doc=Jsoup.connect(formatpath(url+filepath+curnode)).timeout(0).get();
     
145.                     System.out.println("当前目录："+url+formatpath(filepath)+curnode);
     
146.                     Elements items=doc.select("tbody tr a");
     
147.                     for(Element ele1:items)
     
148.                     {
     
149.                         folders.offer(new FolderClass(ele1,filepath+curnode));
     
150.                     }
     
151.                     items.clear();
     
152.                     items=doc.select("ul li a");
     
153.                     for(Element ele2:items)
     
154.                     {
     
155.                         folders.offer(new FolderClass(ele2,filepath+curnode));
     
156.                     }
     
157.                 }
     
158.                 else
     
159.                 {//文件
     
160.                     File curfile=new File((path+filepath+curnode).replace("%20"," "));
     
161.                     if(curfile.exists())
     
162.                         return;
     
163.                     (new FileThread(filepath,curnode)).start();
     
164.                 }
     
165.             }
     
166.             catch(Exception e)
     
167.             {
     
168.                 System.out.println("error");
     
169.             }
     
170.         }
     
171.     }
     
172.    
     
173.     public static void main(String[] args) throws IOException
     
174.     {
     
175.         try
     
176.         {
     
177.             Document doc = Jsoup.connect(url).timeout(0).get();
     
178.             Elements items=doc.select("tbody tr a");
     
179.             createFolder(path);
     
180.             for(Element e1:items)
     
181.             {
     
182.                 folders.offer(new FolderClass(e1,""));
     
183.             }
     
184.             items=doc.select("ul li a");
     
185.             for(Element e2:items)
     
186.             {
     
187.                 folders.offer(new FolderClass(e2,""));
     
188.             }
     
189.             
     
190.             new Thread()
     
191.             {
     
192.                 @Override
     
193.                 public void run()
     
194.                 {
     
195.                     while(!folders.isEmpty())
     
196.                     {
     
197.                         int searchonce=(folders.size()>100)?100:folders.size();
     
198.                         while(searchonce-- > 0)
     
199.                         {
     
200.                             folders.poll().ResolveFolder();
     
201.                         }
     
202.                     }
     
203.                 }
     
204.             }.start();
     
205.                         
     
206.             while(filethreadnum != 0)
     
207.             {
     
208.                 Thread.sleep(1000);
     
209.             }
     
210.         }
     
211.         catch(Exception exc)
     
212.         {
     
213.             System.out.println("错误!");
     
214.         }
     
215.     }
     
216. }

复制代码

问题2：代码中实现了一种功能，它允许你今天下载了一部分reactos代码，然后结束java程序，第二天开电脑的时候只需要设置以下参数，就可以从昨天开始处继续运行，请问代码中如何实现的
在最早的版本（非队列非堆栈版）里，这种继续下载的机制是通过记录目录实现的
关键代码在：

1. public static boolean setinit=false;//是否强制初始化
   
2. 。。。。。
   
3.     if(setinit)
   
4.     {
   
5.             if(!curnode.equals(initstring[curdepth]))
   
6.                 return;
   
7.             else
   
8.                 curdepth++;
   
9.             if(curdepth >= initstring.length)
   
10.                 setinit=false;
    
11.     }

复制代码

而在上面的堆栈版，是通过java独有的序列化方式实现的，，每隔1秒将堆栈数据写入文件，启动时读出。序列化和反射是java最强大的2各功能，其中序列化可以保存任何东西，包括类
关键代码在：

1. public static class SerialElement implements Serializable
   
2. {
   
3.     /**
   
4.         *
   
5.         */
   
6.     public String attrhref="";
   
7.     private static final long serialVersionUID = 1L;
   
8.    
   
9.     public SerialElement(Element ele)
   
10.     {
    
11.         attrhref=ele.attr("href");
    
12.     }
    
13. }
    
14. 
    
15. public static class SerialData implements Serializable
    
16. {
    
17.     /**
    
18.         *
    
19.         */
    
20.     public Stack<FolderClass> inner=new Stack<FolderClass>();
    
21.     private static final long serialVersionUID = 1L;
    
22.     public SerialData(Stack<FolderClass> data)
    
23.     {
    
24.         inner.clear();
    
25.         inner.addAll(data);
    
26.     }
    
27.     public void ReadFromData(Stack<FolderClass> data)
    
28.     {
    
29.         data.clear();
    
30.         data.addAll(inner);
    
31.     }
    
32. }
    
33. 。。。
    
34.         if(new File("savedata").exists())
    
35.         {
    
36.             FileInputStream fis=new FileInputStream("savedata");
    
37.             ObjectInputStream ois=new ObjectInputStream(fis);
    
38.             SerialData data=(SerialData) ois.readObject();
    
39.             data.ReadFromData(folders);
    
40.             ois.close();
    
41.             fis.close();
    
42.         }
    
43. 。。。
    
44.         new Thread()
    
45.         {
    
46.             @Override
    
47.             public void run()
    
48.             {
    
49.                 while(true)
    
50.                 {
    
51.                     try
    
52.                     {
    
53.                      sleep(1000);
    
54.                      FileOutputStream fos=new FileOutputStream("savedata");
    
55.                      ObjectOutputStream oos=new ObjectOutputStream(fos);
    
56.                      SerialData data=new SerialData(folders);
    
57.                      oos.writeObject(data);
    
58.                      oos.close();
    
59.                      fos.close();
    
60.                     }
    
61.                     catch(Exception e)
    
62.                     {
    
63.                     }
    
64.                 }
    
65.             }
    
66.         }.start();

复制代码

经测试，性能没有较大改变，且输出的文件总在7k以内，说明堆栈项目最多在200，很少

这次给你们留的问题so-easy，
①我只实现了堆栈版的序列化，现在你们实现队列版的序列化

②对比堆栈版和队列版运行速度，并说明原因

夜雨

不明觉厉~~mark