Inleiding tot Docx4J

1. Overzicht

In dit artikel zullen we ons concentreren op het maken van een.docx document met behulp van de docx4j-bibliotheek.

Docx4j is een Java-bibliotheek die wordt gebruikt voor het maken en manipuleren van Office Open XML bestanden - wat betekent dat het alleen kan werken met de .docx bestandstype, terwijl oudere versies van Microsoft Word een .doc extensie (binaire bestanden).

Merk op dat de Open XML formaat wordt ondersteund door Microsoft Office vanaf de 2007-versie.

2. Maven-instellingen

Om met docx4j te gaan werken, moeten we de vereiste afhankelijkheid toevoegen aan onze pom.xml:

 org.docx4j docx4j 3.3.5 javax.xml.bind jaxb-api 2.1 

Merk op dat we altijd de nieuwste versies van afhankelijkheden kunnen opzoeken in de Maven Central Repository.

De JAXB afhankelijkheid is nodig, aangezien docx4j deze bibliotheek onder de motorkap gebruikt om XML-onderdelen in een docx het dossier.

3. Maak een Docx-bestandsdocument

3.1. Tekstelementen en stijl

Laten we eerst kijken hoe we een simple docx bestand - met een tekstalinea:

WordprocessingMLPackage wordPackage = WordprocessingMLPackage.createPackage (); MainDocumentPart mainDocumentPart = wordPackage.getMainDocumentPart (); mainDocumentPart.addStyledParagraphOfText ("Titel", "Hallo wereld!"); mainDocumentPart.addParagraphOfText ("Welkom bij Baeldung"); Bestand exportFile = nieuw bestand ("welcome.docx"); wordPackage.save (exportFile); 

Hier is het resultaat welkom.docx het dossier:

Om een ​​nieuw document te maken, moeten we gebruik maken van de TekstverwerkingMLPackage, wat staat voor een docx bestand in Open XML formaat, terwijl de MainDocumentPart klasse bevat een weergave van de belangrijkste document.xml een deel.

Laten we het welkom.docx bestand en open het word / document.xml bestand om te zien hoe de XML-weergave eruitziet:

      Hallo Wereld! Welkom in Baeldung! 

Zoals we kunnen zien, elke zin wordt vertegenwoordigd door een run (r) van tekst (t) binnen een alinea (p), en dat is wat de addParagraphOfText () methode is voor.

De addStyledParagraphOfText () doe iets meer dan dat; het creëert een alinea-eigenschappen (pPr) die de stijl bevat die op de alinea moet worden toegepast.

Simpel gezegd, alinea's declareren afzonderlijke runs en elke run bevat enkele tekstelementen:

Om een ​​mooi ogend document te maken, hebben we de volledige controle over deze elementen nodig (paragraaf, uitvoeren, en tekst).

Laten we dus eens kijken hoe we onze inhoud kunnen stylen met de runProperties (RPr) voorwerp:

ObjectFactory factory = Context.getWmlObjectFactory (); P p = fabriek.createP (); R r = fabriek.createR (); Tekst t = factory.createText (); t.setValue ("Welkom bij Baeldung"); r.getContent (). add (t); p.getContent (). add (r); RPr rpr = fabriek.createRPr (); BooleanDefaultTrue b = nieuwe BooleanDefaultTrue (); rpr.setB (b); rpr.setI (b); rpr.setCaps (b); Kleur groen = factory.createColor (); green.setVal ("groen"); rpr.setColor (groen); r.setRPr (rpr); mainDocumentPart.getContent (). add (p); Bestand exportFile = nieuw bestand ("welcome.docx"); wordPackage.save (exportFile);

Hier is hoe het resultaat eruit ziet:

Nadat we een alinea, een run en een tekstelement hebben gemaakt met createP (), createR () en createText () respectievelijk hebben we een nieuw verklaard runProperties voorwerp (RPr) om wat stijl aan het tekstelement toe te voegen.

De rpr object wordt gebruikt om opmaakeigenschappen in te stellen, Bold (B), Cursief (ik), en met een hoofdletter (Petten), worden die eigenschappen toegepast op de tekst die wordt uitgevoerd met de setRPr () methode.

3.2. Werken met afbeeldingen

Docx4j biedt een gemakkelijke manier om afbeeldingen toe te voegen aan ons Word-document:

