Støtte for XML-biblioteker i Java

1. Introduksjon

I denne artikkelen vil vi sammenligne Java XML-biblioteker og API-er.

Dette er den andre artikkelen fra serien om Java-støtte for XML, hvis du vil gå dypere inn i XPath-støtten i Java, se på forrige artikkel.

2. Oversikt

Nå skal vi grave dypere inn i XML-verdensstøtten, og for det skal vi begynne med å forklare så enkelt som mulig alle fagrelaterte initialer.

I Java XML-støtte kan vi finne få API-definisjoner, hver og en har sine fordeler og ulemper.

SAX: Det er et hendelsesbasert parsing-API, det gir tilgang på lavt nivå, er minneeffektivt og raskere enn DOM siden det ikke laster hele dokumenttreet i minnet, men det gir ikke støtte for navigering som det som tilbys av XPath , selv om det er mer effektivt, er det vanskeligere å bruke det også.

DOM: Det som modellbasert parser som laster et trestrukturdokument i minnet, så vi har den opprinnelige elementrekkefølgen, vi kan navigere i dokumentet i begge retninger, det gir et API for lesing og skriving, det tilbyr XML-manipulering og det er veldig enkelt å bruk selv om prisen er stor belastning på minnesressurser.

StAX: Det gir enkel DOM og effektiviteten til SAX, men den mangler noe funksjonalitet som DOM gir, som XML-manipulering, og det lar oss bare navigere fremover.

JAXB: Det lar oss navigere i dokumentet i begge retninger, det er mer effektivt enn DOM, det tillater konvertering fra XML til java-typer, og det støtter XML-manipulering, men det kan bare analysere et gyldig XML-dokument.

Du kan fremdeles finne noen referanser til JAXP, men siste utgivelse av dette prosjektet er fra mars 2013, og det er praktisk talt dødt.

XML APIs-tabell

3. XML

I denne delen skal vi se de mest populære implementeringene, slik at vi kan teste virkelige arbeidsprøver og sjekke forskjeller mellom dem.

I de følgende eksemplene vil vi jobbe med en enkel XML-fil med en struktur som denne:

  Guava Introduksjon til Guava 04/04/2016 Guava Forfatter ... 

4. DOM4J

Vi begynner med å ta en titt på hva vi kan gjøre med DOM4J og for dette eksemplet må vi legge til den siste versjonen av denne avhengigheten.

Dette er en av de mest populære bibliotekene å jobbe med XML filer, siden det lar oss utføre toveis lesing, opprette nye dokumenter og oppdatere eksisterende.

DOM4J kan jobbe med DOM, SAX, XPath og XLST. SAX støttes via JAXP.

La oss ta en titt her for eksempel, hvordan kan vi velge et element som filtrerer etter en gitt id.

SAXReader-leser = ny SAXReader (); Dokumentdokument = reader.read (fil); Listeelementer = document.selectNodes ("// * [@ tutId = '" + id + "']"); returelementer.get (0);

De SAXReader klasse er ansvarlig for å lage en DOM4J tre fra SAX analysering av hendelser. Når vi har en org.dom4j.Dokument vi trenger bare å kalle den nødvendige metoden og gi den den XPath uttrykk som en String.

Vi kan laste inn et eksisterende dokument, gjøre endringer i innholdet og deretter oppdatere den originale filen.

for (Node node: nodes) {Element element = (Element) node; Iterator iterator = element.elementIterator ("tittel"); mens (iterator.hasNext ()) {Element title = (Element) iterator.next (); title.setText (title.getText () + "oppdatert"); }} XMLWriter-forfatter = ny XMLWriter (ny FileWriter (ny fil ("src / test / resources / example_updated.xml"))); writer.write (dokument); writer.close ();

I eksemplet ovenfor endrer vi innholdet på hver tittel og oppretter en ny fil.

Legg merke til her hvor enkelt det er å få hver tittel node i en liste ved å ringe elementIterator og passerer navnet på node.

Når vi har endret innholdet vårt, vil vi bruke XMLWriter det tar en DOM4J treet og formaterer det til en strøm som XML.

Å lage et nytt dokument fra bunnen av er så enkelt som vi ser nedenfor.

Dokumentdokument = DocumentHelper.createDocument (); Element root = document.addElement ("XMLTutorials"); Element tutorialElement = root.addElement ("tutorial"). AddAttribute ("tutId", "01"); tutorialElement.addAttribute ("type", "xml"); tutorialElement.addElement ("title"). addText ("XML med Dom4J"); ... OutputFormat format = OutputFormat.createPrettyPrint (); XMLWriter-forfatter = ny XMLWriter (ny FileWriter (ny fil ("src / test / resources / example_new.xml")), format); writer.write (dokument); writer.close (); 

DocumentHelper gir oss en samling metoder å bruke DOM4J, som for eksempel createDocument som lager et tomt dokument for å begynne å jobbe med det.

Vi kan lage så mange attributter eller elementer som vi trenger med metodene som tilbys av DOM4J, og når vi har fullført dokumentet, skriver vi det bare til en fil som vi gjorde med oppdateringssaken tidligere.

5. JDOM

For å jobbe med JDOM, Vi må legge denne avhengigheten til pom.

JDOM-er arbeidsstil er ganske lik DOM4J-er, så vi skal ta en titt på bare et par eksempler:

SAXBuilder builder = ny SAXBuilder (); Dokument doc = builder.build (this.getFile ()); Element tutorials = doc.getRootElement (); Listetitler = tutorials.getChildren ("tutorial"); 

I eksemplet ovenfor henter vi alle elementene fra rotelementet på en veldig enkel måte som vi kan gjøre med DOM4J:

