Quale Java ORM preferisci e perché? [chiuso]


262

È una domanda piuttosto aperta. Inizierò un nuovo progetto e cercherò diversi ORM da integrare con l'accesso al database.

Hai dei preferiti? C'è qualcuno di cui consiglieresti di stare alla larga?



Dai un'occhiata ai micro-orm - involucri sottili attorno alla tecnologia di accesso al DB della piattaforma - come sql2o per Java github.com/aaberg/sql2o o ServiceStack.OrmLite per .NET github.com/ServiceStack/ServiceStack.OrmLite
tomaszkubacki

3
Dopo aver utilizzato ORM per più di 5 anni, la mia scelta personale è Spring JDBC rispetto a ORM e il secondo migliore è iBatis (MyBatis), non mi piace ibernare a causa della curva di apprendimento, meno controllo e problemi di prestazioni.

Ecco (anche chiuso) elenco dei wrapper JDBC leggero che può essere utilizzato come alternativa al ORM in piena regola: stackoverflow.com/questions/7137929/...
Vadzim

Risposte:


237

Ho smesso di usare gli ORM.

Il motivo non è un grande difetto nel concetto. Hibernate funziona bene. Invece, ho scoperto che le query hanno un sovraccarico basso e posso adattare molta logica complessa a query SQL di grandi dimensioni e spostare gran parte della mia elaborazione nel database.

Quindi considera solo l'uso del pacchetto JDBC.


81
È la stessa storia ancora e ancora con ORM: un piacevole sviluppo iniziale rapido e un grande drenaggio delle risorse più avanti nel progetto durante il monitoraggio di bug e inefficienze relative a ORM. Odio anche il fatto che sembra dare agli sviluppatori l'idea di non dover mai scrivere query ottimizzate specifiche.
Eelco,

7
Ehi, è tutto vero per i grandi progetti della vita reale?
santiagobasulto,

30
Sono d'accordo. Sto usando ORM da 3 anni ormai e non posso dire quanto tempo è stato sprecato (lo è ancora) per risolvere i problemi relativi alla persistenza. Non abbiamo alcun controllo su ciò che sta accadendo "sotto il cofano", le configurazioni sono troppe per essere gestite in modo efficiente e ci sono comportamenti che potrebbero far impazzire. D'altro canto, ho il supporto per i principali database e non devo mai preoccuparmi delle loro differenze.
marcolopes

58
perché non usare entrambi, a seconda della complessità della query / transazione? non è che si escludano a vicenda.
anfibio

6
@ WillSheppard sì Will. Uso Django ORM parecchio e funziona benissimo. Penso che la differenza potrebbe essere nella natura dinamica di python (e perl). L'uso di un ORM in Java è una seccatura. Ma nei linguaggi dinamici può essere davvero espressivo. Ci sono alcuni grandi progetti per incorporare operazioni ORM come DSL in Python e sono fantastici.
santiagobasulto,

97

Nessuno, perché avere un ORM toglie troppo controllo con piccoli benefici. I risparmi di tempo guadagnati vengono facilmente eliminati quando è necessario eseguire il debug delle anomalie derivanti dall'uso dell'ORM. Inoltre, gli ORM scoraggiano gli sviluppatori dall'apprendimento di SQL e dal modo in cui i database relazionali funzionano e lo utilizzano a loro vantaggio.


4
Sono d'accordo con questa affermazione. Quanto del tempo totale di sviluppo sarà consumato scrivendo il codice di persistenza? Penso che meno del 10-15%
adrian.tarau,

16
Dipende. Certo, se stai usando solo un particolare tipo di database, è facile cavarsela senza usare un ORM. Tuttavia, quando è necessario supportare altri tipi di database, può diventare rapidamente meno gestibile.
Jason Baker,

3
"I risparmi di tempo guadagnati vengono facilmente spazzati via quando si devono eseguire il debug delle anomalie risultanti dall'uso dell'ORM" Questo non è vero quando la curva delle competenze è un fattore decente quando si scelgono le tecnologie.
elsadek,

7
Il tuo argomento potrebbe essere offerto contro l'uso di qualsiasi biblioteca. I maggiori guadagni degli ORM sono cose come unità di lavoro, mappatura degli oggetti, rilevamento delle modifiche, caricamento lento, migrazioni e relazioni. È meraviglioso poter scrivere user.profile.givenName e non preoccuparsi della struttura utilizzata per archiviare i dati.
Alex,

