java - Java で 2 つの XML ドキュメントを比較する最良の方法

Question

基本的にカスタム メッセージ形式を XML メッセージに変換し、それを相手に送信するアプリケーションの自動テストを作成しようとしています。入力メッセージと出力メッセージの適切なペアが揃っているので、入力メッセージを送信して、XML メッセージが送信されるのをリッスンするだけで済みます。

実際の出力を期待される出力と比較するときが来ると、いくつかの問題が発生します。私が最初に考えたのは、予想されるメッセージと実際のメッセージの文字列を比較することだけでした。サンプル データは常に一貫してフォーマットされているとは限らず、XML 名前空間に異なるエイリアスが使用されることがよくあります (名前空間がまったく使用されない場合もあります)。

両方の文字列を解析し、各要素を調べて自分で比較できることはわかっていますが、これはそれほど難しくありませんが、もっと良い方法や活用できるライブラリがあると感じています。

要するに、問題は次のとおりです。

どちらも有効な XML を含む 2 つの Java String が与えられた場合、それらが意味的に同等であるかどうかをどのように判断しますか? 違いが何であるかを判断する方法があれば、ボーナスポイント。

Answer 1

XMLUnit の仕事のように聞こえます

• http://www.xmlunit.org/
• https://github.com/xmlunit

例：

public class SomeTest extends XMLTestCase {
  @Test
  public void test() {
    String xml1 = ...
    String xml2 = ...

    XMLUnit.setIgnoreWhitespace(true); // ignore whitespace differences

    // can also compare xml Documents, InputSources, Readers, Diffs
    assertXMLEqual(xml1, xml2);  // assertXMLEquals comes from XMLTestCase
  }
}

Answer 2

以下では、標準のJDKライブラリを使用してドキュメントが等しいかどうかを確認します。

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance（）;
dbf.setNamespaceAware（true）;
dbf.setCoalescing（true）;
dbf.setIgnoringElementContentWhitespace（true）;
dbf.setIgnoringComments（true）;
DocumentBuilder db = dbf.newDocumentBuilder（）;

ドキュメントdoc1=db.parse（new File（ "file1.xml"））;
doc1.normalizeDocument（）;

ドキュメントdoc2=db.parse（new File（ "file2.xml"））;
doc2.normalizeDocument（）;

Assert.assertTrue（doc1.isEqualNode（doc2））;

normalize（）は、サイクルがないことを確認するためにあります（技術的にはありません）

上記のコードでは、要素内の空白が同じである必要があります。これは、空白を保持して評価するためです。Javaに付属している標準のXMLパーサーでは、正規バージョンを提供する機能を設定したりxml:space、それが問題になるかどうかを理解したりすることはできません。xercesなどの代替XMLパーサーが必要になるか、JDOMを使用する必要があります。

Answer 3

Xomには、DOM を通常の形式に変換する Canonicalizer ユーティリティがあり、これを文字列化して比較できます。そのため、空白の不規則性や属性の順序に関係なく、ドキュメントの定期的で予測可能な比較を取得できます。

これは、Eclipse などの専用のビジュアル文字列コンパレータを備えた IDE で特にうまく機能します。ドキュメント間のセマンティックの違いを視覚的に表現できます。

Answer 4

XMLUnitの最新バージョンは、2 つの XML が等しいと主張する作業を支援します。またXMLUnit.setIgnoreWhitespace()、XMLUnit.setIgnoreAttributeOrder()場合によっては必要になる場合もございます。

以下の XML Unit 使用の簡単な例の作業コードを参照してください。

import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Assert;

public class TestXml {

    public static void main(String[] args) throws Exception {
        String result = "<abc             attr=\"value1\"                title=\"something\">            </abc>";
        // will be ok
        assertXMLEquals("<abc attr=\"value1\" title=\"something\"></abc>", result);
    }

    public static void assertXMLEquals(String expectedXML, String actualXML) throws Exception {
        XMLUnit.setIgnoreWhitespace(true);
        XMLUnit.setIgnoreAttributeOrder(true);

        DetailedDiff diff = new DetailedDiff(XMLUnit.compareXML(expectedXML, actualXML));

        List<?> allDifferences = diff.getAllDifferences();
        Assert.assertEquals("Differences found: "+ diff.toString(), 0, allDifferences.size());
    }

}

