用正则表达式解析XML

import java.util.regex.*;  
import java.util.*;  
/** 
 * 
 * <p>Title: Document</p> 
 * 
 * <p>Description: 用正则表达式解析xml,目的是为了提高性能.</p> 
 * 
 * <p>Copyright: Copyright (c) 2005</p> 
 * 
 * <p>Company: org.axman</p> 
 * 
 * @author :Axman 
 * @version 1.0 
 */  
public class Document {  
  private String xmlString;  
  /** 
   * 传入xml的字符串内容,对于InputStream,Reader对象请转换为String对象后传入构造方法. 
   * @param xmlString String 
   * @throws IllegalArgumentException 
   */  
  public Document(String xmlString) throws IllegalArgumentException{  
    if(xmlString == null || xmlString.length() == 0)  
      throw new IllegalArgumentException("Input string orrer!");  
    this.xmlString = xmlString;  
  }  
  
  /** 
   * 在文档中搜索指定的元素,返回符合条件的元素数组. 
   * @param tagName String 
   * @return String[] 
   */  
  public String[] getElementsByTag(String tagName){  
    Pattern p = Pattern.compile("<"+tagName+"[^>]*?((>.*?</"+tagName+">)|(/>))");  
    Matcher m = p.matcher(this.xmlString);  
    ArrayList<String> al = new ArrayList<String>();  
    while(m.find())  
      al.add(m.group());  
    String[] arr = al.toArray(new String[al.size()]);  
    al.clear();  
    return arr;  
  }  
  
  /** 
   * 用xpath模式提取元素,以#为分隔符 
   * 如 ROOT#PARENT#CHILD表示提取ROOT元素下的PARENT元素下的CHILD元素 
   * @param singlePath String 
   * @return String 
   */  
  public String getElementBySinglePath(String singlePath){  
    String[] path = singlePath.split("#");  
    String lastTag = path[path.length-1];  
    String tmp = "(<"+lastTag+"[^>]*?((>.*?</"+lastTag+">)|(/>)))";  
                                        //最后一个元素,可能是<x>v</x>形式或<x/>形式  
    for(int i=path.length-2;i >=0;i--){  
      lastTag = path[i];  
      tmp = "<"+lastTag+">.*"+tmp + ".*</"+lastTag+">";  
    }  
    Pattern p = Pattern.compile(tmp);  
    Matcher m = p.matcher(this.xmlString);  
    if(m.find()){  
      return m.group(1);  
    }  
    return "";  
  }  
  /** 
   * 用xpath模式提取元素从多重元素中获取指批定元素,以#为分隔符 
   * 元素后无索引序号则默认为0: ROOT#PARENT[2]#CHILD[1] 
   * @param singlePath String 
   * @return String 
   */  
  public String getElementByMultiPath(String singlePath){  
    try{  
      String[] path = singlePath.split("#");  
      String input = this.xmlString;  
      String[] ele = null;  
      for (int i = 0; i < path.length; i++) {  
        Pattern p = Pattern.compile("(//w+)(//[(//d+)//])?");  
        Matcher m = p.matcher(path[i]);  
        if (m.find()) {  
          String tagName = m.group(1);  
          System.out.println(input + "----" + tagName);  
          int index = (m.group(3) == null) ? 0 :  
              new Integer(m.group(3)).intValue();  
          ele = getElementsByTag(input, tagName);  
          input = ele[index];  
        }  
      }  
      return input;  
    }catch(Exception e){  
      return null;  
    }  
  }  
  /** 
   * 在给定的元素中搜索指定的元素,返回符合条件的元素数组.对于不同级别的同名元素限制作用,即可以 
   * 搜索元素A中的子元素C.而对于元素B中子元素C则过虑,通过多级限定可以准确定位. 
   * @param parentElementString String 
   * @param tagName String 
   * @return String[] 
   */  
  public static String[] getElementsByTag(String parentElementString,String tagName){  
    Pattern p = Pattern.compile("<"+tagName+"[^>]*?((>.*?</"+tagName+">)|(/>))");  
    Matcher m = p.matcher(parentElementString);  
    ArrayList<String> al = new ArrayList<String>();  
    while(m.find())  
      al.add(m.group());  
    String[] arr = al.toArray(new String[al.size()]);  
    al.clear();  
    return arr;  
  }  
  /** 
   * 从指定的父元素中根据xpath模式获取子元素,singlePath以#为分隔符 
   * 如 ROOT#PARENT#CHILD表示提取ROOT元素下的PARENT元素下的CHILD元素 
   * @param parentElementString String 
   * @param singlePath String 
   * @return String 
   */  
  public static String getElementBySinglePath(String parentElementString,String singlePath){  
    String[] path = singlePath.split("#");  
    String lastTag = path[path.length-1];  
    String tmp = "(<"+lastTag+"[^>]*?((>.*?</"+lastTag+">)|(/>)))";  
                                        //最后一个元素,可能是<x>v</x>形式或<x/>形式  
    for(int i=path.length-2;i >=0;i--){  
      lastTag = path[i];  
      tmp = "<"+lastTag+">.*"+tmp + ".*</"+lastTag+">";  
    }  
    Pattern p = Pattern.compile(tmp);  
    Matcher m = p.matcher(parentElementString);  
    if(m.find()){  
      return m.group(1);  
    }  
    return "";  
  }  
  /** 
   * 用xpath模式提取元素从指定的多重元素中获取指批定元素,以#为分隔符 
   * @param parentElementString String 
   * @param singlePath String 
   * @return String 
   */  
  public static String getElementByMultiPath(String parentElementString,String singlePath){  
    try{  
      String[] path = singlePath.split("#");  
      String input = parentElementString;  
      String[] ele = null;  
      for (int i = 0; i < path.length; i++) {  
        Pattern p = Pattern.compile("(//w+)(//[(//d+)//])?");  
        Matcher m = p.matcher(path[i]);  
        if (m.find()) {  
          String tagName = m.group(1);  
          int index = (m.group(3) == null) ? 0 :  
              new Integer(m.group(3)).intValue();  
          ele = getElementsByTag(input, tagName);  
          input = ele[index];  
        }  
      }  
      return input;  
    }catch(Exception e){  
      return null;  
    }  
  }  
  