SAXBuilder builder = ny SAXBuilder (); Dokumentdokument = (Dokument) builder.build (fil); Strengfilter = "// * [@ tutId = '" + id + "']"; XPathFactory xFactory = XPathFactory.instance (); XPathExpression expr = xFactory.compile (filter, Filters.element ()); List node = ekspr. Evaluere (dokument);

Igjen, her i koden ovenfor har vi en SAXBuilder skape en Dokument forekomst fra en gitt fil. Vi henter et element etter det veiledning attributt ved å passere en XPath uttrykk for XPathFactory levert av JDOM2.

6. StAX

Nå skal vi se hvordan vi kunne hente alle elementene fra rotelementet vårt ved hjelp av Stax API. Stax er inkludert i JDK siden Java 6, slik at du ikke trenger å legge til noen avhengigheter.

For det første må vi lage en Opplæringen klasse:

public class Tutorial {private String tutId; privat streng type; privat strengetittel; privat strengbeskrivelse; privat streng dato; privat strengforfatter; // standard getters og setters}

og så er vi klare til å følge med:

List tutorials = new ArrayList (); XMLInputFactory fabrikk = XMLInputFactory.newInstance (); XMLEventReader eventReader = factory.createXMLEventReader (ny FileReader (this.getFile ())); Opplæringsstrøm; mens (eventReader.hasNext ()) {XMLEvent hendelse = eventReader.nextEvent (); switch (event.getEventType ()) {case XMLStreamConstants.START_ELEMENT: StartElement startElement = event.asStartElement (); Streng qName = startElement.getName (). GetLocalPart (); ... gå i stykker; sak XMLStreamConstants.CHARACTERS: Characters characters = event.asCharacters (); ... gå i stykker; sak XMLStreamConstants.END_ELEMENT: EndElement endElement = event.asEndElement (); // sjekk om vi fant det avsluttende elementet // lukke ressurser som må eksplisitt lukkes pause; }}

I eksemplet ovenfor, for å hjelpe oss med å hente informasjonen, trengte vi å opprette en klasse for å lagre de hentede dataene i.

For å lese dokumentet erklærte vi det som kalles hendelsesbehandlere, og vi brukte dem til å navigere fremover i dokumentet. Husk at SAX-implementeringene ikke gir toveis navigasjon. Som du kan se her, må mye arbeid gjøres bare for å hente en enkel liste over elementer.

7. JAXB

JAXB er inkludert i JDK, i tillegg til Xerces, trenger ikke noen ekstra avhengighet for denne.

Det er veldig enkelt å laste inn, opprette og manipulere informasjon fra en XML fil ved hjelp av JAXB.

Vi trenger bare å lage de riktige java-enhetene for å binde XML og det er det.

JAXBContext jaxbContext = JAXBContext.newInstance (Tutorials.class); Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller (); Tutorials tutorials = (Tutorials) jaxbUnmarshaller.unmarshal (this.getFile ());

I eksemplet ovenfor laster vi inn vår XML fil inn i objektet vårt og derfra kan vi håndtere alt som en normal Java-struktur;

For å lage et nytt dokument er det så enkelt som å lese det, men å gjøre omvendt, som gjort i koden nedenfor.

For det første skal vi endre vår Opplæringen klasse å legge til JAXB kommentarer til getters og settere:

public class Tutorial {... public String getTutId () {return tutId; } @XmlAttribute public void setTutId (String tutId) {this.tutId = tutId; } ... @XmlElement public void setTitle (String title) {this.title = title; } ...} @XmlRootElement Tutorials for offentlige klasser {private List tutorial; // standard getters og setters med @XmlElement-kommentar}

Med @XmlRootElement vi definerer hvilket objekt som skal representere rotnoden til dokumentet vårt, og deretter bruker vi det @XmlAttributt eller @XmlElement for å definere om det attributtet representerer et attributt til en node eller et element i dokumentet.

Så kan vi følge med:

Tutorials tutorials = new Tutorials (); tutorials.setTutorial (ny ArrayList ()); Opplæringsveiledning = ny opplæring (); tut.setTutId ("01"); ... tutorials.getTutorial (). add (tut); JAXBContext jaxbContext = JAXBContext.newInstance (Tutorials.class); Marshaller jaxbMarshaller = jaxbContext.createMarshaller (); jaxbMarshaller.setProperty (Marshaller.JAXB_FORMATTED_OUTPUT, sant); jaxbMarshaller.marshal (tutorials, file);

Som du kan se, er å binde XML-fil til Java-objekter den enkleste måten å jobbe denne typen filer på.

8. Støtte for XPath-uttrykk

For å lage komplekse XPath-uttrykk, kan vi bruke Jaxen. Dette er et open source XPath-bibliotek som kan tilpasses til mange forskjellige objektmodeller, inkludert DOM, XOM, DOM4J, og JDOM.

Vi kan lage XPath-uttrykk og kompilere dem mot mange støttede dokumenter.

Strenguttrykk = "/ tutorials / tutorial"; XPath-sti = ny DOMXPath (uttrykk); Liste resultat = path.selectNodes (xmlDocument);

For å få det til å fungere, må vi legge til denne avhengigheten i prosjektet vårt.

9. Konklusjon

Som du ser er det mange muligheter for å jobbe med XML, avhengig av kravene i applikasjonen din, kan du jobbe med noen av dem, eller du må velge mellom effektivitet og enkelhet.

Du finner de fullstendige arbeidseksemplene for denne artikkelen i vårt git-arkiv her.


$config[zx-auto] not found$config[zx-overlay] not found