streamalism.org

1. Inleiding

In deze zelfstudie beschrijven we hoe u dit kunt doen converteer XML naar HTML met behulp van veelgebruikte Java-bibliotheken en sjabloonengines - JAXP, StAX, Freemarker en Moustache.

2. Een XML naar Unmarshal

Laten we beginnen met een eenvoudig XML-document dat we zullen unmarshal in een geschikte Java-representatie voordat we het naar HTML converteren. We zullen enkele belangrijke doelen in gedachten houden:

1. Bewaar dezelfde XML voor al onze voorbeelden
2. Maak aan het einde een syntactisch en semantisch geldig HTML5-document
3. Zet alle XML-elementen om in tekst

Laten we een eenvoudige Jenkins-melding gebruiken als onze voorbeeld-XML:

  [email protected] Build # 7 geslaagd. Succes: de Jenkins CI-build is geslaagd 

En het is vrij eenvoudig. Het bevat een root-element en enkele geneste elementen.

We streven ernaar om alle unieke XML-tags te verwijderen en sleutel-waardeparen af ​​te drukken wanneer we ons HTML-bestand maken.

3. JAXP

Java Architecture for XML Processing (JAXP) is een bibliotheek die bedoeld was om de functionaliteit van de populaire SAX Parser uit te breiden met extra DOM-ondersteuning. JAXP biedt de mogelijkheid om Marshal en unmarshal XML-gedefinieerde objecten van en naar POJO's met behulp van SAX Parser. We maken ook gebruik van de ingebouwde DOM-helpers.

Laten we de Maven-afhankelijkheid voor JAXP aan ons project toevoegen:

 javax.xml jaxp-api 1.4.2 

3.1. Unmarshalling met DOM Builder

