htmlparser 工具类

package whu.util.tools;

import java.util.LinkedHashSet;
import java.util.Stack;

import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.PrototypicalNodeFactory;
import org.htmlparser.filters.AndFilter;
import org.htmlparser.filters.HasAttributeFilter;
import org.htmlparser.filters.TagNameFilter;
import org.htmlparser.http.ConnectionManager;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;

import whu.common.Global;
import whu.util.tags.FontTag;


public class FindTag {

	/**
	 * 通过给定的初始节点集合和指定的匹配tag序列，依次遍历初始节点集合的每一个元素，从每一个初始节点中过滤出相应的唯一一个节点，并把所有的返回数组
	 * @param sourceList
	 * @param sequence
	 * @return根据我们要求而过滤得出的节点
	 */
	public static Node[] getTargetNodeArray(NodeList sourceList,String[] sequence){
		if(sourceList==null||sourceList.size()==0)
		{
			return null;
		}
		else
		{
			Node[] roots = sourceList.toNodeArray();
			int cNum = roots.length;
			LinkedHashSet found = new LinkedHashSet();
			for (int i = 0; i < cNum; i++) {
				Node newNode = findNode(roots[i], sequence);
				if(newNode!=null)
					found.add(newNode);
			}
			return (Node[])found.toArray(new Node[found.size()]);

		}
	}

	/**
	 * 通过给定的初始节点集合和指定的匹配tag序列，依次遍历初始节点集合的每一个元素，从中过滤出相应的所有节点，并把所有的返回数组
	 * @param sourceList
	 * @param sequence
	 * @return根据我们要求而过滤得出的节点
	 */
	public static Node[] getAllTargetNodeArray(NodeList sourceList,String[] sequence){
		if(sourceList==null||sourceList.size()==0)
		{
			return null;
		}
		else
		{
			Node[] roots = sourceList.toNodeArray();
			int cNum = roots.length;
			LinkedHashSet found = new LinkedHashSet();
			for (int i = 0; i < cNum; i++) {
				Node[] newNodes = findNodes(roots[i], sequence);
				if(newNodes!=null&&newNodes.length!=0)
					for(Node n:newNodes)
						found.add(n);
			}
			return (Node[])found.toArray(new Node[found.size()]);

		}
	}

	/**
	 * 通过给定的一个初始节点和指定的匹配tag序列，依次遍历初始节点的孩子集合的每一个元素，从中过滤出相应的唯一一个节点，并返回该节点
	 * @param sourceList
	 * @param sequence
	 * @return根据我们要求而过滤得出的节点
	 */
	public static Node getTargetNode(Node sourceNode,String[] sequence){
		if(sourceNode!=null)
		{
		 	//System.out.println(" sourceNode not null------ ");
			Node newNode = findNode(sourceNode, sequence);
			if(newNode!=null)
				return newNode;
			else
			{
			 	//System.out.println("result Node null ------ ");
				return null;
			}
		}
		else
		{
			//System.out.println(" sourceNode null------ ");
			return null;
		}
	}

	/**
	 * 通过给定的一个初始节点和指定的匹配tag序列，找出初始节点的子节点中符合要求的所有节点，并把所有的那些相似节点以数组的形式返回
	 * @param sourceList
	 * @param sequence
	 * @return根据我们要求而过滤得出的节点
	 */
	public static Node[] getSimilarNodeArray(Node sourceNode,String[] sequence){
		if(sourceNode!=null)
		{
			Node[] similarNodes = findNodes(sourceNode,sequence);
			return similarNodes;
		}
		else
			return null;
	}

	/**
	 * 通过给定的一个节点，按匹配序列进行查找，返回符合条件的唯一一个节点
	 * @param source
	 * @param sequence
	 * @return
	 */
	public static Node findNode(Node source, String[] sequence) {
	    Stack curNode = new Stack();
	    curNode.push(source);
	    return matchTags(curNode, sequence);
	}

	/**
	 * 通过给定的一个节点，按匹配序列进行查找，返回符合条件的所有相似节点
	 * @param source
	 * @param sequence
	 * @return
	 */
	public static Node[] findNodes(Node source, String[] sequence) {
	    Stack curNode = new Stack();
	    curNode.push(source);
	    return matchTags(curNode, sequence,true);
	}

	public static final int FIND_SUB = 0; // 找子节点
	public static final int FIND_SIB = 1; // 找同级节点
	public static final int FIND_END = 2; // 结束