1
Potrebbe essere usato contro qualsiasi libreria, ma a vari livelli. In generale, sono un grande sostenitore dell'uso delle librerie: perché reinventare la ruota? Tuttavia, in questo caso ritengo che Hibernate sia per la maggior parte degli usi un peso troppo elevato e un ORM più leggero sarebbe più preferibile. Le mie esperienze si basano su diversi anni di esperienza nello sviluppo di Hibernate e nell'apprendimento approfondito dei suoi dettagli.
simon,

92

Molti ORM sono fantastici, devi sapere perché vuoi aggiungere astrazione su JDBC. Posso consigliarti http://www.jooq.org (dichiarazione di non responsabilità: sono il creatore di jOOQ, quindi questa risposta è parziale). jOOQ abbraccia il seguente paradigma:

  • SQL è una buona cosa. Molte cose possono essere espresse abbastanza bene in SQL. Non è necessaria un'astrazione completa di SQL.
  • Il modello di dati relazionali è una buona cosa. Ha dimostrato il miglior modello di dati negli ultimi 40 anni. Non sono necessari database XML o modelli di dati realmente orientati agli oggetti. Invece, la tua azienda esegue diverse istanze di Oracle, MySQL, MSSQL, DB2 o qualsiasi altro RDBMS.
  • SQL ha una struttura e una sintassi. Non dovrebbe essere espresso usando la concatenazione di stringhe "di basso livello" in JDBC - o la concatenazione di stringhe "di alto livello" in HQL - entrambi inclini a contenere errori di sintassi.
  • L'associazione variabile tende ad essere molto complessa quando si affrontano query importanti. È qualcosa che dovrebbe essere astratto.
  • I POJO sono ottimi quando si scrive codice Java manipolando i dati del database.
  • I POJO sono un dolore da scrivere e mantenere manualmente. La generazione del codice è la strada da percorrere. Avrai query sicure per la compilazione, incluso datatype-safety.
  • Il database viene prima di tutto. Mentre l'applicazione nella parte superiore del database può cambiare nel tempo, probabilmente il database stesso durerà più a lungo.
  • Sì, nel tuo database legacy sono presenti procedure memorizzate e tipi definiti dall'utente (UDT). Il tuo strumento di database dovrebbe supportarlo.

Ci sono molti altri buoni ORM. Soprattutto Hibernate o iBATIS hanno una grande comunità. Ma se stai cercando uno intuitivo e semplice, ti dirò di provare jOOQ. Ti piacerà! :-)

Dai un'occhiata a questo esempio SQL:

  // Select authors with books that are sold out
  SELECT * 
    FROM T_AUTHOR a
   WHERE EXISTS (SELECT 1
                   FROM T_BOOK
                  WHERE T_BOOK.STATUS = 'SOLD OUT'
                    AND T_BOOK.AUTHOR_ID = a.ID);

E come può essere espresso in jOOQ:

  // Alias the author table
  TAuthor a = T_AUTHOR.as("a");

  // Use the aliased table in the select statement
  create.selectFrom(a)
        .whereExists(create.selectOne()
                           .from(T_BOOK)
                           .where(T_BOOK.STATUS.equal(TBookStatus.SOLD_OUT)
                           .and(T_BOOK.AUTHOR_ID.equal(a.ID))))));

1
Gli strumenti ORM sono grandi quanto riesci a usarli correttamente. Ci sono progetti in cui gli strumenti ORM funzionano come un fascino, mentre in altri non si adattano affatto bene. Alla fine, è responsabilità del team di sviluppo scegliere lo strumento giusto per i requisiti del proprio progetto. Gli strumenti ORM sono complessi. Sfortunatamente, solo una parte di tutti gli sviluppatori trascorrerà del tempo per capire come funzionano. Il resto incolperà lo strumento e dirà che è male. La domanda è: la risposta più votata offre i migliori consigli? > Quindi considera solo l'uso del pacchetto JDBC. Vogliamo davvero usare JDBC semplice?
Vlad Mihalcea,

Cerco di non lasciare "Il database viene prima.". Un'applicazione contiene le regole di business per le funzionalità richieste da un client e non chiedono quasi mai di creare un database. Questo è un dettaglio tecnico determinato durante l'implementazione.
Kwebble,

58

Ibernazione, perché è fondamentalmente lo standard defacto in Java ed è stata una delle forze trainanti nella creazione dell'APP. Ha un eccellente supporto in primavera e quasi tutti i framework Java lo supportano. Infine, GORM è un vero e proprio wrapper attorno a sé che ricerca dinamici e così via usando Groovy.