Maven を使用している場合は、これを に追加しますpom.xml。

<dependency>
    <groupId>xmlunit</groupId>
    <artifactId>xmlunit</artifactId>
    <version>1.4</version>
</dependency>

Answer 5

おかげで、私はこれを拡張しました、これを試してください...

import java.io.ByteArrayInputStream;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

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

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class XmlDiff 
{
    private boolean nodeTypeDiff = true;
    private boolean nodeValueDiff = true;

    public boolean diff( String xml1, String xml2, List<String> diffs ) throws Exception
    {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        dbf.setCoalescing(true);
        dbf.setIgnoringElementContentWhitespace(true);
        dbf.setIgnoringComments(true);
        DocumentBuilder db = dbf.newDocumentBuilder();


        Document doc1 = db.parse(new ByteArrayInputStream(xml1.getBytes()));
        Document doc2 = db.parse(new ByteArrayInputStream(xml2.getBytes()));

        doc1.normalizeDocument();
        doc2.normalizeDocument();

        return diff( doc1, doc2, diffs );

    }

    /**
     * Diff 2 nodes and put the diffs in the list 
     */
    public boolean diff( Node node1, Node node2, List<String> diffs ) throws Exception
    {
        if( diffNodeExists( node1, node2, diffs ) )
        {
            return true;
        }

        if( nodeTypeDiff )
        {
            diffNodeType(node1, node2, diffs );
        }

        if( nodeValueDiff )
        {
            diffNodeValue(node1, node2, diffs );
        }


        System.out.println(node1.getNodeName() + "/" + node2.getNodeName());

        diffAttributes( node1, node2, diffs );
        diffNodes( node1, node2, diffs );

        return diffs.size() > 0;
    }

    /**
     * Diff the nodes
     */
    public boolean diffNodes( Node node1, Node node2, List<String> diffs ) throws Exception
    {
        //Sort by Name
        Map<String,Node> children1 = new LinkedHashMap<String,Node>();      
        for( Node child1 = node1.getFirstChild(); child1 != null; child1 = child1.getNextSibling() )
        {
            children1.put( child1.getNodeName(), child1 );
        }

        //Sort by Name
        Map<String,Node> children2 = new LinkedHashMap<String,Node>();      
        for( Node child2 = node2.getFirstChild(); child2!= null; child2 = child2.getNextSibling() )
        {
            children2.put( child2.getNodeName(), child2 );
        }

        //Diff all the children1
        for( Node child1 : children1.values() )
        {
            Node child2 = children2.remove( child1.getNodeName() );
            diff( child1, child2, diffs );
        }

        //Diff all the children2 left over
        for( Node child2 : children2.values() )
        {
            Node child1 = children1.get( child2.getNodeName() );
            diff( child1, child2, diffs );
        }

        return diffs.size() > 0;
    }


    /**
     * Diff the nodes
     */
    public boolean diffAttributes( Node node1, Node node2, List<String> diffs ) throws Exception
    {        
        //Sort by Name
        NamedNodeMap nodeMap1 = node1.getAttributes();
        Map<String,Node> attributes1 = new LinkedHashMap<String,Node>();        
        for( int index = 0; nodeMap1 != null && index < nodeMap1.getLength(); index++ )
        {
            attributes1.put( nodeMap1.item(index).getNodeName(), nodeMap1.item(index) );
        }

        //Sort by Name
        NamedNodeMap nodeMap2 = node2.getAttributes();
        Map<String,Node> attributes2 = new LinkedHashMap<String,Node>();        
        for( int index = 0; nodeMap2 != null && index < nodeMap2.getLength(); index++ )
        {
            attributes2.put( nodeMap2.item(index).getNodeName(), nodeMap2.item(index) );

        }

        //Diff all the attributes1
        for( Node attribute1 : attributes1.values() )
        {
            Node attribute2 = attributes2.remove( attribute1.getNodeName() );
            diff( attribute1, attribute2, diffs );
        }

        //Diff all the attributes2 left over
        for( Node attribute2 : attributes2.values() )
        {
            Node attribute1 = attributes1.get( attribute2.getNodeName() );
            diff( attribute1, attribute2, diffs );
        }

        return diffs.size() > 0;
    }
    /**
     * Check that the nodes exist
     */
    public boolean diffNodeExists( Node node1, Node node2, List<String> diffs ) throws Exception
    {
        if( node1 == null && node2 == null )
        {
            diffs.add( getPath(node2) + ":node " + node1 + "!=" + node2 + "\n" );
            return true;
        }

        if( node1 == null && node2 != null )
        {
            diffs.add( getPath(node2) + ":node " + node1 + "!=" + node2.getNodeName() );
            return true;
        }

        if( node1 != null && node2 == null )
        {
            diffs.add( getPath(node1) + ":node " + node1.getNodeName() + "!=" + node2 );
            return true;
        }

        return false;
    }

    /**
     * Diff the Node Type
     */
    public boolean diffNodeType( Node node1, Node node2, List<String> diffs ) throws Exception
    {       
        if( node1.getNodeType() != node2.getNodeType() ) 
        {
            diffs.add( getPath(node1) + ":type " + node1.getNodeType() + "!=" + node2.getNodeType() );
            return true;
        }

        return false;
    }

    /**
     * Diff the Node Value
     */
    public boolean diffNodeValue( Node node1, Node node2, List<String> diffs ) throws Exception
    {       
        if( node1.getNodeValue() == null && node2.getNodeValue() == null )
        {
            return false;
        }

        if( node1.getNodeValue() == null && node2.getNodeValue() != null )
        {
            diffs.add( getPath(node1) + ":type " + node1 + "!=" + node2.getNodeValue() );
            return true;
        }

        if( node1.getNodeValue() != null && node2.getNodeValue() == null )
        {
            diffs.add( getPath(node1) + ":type " + node1.getNodeValue() + "!=" + node2 );
            return true;
        }

        if( !node1.getNodeValue().equals( node2.getNodeValue() ) )
        {
            diffs.add( getPath(node1) + ":type " + node1.getNodeValue() + "!=" + node2.getNodeValue() );
            return true;
        }

        return false;
    }


    /**
     * Get the node path
     */
    public String getPath( Node node )
    {
        StringBuilder path = new StringBuilder();

        do
        {           
            path.insert(0, node.getNodeName() );
            path.insert( 0, "/" );
        }
        while( ( node = node.getParentNode() ) != null );

        return path.toString();
    }
}