	/**
	 * 本方法必须要求每个初始根节点必须有children。该方法返回符合条件的唯一一个节点
	 * @param curNode
	 * @param sequence
	 * @return
	 */
	public static Node matchTags(Stack curNode, String[] sequence) {
		int state = FIND_SUB; // 开始
		int i=0;  //记录匹配的tag序号
		int depth = sequence.length;  //记录查找的深度
		int[] index = new int[depth];  //记录每级匹配的序列索引，即那一级的所有孩子的序列号
	    while (state != FIND_END) {
	          Node cNode = (Node) curNode.pop(); // 当前节点
	          if (state == FIND_SUB) { // 查找子节点
	        	  if(i<depth)
	        	  {
	        		  //下面这一步的getChildren可能会报错
	        		  NodeList cList = cNode.getChildren();
	        		  if(cList!=null)
	        		  {
	        			  Node[] subNodes = cNode.getChildren().extractAllNodesThatMatch(new TagNameFilter(sequence[i])).toNodeArray(); 
	        			  if (subNodes == null || subNodes.length == 0) { // 没有子节点
	  	            			curNode.push(cNode);
	  	            			state = FIND_SIB; // 下一次需要找同级节点
	        			  }
	        			  else
	        			  {

	        				  curNode.push(cNode);
	        				  curNode.push(subNodes[0]);
	        				  index[i]=0;//第i级的当前测试节点索引为0
	        				  i++;
	        				  state = FIND_SUB;
	        			  } 
	        		  }
	        		  else
	        		  {
	        			  curNode.push(cNode);
	            		state = FIND_SIB; // 下一次需要找同级节点
	        		  }

	        	  }
	        	  else if(i==depth)//说明已经匹配到设定的深度了，可以取出该节点了
	        		  return cNode;        		  
	          }
	          else if (state == FIND_SIB) { // 查找同级节点
	        	  if (curNode.isEmpty()) {
	        		  state = FIND_END; // 已经没有可以找的了，需要退出查找过程，反之栈里面一定含有父节点，所以i>0
	        	  }
	        	  else {
	        		  Node parentNode = (Node) curNode.peek();
	        		  Node[] sibNodes = parentNode.getChildren().extractAllNodesThatMatch(new TagNameFilter(sequence[i-1])).toNodeArray();
	        		  int sibNum = sibNodes.length;
	        		  if(index[i-1]+1<sibNum){ //存在下一个同级节点
	        			  curNode.push(sibNodes[index[i-1] + 1]);
	        			  index[i-1]+=1;
    					  state = FIND_SUB; // 需要查找子节点
	        		  }
	        		  else{ // 这就是最后一个同级节点,故要返回上一级
	        			  state = FIND_SIB;
	        			  index[i-1]=0; //第i级匹配索引重设为0
    					  i--;
	        		  }
	            }
	          }
	        }    
	        return null;
	 	}

	/**
	 * 本方法必须要求初始根节点必须有children。该方法返回符合条件的一批相似节点
	 * @param curNode
	 * @param sequence
	 * @param similar 为true标识是查找一个相似的序列
	 * @return
	 */
	public static Node[] matchTags(Stack curNode, String[] sequence,Boolean similar) {
		int state = FIND_SUB; // 开始
		int i=0;  //记录匹配的tag序号
		int depth = sequence.length;  //记录查找的深度
		int[] index = new int[depth];  //记录每级匹配的序列索引，即那一级的所有孩子的序列号
		LinkedHashSet found = new LinkedHashSet(); //记录查出符合要求的节点数组
		if(true==similar)
		{
			while (state != FIND_END) {
				Node cNode = (Node) curNode.pop(); // 当前节点
				if (state == FIND_SUB) { // 查找子节点
					if(i<depth-1)
					{
						//下面这一步的getChildren可能会报错，不过又可能不会报错，因为我压进栈的节点都是在那一级符合我的要求的节点，就肯定是有子节点的，除非到了匹配的最后一级最后
						NodeList cList = cNode.getChildren();
						if(cList!=null)
						{
							Node[] subNodes = cList.extractAllNodesThatMatch(new TagNameFilter(sequence[i])).toNodeArray(); 
							if (subNodes == null || subNodes.length == 0) { // 没有子节点
								curNode.push(cNode);
								state = FIND_SIB; // 下一次需要找同级节点
							}
							else
							{
								curNode.push(cNode);
	  	            	  		curNode.push(subNodes[0]);
	  	            	  		index[i]=0;//第i级的当前测试节点索引为0
	  	            	  		i++;//进入下一级
	  	            	  		state = FIND_SUB;
							}
						}
						else
						{
							curNode.push(cNode);
	  	            		state = FIND_SIB; // 下一次需要找同级节点
						}
					}
					else if(i==depth-1)
					{
						NodeList cList = cNode.getChildren();
						if(cList!=null)
						{
							Node[] subNodes = cList.extractAllNodesThatMatch(new TagNameFilter(sequence[i])).toNodeArray(); 
							if (subNodes != null && subNodes.length != 0) { // 有子节点，由于是最后一级，故全部采集
								for(int j=0;j<subNodes.length;j++)
	        					  found.add(subNodes[j]);
							}
						}
						curNode.push(cNode);
						state = FIND_SIB; // 下一次需要找同级节点

	        	  }
	          }
	          else if (state == FIND_SIB) { // 查找同级节点
	        	  if (curNode.isEmpty()) {
	        		  state = FIND_END; // 已经没有可以找的了，需要退出查找过程，反之栈里面一定含有父节点，所以i>0
	        	  }
	        	  else {
	        		  Node parentNode = (Node) curNode.peek();
	        		  Node[] sibNodes = parentNode.getChildren().extractAllNodesThatMatch(new TagNameFilter(sequence[i-1])).toNodeArray();
	        		  int sibNum = sibNodes.length;
	        		  if(index[i-1]+1<sibNum){ //存在下一个同级节点
	        			  curNode.push(sibNodes[index[i-1] + 1]);
	        			  index[i-1]+=1;
    					  state = FIND_SUB; // 需要查找子节点
	        		  }
	        		  else{ // 这就是最后一个同级节点,故要返回上一级
	        			  state = FIND_SIB;
	        			  index[i-1]=0; //第i级匹配索引重设为0
    					  i--;
	        		  }
	            }
	          }
	        }
			return (Node[])found.toArray(new Node[found.size()]);
		}
		return null;
	}


