java开发一个搜索导航网站2

hannibal730816

定向抓取网站频道
       如果我们要想定向抓取一个网站的某个特定频道，例如JAVA编程。就要分析这个频道在网页中所处的位置。一般来说某个
    频道的文章列表一定是在某个特定的TABLE，或者DIV中。所以定向分析页面的核心就在于定位这个频道的TABLE位置。我们可以用
    递归的方式搜索网页，给每个TABLE编号，然后列出每个TABLE或者DIV的编号和其中的内容就可以准确定位。一般来说每个网站都有
    自己的风格，不会每天都变，所以用这个方式定位频道文章列表是很可靠的，而且一旦网站改版后，TABLE或者DIV的数量会发生变化
    我们可以根据这个变化知道，然后重新定位就可以了。用这种方式配置抓取模版是种不错的尝试。

    下面的代码中，请大家重点关注public List extractHtml(Node nodeP)  函数，该函数利用递归的方法定位频道。
    该代码利用了HTMLPARSER的抓取分析功能。

1. 
   
2. package com.newwatch.tools;
   
3. 
   
4. import com.newwatch.toolkit.splitwords.SpiderConstant;
   
5. import com.newwatch.toolkit.splitwords.SplitManager;
   
6. 
   
7. import org.htmlparser.Node;
   
8. import org.htmlparser.Parser;
   
9. 
   
10. import org.htmlparser.nodes.TextNode;
    
11. 
    
12. import org.htmlparser.tags.Div;
    
13. import org.htmlparser.tags.Html;
    
14. import org.htmlparser.tags.LinkTag;
    
15. import org.htmlparser.tags.ScriptTag;
    
16. import org.htmlparser.tags.SelectTag;
    
17. import org.htmlparser.tags.StyleTag;
    
18. import org.htmlparser.tags.TableTag;
    
19. 
    
20. import org.htmlparser.util.NodeIterator;
    
21. import org.htmlparser.util.NodeList;
    
22. 
    
23. import java.util.ArrayList;
    
24. import java.util.Iterator;
    
25. import java.util.List;
    
26. import java.util.regex.Matcher;
    
27. import java.util.regex.Pattern;
    
28. 
    
29. 
    