Laten we beginnen door eerst ons XML-bestand te unmarshallen naar een Java Element voorwerp:

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance (); factory.setFeature (XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setFeature ("// apache.org/xml/features/disallow-doctype-decl", true); Documentinvoer = fabriek .newDocumentBuilder () .parse (resourcePath); Element xml = input.getDocumentElement (); 

3.2. De inhoud van het XML-bestand uitpakken in een kaart

Laten we nu een Kaart met de relevante inhoud van ons XML-bestand:

Map map = nieuwe HashMap (); map.put ("rubriek", xml.getElementsByTagName ("rubriek") .item (0) .getTextContent ()); map.put ("from", String.format ("from:% s", xml.getElementsByTagName ("from") .item (0) .getTextContent ())); map.put ("content", xml.getElementsByTagName ("content") .item (0) .getTextContent ());

3.3. Marshalling met behulp van DOM Builder

Onze XML omzetten in een HTML-bestand is iets ingewikkelder.

Laten we een transfer voorbereiden Document die we zullen gebruiken om de HTML uit te schrijven:

Document doc = fabriek .newDocumentBuilder () .newDocument (); 

Vervolgens vullen we de Document met de Elementen in onze kaart:

Element html = doc.createElement ("html"); Element head = doc.createElement ("head"); html.setAttribute ("lang", "en"); Element title = doc.createElement ("title"); title.setTextContent (map.get ("heading")); head.appendChild (titel); html.appendChild (hoofd); Element body = doc.createElement ("body"); Element van = doc.createElement ("p"); from.setTextContent (map.get ("van")); Element success = doc.createElement ("p"); success.setTextContent (map.get ("content")); body.appendChild (uit); body.appendChild (succes); html.appendChild (lichaam); doc.appendChild (html); 

Laten we tot slot maarschalk onze Document object met behulp van een TransformerFactory:

TransformerFactory transformerFactory = TransformerFactory.newInstance (); transformerFactory.setFeature (XMLConstants.FEATURE_SECURE_PROCESSING, waar); transformerFactory.setAttribute (XMLConstants.ACCESS_EXTERNAL_DTD, ""); transformerFactory.setAttribute (XMLConstants.ACCESS_EXTERNAL_STYLESHEET, ""); probeer (uitvoer van schrijver = nieuwe StringWriter ()) {Transformer transformer = transformerFactory.newTransformer (); transformer.transform (nieuwe DOMSource (doc), nieuwe StreamResult (output)); }

Als we bellen output.toString (), we krijgen de HTML-weergave.

Merk op dat sommige van de extra functies en attributen die we in onze fabriek hebben ingesteld, zijn overgenomen uit de aanbevelingen van het OWASP-project om XXE-injectie te voorkomen.

4. StAX

Een andere bibliotheek die we kunnen gebruiken, is de Streaming API voor XML (StAX). Net als JAXP bestaat StAX al heel lang - sinds 2004.

De andere twee bibliotheken vereenvoudigen het parseren van XML-bestanden. Dat is geweldig voor eenvoudige taken of projecten, maar minder wanneer we moeten herhalen of expliciete en fijnmazige controle hebben over het parseren van elementen zelf. Dat is waar StAX van pas komt.

Laten we de Maven-afhankelijkheid voor de StAX API aan ons project toevoegen:

 javax.xml.stream stax-api 1.0-2 

4.1. Unmarshalling met StAX

We gebruiken een eenvoudige iteratiebesturingsstroom naar sla XML-waarden op in onze Kaart:

XMLInputFactory factory = XMLInputFactory.newInstance (); factory.setProperty (XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE); factory.setProperty (XMLInputFactory.SUPPORT_DTD, Boolean.FALSE); XMLStreamReader-invoer = null; probeer (FileInputStream-bestand = nieuwe FileInputStream (resourcePath)) {input = factory.createXMLStreamReader (bestand); Map map = nieuwe HashMap (); while (input.hasNext ()) {input.next (); if (input.isStartElement ()) {if (input.getLocalName (). equals ("rubriek")) {map.put ("rubriek", input.getElementText ()); } if (input.getLocalName (). equals ("from")) {map.put ("from", String.format ("from:% s", input.getElementText ())); } if (input.getLocalName (). equals ("content")) {map.put ("content", input.getElementText ()); }}}} eindelijk {if (input! = null) {input.close (); }}

4.2. Marshalling met StAX

Laten we nu onze kaart en schrijf de HTML op:

probeer (Writer output = nieuwe StringWriter ()) {XMLStreamWriter writer = XMLOutputFactory .newInstance () .createXMLStreamWriter (output); writer.writeDTD (""); writer.writeStartElement ("html"); writer.writeAttribute ("lang", "en"); writer.writeStartElement ("hoofd"); writer.writeDTD (""); writer.writeStartElement ("titel"); writer.writeCharacters (map.get ("rubriek")); writer.writeEndElement (); writer.writeEndElement (); writer.writeStartElement ("body"); writer.writeStartElement ("p"); writer.writeCharacters (map.get ("van")); writer.writeEndElement (); writer.writeStartElement ("p"); writer.writeCharacters (map.get ("content")); writer.writeEndElement (); writer.writeEndElement (); writer.writeEndDocument (); schrijver.flush (); }

Net als in het JAXP-voorbeeld kunnen we bellen output.toString () om de HTML-weergave te krijgen.

5. Gebruik van sjabloonengines

Als alternatief voor het schrijven van de HTML-weergave kunnen we sjabloonengines gebruiken. Er zijn meerdere opties in het Java-ecosysteem. Laten we er een paar bekijken.

5.1. Apache Freemarker gebruiken

Apache FreeMarker is een op Java gebaseerde sjabloonengine voor het genereren van tekstuitvoer (HTML-webpagina's, e-mails, configuratiebestanden, broncode, enz.) Op basis van sjablonen en het wijzigen van gegevens.

Om het te kunnen gebruiken, moeten we de freemarker-afhankelijkheid toevoegen aan ons Maven-project:

 org.freemarker freemarker 2.3.29 

Laten we eerst een sjabloon maken met behulp van de FreeMarker-syntaxis:

    $ {rubriek} 
$ {van}
$ {content}

Laten we nu onze kaart en vul de gaten in de sjabloon:

Configuratie cfg = nieuwe configuratie (Configuration.VERSION_2_3_29); cfg.setDirectoryForTemplateLoading (nieuw bestand (templateDirectory)); cfg.setDefaultEncoding (StandardCharsets.UTF_8.toString ()); cfg.setTemplateExceptionHandler (TemplateExceptionHandler.RETHROW_HANDLER); cfg.setLogTemplateExceptions (false); cfg.setWrapUncheckedExceptions (true); cfg.setFallbackOnNullLoopVariable (false); Sjabloon temp = cfg.getTemplate (templateFile); probeer (uitvoer van schrijver = nieuwe StringWriter ()) {temp.process (staxTransformer.getMap (), uitvoer); }

5.2. Snor gebruiken

Moustache is een sjabloon-engine zonder logica. Moustache kan worden gebruikt voor HTML, configuratiebestanden, broncode - vrijwel alles. Het werkt door tags in een sjabloon uit te breiden met waarden in een hash of object.

Om het te gebruiken, moeten we de snorafhankelijkheid toevoegen aan ons Maven-project:

 com.github.spullara.mustache.java-compiler 0.9.6 

Laten we beginnen met het maken van een sjabloon met behulp van de Moustache-syntaxis:

    {{heading}} 
{{van}}
{{inhoud}}

Laten we nu de sjabloon vullen met onze kaart:

MoustacheFactory mf = nieuwe DefaultMustacheFactory (); Snor snor = mf.compile (templateFile); probeer (uitvoer van schrijver = nieuwe StringWriter ()) {snor.execute (uitvoer, staxTransformer.getMap ()); output.flush (); }

6. De resulterende HTML

Uiteindelijk krijgen we met al onze codevoorbeelden dezelfde HTML-uitvoer:

    Build # 7 geslaagd 
van: [email protected]
Succes: de Jenkins CI-build is geslaagd

7. Conclusie

In deze tutorial hebben we de basis geleerd van het gebruik van JAXP, StAX, Freemarker en Moustache om XML naar HTML te converteren.

Bekijk deze andere geweldige bronnen hier op Baeldung voor meer informatie over XML in Java:

• XML deserialiseren naar objecten in XStream
• Objecten serialiseren naar XML in XStream
• Java XML-bibliotheken

Zoals altijd zijn de volledige codevoorbeelden die hier te zien zijn, beschikbaar op GitHub.