HtmlparseUtil.java

类并不是一个通用的工具类，需要按自己的要求实现，这里只记录了Htmlparse.jar包的一些用法。仅此而已！ 
详细看这里：http://gundumw100.iteye.com/blog/704311

Java代码  

    1. import java.util.*;
    2. import org.htmlparser.Node;
    3. import org.htmlparser.NodeFilter;
    4. import org.htmlparser.Parser;
    5. import org.htmlparser.filters.AndFilter;
    6. import org.htmlparser.filters.HasAttributeFilter;
    7. import org.htmlparser.filters.NodeClassFilter;
    8. import org.htmlparser.filters.TagNameFilter;
    9. import org.htmlparser.tags.BodyTag;
    10. import org.htmlparser.tags.LinkTag;
    11. import org.htmlparser.util.NodeList;
    12. import org.htmlparser.util.ParserException;
    13. /**
    14. * httpclient与htmlparse对网页的解析
    15. *
    16. * @author Administrator
    17. *
    18. */
    19. public class HtmlparseUtil {
    20. WebHttpClient util=new WebHttpClient();
    21. /**
    22. * 获得网页中的超链接，将href和text保存在Map中：map(href,text)
    23. * @param url
    24. * @param charset
    25. * @return
    26. */
    27. public Map<String, String> linkGet(String url, String charset) {
    28. String content=util.getWebContentByGet(url,charset);
    29. Map<String, String> linkMap = new HashMap<String, String>();
    30. try {
    31. //开始解析
    32. Parser parser = Parser.createParser(content, charset);
    33. // 过滤出<a></a>标签
    34. NodeFilter linkFilter = new NodeClassFilter(LinkTag.class);
    35. NodeList list = parser.extractAllNodesThatMatch(linkFilter);
    36. Node node = null;
    37. for (int i = 0; i < list.size(); i++) {
    38. node = list.elementAt(i);
    39. // 获得网页中的链接map(href,text)
    40. linkMap.put(((LinkTag) node).getLink(), this.processText(((LinkTag) node).getLinkText()));
    41. }
    42. } catch (ParserException e) {
    43. e.printStackTrace();
    44. }
    45. return linkMap;
    46. }
    47. /**
    48. * 获得网页<body></body>标签中的内容， 保存在body中
    49. * @param url
    50. * @param charset
    51. * @return
    52. */
    53. public String bodyGet(String url, String charset) {
    54. String content=util.getWebContentByGet(url,charset);
    55. String body = "";
    56. try {
    57. Parser parser = Parser.createParser(content, charset);
    58. // 过滤<body></body>标签
    59. NodeFilter bodyFilter = new NodeClassFilter(BodyTag.class);
    60. NodeList list = parser.extractAllNodesThatMatch(bodyFilter);
    61. Node node = null;
    62. for (int i = 0; i < list.size(); i++) {
    63. node = list.elementAt(i);
    64. // 获得网页内容 保存在content中
    65. body = ((BodyTag) node).getBody();
    66. }
    67. } catch (ParserException e) {
    68. e.printStackTrace();
    69. }
    70. return body;
    71. }
    72. /**
    73. * 过滤出class为term的<span>元素,并获得他们的文本
    74. * @param url
    75. * @param charset
    76. * @return
    77. */
    78. public Map<String,String> termGet(String url, String charset) {
    79. String content=util.getWebContentByGet(url,charset);
    80. Map<String, String> map = new HashMap<String, String>();
    81. try {
    82. //开始解析
    83. // 过滤出class为term的<span>元素
    84. Parser parser = Parser.createParser(content, charset);
    85. AndFilter filter =
    86. new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","term"));
    87. Node node = null;
    88. NodeList nodeList = parser.parse(filter);
    89. for (int i = 0; i < nodeList.size(); i++) {
    90. node = nodeList.elementAt(i);
    91. map.put("term", node.toPlainTextString());
    92. }
    93. // 过滤出class为start-time的<span>元素
    94. Parser parser2 = Parser.createParser(content, charset);
    95. AndFilter filter2 =
    96. new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","start-time"));
    97. NodeList nodeList2 = parser2.parse(filter2);
    98. for (int i = 0; i < nodeList2.size(); i++) {
    99. node = nodeList2.elementAt(i);
    100. map.put("start-time", node.toPlainTextString());
    101. }
    102. // 过滤出id为J_SingleEndTimeLabel的<span>元素
    103. Parser parser3 = Parser.createParser(content, charset);
    104. AndFilter filter3 =
    105. new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("id","J_SingleEndTimeLabel"));
    106. NodeList nodeList3 = parser3.parse(filter3);
    107. for (int i = 0; i < nodeList3.size(); i++) {
    108. node = nodeList3.elementAt(i);
    109. map.put("end-time", node.toPlainTextString());
    110. }
    111. // 过滤出class为box post的<div>元素
    112. Parser parser4 = Parser.createParser(content, charset);
    113. AndFilter filter4 =
    114. new AndFilter(new TagNameFilter("div"),new HasAttributeFilter("class","box post"));
    115. NodeList nodeList4 = parser4.parse(filter4);
    116. for (int i = 0; i < nodeList4.size(); i++) {
    117. node = nodeList4.elementAt(i);
    118. String temp=node.toPlainTextString().trim();
    119. temp=temp.substring(10,20).trim();
    120. map.put("pre-term", temp);
    121. }
    122. // 过滤出class为J_AwardNumber的<span>元素
    123. Parser parser5 = Parser.createParser(content, charset);
    124. //          AndFilter filter5 =
    125. //                new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","J_AwardNumber"));
    126. NodeList nodeList5 = parser5.parse(new HasAttributeFilter("class","J_AwardNumber"));
    127. StringBuffer buffer=new StringBuffer();
    128. for (int i = 0; i < nodeList5.size(); i++) {
    129. node = nodeList5.elementAt(i);
    130. buffer.append(","+node.toPlainTextString());
    131. }
    132. buffer.append("|");
    133. // 过滤出class为blue J_AwardNumber的<span>元素
    134. Parser parser6 = Parser.createParser(content, charset);
    135. //          AndFilter filter6 =
    136. //                new AndFilter(new TagNameFilter("span"),new HasAttributeFilter("class","blue J_AwardNumber"));
    137. NodeList nodeList6 = parser6.parse(new HasAttributeFilter("class","blue J_AwardNumber"));
    138. for (int i = 0; i < nodeList6.size(); i++) {
    139. node = nodeList6.elementAt(i);
    140. buffer.append(node.toPlainTextString()+",");
    141. }
    142. map.put("numbers", buffer.toString());
    143. } catch (ParserException e) {
    144. // TODO Auto-generated catch block
    145. e.printStackTrace();
    146. }
    147. return map;
    148. }
    149. private String processText(String content){
    150. content=content.trim().replaceAll("&nbsp;", "");
    151. //      content=content.replaceAll("<p>", "\n");
    152. //      content=content.replaceAll("</TD>", "");
    153. //      content=content.replaceAll("</div>", "");
    154. //      content=content.replaceAll("</a>", "");
    155. //      content=content.replaceAll("<a href=.*>", "");
    156. return content;
    157. }
    158. public static void main(String[] str) {
    159. String url="http://caipiao.taobao.com/lottery/order/lottery_dlt.htm?type=1";
    160. HtmlparseUtil util=new HtmlparseUtil();
    161. Map<String,String> map=util.termGet(url, "gb2312");
    162. System.out.println("term="+map.get("term"));//<span class="term">第<em>10074</em>期</span>
    163. System.out.println("start-time="+map.get("start-time"));//
    164. System.out.println("end-time="+map.get("end-time"));//
    165. System.out.println("pre-term="+map.get("pre-term"));//
    166. System.out.println("numbers="+map.get("numbers"));//
    167. /*
    168. Map<String, String> linkMap = util.linkGet(url, "gb2312");
    169. for (String s : linkMap.keySet()) {
    170. System.out.println(s + " = " + linkMap.get(s));
    171. //如果是个链接，则再获取它的<body>中的内容
    172. //          if (s.startsWith("http")) {
    173. //              util.bodyGet(s, "gb2312");
    174. //          }
    175. }
    176. */
    177. }
    178. }