30. public class TestTabDivSerial {
    
31.     /**
    
32.     * A newline.
    
33.     */
    
34.     private static final String NEWLINE = System.getProperty("line.separator");
    
35. 
    
36.     /**
    
37.      * The length of the NEWLINE.
    
38.      */
    
39.     private static final int NEWLINE_SIZE = NEWLINE.length();
    
40.     private String url;
    
41.     private final String oriEncode = "gb2312,utf-8,gbk,iso-8859-1";
    
42.     private ArrayList htmlContext = new ArrayList();
    
43.     private String urlEncode;
    
44.     private int tableNumber;
    
45.     private int channelNumber;
    
46.     private int totalNumber;
    
47. 
    
48.     //url正则表达
    
49.     private String domain;
    
50.     private String urlDomaiPattern;
    
51.     private String urlPattern;
    
52.     private Pattern pattern;
    
53.     private Pattern patternPost;
    
54. 
    
55.     public void channelParseProcess() {
    
56.         /**提取本站信息的正则表达式**/
    
57.         urlDomaiPattern = "(http://[^/]*?" + domain + "/)(.*?)";
    
58.         urlPattern = "(http://[^/]*?" + domain +
    
59.             "/[^.]*?).(shtml|html|htm|shtm|php|asp#|asp|cgi|jsp|aspx)";
    
60. 
    
61.         pattern = Pattern.compile(urlDomaiPattern,
    
62.                 Pattern.CASE_INSENSITIVE + Pattern.DOTALL);
    
63.         patternPost = Pattern.compile(urlPattern,
    
64.                 Pattern.CASE_INSENSITIVE + Pattern.DOTALL);
    
65. 
    
66.         /**收集表单集合**/
    
67.         SplitManager splitManager = (SplitManager) ExtractLinkConsole.context.getBean(
    
68.                 "splitManager");
    
69.         urlEncode = dectedEncode(url);
    
70. 
    
71.         if (urlEncode == null) {
    
72.             return;
    
73.         }
    
74. 
    
75.         singContext(url);
    
76. 
    
77.         Iterator hi = htmlContext.iterator();
    
78. 
    
79.         if (htmlContext.size() == 0) {
    
80.             return;
    
81.         }
    
82. 
    
83.         totalNumber = htmlContext.size();
    
84. 
    
85.         //分析表单集合
    
86.         while (hi.hasNext()) {
    
87.             TableContext tc = (TableContext) hi.next();
    
88. 
    
89.             this.totalNumber = tc.getTableRow();
    
90. 
    
91.             if ((tc.getTableRow() == this.channelNumber) ||
    
92.                     (this.channelNumber == -1)) {
    
93.                 System.out.println("*********************表单" +
    
94.                     tc.getTableRow() + "****************");
    
95. 
    
96.                 List linkList = tc.getLinkList();
    
97. 
    
98.                 //如果没有任何连接
    
99.                 if ((linkList == null) || (linkList.size() == 0)) {
    
100.                     continue;
     
101.                 }
     
102. 
     
103.                 Iterator hl = linkList.iterator();
     
104. 
     
105.                 /**分析单个表单**/
     
106.                 while (hl.hasNext()) {
     
107.                     LinkTag lt = (LinkTag) hl.next();
     
108. 
     
109.                     //**过滤非法link*
     
110.                     if (isValidLink(lt.getLink()) == SpiderConstant.OUTDOMAINLINKTYPE) {
     
111.                         continue;
     
112.                     }
     
113. 
     
114.                     if (lt.getLinkText().length() < 8) {
     
115.                         continue;
     
116.                     }
     
117. 
     
118.                     /**过滤无效link**/
     
119.                     if (splitManager.isChannelLink(lt.getLinkText()) != SpiderConstant.COMMONCHANNEL) {
     
120.                         continue;
     
121.                     }
     
122. 
     
123.                     /**生成link的hashcode**/
     
124.                     System.out.println("URL:" + lt.getLinkText() + "   " +
     
125.                         lt.getLink());
     
126.                 }
     
127.             }
     
128.         }
     
129.     }
     
130. 
     
131.     /**
     
132.     *判断是否有效连接
     
133.     * @return
     
134.     */
     
135.     public int isValidLink(String link) {
     
136.         Matcher matcher = pattern.matcher(link);
     
137. 
     
138.         while (matcher.find()) {
     
139.             int start = matcher.start(2);
     
140.             int end = matcher.end(2);
     
141. 
     
142.             String postUrl = link.substring(end).trim();
     
143. 
     
144.             //如果是目录型连接
     
145.             if ((postUrl.length() == 0) || (postUrl.indexOf(".") < 0)) {
     
146.                 return SpiderConstant.CHANNELLINKTYPE;
     
147.             } else {
     
148.                 Matcher matcherPost = patternPost.matcher(link);
     
149. 
     
150.                 if (matcherPost.find()) {
     
151.                     return SpiderConstant.COMMONLINKTYPE;
     
152.                 } else {
     
153.                     return SpiderConstant.OUTDOMAINLINKTYPE;
     
154.                 }
     
155.             }
     
156.         }
     
157. 
     
158.         return SpiderConstant.OUTDOMAINLINKTYPE;
     
159.     }
     
160. 
     
161.     /**
     
162.      * 收集HTML页面信息
     
163.      * @param url
     
164.      * @param urlEncode
     
165.      */
     
166.     public void singContext(String url) {
     
167.         try {
     
168.             Parser parser = new Parser(url);
     
169.             parser.setEncoding(urlEncode);
     
170.             tableNumber = 0;
     
171. 
     
172.             for (NodeIterator e = parser.elements(); e.hasMoreNodes();) {
     
173.                 Node node = (Node) e.nextNode();
     
174. 
     
175.                 if (node instanceof Html) {
     
176.                     extractHtml(node);
     
177.                 }
     
178.             }
     
179.         } catch (Exception e) {
     
180.         }
     
181.     }
     
182. 
     
183.     /**
     
184.     * 递归钻取信息
     
185.     * @param nodeP
     
186.     * @return
     
187.     */
     
188.     public List extractHtml(Node nodeP) {
     
189.         NodeList nodeList = nodeP.getChildren();
     
190.         boolean bl = false;
     
191. 
     
192.         if ((nodeList == null) || (nodeList.size() == 0)) {
     
193.             return null;
     
194.         }
     
195. 
     
196.         if ((nodeP instanceof TableTag) || (nodeP instanceof Div)) {
     
197.             bl = true;
     
198.         }
     
199. 
     
200.         ArrayList tableList = new ArrayList();
     
201. 
     
202.         try {
     
203.             for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
     
204.                 Node node = (Node) e.nextNode();
     
205. 
     
206.                 if (node instanceof LinkTag) {
     
207.                     tableList.add(node);
     
208.                 } else if (node instanceof ScriptTag ||
     
209.                         node instanceof StyleTag || node instanceof SelectTag) {
     
210.                 } else if (node instanceof TextNode) {
     
211.                     if (node.getText().trim().length() > 0) {
     
212.                         tableList.add(node);
     
213.                     }
     
214.                 } else {
     
215.                     List tempList = extractHtml(node);
     
216. 
     
217.                     if ((tempList != null) && (tempList.size() > 0)) {
     
218.                         Iterator ti = tempList.iterator();
     
219. 
     
220.                         while (ti.hasNext()) {
     
221.                             tableList.add(ti.next());
     
222.                         }
     
223.                     }
     
224.                 }
     
225.             }
     
226.         } catch (Exception e) {
     
227.         }
     
228. 
     
229.         if ((tableList != null) && (tableList.size() > 0)) {
     
230.             if (bl) {
     
231.                 TableContext tc = new TableContext();
     
232.                 tc.setLinkList(new ArrayList());
     
233.                 tc.setTextBuffer(new StringBuffer());
     
234.                 tableNumber++;
     
235.                 tc.setTableRow(tableNumber);
     
236. 
     
237.                 Iterator ti = tableList.iterator();
     
238. 
     
239.                 while (ti.hasNext()) {
     
240.                     Node node = (Node) ti.next();
     
241. 
     
242.                     if (node instanceof LinkTag) {
     
243.                         tc.getLinkList().add(node);
     
244.                     } else {
     
245.                         tc.getTextBuffer()
     
246.                           .append(collapse(node.getText()
     
247.                                                .replaceAll(" ", "")));
     
248.                     }
     
249.                 }
     
250. 
     
251.                 htmlContext.add(tc);
     
252. 
     
253.                 return null;
     
254.             } else {
     
255.                 return tableList;
     
256.             }
     
257.         }
     
258. 
     
259.         return null;
     
260.     }
     
