BeanIO è una libreria Java per il marshalling e l’unmarshalling di bean da file, stream o stringhe. È particolarmente utile quando dobbiamo leggere o scrivere dati strutturati in formati come CSV, XML, file delimitati o file a lunghezza fissa.
In molte applicazioni enterprise capita spesso di dover importare o esportare file: anagrafiche clienti, tracciati bancari, flussi gestionali, file contabili, report, dati per sistemi legacy o tracciati da elaborare in batch. In questi casi, scrivere manualmente parser e generatori di file può diventare ripetitivo, fragile e difficile da mantenere.
BeanIO nasce proprio per risolvere questo problema: permette di mappare record e campi su classi Java, definendo la struttura del file tramite XML, annotazioni o builder API. In questo modo possiamo trasformare righe di un file in oggetti Java e, al contrario, trasformare oggetti Java in righe, record o documenti strutturati.
In breve: BeanIO permette di leggere e scrivere file strutturati in Java, trasformando dati CSV, XML, delimitati o fixed length in bean Java e viceversa.
Indice dei contenuti
- Cos’è BeanIO
- Quando usare BeanIO
- Formati supportati da BeanIO
- Dipendenza Maven di BeanIO
- Creazione del modello dati
- Configurazione con mapping XML
- Stream, record, field e segment
- StreamFactory in BeanIO
- Marshaller e Unmarshaller
- Scrivere file con BeanWriter
- Leggere file con BeanReader
- File delimitati con separatore personalizzato
- File a lunghezza fissa
- Validazione ed errori
- BeanIO e Spring Batch
- Best practice
- Errori comuni
- FAQ su BeanIO
Cos’è BeanIO
BeanIO è una libreria Java open source pensata per leggere e scrivere oggetti Java da e verso file strutturati. Il suo utilizzo è molto comune in scenari di integrazione, import/export dati e batch processing.
Il concetto principale è semplice: invece di leggere manualmente una riga, dividerla con split(), convertire i singoli campi, controllare posizioni, lunghezze e formati, BeanIO permette di definire un mapping tra il file e le classi Java.
Per esempio, una riga CSV come questa:
Jennifer,Jones,05/02/2019,44 West 29th Street,New York,NY,10001può essere trasformata automaticamente in un oggetto Customer contenente dati anagrafici e un oggetto annidato Address.
Allo stesso modo, un oggetto Java può essere trasformato in una riga CSV, in un record delimitato, in un record a lunghezza fissa o in un documento XML.
Schema concettuale
File CSV / XML / Fixed Length
↓
BeanIO Mapping
↓
BeanReader / Unmarshaller
↓
Bean JavaBean Java
↓
BeanIO Mapping
↓
BeanWriter / Marshaller
↓
File CSV / XML / Fixed LengthConcetto chiave: BeanIO separa la struttura del file dal codice Java. Il formato del file viene descritto nel mapping, mentre il codice lavora con normali oggetti Java.
Quando usare BeanIO
BeanIO è utile quando un’applicazione Java deve importare o esportare dati in formati strutturati, specialmente in ambito enterprise.
È indicato quando devi lavorare con:
- file CSV ricevuti da sistemi esterni;
- file delimitati da caratteri come
|,;o tabulazioni; - file a lunghezza fissa usati da sistemi legacy;
- flussi XML mappati su oggetti Java;
- tracciati di importazione o esportazione;
- batch periodici che leggono file da cartelle o sistemi esterni;
- integrazioni con Spring Batch;
- validazione e conversione di record strutturati.
Quando BeanIO è una buona scelta
- Il formato del file è stabile e ben definito.
- Hai molti campi da leggere o scrivere.
- Devi mappare file su oggetti Java.
- Vuoi separare configurazione del tracciato e logica applicativa.
- Devi gestire file legacy a lunghezza fissa.
- Vuoi integrare la lettura/scrittura in processi batch.
Quando potrebbe non servire
- Il file è molto semplice e contiene pochi campi.
- Ti basta una libreria CSV leggera.
- Il formato cambia continuamente.
- Non hai bisogno di mapping su bean Java.
- Devi processare grandi file con logiche molto personalizzate e streaming manuale.
Formati supportati da BeanIO
Uno dei punti forti di BeanIO è il supporto a diversi formati di stream.
| Formato | Descrizione | Esempio d’uso |
|---|---|---|
| CSV | File con campi separati da virgola. | Import/export dati tabellari. |
| Delimited | File delimitato da un separatore personalizzato. | File con separatore | o ;. |
| Fixed length | File con campi in posizioni e lunghezze fisse. | Tracciati legacy o bancari. |
| XML | Documenti XML mappati su bean Java. | Integrazioni strutturate. |
Nel file di mapping, il formato viene indicato tramite l’attributo format del tag stream.
<stream name="customerFile" format="csv">
...
</stream>Dipendenza Maven di BeanIO
Nei vecchi esempi si trova spesso la dipendenza storica con gruppo org.beanio. Nei progetti moderni è opportuno controllare la versione aggiornata e il gruppo Maven più recente.
Dipendenza moderna
<dependency>
<groupId>com.github.beanio</groupId>
<artifactId>beanio</artifactId>
<version>3.2.1</version>
</dependency>Vecchia dipendenza legacy
<dependency>
<groupId>org.beanio</groupId>
<artifactId>beanio</artifactId>
<version>2.1.0.M1</version>
</dependency>Nota pratica: se stai aggiornando un progetto legacy, verifica sempre compatibilità, package, versioni e comportamento dei mapping prima di sostituire la dipendenza.
Creazione del modello dati
Per iniziare con BeanIO, creiamo due classi Java: Customer e Address. L’obiettivo è leggere e scrivere un record cliente contenente dati anagrafici e indirizzo.
Classe Customer
package it.javaboss.beanio.model;
import java.util.Date;
public class Customer {
private String firstName;
private String lastName;
private Date acquisition;
private Address address;
public Customer() {
}
public Customer(String firstName, String lastName, Date acquisition, Address address) {
this.firstName = firstName;
this.lastName = lastName;
this.acquisition = acquisition;
this.address = address;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Date getAcquisition() {
return acquisition;
}
public void setAcquisition(Date acquisition) {
this.acquisition = acquisition;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
}Classe Address
package it.javaboss.beanio.model;
public class Address {
private String street;
private String city;
private String state;
private String zip;
public Address() {
}
public Address(String street, String city, String state, String zip) {
this.street = street;
this.city = city;
this.state = state;
this.zip = zip;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getZip() {
return zip;
}
public void setZip(String zip) {
this.zip = zip;
}
}BeanIO lavora bene con JavaBean tradizionali, quindi è importante avere costruttore vuoto, getter e setter.
Best practice: mantieni i bean semplici. Il mapping BeanIO deve collegare i campi del file alle proprietà Java in modo chiaro.
Configurazione con mapping XML
BeanIO può essere configurato tramite XML, annotazioni o builder API. In molti scenari enterprise, il mapping XML è ancora molto comodo perché separa il tracciato del file dal codice Java.
Creiamo nella cartella src/main/resources il file:
customer-mapping.xmlMapping XML per file CSV
<beanio xmlns="http://www.beanio.org/2012/03"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.beanio.org/2012/03
http://www.beanio.org/2012/03/mapping.xsd">
<stream name="customerFile" format="csv">
<record name="customer" class="it.javaboss.beanio.model.Customer">
<field name="firstName" />
<field name="lastName" />
<field name="acquisition" format="dd/MM/yyyy" />
<segment name="address" class="it.javaboss.beanio.model.Address">
<field name="street" />
<field name="city" />
<field name="state" />
<field name="zip" />
</segment>
</record>
</stream>
</beanio>Questo file indica a BeanIO come leggere e scrivere il record cliente. Ogni campo del CSV viene collegato a una proprietà del bean.
CSV atteso
Jennifer,Jones,05/02/2019,44 West 29th Street,New York,NY,10001Il mapping dice a BeanIO che:
Jennifercorrisponde afirstName;Jonescorrisponde alastName;05/02/2019corrisponde aacquisition;- gli ultimi quattro campi appartengono al segmento
address.
Stream, record, field e segment
Per usare bene BeanIO, bisogna capire i principali elementi del file di mapping.
stream
Il tag stream definisce un flusso di input o output. Ogni stream ha un nome e un formato.
<stream name="customerFile" format="csv">
...
</stream>Il nome viene usato nel codice Java quando creiamo BeanReader, BeanWriter, Marshaller o Unmarshaller.
record
Il tag record definisce un tipo di record all’interno dello stream.
<record name="customer" class="it.javaboss.beanio.model.Customer">
...
</record>In questo caso, ogni record viene mappato sulla classe Customer.
field
Il tag field definisce un campo semplice.
<field name="firstName" />Il nome del campo deve corrispondere a una proprietà del bean, cioè a getter e setter compatibili.
segment
Il tag segment permette di mappare un oggetto annidato.
<segment name="address" class="it.javaboss.beanio.model.Address">
<field name="street" />
<field name="city" />
<field name="state" />
<field name="zip" />
</segment>Nel nostro esempio, i campi dell’indirizzo non vengono salvati direttamente in Customer, ma dentro la proprietà address.
StreamFactory in BeanIO
StreamFactory è il punto di accesso principale per caricare il mapping e creare reader, writer, marshaller e unmarshaller.
Caricare il mapping XML
package it.javaboss.beanio;
import org.beanio.StreamFactory;
import java.io.File;
public class BeanIOFactoryExample {
public static StreamFactory createFactory() throws Exception {
StreamFactory factory = StreamFactory.newInstance();
File mappingFile = new File(
BeanIOFactoryExample.class
.getClassLoader()
.getResource("customer-mapping.xml")
.getFile()
);
factory.load(mappingFile);
return factory;
}
}Una volta caricato il file di mapping, possiamo usare la factory per creare gli oggetti necessari alle operazioni di lettura e scrittura.
Nota pratica: in ambienti reali, presta attenzione al caricamento delle risorse da classpath, specialmente quando l’applicazione viene pacchettizzata in jar.
Marshaller e Unmarshaller
Le operazioni più semplici con BeanIO sono marshalling e unmarshalling.
- Marshalling: trasformare un bean Java in una stringa o record.
- Unmarshalling: trasformare una stringa o record in un bean Java.
Creare un Customer di esempio
package it.javaboss.beanio;
import it.javaboss.beanio.model.Address;
import it.javaboss.beanio.model.Customer;
import java.text.SimpleDateFormat;
public class CustomerUtils {
public static Customer createJenniferJones() throws Exception {
Address address = new Address(
"44 West 29th Street",
"New York",
"NY",
"10001"
);
return new Customer(
"Jennifer",
"Jones",
new SimpleDateFormat("dd/MM/yyyy").parse("05/02/2019"),
address
);
}
}Marshalling: da bean a CSV
package it.javaboss.beanio;
import it.javaboss.beanio.model.Customer;
import org.beanio.StreamFactory;
public class CustomerMarshallerExample {
public static void main(String[] args) throws Exception {
StreamFactory factory = BeanIOFactoryExample.createFactory();
Customer customer = CustomerUtils.createJenniferJones();
String record = factory
.createMarshaller("customerFile")
.marshal(customer)
.toString();
System.out.println(record);
}
}Output atteso
Jennifer,Jones,05/02/2019,44 West 29th Street,New York,NY,10001Unmarshalling: da CSV a bean
package it.javaboss.beanio;
import it.javaboss.beanio.model.Customer;
import org.beanio.StreamFactory;
public class CustomerUnmarshallerExample {
public static void main(String[] args) throws Exception {
StreamFactory factory = BeanIOFactoryExample.createFactory();
String record = "Jennifer,Jones,05/02/2019,44 West 29th Street,New York,NY,10001";
Customer customer = (Customer) factory
.createUnmarshaller("customerFile")
.unmarshal(record);
System.out.println(customer.getFirstName());
System.out.println(customer.getLastName());
System.out.println(customer.getAddress().getCity());
}
}Output
Jennifer
Jones
New YorkConcetto chiave: con il marshalling generi un record partendo da un bean. Con l’unmarshalling ottieni un bean partendo da un record.
Scrivere file con BeanWriter
Quando dobbiamo scrivere più record su file, usiamo BeanWriter.
Lista di clienti
package it.javaboss.beanio;
import it.javaboss.beanio.model.Address;
import it.javaboss.beanio.model.Customer;
import java.text.SimpleDateFormat;
import java.util.List;
public class CustomerData {
public static List<Customer> customers() throws Exception {
SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
return List.of(
new Customer(
"Jennifer",
"Jones",
format.parse("05/02/2019"),
new Address("44 West 29th Street", "New York", "NY", "10001")
),
new Customer(
"Paul",
"Adams",
format.parse("05/02/2019"),
new Address("29 West 44th Street", "New York", "NY", "10001")
)
);
}
}Scrittura del file CSV
package it.javaboss.beanio;
import it.javaboss.beanio.model.Customer;
import org.beanio.BeanWriter;
import org.beanio.StreamFactory;
import java.io.File;
public class CustomerWriter {
public static void main(String[] args) throws Exception {
StreamFactory factory = BeanIOFactoryExample.createFactory();
BeanWriter writer = factory.createWriter(
"customerFile",
new File("customers.csv")
);
try {
for (Customer customer : CustomerData.customers()) {
writer.write(customer);
}
writer.flush();
} finally {
writer.close();
}
}
}File generato
Jennifer,Jones,05/02/2019,44 West 29th Street,New York,NY,10001
Paul,Adams,05/02/2019,29 West 44th Street,New York,NY,10001Il BeanWriter usa il mapping per sapere come trasformare ogni oggetto Customer in una riga CSV.
Best practice: chiudi sempre il writer in un blocco
finallyoppure usa una strategia equivalente per garantire il rilascio delle risorse.
Leggere file con BeanReader
Per leggere un file e trasformare ogni record in un bean Java, BeanIO mette a disposizione BeanReader.
File customers.csv
Jennifer,Jones,05/02/2019,44 West 29th Street,New York,NY,10001
Paul,Adams,05/02/2019,29 West 44th Street,New York,NY,10001Lettura del file CSV
package it.javaboss.beanio;
import it.javaboss.beanio.model.Customer;
import org.beanio.BeanReader;
import org.beanio.StreamFactory;
import java.io.File;
public class CustomerReader {
public static void main(String[] args) throws Exception {
StreamFactory factory = BeanIOFactoryExample.createFactory();
BeanReader reader = factory.createReader(
"customerFile",
new File("customers.csv")
);
try {
Customer customer;
while ((customer = (Customer) reader.read()) != null) {
System.out.println(
customer.getFirstName()
+ " "
+ customer.getLastName()
+ " - "
+ customer.getAddress().getCity()
);
}
} finally {
reader.close();
}
}
}Output
Jennifer Jones - New York
Paul Adams - New YorkFile delimitati con separatore personalizzato
Oltre al formato CSV classico, BeanIO supporta anche file delimitati con separatori personalizzati.
Per esempio, possiamo avere un file con separatore |:
Jennifer|Jones|05/02/2019|44 West 29th Street|New York|NY|10001Mapping delimited
<beanio xmlns="http://www.beanio.org/2012/03">
<stream name="customerDelimitedFile" format="delimited">
<parser>
<property name="delimiter" value="|" />
</parser>
<record name="customer" class="it.javaboss.beanio.model.Customer">
<field name="firstName" />
<field name="lastName" />
<field name="acquisition" format="dd/MM/yyyy" />
<segment name="address" class="it.javaboss.beanio.model.Address">
<field name="street" />
<field name="city" />
<field name="state" />
<field name="zip" />
</segment>
</record>
</stream>
</beanio>La differenza principale rispetto al CSV è il formato dello stream e la configurazione del parser.
Attenzione: nel mapping, il valore corretto del formato è
delimited. Evita errori di battitura comedelmiited.
File a lunghezza fissa
I file a lunghezza fissa sono molto diffusi nei sistemi legacy, bancari, assicurativi e gestionali. In questi file, ogni campo occupa una posizione e una lunghezza precisa.
Esempio concettuale
Jennifer Jones 05022019NY10001In un file fixed length non esiste un separatore tra i campi. È la posizione a determinare dove inizia e finisce ogni valore.
Mapping fixed length
<beanio xmlns="http://www.beanio.org/2012/03">
<stream name="customerFixedFile" format="fixedlength">
<record name="customer" class="it.javaboss.beanio.model.Customer">
<field name="firstName" length="10" padding=" " justify="left" />
<field name="lastName" length="10" padding=" " justify="left" />
<field name="acquisition" length="10" format="dd/MM/yyyy" />
<segment name="address" class="it.javaboss.beanio.model.Address">
<field name="city" length="15" padding=" " justify="left" />
<field name="state" length="2" />
<field name="zip" length="5" />
</segment>
</record>
</stream>
</beanio>Questo tipo di mapping è molto utile quando devi rispettare tracciati rigidi definiti da sistemi esterni.
Quando usare fixed length
- tracciati bancari;
- flussi legacy;
- integrazioni mainframe;
- scambi dati con sistemi vecchi;
- file con specifiche di posizione e lunghezza campo.
Validazione ed errori
BeanIO non si limita a leggere e scrivere campi. Può anche aiutare a validare la struttura del record in base al mapping.
Gli errori più comuni possono riguardare:
- numero di campi non corretto;
- formato data non valido;
- lunghezza campo errata;
- conversione non riuscita;
- record non riconosciuto;
- campo obbligatorio mancante;
- valore non compatibile con il tipo Java.
Esempio di gestione errori in lettura
import org.beanio.BeanReader;
import org.beanio.InvalidRecordException;
import org.beanio.StreamFactory;
import java.io.File;
public class CustomerReaderWithErrors {
public static void main(String[] args) throws Exception {
StreamFactory factory = BeanIOFactoryExample.createFactory();
BeanReader reader = factory.createReader(
"customerFile",
new File("customers.csv")
);
try {
Object record;
while (true) {
try {
record = reader.read();
if (record == null) {
break;
}
Customer customer = (Customer) record;
System.out.println(customer.getFirstName());
} catch (InvalidRecordException e) {
System.err.println("Record non valido: " + e.getRecordContext().getRecordText());
System.err.println("Linea: " + e.getRecordContext().getLineNumber());
}
}
} finally {
reader.close();
}
}
}Gestire gli errori in modo esplicito è importante soprattutto nei batch, dove un file può contenere migliaia o milioni di record.
Best practice: nei processi batch reali, non limitarti a stampare lo stack trace. Registra record errati, numero riga, messaggio e causa dell’errore.
BeanIO e Spring Batch
BeanIO si integra molto bene con scenari di batch processing. In un processo Spring Batch, infatti, è comune dover leggere file strutturati e trasformare ogni riga in un oggetto Java da processare.
Lo schema tipico è:
File input
↓
BeanIO Reader
↓
ItemProcessor
↓
ItemWriter
↓
Database / File output / APIPerché BeanIO è utile con Spring Batch
- Permette di separare il mapping del file dalla logica batch.
- Supporta file CSV, delimited e fixed length.
- Aiuta a convertire record in bean Java.
- È adatto a tracciati strutturati e legacy.
- Può essere usato per import e export.
Esempio concettuale di reader batch
public class CustomerItemReader {
private final BeanReader beanReader;
public CustomerItemReader(BeanReader beanReader) {
this.beanReader = beanReader;
}
public Customer read() {
return (Customer) beanReader.read();
}
}In un progetto reale, questo reader dovrebbe gestire apertura, chiusura, eccezioni, restart e stato dell’esecuzione secondo le regole di Spring Batch.
Confronto: BeanIO, OpenCSV e parsing manuale
BeanIO non è l’unica soluzione per leggere file CSV o strutturati. Tuttavia, offre un approccio diverso rispetto a librerie più semplici.
| Soluzione | Quando usarla | Limite principale |
|---|---|---|
| Parsing manuale | File molto semplici e temporanei. | Poco manutenibile su tracciati complessi. |
| OpenCSV | CSV semplici o mediamente strutturati. | Meno adatto a fixed length e mapping complessi. |
| BeanIO | CSV, delimited, fixed length, XML, tracciati enterprise. | Richiede mapping e configurazione iniziale. |
| Spring Batch FlatFileItemReader | Batch Spring con file strutturati. | Configurazione più legata a Spring Batch. |
Se devi semplicemente leggere un CSV di poche colonne, una libreria CSV può bastare. Se invece hai tracciati complessi, campi annidati, formati diversi e integrazione batch, BeanIO diventa più interessante.
Best practice con BeanIO
- Definisci mapping chiari e versionati.
- Evita di nascondere la struttura del file nel codice Java.
- Usa nomi di stream descrittivi.
- Controlla sempre il formato delle date.
- Gestisci gli errori di parsing in modo esplicito.
- Chiudi sempre
BeanReadereBeanWriter. - Usa test automatici sui file di esempio.
- Conserva file input e output di test.
- Non modificare mapping di produzione senza regression test.
- Documenta posizione, lunghezza e significato dei campi.
- Verifica attentamente l’encoding dei file.
- Nei batch, registra numero riga e record problematico.
Errori comuni con BeanIO
Usare una dipendenza vecchia senza verificarla
Molti tutorial storici usano versioni vecchie di BeanIO. Prima di creare un nuovo progetto, verifica sempre la versione più recente e il gruppo Maven corretto.
Dimenticare getter e setter
BeanIO lavora con proprietà JavaBean. Se mancano getter, setter o costruttore vuoto, il mapping può non funzionare correttamente.
Confondere CSV e delimited
CSV e delimited sono simili, ma non sempre identici. Se usi un separatore personalizzato come |, valuta il formato delimited.
Non chiudere reader e writer
Lasciare aperti reader o writer può causare problemi di risorse, file non completi o dati non scritti correttamente.
Non testare i formati data
Un formato data errato può causare errori di conversione. Se il file usa dd/MM/yyyy, il mapping deve rifletterlo esattamente.
Ignorare i file a lunghezza fissa
Nei fixed length, anche uno spazio in più o in meno può rompere il tracciato. È fondamentale testare posizioni e lunghezze.
Non gestire record non validi
Nei batch reali, prima o poi arriverà un file sporco. Prevedi sempre una strategia di errore.
Checklist prima di usare BeanIO in produzione
| Controllo | Domanda da farsi |
|---|---|
| Mapping | Il mapping XML riflette esattamente il tracciato? |
| Versione | La dipendenza Maven è aggiornata e compatibile? |
| Bean | Le classi hanno costruttore vuoto, getter e setter? |
| Date | I formati data sono corretti? |
| Encoding | Il file usa l’encoding previsto? |
| Errori | Gli errori di parsing vengono loggati con numero riga? |
| Test | Esistono test con file validi e non validi? |
| Performance | Il processo è stato testato con file realistici? |
| Batch | Il reader è integrato correttamente con Spring Batch? |
FAQ su BeanIO
Cos’è BeanIO?
BeanIO è una libreria Java per leggere e scrivere bean da e verso file strutturati, stream o stringhe. Supporta formati come CSV, XML, delimited e fixed length.
A cosa serve BeanIO?
Serve a trasformare record di file in oggetti Java e oggetti Java in record di file, riducendo codice manuale di parsing e generazione.
BeanIO supporta CSV?
Sì. BeanIO supporta file CSV e permette di mappare i campi del CSV su proprietà Java.
BeanIO supporta file a lunghezza fissa?
Sì. Uno dei punti forti di BeanIO è il supporto ai file fixed length, molto usati in sistemi legacy ed enterprise.
Cos’è StreamFactory in BeanIO?
StreamFactory è il componente principale usato per caricare il mapping e creare BeanReader, BeanWriter, Marshaller e Unmarshaller.
Cos’è BeanReader?
BeanReader legge record da un file o stream e li trasforma in oggetti Java secondo il mapping definito.
Cos’è BeanWriter?
BeanWriter scrive oggetti Java in un file o stream, trasformandoli nel formato definito dal mapping.
Che differenza c’è tra marshalling e unmarshalling?
Il marshalling trasforma un oggetto Java in un record o stringa. L’unmarshalling trasforma un record o stringa in un oggetto Java.
BeanIO si integra con Spring Batch?
Sì. BeanIO è molto adatto a scenari batch, perché permette di leggere e scrivere file strutturati trasformandoli in bean Java.
Meglio BeanIO o OpenCSV?
OpenCSV può essere più semplice per CSV basilari. BeanIO è più adatto quando devi gestire formati diversi, mapping strutturati, oggetti annidati, fixed length o integrazioni enterprise.
BeanIO richiede un file XML?
No. BeanIO può essere configurato anche con annotazioni o builder API. Tuttavia, il mapping XML è spesso molto usato perché è flessibile e separa il tracciato dal codice.
Qual è la dipendenza Maven moderna di BeanIO?
Nei progetti moderni puoi usare il gruppo com.github.beanio con artifact beanio, verificando sempre la versione più recente disponibile.
Conclusione
BeanIO è una libreria molto utile quando un’applicazione Java deve leggere o scrivere file strutturati. Grazie al mapping tra record e bean Java, permette di ridurre codice manuale, rendere più chiara la struttura dei tracciati e gestire formati diversi come CSV, XML, delimited e fixed length.
Il punto centrale di BeanIO è la separazione tra file e codice: il mapping descrive la struttura del dato, mentre il codice Java lavora con oggetti come Customer e Address. Questa separazione è particolarmente utile in contesti enterprise, dove i tracciati possono essere complessi, versionati e condivisi tra sistemi diversi.
Per iniziare bastano pochi concetti: una dipendenza Maven, un file di mapping, una StreamFactory, un Marshaller o Unmarshaller per singoli record, e BeanReader o BeanWriter per leggere e scrivere file completi.
BeanIO non è sempre necessario per file molto semplici, ma diventa molto interessante quando devi gestire tracciati reali, file legacy, importazioni batch, esportazioni periodiche e integrazione con Spring Batch.
Riassunto finale: BeanIO è una soluzione pratica per trasformare file strutturati in bean Java e bean Java in file strutturati. È particolarmente utile per CSV, delimited, XML, fixed length e processi batch enterprise.