Answer 6

AssertJ 1.4+ には、XML コンテンツを比較するための特定のアサーションがあります。

String expectedXml = "<foo />";
String actualXml = "<bar />";
assertThat(actualXml).isXmlEqualTo(expectedXml);

ドキュメントはこちら

Answer 7

XML ファイルを構造的に比較するオプションを持つAltova DiffDogを使用しています (文字列データを無視します)。

これは、(「テキストを無視」オプションをチェックしている場合):

<foo a="xxx" b="xxx">xxx</foo>

と

<foo b="yyy" a="yyy">yyy</foo> 

構造的に等しいという意味で等しい。これは、データは異なるが構造が異なるサンプル ファイルがある場合に便利です。

Answer 8

スカフマンは良い答えを出しているようです。

もう 1 つの方法は、xmlstarlet ( http://xmlstar.sourceforge.net/ ) などのコマンド ライン ユーティリティを使用して XML をフォーマットし、両方の文字列をフォーマットしてから、任意の diff ユーティリティ (ライブラリ) を使用して結果の出力ファイルを比較することです。問題が名前空間にある場合、これが良い解決策であるかどうかはわかりません。

Answer 9

主な質問で要求されたのと同じ機能が必要でした。サードパーティのライブラリを使用することは許可されていなかったため、@Archimedes Trajano ソリューションに基づいて独自のソリューションを作成しました。

以下は私の解決策です。

import java.io.ByteArrayInputStream;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.junit.Assert;
import org.w3c.dom.Document;

/**
 * Asserts for asserting XML strings.
 */
public final class AssertXml {

    private AssertXml() {
    }

    private static Pattern NAMESPACE_PATTERN = Pattern.compile("xmlns:(ns\\d+)=\"(.*?)\"");

    /**
     * Asserts that two XML are of identical content (namespace aliases are ignored).
     * 
     * @param expectedXml expected XML
     * @param actualXml actual XML
     * @throws Exception thrown if XML parsing fails
     */
    public static void assertEqualXmls(String expectedXml, String actualXml) throws Exception {
        // Find all namespace mappings
        Map<String, String> fullnamespace2newAlias = new HashMap<String, String>();
        generateNewAliasesForNamespacesFromXml(expectedXml, fullnamespace2newAlias);
        generateNewAliasesForNamespacesFromXml(actualXml, fullnamespace2newAlias);

        for (Entry<String, String> entry : fullnamespace2newAlias.entrySet()) {
            String newAlias = entry.getValue();
            String namespace = entry.getKey();
            Pattern nsReplacePattern = Pattern.compile("xmlns:(ns\\d+)=\"" + namespace + "\"");
            expectedXml = transletaNamespaceAliasesToNewAlias(expectedXml, newAlias, nsReplacePattern);
            actualXml = transletaNamespaceAliasesToNewAlias(actualXml, newAlias, nsReplacePattern);
        }

        // nomralize namespaces accoring to given mapping

        DocumentBuilder db = initDocumentParserFactory();

        Document expectedDocuemnt = db.parse(new ByteArrayInputStream(expectedXml.getBytes(Charset.forName("UTF-8"))));
        expectedDocuemnt.normalizeDocument();

        Document actualDocument = db.parse(new ByteArrayInputStream(actualXml.getBytes(Charset.forName("UTF-8"))));
        actualDocument.normalizeDocument();

        if (!expectedDocuemnt.isEqualNode(actualDocument)) {
            Assert.assertEquals(expectedXml, actualXml); //just to better visualize the diffeences i.e. in eclipse
        }
    }


    private static DocumentBuilder initDocumentParserFactory() throws ParserConfigurationException {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(false);
        dbf.setCoalescing(true);
        dbf.setIgnoringElementContentWhitespace(true);
        dbf.setIgnoringComments(true);
        DocumentBuilder db = dbf.newDocumentBuilder();
        return db;
    }

    private static String transletaNamespaceAliasesToNewAlias(String xml, String newAlias, Pattern namespacePattern) {
        Matcher nsMatcherExp = namespacePattern.matcher(xml);
        if (nsMatcherExp.find()) {
            xml = xml.replaceAll(nsMatcherExp.group(1) + "[:]", newAlias + ":");
            xml = xml.replaceAll(nsMatcherExp.group(1) + "=", newAlias + "=");
        }
        return xml;
    }

    private static void generateNewAliasesForNamespacesFromXml(String xml, Map<String, String> fullnamespace2newAlias) {
        Matcher nsMatcher = NAMESPACE_PATTERN.matcher(xml);
        while (nsMatcher.find()) {
            if (!fullnamespace2newAlias.containsKey(nsMatcher.group(2))) {
                fullnamespace2newAlias.put(nsMatcher.group(2), "nsTr" + (fullnamespace2newAlias.size() + 1));
            }
        }
    }

}

2 つの XML 文字列を比較し、両方の入力文字列でそれらを一意の値に変換することで、一致しない名前空間マッピングを処理します。

名前空間の変換の場合など、微調整できます。しかし、私の要件では、仕事をするだけです。

Answer 10

JExamXML を Java アプリケーションで使用する

    import com.a7soft.examxml.ExamXML;
    import com.a7soft.examxml.Options;

       .................

       // Reads two XML files into two strings
       String s1 = readFile("orders1.xml");
       String s2 = readFile("orders.xml");

       // Loads options saved in a property file
       Options.loadOptions("options");

       // Compares two Strings representing XML entities
       System.out.println( ExamXML.compareXMLString( s1, s2 ) );

Answer 11

「意味的に同等」と言うので、xml出力が（文字列）等しいことを文字通り検証するだけでなく、次のようなものが必要であることを意味していると思います

<foo>ここに何か</foo></code>

と

<foo>ここに何か</foo></code>

同等のものとして読んでください。最終的には、メッセージを再構成するオブジェクトが何であれ、「意味的に同等」をどのように定義するかが重要になります。メッセージからそのオブジェクトを構築し、カスタム equals() を使用して探しているものを定義するだけです。