Genera tabella da Datatable

Introduzione

Creare tabelle in modo dinamico da fonti dati è un’attività comune in molte applicazioni. Che tu stia generando report, fatture o riepiloghi di dati, essere in grado di popolare una tabella con dati in modo programmatico può farti risparmiare molto tempo e fatica. In questo tutorial, esploreremo come generare una tabella da un DataTable usando Aspose.Words per Java. Suddivideremo il processo in passaggi gestibili, assicurandoti di avere una chiara comprensione di ogni parte.

Prerequisiti

Prima di immergerci nel codice, assicuriamoci di avere tutto il necessario per iniziare:

Java Development Kit (JDK): assicurati di avere JDK installato sulla tua macchina. Puoi scaricarlo da Sito web di Oracle .
Aspose.Words per Java: avrai bisogno della libreria Aspose.Words. Puoi scaricare l’ultima versione da Pagina delle release di Aspose .
IDE: un ambiente di sviluppo integrato (IDE) come IntelliJ IDEA o Eclipse semplificherà la codifica.
Conoscenza di base di Java: la familiarità con i concetti di programmazione Java ti aiuterà a comprendere meglio i frammenti di codice.
Dati campione: per questo tutorial, useremo un file XML denominato “List of people.xml” per simulare una fonte dati. Puoi creare questo file con dati campione per i test.

Passaggio 1: creare un nuovo documento

Per prima cosa, dobbiamo creare un nuovo documento in cui risiederà la nostra tabella. Questa è la tela per il nostro lavoro.

Document doc = new Document();

Qui, istanziamo un nuovoDocument oggetto. Questo servirà come documento di lavoro in cui costruiremo la nostra tabella.

Passaggio 2: inizializzare DocumentBuilder

Successivamente, utilizzeremo ilDocumentBuilder classe, che ci consente di manipolare il documento più facilmente.

DocumentBuilder builder = new DocumentBuilder(doc);

ILDocumentBuilder L’oggetto fornisce metodi per inserire tabelle, testo e altri elementi nel documento.

Passaggio 3: imposta l’orientamento della pagina

Poiché prevediamo che la nostra tabella sia ampia, imposteremo l’orientamento della pagina su orizzontale.

doc.getFirstSection().getPageSetup().setOrientation(Orientation.LANDSCAPE);

Questo passaggio è fondamentale perché garantisce che la tabella si adatti perfettamente alla pagina senza essere tagliata.

Passaggio 4: caricare i dati da XML

Ora, dobbiamo caricare i nostri dati dal file XML in unDataTableEcco da dove provengono i nostri dati.

DataSet ds = new DataSet();
ds.readXml(getMyDir() + "List of people.xml");
DataTable dataTable = ds.getTables().get(0);

Qui, leggiamo il file XML e recuperiamo la prima tabella dal set di dati. QuestoDataTable conterrà i dati che vogliamo visualizzare nel nostro documento.

Passaggio 5: importare la tabella da DataTable

Adesso arriva la parte interessante: importare i nostri dati nel documento come tabella.

Table table = importTableFromDataTable(builder, dataTable, true);

Chiamiamo il metodoimportTableFromDataTable , passando ilDocumentBuilder , NostroDataTablee un valore booleano per indicare se includere le intestazioni di colonna.

Passaggio 6: assegna uno stile alla tabella

Una volta sistemato il tavolo, possiamo applicare qualche modifica per renderlo più gradevole alla vista.

table.setStyleIdentifier(StyleIdentifier.MEDIUM_LIST_2_ACCENT_1);
table.setStyleOptions(TableStyleOptions.FIRST_ROW | TableStyleOptions.ROW_BANDS | TableStyleOptions.LAST_COLUMN);

Questo codice applica uno stile predefinito alla tabella, migliorandone l’aspetto visivo e la leggibilità.

Passaggio 7: rimuovere le celle indesiderate

Se ci sono colonne che non vuoi visualizzare, ad esempio una colonna immagine, puoi rimuoverle facilmente.

