Wie kann ich eine HTML-org.w3c.dom.Dokument?

Scheinen Sie zwei explizite Anforderungen:

1. Sie benötigen zum darstellen von HTML als org.w3c.dom.Document.
2. Müssen Sie Document#getElementsByTagName(String tagname) für den Betrieb in einer case-insensitive Weise.

Wenn Sie versuchen, die Arbeit mit HTML org.w3c.dom.Document, dann nehme ich an, Sie arbeiten mit irgendeiner Version von XHTML. Weil eine XML-API wie DOM, noch zu erwarten, dass wohlgeformtes XML. HTML ist nicht unbedingt wohlgeformtes XML, aber XHTML ist wohlgeformtes XML. Auch wenn Sie die Arbeit mit HTML, würden Sie haben zu tun, einige vor-Verarbeitung, um sicherzustellen, es ist well-formed XML, bevor Sie versuchen, führen Sie es durch einen XML-parser. Vielleicht ist es einfach einfacher zu Parsen der HTML-zunächst mit einem HTML-parser, wie jsoup, und dann bauen Sie Ihre org.w3c.dom.Document zu Fuß durch den HTML-parser produziert, Baum (org.jsoup.nodes.Document im Fall von jsoup).

Es ist ein org.w3c.dom.html-Code.HTMLDocument - Schnittstelle, die sich org.w3c.dom.Document. Die einzige Implementierung, die ich fand, war in Xerces-j (2.11.0) in form von org.apache.html-Code.dom.HTMLDocumentImpl. Am Anfang scheint vielversprechend, doch bei näherer Untersuchung finden wir, dass es einige Probleme.

1. Es ist nicht eine klare, "saubere" Weg, um eine Instanz eines Objekts der Umsetzung der org.w3c.dom.html.HTMLDocument - Schnittstelle.

Mit Xerces würden wir normalerweise erhalten Sie eine Document Objekt mit einem DocumentBuilder in der folgenden Weise:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.newDocument();
//or doc = builder.parse(xmlFile) if parsing from a file

Oder mit einem DOMImplementation Vielfalt:

DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance();
DOMImplementationLS impl = (DOMImplementationLS)registry.getDOMImplementation("LS");
LSParser lsParser = impl.createLSParser(DOMImplementationLS.MODE_SYNCHRONOUS, null);
Document document = lsParser.parseURI("myFile.xml");

In beiden Fällen sind wir rein mit org.w3c.dom.* Schnittstellen zu erhalten, die DocumentObjekt.

Nächste Variante fand ich für HTMLDocument war so etwas wie dieses:

HTMLDOMImplementation htmlDocImpl = HTMLDOMImplementationImpl.getHTMLDOMImplementation();
HTMLDocument htmlDoc = htmlDocImpl.createHTMLDocument("My Title");

Dies erfordert von uns direkt instanziieren interne Implementierung der Klassen ist, dass uns die Umsetzung abhängig von Xerces.

