java验证一个xml是否存在语法错误

下文笔者讲述使用原生态的java代码验证一个xml文件是否语法错误的方法分享

xml的简介

XML(Extensible Markup Language):
   可扩展标记语言
    是一种简单的数据存储语言
    采用一系列简单的标记对结构化数据进行描述
XML语言的特点
   XML与操作系统,编程语言的开发平台无关
   规范统一,实现不同系统之间的数据交互
   XML技术应用广泛
    我们以前常见的网站配置，都是采用xml进行配置
	如:web.xml

XML使用场景

 1.数据存储:
     XML与文件
     数据可一样
     都可以实现数据的持久化存储
   XML及其简单，正是这点使XML与众不同。
 
 2.数据交换:
     在实际运用中,
	  由于各种计算机所使用的操作系统,
	   数据库不同,
	   因此数据之间的交换很复杂
	   现在可以使用XML来 交换数据
          如可以将数据库A中的数据转换成标准的XML文件
           然后数据库B再将标准的XML文件转换成合适自己的数据要求的数据
		   以达到交换数据的目的。
 
 3.数据配置
    许多应用都将配置信息存储在XML文件中

XML使用场景

<?xml version="1.0” encoding="UTF-8" ?>
<books>
    <book>
        <title>猫猫传记</title>
        <author>adeal</author>
        <description>讲述猫的故事</description>
    </book>
    <book>
        <title>java爱好者传</title>
        <author>Java265</author>
        <description>是市面上最好的java教程</description>
    </book>
</books> 

验证xml正确性的方法

实现思路:
    直接使用DocumentBuilder对xml进行转换
	 如果转换成功,则代表是符合条件的xml文件
	 否则不是有效的xml文件

例:
验证xml正确性

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;

public class XmlValidateUtils {
	
	private static final DocumentBuilderFactory FACTORY = DocumentBuilderFactory.newInstance();
	
	/**
	 * 验证xml文档是否存在语法错误
	 * @param xmlInputStream
	 * @return true 通过校验， false xml有语法错误或未通过校验
	 * @throws ParserConfigurationException 严重的配置错误
	 */
	public static boolean isValid(InputStream xmlInputStream) throws ParserConfigurationException {
	    return isValid(xmlInputStream, (ErrorHandler) null);
	}
	
	/**
	 * 验证xml文档是否存在语法错误
	 * @param xml
	 * @return true 通过校验， false xml有语法错误或未通过校验
	 * @throws ParserConfigurationException 严重的配置错误
	 * @throws IOException 字符串转输入流错误
	 */
	public static boolean isValid(String xml) throws ParserConfigurationException, IOException {
	    return isValid(xml, (ErrorHandler) null);
	}
	
	/**
	 * 验证xml文档是否存在语法错误
	 * @param xmlInputStream
	 * @param errorHandler xml文档warning、error、fatalError的回调接口
	 * @return true 由errorHandler的方法实现决定，false xml校验未通过
	 * @throws ParserConfigurationException 严重的配置错误
	 */
	public static boolean isValid(InputStream xmlInputStream, ErrorHandler errorHandler) throws ParserConfigurationException {
		DocumentBuilder builder = FACTORY.newDocumentBuilder();
		if (errorHandler != null) {
			builder.setErrorHandler(errorHandler);
		}
		try {
			builder.parse(xmlInputStream);
			return true;
		} catch (Exception e) {
			return false;
		}
	}
	
	/**
	 * 验证xml文档是否存在语法错误
	 * @param xml
	 * @param errorHandler xml文档warning、error、fatalError的回调接口
	 * @return true 由errorHandler的方法实现决定，false xml校验未通过
	 * @throws ParserConfigurationException 严重的配置错误
	 * @throws IOException 字符串转输入流错误
	 */
	public static boolean isValid(String xml, ErrorHandler errorHandler) throws ParserConfigurationException, IOException {
		try (
				ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xml.getBytes());
				) {
			return isValid(xmlInputStream, errorHandler);
		}
	}
}

errorHandler:
   是自定义异常处理类 
