Java中的xml文件怎么利用正则表达式进行解析

这篇文章将为大家详细讲解有关Java中的xml文件怎么利用正则表达式进行解析，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。

创新互联建站坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都做网站、网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的商洛网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

一、编写Node类

Node对象是文档解析的基础，最终可以通过对象的不同属性实现对文档信息的访问。

Node.java：

import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class Node implements Serializable {
  // 可以对Node对象持久化保存
  private static final long serialVersionUID = 1L;
  private int id;
  // 节点类型
  private String title;
  // 节点内容
  private String text;
  // 节点属性集合
  private Map attributes = new HashMap();
  // 子节点集合
  private List childNodes = new LinkedList();
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getTitle() {
    return title;
  }
  public void setTitle(String title) {
    this.title = title;
  }
  public Map getAttribute() {
    return attributes;
  }
  public void setAttribute(Map attribute) {
    this.attributes = attribute;
  }
  public String getText() {
    return text;
  }
  public void setText(String text) {
    this.text = text;
  }
  public List getChildNode() {
    return childNodes;
  }
  public void setChildNode(List childNode) {
    this.childNodes = childNode;
  }
  // 将属性集合转换成一条完整的字符串
  private String attrToString() {
    if (attributes.isEmpty()) {
      return "";
    }
    Iterator> its = attributes.entrySet().iterator();
    StringBuffer buff = new StringBuffer();
    while (its.hasNext()) {
      Entry entry = its.next();
      buff.append(entry.getKey() + "=\"" + entry.getValue() + "\" ");
    }
    return " " + buff.toString().trim();
  }
  // 输出完整的节点字符串也用到了递归
  @Override
  public String toString() {
    String attr = attrToString();
    if (childNodes.isEmpty() && text == null) {
      return "<" + title + attr + "/>\n";
    } else if (childNodes.isEmpty() && text != null) {
      return "<" + title + attr + ">\n" + text + "\n" + "\n";
    } else {
      StringBuffer buff = new StringBuffer();
      buff.append("<" + title + attr + ">\n");
      if (!text.isEmpty()) {
        buff.append(text + "\n");
      }
      for (Node n : childNodes) {
        buff.append(n.toString());
      }
      buff.append("\n");
      return buff.toString();
    }
  }
}

二、创建接口

把文档的读取和分析抽象成接口方便今后替换实现。

过滤器：读取文档的字符流并删除注释的部分。这些信息通常是提供给人阅读的，程序分析直接忽略。

XmlFilter.java：

/*
 * 过滤器的作用是删除xml文件中不重要的部分。
 * 通常都是一些注释性文字，不需要被机器解析。
 */
public interface XmlFilter {
  String filter();
  // 提供自定义正则表达式，识别符合过滤条件的字符串
  String filter(String[] regex);
}

解析器：将一个父节点解析成多条子节点的字符串。如果返回值为null，代表当前节点下不存在可以继续解析的对象。

XmlParser.java：

import java.util.List;
/*
 * 解析器可以对一段完整的父节点字符串提供解析服务。
 * 将一条父节点的字符串解析成为多条子节点字符串
 */
public interface XmlParser {
  // 解析一段父节点，返回子节点字符串
  List parser(String str);
}

三、根据接口编写实现类

回车、换行、制表符以及各种注释部分的内容都被删除，简化字符输出。

SimpleXmlFilter.java：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class SimpleXmlFilter implements XmlFilter {
  private String text;
  // 常用的过滤正则表达式
  public final static String[] REG = { "\t", "<\\?.*?\\?>", "", "<%.*?%>", "\\s{2,}" };
  // 读取xml文档返回字符串
  public SimpleXmlFilter(File file) throws IOException {
    BufferedReader in = new BufferedReader(new FileReader(file));
    StringBuffer buff = new StringBuffer();
    String temp = null;
    while ((temp = in.readLine()) != null) {
      buff.append(temp);
    }
    in.close();
    text = buff.toString().trim();
  }
  @Override
  public String filter() {
    return filter(REG);
  }
  @Override
  public String filter(String[] regex) {
    String result = text;
    for (String reg : regex) {
      result = result.replaceAll(reg, "");
    }
    return result;
  }
}

主要是通过正则表达式区分一个节点内部的子节点，考虑到节点的类型我将它们分为自闭合与非自闭合两种类型。这样的节点属于自闭合类型，它们不包含子节点和text属性，它们属于文档树的叶子节点。<title attributes ...>text ...这样的节点属于非自闭合类型，它们属于文档树的分支节点。

SimpleXmlParser.java：

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SimpleXmlParser implements XmlParser {
  @Override
  public List parser(String text) {
    List childrenDocs = new ArrayList();
    // 捕获根节点中间的文本
    Pattern p = Pattern.compile("<.*?>(.*)");
    Matcher m = p.matcher(text);
    if (m.matches()) {
      String inner = m.group(1);
      // 匹配节点字符串
      p = Pattern.compile("<(.*?)>");
      m = p.matcher(inner);
      while (m.find()) {
        String s1 = m.group(1);
        // 如果节点以/结尾，代表此节点不包含子节点
        if (s1.endsWith("/")) {
          childrenDocs.add(m.group());
          // 如果节点既不以/开头，也不以/结尾则表示需要查找对应的闭合节点
        } else if (!s1.startsWith("/") && !s1.endsWith("/")) {
          // 计算起始字符数
          int start = m.end() - m.group().length();
          // 如果捕获到未闭合节点则index++，如果捕获到闭合节点则index--
          int index = 1;
          while (m.find()) {
            String s2 = m.group(1);
            if (!s2.startsWith("/") && !s2.endsWith("/")) {
              index++;
            } else if (s2.startsWith("/")) {
              index--;
            }
            // 找到符合条件的闭合节点则循环终止
            if (index == 0) {
              break;
            }
          }
          // 计算结束字符数
          int end = m.end();
          // 截取对应字符串
          childrenDocs.add(inner.substring(start, end));
        }
      }
    }
    return childrenDocs;
  }
}