  /** 
   * 在给定的元素中获取所有属性的集合.该元素应该从getElementsByTag方法中获取 
   * @param elementString String 
   * @return HashMap 
   */  
  public HashMap<String,String> getAttributes(String elementString){  
    HashMap hm = new HashMap<String,String>();  
    Pattern p = Pattern.compile("<[^>]+>");  
    Matcher m = p.matcher(elementString);  
    String tmp = m.find()?m.group():"";  
    p = Pattern.compile("(//w+)//s*=//s*/"([^/"]+)/"");  
    m = p.matcher(tmp);  
    while(m.find()){  
      hm.put(m.group(1).trim(),m.group(2).trim());  
    }  
    return hm;  
  }  
  
  /** 
   * 在给定的元素中获取指定属性的值.该元素应该从getElementsByTag方法中获取 
   * @param elementString String 
   * @param attributeName String 
   * @return String 
   */  
  public static String getAttribute(String elementString,String attributeName){  
    HashMap hm = new HashMap<String,String>();  
    Pattern p = Pattern.compile("<[^>]+>");  
    Matcher m = p.matcher(elementString);  
    String tmp = m.find()?m.group():"";  
    p = Pattern.compile("(//w+)//s*=//s*/"([^/"]+)/"");  
    m = p.matcher(tmp);  
    while(m.find()){  
      if(m.group(1).trim().equals(attributeName))  
        return m.group(2).trim();  
    }  
    return "";  
  }  
  
  /** 
   * 获取指定元素的文本内容 
   * @param elementString String 
   * @return String 
   */  
  public static String getElementText(String elementString){  
    Pattern p = Pattern.compile(">([^<>]*)<");  
    Matcher m = p.matcher(elementString);  
    if(m.find()){  
      return m.group(1);  
    }  
    return "";  
  }  
  public static void main(String[] args){  
    new Document("<ROOT>sss <PARENT>sss <CHILD>aaaa</CHILD>ss </PARENT>sss </ROOT>").getElementByMultiPath("ROOT[0]#PARENT#CHILD");  
    //System.out.println(child);  
  }  
}