È stato anche portato su .NET (NHibernate), quindi puoi usarlo anche lì.


4
Anche io voto Hib, ma con un'importante aggiunta: dovremmo usare l'API JPA solo se l'implementazione JPA è effettivamente fornita da Hib.
Vladimir Dyuzhev,

52

Iberna, perché:

  • è stabile - essendo in circolazione per così tanti anni, non ha problemi importanti
  • detta gli standard nel campo ORM
  • implementa lo standard (JPA), oltre a dettarlo.
  • ha tonnellate di informazioni al riguardo su Internet. Esistono molti tutorial, soluzioni di problemi comuni, ecc
  • è potente: puoi tradurre un modello a oggetti molto complesso in un modello relazionale.
  • ha il supporto per qualsiasi RDBMS principale e medio
  • è facile lavorare con te, una volta che lo impari bene

Alcuni punti sul perché (e quando) utilizzare ORM:

  • lavori con oggetti nel tuo sistema (se il tuo sistema è stato progettato bene). Anche se usi JDBC, finirai per creare un livello di traduzione, in modo da trasferire i tuoi dati sui tuoi oggetti. Ma le mie scommesse sono che l'ibernazione è migliore nella traduzione rispetto a qualsiasi soluzione su misura.
  • non ti priva del controllo. Puoi controllare le cose con dettagli molto piccoli e se l'API non ha alcune funzionalità remote, esegui una query nativa e ce l'hai.
  • qualsiasi sistema di medie o grandi dimensioni non può permettersi di avere una tonnellata di query (che si tratti di un punto o sparse), se mira a essere mantenibile
  • se le prestazioni non sono critiche. Hibernate aggiunge un sovraccarico prestazionale, che in alcuni casi non può essere ignorato.

Quando confronto Hibernate e JPA vado per Hibernate, e se confronto JPA e JDO vado per JDO! Mi piace molto JDO, ma adoro due funzionalità di Hibernate (che non sono disponibili in JDO), una è @Filters e l'altra è che puoi mappare i campi della versione (per il blocco ottimistico) in campi normali, cosa impossibile in JDO .
Amir Pashazadeh,

27

Consiglierei di usare MyBatis . È un sottile strato sopra JDBC, è molto facile mappare oggetti su tabelle e usare ancora il semplice SQL, tutto è sotto il tuo controllo.


10
Ibatis per letture complesse e ibernazione per creare, aggiornare Elimina e letture semplici è la scelta perfetta.
Darpet,

19

Ho avuto un'ottima esperienza con Avaje Ebean mentre stavo scrivendo un'applicazione JavaSE di medie dimensioni.

Utilizza le annotazioni JPA standard per definire le entità, ma espone un'API molto più semplice (nessun EntityManager o una qualsiasi delle cazzate di entità collegate / staccate). Inoltre, consente di utilizzare facilmente query SQL o chiamate JDBC di eventi semplici quando necessario.

Ha anche un'API molto fluida e sicura per le query. Puoi scrivere cose come:

List<Person> boys = Ebean.find(Person.class)
                                  .where()
                                       .eq("gender", "M")
                                       .le("age", 18)
                                  .orderBy("firstName")
                                  .findList();

6
Devo essere un po 'strano ... selezionare da Persona in cui sesso =' M 'ed età <18 ordinati per firstName mi sembrano molto meglio :-)
Eelco,

4
Questo è uno dei migliori orms che ho visto in Java. La decisione di utilizzare un singleton è rinfrescante e gli conferisce un enorme vantaggio pratico rispetto agli altri.
opsb,

Penso che intendi fluente, non fluido.
Montdidier,

@opsb Penso che tecnicamente sia un monostato, non un singleton.
Montdidier,

Come iniziare con Avaje Ebean ORM? Tutti i video Tutorial ??
Avinash,

11

SimpleORM , perché è semplice e senza magia. Definisce tutte le strutture di metadati nel codice Java ed è molto flessibile.

SimpleORM fornisce funzionalità simili a Hibernate mappando i dati in un database relazionale su oggetti Java in memoria. Le query possono essere specificate in termini di oggetti Java, l'identità dell'oggetto è allineata con le chiavi del database, le relazioni tra gli oggetti vengono mantenute e gli oggetti modificati vengono automaticamente scaricati nel database con blocchi ottimistici.