四、编写NodeBuilder类

根据过滤器和解析器获取Node节点各属性的值。

NodeBuilder.java：

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
// 生成Node
public class NodeBuilder {
  private Node root = new Node();
  private XmlParser parser;
  private XmlFilter filter;
  // 提供合适的过滤器和解析器
  public NodeBuilder(XmlParser parser, XmlFilter filter) {
    this.parser = parser;
    this.filter = filter;
  }
  public Node getRoot(String... regex) {
    String str = null;
    if (regex.length == 0) {
      str = filter.filter();
    } else {
      str = filter.filter(regex);
    }
    buildNodeTree(str, root);
    return root;
  }
  // 设置节点类型
  private void buildNodeTitle(String str, Node n) {
    Pattern p = Pattern.compile("<.*?>");
    Matcher m = p.matcher(str);
    if (m.find()) {
      String temp = m.group();
      String s = temp.substring(1, temp.length() - 1).split(" ")[0];
      if (s.endsWith("/")) {
        n.setTitle(s.substring(0, s.length() - 1));
      } else {
        n.setTitle(s.split(" ")[0]);
      }
    }
  }
  // 设置节点属性集合
  private void buildNodeAttribute(String str, Node n) {
    Pattern p = Pattern.compile("<.*?>");
    Matcher m = p.matcher(str);
    if (m.find()) {
      String temp = m.group();
      String s = temp.substring(1, temp.length() - 1);
      // 匹配字符串
      p = Pattern.compile("(\\S*)=\"(.*?)\"");
      m = p.matcher(s);
      while (m.find()) {
        String key = m.group(1).trim();
        String value = m.group(2).trim();
        n.getAttribute().put(key, value);
      }
      // 匹配数字
      p = Pattern.compile("(\\S*)=(-?\\d+(\\.\\d+)?)");
      m = p.matcher(s);
      while (m.find()) {
        String key = m.group(1).trim();
        String value = m.group(2).trim();
        n.getAttribute().put(key, value);
      }
    }
  }
  // 设置节点内容,节点的内容是删除了所有子节点字符串以后剩下的部分
  private void buildNodeText(String str, Node n) {
    Pattern p = Pattern.compile("<.*?>(.*)");
    Matcher m = p.matcher(str);
    List childrenDocs = parser.parser(str);
    if (m.find()) {
      String temp = m.group(1);
      for (String s : childrenDocs) {
        temp = temp.replaceAll(s, "");
      }
      n.setText(temp.trim());
    }
  }
  // 通过递归生成完整节点树
  private void buildNodeTree(String str, Node n) {
    buildNodeTitle(str, n);
    buildNodeAttribute(str, n);
    buildNodeText(str, n);
    // 如果存在子节点则继续下面的操作
    if (!parser.parser(str).isEmpty()) {
      // 对每一个子节点都应该继续调用直到递归结束
      for (String temp : parser.parser(str)) {
        Node child = new Node();
        buildNodeTitle(temp, child);
        buildNodeAttribute(temp, child);
        buildNodeText(temp, child);
        n.getChildNode().add(child);
        buildNodeTree(temp, child);
      }
    }
  }
}

五、测试

编写xml测试文件

测试文件：


  
  package message before!
  
  
    
      class message inner.
    
  
  package message middle!
  
  
    
      
      
      
      
        method message inner!
      
    
  
  package message after!

编写测试类

Demo.java：

import java.io.File;
import java.io.IOException;
public class Demo {
  public static void main(String[] args) {
    File f = new File("xxx");
    XmlFilter filter = null;
    try {
      filter = new SimpleXmlFilter(f);
    } catch (IOException e) {
      e.printStackTrace();
    }
    XmlParser parser = new SimpleXmlParser();
    NodeBuilder builder = new NodeBuilder(parser, filter);
    Node node = builder.getRoot();
    System.out.println(node);
  }
}

输出：


package message before!package message middle!package message after!



class message inner.






method message inner!

关于Java中的xml文件怎么利用正则表达式进行解析就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。

网页题目：Java中的xml文件怎么利用正则表达式进行解析
文章源于：http://kswjz.com/article/gcphch.html

扫二维码与项目经理沟通

我们在微信上24小时期待你的声音

解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流

Java中的xml文件怎么利用正则表达式进行解析

扫二维码与项目经理沟通

其他资讯

行业动态

企业网站建设的重要性！

服务项目

网站建设

移动端/APP

微信/小程序

技术支持

其它服务

更多服务项目

联系吧在百度地图上找到我们

电话：13518219792

Java中的xml文件怎么利用正则表达式进行解析

扫二维码与项目经理沟通

其他资讯

行业动态

企业网站建设的重要性！

服务项目

网站建设

移动端/APP

微信/小程序

技术支持

其它服务

更多服务项目

联系吧 在百度地图上找到我们

电话：13518219792

联系吧在百度地图上找到我们