Introduzione a Docx4J

1. Panoramica

In questo articolo ci concentreremo sulla creazione di un file. documento docx utilizzando la libreria docx4j.

Docx4j è una libreria Java utilizzata per creare e manipolare file Office OpenXML , il che significa che può funzionare solo con il tipo di file .docx , mentre le versioni precedenti di Microsoft Word utilizzano un'estensione .doc (file binari).

Tieni presente che il formato OpenXML è supportato da Microsoft Office a partire dalla versione 2007.

2. Installazione di Maven

Per iniziare a lavorare con docx4j, dobbiamo aggiungere la dipendenza richiesta nel nostro pom.xml :

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

Tieni presente che possiamo sempre cercare le ultime versioni delle dipendenze nel Maven Central Repository.

La dipendenza JAXB è necessaria, poiché docx4j utilizza questa libreria sotto il cofano per eseguire il marshalling / unmarshall delle parti XML in un file docx .

3. Creare un documento file Docx

3.1. Elementi di testo e stile

Vediamo prima come creare un semplice file docx - con un paragrafo di testo:

WordprocessingMLPackage wordPackage = WordprocessingMLPackage.createPackage(); MainDocumentPart mainDocumentPart = wordPackage.getMainDocumentPart(); mainDocumentPart.addStyledParagraphOfText("Title", "Hello World!"); mainDocumentPart.addParagraphOfText("Welcome To Baeldung"); File exportFile = new File("welcome.docx"); wordPackage.save(exportFile); 

Ecco il file welcome.docx risultante :

Per creare un nuovo documento dobbiamo utilizzare il WordprocessingMLPackage , che rappresenta un file docx in formato OpenXML , mentre la classe MainDocumentPart contiene una rappresentazione della parte principale document.xml .

Per chiarire le cose, decomprimiamo il file welcome.docx e apriamo il file word / document.xml per vedere come appare la rappresentazione XML:

      Hello World!     Welcome To Baeldung!   

Come possiamo vedere, ogni frase è rappresentata da una sequenza ( r ) di testo ( t ) all'interno di un paragrafo ( p ) , ed è a questo che serve il metodo addParagraphOfText () .

L'addStyledParagraphOfText () fare un po 'più di questo; crea una proprietà del paragrafo ( pPr ) che contiene lo stile da applicare al paragrafo.

In poche parole, i paragrafi dichiarano sequenze separate e ciascuna sequenza contiene alcuni elementi di testo:

Per creare un documento dall'aspetto gradevole, dobbiamo avere il pieno controllo di questi elementi (paragrafo, sequenza e testo).

Quindi, scopriamo come stilizzare il nostro contenuto utilizzando l'oggetto runProperties ( RPr ):

ObjectFactory factory = Context.getWmlObjectFactory(); P p = factory.createP(); R r = factory.createR(); Text t = factory.createText(); t.setValue("Welcome To Baeldung"); r.getContent().add(t); p.getContent().add(r); RPr rpr = factory.createRPr(); BooleanDefaultTrue b = new BooleanDefaultTrue(); rpr.setB(b); rpr.setI(b); rpr.setCaps(b); Color green = factory.createColor(); green.setVal("green"); rpr.setColor(green); r.setRPr(rpr); mainDocumentPart.getContent().add(p); File exportFile = new File("welcome.docx"); wordPackage.save(exportFile);

Ecco come appare il risultato:

Dopo abbiamo creato un paragrafo, una corsa e un elemento di testo utilizzando createP () , Creator () e CreateText () , rispettivamente, abbiamo dichiarato un nuovo runProperties oggetto ( RPr ) per aggiungere un po 'di stile per l'elemento di testo.

La RPR oggetto viene utilizzato per impostare le proprietà di formattazione, Bold ( B ), in corsivo ( I ), e capitalizzati ( Cappelli ), queste proprietà vengono applicate alla corsa testo utilizzando il () setRPr metodo.

3.2. Lavorare con le immagini

Docx4j offre un modo semplice per aggiungere immagini al nostro documento Word:

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

Ed ecco come appare l'implementazione del metodo addImageToParagraph () :

private static P addImageToParagraph(Inline inline) { ObjectFactory factory = new ObjectFactory(); P p = factory.createP(); R r = factory.createR(); p.getContent().add(r); Drawing drawing = factory.createDrawing(); r.getContent().add(drawing); drawing.getAnchorOrInline().add(inline); return p; }

Per prima cosa, abbiamo creato il file che contiene l'immagine che vogliamo aggiungere nella nostra parte principale del documento, quindi abbiamo collegato l'array di byte che rappresenta l'immagine con l' oggetto wordMLPackage .

Una volta creata la parte dell'immagine, dobbiamo creare un oggetto Inline utilizzando il metodo createImageInline ( ).

Il metodo addImageToParagraph () incorpora l' oggetto Inline in un Drawing in modo che possa essere aggiunto a una corsa.

Infine, come un paragrafo di testo, il paragrafo contenente l'immagine viene aggiunto alla mainDocumentPart .

Ed ecco il documento risultante:

3.3. Creazione di tabelle

Docx4j rende anche abbastanza facile manipolare tabelle (Tbl), righe (Tr) e colonne (Tc).

Vediamo come creare una tabella 3 × 3 e aggiungervi del contenuto:

int writableWidthTwips = wordPackage.getDocumentModel() .getSections().get(0).getPageDimensions().getWritableWidthTwips(); int columnNumber = 3; Tbl tbl = TblFactory.createTable(3, 3, writableWidthTwips/columnNumber); List rows = tbl.getContent(); for (Object row : rows) { Tr tr = (Tr) row; List cells = tr.getContent(); for(Object cell : cells) { Tc td = (Tc) cell; td.getContent().add(p); } }

Date alcune righe e colonne, il metodo createTable () crea un nuovo oggetto Tbl , il terzo argomento si riferisce alla larghezza della colonna in twip (che è una misura della distanza - 1/1440 di pollice).

Una volta creato, possiamo iterare sul contenuto dell'oggetto tbl e aggiungere oggetti Paragraph in ogni cella.

Vediamo come si presenta il risultato finale:

4. Lettura di un documento File Docx

Ora che abbiamo scoperto come utilizzare docx4j per creare documenti, vediamo come leggere un file docx esistente e stamparne il contenuto:

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

In questo esempio, abbiamo creato un oggetto WordprocessingMLPackage basato su un file helloWorld.docx esistente , utilizzando il metodo load () .

Successivamente, abbiamo utilizzato un'espressione XPath ( // w: t ) per ottenere tutti i nodi di testo dalla parte del documento principale.

Il metodo getJAXBNodesViaXPath () restituisce un elenco di oggetti JAXBElement .

Di conseguenza, tutti gli elementi di testo all'interno dell'oggetto mainDocumentPart vengono stampati nella console.

Si noti che possiamo sempre decomprimere i nostri file docx per ottenere una migliore comprensione della struttura XML, che aiuta nell'analisi dei problemi e fornisce una migliore visione di come affrontarli.

5. conclusione

In questo articolo, abbiamo scoperto come docx4j semplifica l'esecuzione di operazioni complesse sul documento MSWord, come la creazione di paragrafi, tabelle, parti di documenti e l'aggiunta di immagini.

Gli snippet di codice possono essere trovati, come sempre, su GitHub.