Ma a differenza di Hibernate, SimpleORM utilizza una struttura e un'architettura di oggetti molto semplici che evitano la necessità di analisi complesse, elaborazione di codici byte ecc. SimpleORM è piccolo e trasparente, confezionato in due vasetti di appena 79K e 52K di dimensioni, con un solo piccolo e opzionale dipendenza (Slf4j). (Hibernate è oltre 2400 K più circa 2000 K di barattoli dipendenti.) Ciò rende SimpleORM di facile comprensione e riduce notevolmente il rischio tecnico.


Non l'ho mai usato, ma ActiveObjects si descrive come una specie di Hibernate-lite sul loro sito Web, quindi probabilmente c'è qualche somiglianza.
Abdullah Jibaly,

10

Eclipse Link , per molte ragioni, ma in particolare mi sento come se avesse meno gonfiore rispetto ad altre soluzioni di flusso principali (almeno meno gonfiore in faccia).

Oh ed Eclipse Link è stato scelto come implementazione di riferimento per JPA 2.0


5

Mentre condivido le preoccupazioni riguardanti le sostituzioni Java per le query SQL in formato libero, penso davvero che le persone che criticano ORM lo stiano facendo a causa di una progettazione delle applicazioni generalmente scadente.

True OOD è guidato da classi e relazioni e ORM offre una mappatura coerente di diversi tipi e oggetti di relazione. Se usi uno strumento ORM e finisci per codificare espressioni di query in qualsiasi linguaggio di query supportato dal framework ORM (incluso, ma non limitato a alberi di espressioni Java, metodi di query, OQL ecc.), Stai sicuramente facendo qualcosa di sbagliato, cioè il tuo modello di classe molto probabilmente non supporta le tue esigenze nel modo in cui dovrebbe. Un design pulito dell'applicazione non ha davvero bisogno di query a livello di applicazione. Ho eseguito il refactoring di molti progetti che le persone hanno iniziato a utilizzare un framework ORM nello stesso modo in cui sono stati utilizzati per incorporare costanti di stringhe SQL nel loro codice e alla fine tutti sono rimasti sorpresi di quanto sia semplice e gestibile l'intera applicazione una volta abbinata il tuo modello di classe con il modello di utilizzo. Certo, per cose come la funzionalità di ricerca ecc. Hai bisogno di un linguaggio di query, ma anche in questo caso le query sono così limitate che la creazione di una VISTA e la mappatura anche complesse che a una classe persistente di sola lettura è molto più facile da mantenere e guardare rispetto alla creazione di espressioni in un linguaggio di query nel codice dell'applicazione. L'approccio VIEW sfrutta anche le capacità del database e, attraverso la materializzazione, può essere molto più efficiente dal punto di vista delle prestazioni rispetto a qualsiasi SQL scritto a mano nella tua sorgente Java. Quindi, non vedo alcun motivo per un'applicazione non banale NON utilizzare ORM. ma anche in questo caso le query sono così limitate che la creazione di una VISTA e la mappatura anche complesse che a una classe persistente di sola lettura è molto più semplice da mantenere e da guardare rispetto alla creazione di espressioni in un linguaggio di query nel codice dell'applicazione. L'approccio VIEW sfrutta anche le capacità del database e, attraverso la materializzazione, può essere molto più efficiente dal punto di vista delle prestazioni rispetto a qualsiasi SQL scritto a mano nella tua sorgente Java. Quindi, non vedo alcun motivo per un'applicazione non banale NON utilizzare ORM. ma anche in questo caso le query sono così limitate che la creazione di una VISTA e la mappatura anche complesse che a una classe persistente di sola lettura è molto più semplice da mantenere e da guardare rispetto alla creazione di espressioni in un linguaggio di query nel codice dell'applicazione. L'approccio VIEW sfrutta anche le capacità del database e, attraverso la materializzazione, può essere molto più efficiente dal punto di vista delle prestazioni rispetto a qualsiasi SQL scritto a mano nella tua sorgente Java. Quindi, non vedo alcun motivo per un'applicazione non banale NON utilizzare ORM.


11
Se stai costruendo applicazioni su un negozio persistente, come molti di noi, sia che si tratti di un RDBMS o di un sapore NoSQL, quel negozio avrà il suo modo efficace di accedervi. Cercare di sottrarre troppo a questo è semplicemente ingegnerizzazione eccessiva. Essere troppo zelanti riguardo al "vero OOD" rende queste architetture di astronauti per cui Java è tristemente famoso.
Eelco,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.