时间： 2024-11-05 23:22:26

HtmlparseUtil.java的相关文章

HtmlParseUtil

package com.hszc.commons.utils; import java.net.HttpURLConnection; import java.net.URL; import org.apache.log4j.Logger; import org.htmlparser.Node; import org.htmlparser.Parser; import org.htmlparser.util.NodeIterator; /** * 解析HTML * @author admin *

Java多线程学习（吐血超详细总结）

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 目录(?)[-] 一扩展javalangThread类 二实现javalangRunnable接口 三Thread和Runnable的区别 四线程状态转换 五线程调度 六常用函数说明 使用方式 为什么要用join方法 七常见线程名词解释 八线程同步 九线程数据传递 本文主要讲了java中多线程的使用方法.线程同步.线程数据传递.线程状态及相应的一些线程函数用法.概述等. 首先讲一下进程和线程

Java TM 已被阻止，因为它已过时需要更新的解决方法

公司的堡垒机需要通过浏览器登陆,且该堡垒机的网站需要Java的支持,最近通过浏览器登陆之后总是提示"java TM 已被阻止,因为它已过时需要更新的解决方法"导致登陆之后不能操作, 但是操作系统中确实已经安装了比较新的JDK,安装的JDK版本是jdk-7u67-windows-i586,因为太烦人,所以决定搞清楚报错的原因,一劳永逸,彻底解决这个问题 准备工作:安装JDK,安装版本jdk-7u67-windows-i586.exe,因为机器的Eclipse还依赖64位的JDK,所以另安

Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor

介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗? Java new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 1 2 3 4 5 6 7 new Thread(new

由@NotNull 注解引出的关于Java空指针的控制(转)

Java 小技巧和在java应用避免NullPonintException的最佳方法 在java应用程序中,一个NullPonintException(空指针异常)是最好解决(问题)的方法.同时,空指针也是写健壮的顺畅运行的代码的关键.“预防好过治疗”这句话也同样适用于令人不爽的NullPonintException.通过应用防御性的编码技术和在遵守多个部分之间的约定,你可以再很大程度上避免NullPointException.下面的这些java小技巧可以最小化像!=null这种检查的代码.作为

Java注解(2)-注解处理器(运行时|RetentionPolicy.RUNTIME)

如果没有用来读取注解的工具,那注解将基本没有任何作用,它也不会比注释更有用.读取注解的工具叫作注解处理器.Java提供了两种方式来处理注解:第一种是利用运行时反射机制:另一种是使用Java提供的API来处理编译期的注解. 反射机制方式的注解处理器 仅当定义的注解的@Retention为RUNTIME时,才能够通过运行时的反射机制来处理注解.下面结合例子来说明这种方式的处理方法. Java中的反射API(如java.lang.Class.java.lang.reflect.Field等)都实现了接

jvm系列(一):java类的加载机制

java类的加载机制 原文:http://www.cnblogs.com/ityouknow/p/5603287.html 1.什么是类的加载 类的加载指的是将类的.class文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区内,然后在堆区创建一个java.lang.Class对象,用来封装类在方法区内的数据结构.类的加载的最终产品是位于堆区中的Class对象,Class对象封装了类在方法区内的数据结构,并且向Java程序员提供了访问方法区内的数据结构的接口. 类加载器并不需要等到某个

Java注解(1)-注解基础

注解(Annotation)是在JAVA5中开始引入的,它为在代码中添加信息提供了一种新的方式.注解在一定程度上把元数据与源代码文件结合在一起,正如许多成熟的框架(Spring)所做的那样.那么,注解到底可以做什么呢? 1.注解的作用. 提供用来完整地描述程序所需要的信息,如编译期校验程序信息. 生成描述符文件,或生成新类的定义. 减轻编写"样板"代码(配置文件)的负担,可以使用注解自动生成. 更加干净易读的代码. 编译期类型检查. 2.Java提供的注解 Java5内置了一些原生的注

异常笔记--java编程思想

开一个新的系列,主要记一些琐碎的重要的知识点,把书读薄才是目的...特点: 代码少,概念多... 1. 基本概念 异常是在当前环境下无法获得必要的信息来解决这个问题,所以就需要从当前环境跳出,就是抛出异常.抛出异常后发生的几件事: 1.在堆上创建异常对象. 2.当前的执行路径中止                                          3. 当前环境抛出异常对象的引用.                                         4. 异常处理机制接