如:
  自定义XmlErrorHandler类
  当xml严重错误时执行fatalError方法
  当xml内容不符合xsd规则时执行error方法
  此时未抛出异常
  而是将异常对象SAXParseException加入到对应的 list
  由private static boolean isValid(InputStream xmlInputStream) throws ParserConfigurationException
  方法捕获
  返回false表示xml存在语法错误
  当不存在语法错误时,不执行error方法和fatalError方法
  不抛出SAXParseException异常,返回true

package com.sun.org.apache.xerces.internal.jaxp.validation;

import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

/**
 * {@link ErrorHandler} that throws all errors and fatal errors.
 *
 * @author Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com)
 */
final class DraconianErrorHandler implements ErrorHandler {

    /**
     * Singleton instance.
     */
    private static final DraconianErrorHandler ERROR_HANDLER_INSTANCE
        = new DraconianErrorHandler();

    private DraconianErrorHandler() {}

    /** Returns the one and only instance of this error handler. */
    public static DraconianErrorHandler getInstance() {
        return ERROR_HANDLER_INSTANCE;
    }

    /** Warning: Ignore. */
    public void warning(SAXParseException e) throws SAXException {
        // noop
    }

    /** Error: Throws back SAXParseException. */
    public void error(SAXParseException e) throws SAXException {
        throw e;
    }

    /** Fatal Error: Throws back SAXParseException. */
    public void fatalError(SAXParseException e) throws SAXException {
        throw e;
    }

}

例:

import java.util.ArrayList;
import java.util.List;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
public class XmlErrorHandler implements ErrorHandler {
	private List<SAXParseException> warningExceptions;
	private List<SAXParseException> errorExceptions;
	private List<SAXParseException> fatalErrorExceptions;

    public XmlErrorHandler() {
        this.warningExceptions = new ArrayList<>();
        this.errorExceptions = new ArrayList<>();
        this.fatalErrorExceptions = new ArrayList<>();
    }

    public List<SAXParseException> getWarningExceptions() {
		return warningExceptions;
	}

	public List<SAXParseException> getErrorExceptions() {
		return errorExceptions;
	}

	public List<SAXParseException> getFatalErrorExceptions() {
		return fatalErrorExceptions;
	}

	@Override
    public void warning(SAXParseException exception) {
		warningExceptions.add(exception);
    }

    @Override
    public void error(SAXParseException exception) {
    	errorExceptions.add(exception);
    }

    @Override
    public void fatalError(SAXParseException exception) {
    	fatalErrorExceptions.add(exception);
    }
}

例:
使用JDK默认errorHandler

public static void main(String[] args) throws SAXException, IOException, ParserConfigurationException {
	String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\r\n"
			+ "<individual>\r\n"
			+ "    <name>test</name>\r\n"
			+ "    <address>\r\n"
			+ "        <zip>868868</zip>\r\n"
			+ "        <city>test <Success</city>\r\n"
			+ "    </address>\r\n"
			+ "</individual>";
	
	boolean valid1 = isValid(xml);
	System.out.println(valid1);
}

使用自定义errorHandler处理xml异常

/**
 * 验证xml文档是否存在语法错误
 * @param xml
 * @throws RuntimeException 校验程序出错
 * @throws IllegalArgumentException 校验未通过
 */
public static void validate(String xml) {
	XmlErrorHandler errorHandler = new XmlErrorHandler();
	try {
		boolean valid = isValid(xml, errorHandler);
		if (!valid) {
			if (!errorHandler.getFatalErrorExceptions().isEmpty()) {
				throw new IllegalArgumentException("xml：" + xml + "语法错误", errorHandler.getFatalErrorExceptions().get(0));
			}
			throw new RuntimeException("校验程序出错");
		}
	} catch (IllegalArgumentException e) {
		throw e;
	} catch (Exception e) {
		throw new RuntimeException("校验程序出错", e);
	}
	if (!errorHandler.getErrorExceptions().isEmpty()) {
		throw new IllegalArgumentException("xml：" + xml + "校验未通过", errorHandler.getErrorExceptions().get(0));
	}
}

public static void main(String[] args) throws SAXException, IOException, ParserConfigurationException {
	String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\r\n"
			+ "<individual>\r\n"
			+ "    <name>java265</name>\r\n"
			+ "    <address>\r\n"
			+ "        <zip>886868</zip>\r\n"
			+ "        <city>Test</city>\r\n"
			+ "    </address>\r\n"
			+ "</individual>";
	
	validate(xml);
}