table.getFirstRow().getLastCell().removeAllChildren();

Questo passaggio garantisce che la nostra tabella mostri solo le informazioni rilevanti.

Passaggio 8: Salvare il documento

Infine, salviamo il nostro documento con la tabella generata.

doc.save(getArtifactsDir() + "WorkingWithTables.BuildTableFromDataTable.docx");

Questa riga salva il documento nella directory specificata, consentendo di rivedere i risultati.

Il metodo importTableFromDataTable

Diamo un’occhiata più da vicino alimportTableFromDataTable metodo. Questo metodo è responsabile della creazione della struttura della tabella e del suo popolamento con i dati.

Passaggio 1: avviare la tabella

Per prima cosa dobbiamo creare una nuova tabella nel documento.

Table table = builder.startTable();

Questo inizializza una nuova tabella nel nostro documento.

Passaggio 2: aggiungere intestazioni di colonna

Se vogliamo includere le intestazioni di colonna, selezioniamoimportColumnHeadings bandiera.

if (importColumnHeadings) {
    // Memorizza la formattazione originale
    boolean boldValue = builder.getFont().getBold();
    int paragraphAlignmentValue = builder.getParagraphFormat().getAlignment();

    // Imposta formattazione intestazione
    builder.getFont().setBold(true);
    builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);

    // Inserisci nomi di colonna
    for (DataColumn column : dataTable.getColumns()) {
        builder.insertCell();
        builder.writeln(column.getColumnName());
    }

    builder.endRow();

    // Ripristina la formattazione originale
    builder.getFont().setBold(boldValue);
    builder.getParagraphFormat().setAlignment(paragraphAlignmentValue);
}

Questo blocco di codice formatta la riga di intestazione e inserisce i nomi delle colonne daDataTable.

Passaggio 3: popolare la tabella con i dati

Ora, eseguiamo un ciclo su ogni riga delDataTable per inserire dati nella tabella.

for (DataRow dataRow : (Iterable<DataRow>) dataTable.getRows()) {
    for (Object item : dataRow.getItemArray()) {
        builder.insertCell();
        switch (item.getClass().getName()) {
            case "DateTime":
                Date dateTime = (Date) item;
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("MMMM d, yyyy");
                builder.write(simpleDateFormat.format(dateTime));
                break;
            default:
                builder.write(item.toString());
                break;
        }
    }
    builder.endRow();
}

In questa sezione gestiremo diversi tipi di dati, formattando opportunamente le date e inserendo altri dati come testo.

Fase 4: Termina la tabella

Infine, una volta inseriti tutti i dati, completiamo la tabella.

builder.endTable();

Questa linea segna la fine della nostra tabella, consentendo laDocumentBuilder per sapere che abbiamo terminato questa sezione.

Conclusione

Ed ecco fatto! Hai imparato con successo come generare una tabella da un DataTable usando Aspose.Words per Java. Seguendo questi passaggi, puoi facilmente creare tabelle dinamiche nei tuoi documenti in base a varie fonti di dati. Che tu stia generando report o fatture, questo metodo semplificherà il tuo flusso di lavoro e migliorerà il processo di creazione dei documenti.

Domande frequenti

Che cos’è Aspose.Words per Java?

Aspose.Words per Java è una potente libreria per creare, manipolare e convertire documenti Word a livello di programmazione.

Posso usare Aspose.Words gratuitamente?

Sì, Aspose offre una versione di prova gratuita. Puoi scaricarla da Qui .

Come si formattano le tabelle in Aspose.Words?

È possibile applicare stili utilizzando identificatori di stile predefiniti e opzioni fornite dalla libreria.

Quali tipi di dati posso inserire nelle tabelle?

È possibile inserire vari tipi di dati, tra cui testo, numeri e date, che possono essere formattati di conseguenza.

Dove posso ottenere supporto per Aspose.Words?

Puoi trovare supporto e porre domande su Forum di Aspose .

Go Top