Qual è il modo più semplice per mantenere oggetti java?

Question

In questo momento ho un programma java le cui classi sono attualmente POJO e memorizzate nella memoria volatile. Questi devono essere persistenti. A quanto ho capito, due scelte popolari sono JDO e Java Persistence API. Per qualcuno che sa poco di SQL, Torque, ecc. Qual è il modo più semplice per aggiungere persistenza ai dati del mio programma?

Answer 1

Il modo tradizionale di serializzare sul filesystem è utilizzare Java Serialisation. Tuttavia è necessario implementare Serializable ovunque.

Una soluzione più semplice consiste nel serializzare in XML (e quindi eseguire il dump nel file system) utilizzando XStream. Non è necessario implementare alcuna interfaccia e la maggior parte di tutte le serializzazioni e deserializzazioni senza ulteriori interventi. È possibile personalizzare ulteriormente la serializzazione, se necessario. L'unico problema che abbia mai avuto è serializzazione di una classe interna, senza serializzazione intenzionalmente la classe esterna che contiene (questo è dovuto al implicita this riferimento)

Answer 2

Serializzare gli oggetti nel file system se non si conoscono database SQL o relazionali.

Dovrai imparare JDBC per usare JDO, JPA, Hibernate o qualsiasi altra cosa. A meno che i tuoi POJO non siano complessi, ti consiglio di iniziare da lì e di iniziare a lavorare.

Assicurati di conoscere la normalizzazione e la corretta progettazione degli indici.

Answer 3

Sembra che si desideri mantenere un DB. Tuttavia, per evitare le complessità di un DB una soluzione semplice per persistere POJO al file system è serializzarli su un documento XML. L'API Java 1.6 include il framework JAXB trovato nel pacchetto javax.xml.bind. Per utilizzare JAXB si essenzialmente annotazione tuo POJO e creare maresciallo e unmarshalling metodi in questo modo:

@XmlRootElement(name="Foo") 
public class Foo { 

    @XmlElement(name="Bar") 
    public int mBar; 

    public static void marshal(Foo foo, OutputStream out) IOException {  
     try { 
     JAXBContext jc = JAXBContext.newInstance(Foo.class); 
     Marshaller marshaller = jc.createMarshaller(); 
     marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); 
     marshaller.marshal(qaConfig, out); 
     } 
     catch (JAXBException ex) { 
     throw new IOException(ex); 
     } 
     finally { 
     out.close(); 
     } 
    } 

    public static Foo unmarshal(InputStream in) throws IOException { 

     try { 
     JAXBContext jc = JAXBContext.newInstance(Foo.class); 
     Unmarshaller unmarshaller = jc.createUnmarshaller(); 

     return (Foo)unmarshaller.unmarshal(in); 
     } 
     catch (JAXBException ex) { 
     throw new IOException(ex); 
     } 
     finally { 
     in.close(); 
     } 
    } 
} 

Diciamo che persistono un'istanza di Foo dove mBar è 42, allora questa soluzione produrrebbe un file XML in questo modo:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?> 
<Foo> 
    <Bar>42</Bar> 
</Foo> 

Answer 4

Il modo più semplice mi sono imbattuto finora è db4o:

ObjectContainer db = Db4o.openFile(location); 
db.store(myObject); 
List<MyObject> myObjects = db.query(MyObject.class); 

In più ci sono modi davvero interessanti di interrogare in altri modi.

Answer 5

Se la serializzazione è un'opzione, è consigliabile utilizzare un'API di prevalenza come prevalayer o Space4J (più recente). Informazioni sulla prevalenza degli oggetti:

Prevalence è un concetto iniziato da Klaus Wuestefeld su come memorizzare i dati in modo orientato agli oggetti reali, utilizzando solo snapshot di memoria, registri delle transazioni e serializzazione.

Controllare this article per ulteriori informazioni su questo argomento (ulteriori informazioni su Google).

Answer 6

DataNucleus è il modo più semplice in quanto fornisce le API JDO e JPA per la persistenza in quasi tutti i tipi di archivio dati che si vorrebbe. Perché scrivere tutto il codice JAXB in una delle altre risposte quando DataNucleus lo fa per te? Il tutto supportato dagli standard Java