	/**
	 * 根据给定的节点名字、标签属性、标签值提取出符合条件的所有tag节点
	 * @param url
	 * @param tagName
	 * @param attributeName
	 * @param attributeValue
	 * @return符合条件的List
	 */
	public static NodeList getNodeList(String url,String tagName,String attributeName,String attributeValue)
	{
		ConnectionManager manager;
        manager = org.htmlparser.lexer.Page.getConnectionManager();
        Parser parser;
        try 
        {

            parser = new Parser(manager.openConnection(url));
            parser.setEncoding(Global.PAGE_ENCODING);

            //下面的节点注册一定要放在最前面，才能把指定节点的所有孩子节点都按我们的要求解析（有些自定义标签必须能够解析）
            //注册新的结点解析器，其实我觉得在htmlparser的源码里面可以直接编写新的节点类，然后重新编译
    		PrototypicalNodeFactory factory = new PrototypicalNodeFactory ();
    		factory.registerTag(new FontTag());
    		parser.setNodeFactory(factory);

    		NodeFilter filterAttribute = new HasAttributeFilter(attributeName,attributeValue);
            NodeFilter filterTag = new TagNameFilter(tagName);
            NodeFilter andFilter = new AndFilter(filterAttribute, filterTag);

            return parser.parse(andFilter);//如果没有对应的节点，则会返回size=0的NodeList
        }
        catch(ParserException e)
        {
        	e.printStackTrace();
        	return null;
        }
	}

	/**
	 * 根据给定的节点名字提取出符合条件的所有tag节点
	 * @param url
	 * @return符合条件的List
	 */
	public static NodeList getNodeList(String url,String tagName)
	{
		ConnectionManager manager;
        manager = org.htmlparser.lexer.Page.getConnectionManager();
        Parser parser;
        try 
        {

            parser = new Parser(manager.openConnection(url));
            parser.setEncoding(Global.PAGE_ENCODING);

            //下面的节点注册一定要放在最前面，才能把指定节点的所有孩子节点都按我们的要求解析（有些自定义标签必须能够解析）
            //注册新的结点解析器，其实我觉得在htmlparser的源码里面可以直接编写新的节点类，然后重新编译
    		PrototypicalNodeFactory factory = new PrototypicalNodeFactory ();
    		factory.registerTag(new FontTag());
    		parser.setNodeFactory(factory);

            NodeFilter filterTag = new TagNameFilter(tagName); 
            return parser.parse(filterTag);//如果没有对应的节点，则会返回size=0的NodeList
        }
        catch(ParserException e )
        {
        	e.printStackTrace();
        	return null;
        }
	}
}

自定义的标签，某些不常用的标签htmlparser并不支持，需要自己拓展，比如EM 、 FONT等

package whu.util.tags;

import org.htmlparser.tags.CompositeTag;

public class FontTag extends CompositeTag{
	private static final String[] mIds = new String[] {"FONT"};

    public String[] getIds (){
        return (mIds);
    }
    public String[] getEnders (){
        return (mIds);
    }
}