(Anmerkung: ich sah auch Xerces hatte auch eine interne HTMLBuilder (die setzt das veraltet DocumentHandler), die angeblich generiert ein HTMLDocument using a SAX parser, but I didn't bother looking into it.)

2. org.w3c.dom.html.HTMLDocument generiert keine korrekten XHTML.

Obwohl, können Sie suchen, die HTMLDocument Baum mit getElementsByTagName(String tagname) in einer case-insensitive Weise, die alle den Namen der Elemente werden intern gespeichert in ALLE CAPS. Aber XHTML-Elemente und Attribut-Namen sind eigentlich in alle Kleinbuchstaben. (Dies könnte umgangen werden, indem Sie zu Fuß das gesamte Dokument Baum und mit Document's renameNode() Methode zu ändern, das element, das die Namen in Kleinbuchstaben um.)

Außerdem ein XHTML-Dokument sollte an einem geeigneten DOCTYPE-Deklaration und xmlns-Deklaration für den XHTML-Namensraum . Es scheint nicht, eine einfache Möglichkeit, um diese in einem HTMLDocument (es sei denn, Sie tun etwas Gefummel mit internen Xerces-Implementierungen).

3. org.w3c.dom.html.HTMLDocument hat wenig Dokumentation und Xerces-Implementierung der Schnittstelle scheint unvollständig.

Ich nicht durchforsten das gesamte Internet, sondern nur die Unterlagen, die ich gefunden für HTMLDocument wurde die zuvor im Zusammenhang mit JavaDocs und Kommentare in den source-code der Xerces internen Umsetzung. In den Kommentaren fand ich auch Hinweise, dass verschiedene Teile der Schnittstelle nicht implementiert. (Sidenote: ich habe wirklich den Eindruck, dass die org.w3c.dom.html.HTMLDocument Schnittstelle selbst ist nicht wirklich von jedem genutzt und vielleicht ist selbst unvollständig.)

Aus diesen Gründen, ich denke, es ist besser, zu vermeiden org.w3c.dom.html.HTMLDocument und nur das tun, was wir können mit org.w3c.dom.Document. Was können wir tun?

Sowie ein Ansatz ist zu erweitern org.apache.xerces.dom.DocumentImpl (die sich org.apache.xerces.dom.CoreDocumentImpl implementiert org.w3c.dom.Document). Dieser Ansatz erfordert nicht viel code, aber es immer noch macht uns die Umsetzung abhängig von Xerces seit wir erweitern DocumentImpl. In unserem MyHTMLDocumentImpl sind wir einfach konvertieren alle tag-Namen in Kleinbuchstaben, die auf der Erstellung des Elements zu suchen. Dies erlaubt die Verwendung von Document#getElementsByTagName(String tagname) in einer case-insensitive Weise.

MyHTMLDocumentImpl:

import org.apache.xerces.dom.DocumentImpl;
import org.apache.xerces.dom.DocumentTypeImpl;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

//a base class somewhere in the hierarchy implements org.w3c.dom.Document
public class MyHTMLDocumentImpl extends DocumentImpl {

    private static final long serialVersionUID = 1658286253541962623L;


    /**
     * Creates an Document with basic elements required to meet
     * the <a href="http://www.w3.org/TR/xhtml1/#strict">XHTML standards</a>.
     * <pre>
     * {@code
     * <?xml version="1.0" encoding="UTF-8"?>
     * <!DOCTYPE html 
     *     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
     *     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
     * <html xmlns="http://www.w3.org/1999/xhtml">
     *     <head>
     *         <title>My Title</title>
     *     </head>
     *     <body/>
     * </html>
     * }
     * </pre>
     * 
     * @param title desired text content for title tag. If null, no text will be added.
     * @return basic HTML Document. 
     */
    public static Document makeBasicHtmlDoc(String title) {
        Document htmlDoc = new MyHTMLDocumentImpl();
        DocumentType docType = new DocumentTypeImpl(null, "html",
                "-//W3C//DTD XHTML 1.0 Strict//EN",
                "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
        htmlDoc.appendChild(docType);
        Element htmlElement = htmlDoc.createElementNS("http://www.w3.org/1999/xhtml", "html");
        htmlDoc.appendChild(htmlElement);
        Element headElement = htmlDoc.createElement("head");
        htmlElement.appendChild(headElement);
        Element titleElement = htmlDoc.createElement("title");
        if(title != null)
            titleElement.setTextContent(title);
        headElement.appendChild(titleElement);
        Element bodyElement = htmlDoc.createElement("body");
        htmlElement.appendChild(bodyElement);

        return htmlDoc;
    }

    /**
     * This method will allow us to create a our
     * MyHTMLDocumentImpl from an existing Document.
     */
    public static Document createFrom(Document doc) {
        Document htmlDoc = new MyHTMLDocumentImpl();
        DocumentType originDocType = doc.getDoctype();
        if(originDocType != null) {
            DocumentType docType = new DocumentTypeImpl(null, originDocType.getName(),
                    originDocType.getPublicId(),
                    originDocType.getSystemId());
            htmlDoc.appendChild(docType);
        }
        Node docElement = doc.getDocumentElement();
        if(docElement != null) {
            Node copiedDocElement = docElement.cloneNode(true);
            htmlDoc.adoptNode(copiedDocElement);
            htmlDoc.appendChild(copiedDocElement);
        }
        return htmlDoc;
    }

    private MyHTMLDocumentImpl() {
        super();
    }

    @Override
    public Element createElement(String tagName) throws DOMException {
        return super.createElement(tagName.toLowerCase());
    }

    @Override
    public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException {
        return super.createElementNS(namespaceURI, qualifiedName.toLowerCase());
    }

    @Override
    public NodeList getElementsByTagName(String tagname) {
        return super.getElementsByTagName(tagname.toLowerCase());
    }

    @Override
    public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
        return super.getElementsByTagNameNS(namespaceURI, localName.toLowerCase());
    }

    @Override
    public Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException {
        return super.renameNode(n, namespaceURI, qualifiedName.toLowerCase());
    }
}

Tester:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import org.w3c.dom.DOMConfiguration;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.bootstrap.DOMImplementationRegistry;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSOutput;
import org.w3c.dom.ls.LSSerializer;


public class HTMLDocumentTest {

    private final static int P_ELEMENT_NUM = 3;

    public static void main(String[] args) //I'm throwing all my exceptions here to shorten the example, but obviously you should handle them appropriately.
            throws ClassNotFoundException, InstantiationException, IllegalAccessException, ClassCastException, IOException {

        Document htmlDoc = MyHTMLDocumentImpl.makeBasicHtmlDoc("My Title");

        //populate the html doc with some example content
        Element bodyElement = (Element) htmlDoc.getElementsByTagName("body").item(0);
        for(int i = 0; i < P_ELEMENT_NUM; ++i) {
            Element pElement = htmlDoc.createElement("p");
            String id = Integer.toString(i+1);
            pElement.setAttribute("id", "anId"+id);
            pElement.setTextContent("Here is some text"+id+".");
            bodyElement.appendChild(pElement);
        }

        //get the title element in a case insensitive manner.
        NodeList titleNodeList = htmlDoc.getElementsByTagName("tItLe");
        for(int i = 0; i < titleNodeList.getLength(); ++i)
            System.out.println(titleNodeList.item(i).getTextContent());

        System.out.println();

        {//get all p elements searching with lowercase
            NodeList pNodeList = htmlDoc.getElementsByTagName("p");
            for(int i = 0; i < pNodeList.getLength(); ++i) {
                System.out.println(pNodeList.item(i).getTextContent());
            }
        }

        System.out.println();

        {//get all p elements searching with uppercase
            NodeList pNodeList = htmlDoc.getElementsByTagName("P");
            for(int i = 0; i < pNodeList.getLength(); ++i) {
                System.out.println(pNodeList.item(i).getTextContent());
            }
        }

        System.out.println();

        //to serialize
        DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance();
        DOMImplementationLS domImplLS = (DOMImplementationLS) registry.getDOMImplementation("LS");

        LSSerializer lsSerializer = domImplLS.createLSSerializer();
        DOMConfiguration domConfig = lsSerializer.getDomConfig();
        domConfig.setParameter("format-pretty-print", true);  //if you want it pretty and indented

        LSOutput lsOutput = domImplLS.createLSOutput();
        lsOutput.setEncoding("UTF-8");

        //to write to file
        try (OutputStream os = new FileOutputStream(new File("myFile.html"))) {
            lsOutput.setByteStream(os);
            lsSerializer.write(htmlDoc, lsOutput);
        }

        //to print to screen
        System.out.println(lsSerializer.writeToString(htmlDoc)); 
    }

}

Ausgabe:

My Title

Here is some text1.
Here is some text2.
Here is some text3.

Here is some text1.
Here is some text2.
Here is some text3.

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>My Title</title>
    </head>
    <body>
        <p id="anId1">Here is some text1.</p>
        <p id="anId2">Here is some text2.</p>
        <p id="anId3">Here is some text3.</p>
    </body>
</html>

Anderen ähnlichen Ansatz wie die oben genannten ist stattdessen eine Document wrapper umschließt, die eine Document - Objekt und implementiert die Document Schnittstelle selbst. Dies erfordert mehr code, als die "Verlängerung DocumentImpl" - Ansatz, aber dieser Weg ist "sauberer", da wir nicht zu kümmern, insbesondere Document Implementierungen. Der zusätzliche code für diesen Ansatz ist nicht schwer; es ist nur ein bisschen mühsam zu bieten all diese wrapper-Implementierungen für die Document Methoden. Ich habe nicht ganz funktionierte das noch und kann es einige Probleme, aber wenn es funktioniert, das ist die Allgemeine Vorstellung:

public class MyHTMLDocumentWrapper implements Document {

    private Document doc;

    public MyHTMLDocumentWrapper(Document doc) {
        //...
        this.doc = doc;
        //...
    }

    //...
}

Ob es org.w3c.dom.html.HTMLDocument, einer der Ansätze, den ich oben erwähnt habe, oder etwas anderes, vielleicht diese Vorschläge wird dazu beitragen, Ihnen eine Idee, wie Sie Vorgehen.

Edit:

In meinem Analyse-tests, während Sie versuchen zu analysieren, die folgende XHTML-Datei, Xerces, würden die nach unten hängen in einem entity-management-Klasse zu öffnen versucht, eine http-Verbindung. Warum weiß ich nicht? Vor allem, da ich getestet habe auf einer lokalen html-Datei mit keine Entitäten. (Vielleicht etwas zu tun mit dem DOCTYPE oder namespace?) Dies ist das Dokument:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC 
    "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>My Title</title>
    </head>
    <body>
        <p id="anId1">Here is some text1.</p>
        <p id="anId2">Here is some text2.</p>
        <p id="anId3">Here is some text3.</p>
    </body>
</html>