Bestandsafbeelding = nieuw bestand ("afbeelding.jpg"); byte [] fileContent = Files.readAllBytes (image.toPath ()); BinaryPartAbstractImage imagePart = BinaryPartAbstractImage .createImagePart (wordPackage, fileContent); Inline inline = imagePart.createImageInline ("Baeldung Image (hint bestandsnaam)", "Alt Text", 1, 2, false); P Imageparagraph = addImageToParagraph (inline); mainDocumentPart.getContent (). add (Imageparagraph);

En hier is wat de implementatie van de addImageToParagraph () methode ziet eruit als:

privé statisch P addImageToParagraph (Inline inline) {ObjectFactory factory = new ObjectFactory (); P p = fabriek.createP (); R r = fabriek.createR (); p.getContent (). add (r); Tekening tekening = factory.createDrawing (); r.getContent (). add (tekening); drawing.getAnchorOrInline (). add (inline); terug p; }

Eerst hebben we het bestand gemaakt dat de afbeelding bevat die we aan ons hoofddocumentgedeelte willen toevoegen, en vervolgens hebben we de byte-array die de afbeelding vertegenwoordigt, gekoppeld aan de wordMLPackage voorwerp.

Zodra het afbeeldingsgedeelte is gemaakt, moeten we een In lijn object met behulp van de createImageInline () methode.

De addImageToParagraph () methode insluiten de In lijn object in een Tekening zodat het kan worden toegevoegd aan een rennen.

Ten slotte wordt, net als een tekstalinea, de alinea met de afbeelding toegevoegd aan het mainDocumentPart.

En hier is het resulterende document:

3.3. Tabellen maken

Docx4j maakt het ook vrij eenvoudig om tabellen (Tbl), rijen (Tr) en kolommen (Tc) te manipuleren.

Laten we eens kijken hoe we een 3 × 3-tabel kunnen maken en er wat inhoud aan kunnen toevoegen:

int writableWidthTwips = wordPackage.getDocumentModel () .getSections (). get (0) .getPageDimensions (). getWritableWidthTwips (); int columnNumber = 3; Tbl tbl = TblFactory.createTable (3, 3, writableWidthTwips / columnNumber); Lijst rijen = tbl.getContent (); voor (Object rij: rijen) {Tr tr = (Tr) rij; Lijst met cellen = tr.getContent (); voor (Objectcel: cellen) {Tc td = (Tc) cel; td.getContent (). add (p); }}

Gegeven enkele rijen en kolommen, de createTable () methode creëert een nieuw Tbl object, verwijst het derde argument naar de kolombreedte in twips (wat een afstandsmeting is - 1 / 1440ste van een inch).

Eenmaal gemaakt, kunnen we de inhoud van het tbl object, en voeg toe Paragraaf objecten in elke cel.

Laten we eens kijken hoe het uiteindelijke resultaat eruitziet:

4. Lezen van een Docx-bestandsdocument

Nu we hebben ontdekt hoe we docx4j kunnen gebruiken om documenten te maken, laten we eens kijken hoe we een bestaand docx-bestand kunnen lezen en de inhoud ervan kunnen afdrukken:

Bestand doc = nieuw bestand ("helloWorld.docx"); WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage .load (doc); MainDocumentPart mainDocumentPart = wordMLPackage .getMainDocumentPart (); String textNodesXPath = "// w: t"; Lijst textNodes = mainDocumentPart .getJAXBNodesViaXPath (textNodesXPath, true); voor (Object obj: textNodes) {Text text = (Text) ((JAXBElement) obj) .getValue (); String textValue = text.getValue (); System.out.println (textValue); }

In dit voorbeeld hebben we een TekstverwerkingMLPackage object op basis van een bestaand helloWorld.docx bestand, met behulp van de laden() methode.

Daarna hebben we een XPath uitdrukking (// w: t) om alle tekstknooppunten uit het hoofddocumentgedeelte op te halen.

De getJAXBNodesViaXPath () methode retourneert een lijst met JAXBElement voorwerpen.

Als gevolg hiervan zijn alle tekstelementen binnen het mainDocumentPart objecten worden afgedrukt in de console.

Merk op dat we onze docx-bestanden altijd kunnen unzippen om een ​​beter begrip te krijgen van de XML-structuur, wat helpt bij het analyseren van problemen en een beter inzicht geeft in hoe ze kunnen worden aangepakt.

5. Conclusie

In dit artikel hebben we ontdekt hoe docx4j het gemakkelijker maakt om complexe bewerkingen uit te voeren op MSWord-documenten, zoals het maken van alinea's, tabellen, documentonderdelen en het toevoegen van afbeeldingen.

De codefragmenten zijn, zoals altijd, te vinden op GitHub.