261. 
     
262.     /**
     
263.      * 去除无效字符
     
264.      * @param string
     
265.      * @return
     
266.      */
     
267.     protected String collapse(String string) {
     
268.         int chars;
     
269.         int length;
     
270.         int state;
     
271.         char character;
     
272.         StringBuffer buffer = new StringBuffer();
     
273.         chars = string.length();
     
274. 
     
275.         if (0 != chars) {
     
276.             length = buffer.length();
     
277.             state = ((0 == length) || (buffer.charAt(length - 1) == ' ') ||
     
278.                 ((NEWLINE_SIZE <= length) &&
     
279.                 buffer.substring(length - NEWLINE_SIZE, length).equals(NEWLINE)))
     
280.                 ? 0 : 1;
     
281. 
     
282.             for (int i = 0; i < chars; i++) {
     
283.                 character = string.charAt(i);
     
284. 
     
285.                 switch (character) {
     
286.                 case '\u0020':
     
287.                 case '\u0009':
     
288.                 case '\u000C':
     
289.                 case '\u200B':
     
290.                 case '\u00a0':
     
291.                 case '\r':
     
292.                 case '\n':
     
293. 
     
294.                     if (0 != state) {
     
295.                         state = 1;
     
296.                     }
     
297. 
     
298.                     break;
     
299. 
     
300.                 default:
     
301. 
     
302.                     if (1 == state) {
     
303.                         buffer.append(' ');
     
304.                     }
     
305. 
     
306.                     state = 2;
     
307.                     buffer.append(character);
     
308.                 }
     
309.             }
     
310.         }
     
311. 
     
312.         return buffer.toString();
     
313.     }
     
314. 
     
315.     /**
     
316.      * 检测字符级
     
317.      * @param url
     
318.      * @return
     
319.      */
     
320.     private String dectedEncode(String url) {
     
321.         String[] encodes = oriEncode.split(",");
     
322. 
     
323.         for (int i = 0; i < encodes.length; i++) {
     
324.             if (dectedCode(url, encodes[i])) {
     
325.                 return encodes[i];
     
326.             }
     
327.         }
     
328. 
     
329.         return null;
     
330.     }
     
331. 
     
332.     public boolean dectedCode(String url, String encode) {
     
333.         try {
     
334.             Parser parser = new Parser(url);
     
335.             parser.setEncoding(encode);
     
336. 
     
337.             for (NodeIterator e = parser.elements(); e.hasMoreNodes();) {
     
338.                 Node node = (Node) e.nextNode();
     
339. 
     
340.                 if (node instanceof Html) {
     
341.                     return true;
     
342.                 }
     
343.             }
     
344.         } catch (Exception e) {
     
345.         }
     
346. 
     
347.         return false;
     
348.     }
     
349. 
     
350.     public String getDomain() {
     
351.         return domain;
     
352.     }
     
353. 
     
354.     public void setDomain(String domain) {
     
355.         this.domain = domain;
     
356.     }
     
357. 
     
358.     public Pattern getPattern() {
     
359.         return pattern;
     
360.     }
     
361. 
     
362.     public void setPattern(Pattern pattern) {
     
363.         this.pattern = pattern;
     
364.     }
     
365. 
     
366.     public Pattern getPatternPost() {
     
367.         return patternPost;
     
368.     }
     
369. 
     
370.     public void setPatternPost(Pattern patternPost) {
     
371.         this.patternPost = patternPost;
     
372.     }
     
373. 
     
374.     public String getUrlDomaiPattern() {
     
375.         return urlDomaiPattern;
     
376.     }
     
377. 
     
378.     public void setUrlDomaiPattern(String urlDomaiPattern) {
     
379.         this.urlDomaiPattern = urlDomaiPattern;
     
380.     }
     
381. 
     
382.     public String getUrlPattern() {
     
383.         return urlPattern;
     
384.     }
     
385. 
     
386.     public void setUrlPattern(String urlPattern) {
     
387.         this.urlPattern = urlPattern;
     
388.     }
     
389. 
     
390.     public int getChannelNumber() {
     
391.         return channelNumber;
     
392.     }
     
393. 
     
394.     public void setChannelNumber(int channelNumber) {
     
395.         this.channelNumber = channelNumber;
     
396.     }
     
397. 
     
398.     public int getTotalNumber() {
     
399.         return totalNumber;
     
400.     }
     
401. 
     
402.     public void setTotalNumber(int totalNumber) {
     
403.         this.totalNumber = totalNumber;
     
404.     }
     
405. 
     
406.     public String getUrlEncode() {
     
407.         return urlEncode;
     
408.     }
     
409. 
     
410.     public void setUrlEncode(String urlEncode) {
     
411.         this.urlEncode = urlEncode;
     
412.     }
     
413. 
     
414.     public String getUrl() {
     
415.         return url;
     
416.     }
     
417. 
     
418.     public void setUrl(String url) {
     
419.         this.url = url;
     
420.     }
     
421. }
     

复制代码

[ 本帖最后由 sakulagi 于 2007-12-5 16:16 编辑 ]

南半球

很好，顶一个

domando

哈哈 同行 htmlparser 非常好用

tangchaodong

解析确实是最烦的事,
我想用模板来解析,
但发现制作模板是个非常痛苦的事,
之前都是自己写的,
正好试试用htmlparser来帮我做模板!

james.liu

改版很多的，，我们这里几万个。。。每天都有

南半球

那你也贡献一下吧

tangchaodong

解析这一块一直没有好的方法,所以代码就不帖了,和大家交流下我的想法吧,欢迎指正!

我想做一个解析是做定制的解析,
不只是提取页面上所有的A连接值什么的!

而是想按照一定的特征码来提取连接,文字....等,
例如:
提取具有一定特征码的 table 标签下 第2个height=300 的 tr  标签下的 第3个 width=20 的 td 的文本值,
而且有可能有多个具备特征码的 table.

所以解析的类大致上要支持:
1:根据主模板循环查找有特征码的节点(例如:得到table)
2:对得到的节点根据子模板进行子解析得到子节点(例如:得到tr)
3:对子节点可以实现再解析(例如:得到td)
如上3步通过递归调用多个模板可以实现,
思路好懂,
模板是难点,
要定位到有特征码的特定标签上是个及其困难的事,
因为主子模板间是存在依存关系的,
一错皆错,
精力都费在这上面,
感觉实用性就卡在这里了!

[ 本帖最后由 tangchaodong 于 2007-12-7 21:50 编辑 ]

ycl0165

分析的好啊:wink: :wink: :wink: :wink:

破碎细胞

用递归方式 对于抓取小信息量还好，但多了就会出问题的。

小弟我最近也做做相关的东西，也写了个spider，每天抓500万以上的网页没什么问题。

如果想抓取大量的信息，建议将线程控制独立到单独的调度器里面去实现，蜘蛛线程就负责自己的单独工作就可以了。
个人觉得这样做比较好，至少我是这样做的。

tangchaodong

恩,破碎细胞说的非常的对,
我也是这样做的,
我上面说的也只是这整个过程的其中关于解析的部分,
而且这对于编程来说也是个良好的习惯,
规划好各自要做的事,
多余的事让别的"同事"来做,
一个人都把事做完了,
别人不就只是摆设了吗?
显然你是老板你也不愿意看到这样的事情!

[ 本帖最后由 tangchaodong 于 2007-12-15 23:33 编辑 ]