What Java Orm heb je het liefst, en waarom?

Het is een behoorlijk open vraag. Ik begin een nieuw project en kijk naar verschillende ORM’s om te integreren met databasetoegang.

Heb je favoriete favorieten?
Zijn er iemand die zou willen adviseren om er vrij te blijven?

Antwoord 1, Autoriteit 100%

Ik ben gestopt met ORMS.

De reden is geen grote fout in het concept. HEIBERNATE werkt goed. In plaats daarvan heb ik ontdekt dat query’s lage overhead hebben en ik kan veel complexe logica in grote SQL-query’s passen en veel van mijn verwerking in de database verschuiven.

Overweeg dus gewoon het JDBC-pakket gebruiken.

Antwoord 2, Autoriteit 41%

Geen, want het hebben van een orm neemt te veel controle weg met kleine voordelen. De opgedane tijdsbesparing wordt gemakkelijk weggeblazen als u abnormaliteiten moet debuggen die het gevolg zijn van het gebruik van de ORM. Bovendien ontmoedigen Orms ontwikkelaars van het leren van SQL en hoe relationele databases werken en dit gebruiken voor hun voordeel.

Antwoord 3, Autoriteit 38%

Veel Orm’s zijn geweldig, je moet weten waarom je abstractie bovenop JDBC wilt toevoegen. Ik kan http://www.jooq.org to you (disclaimer: i ‘ m de Schepper van Jooq, dus dit antwoord is bevooroordeeld). Jooq omarmt het volgende paradigma:

• SQL is een goede zaak. Veel dingen kunnen vrij mooi worden uitgedrukt in SQL. Er is geen behoefte aan volledige abstractie van SQL.
• Het relationele gegevensmodel is een goede zaak. Het heeft het beste gegevensmodel voor de laatste 40 jaar bewezen. Er is geen behoefte aan XML-databases of werkelijk objectgeoriënteerde gegevensmodellen. In plaats daarvan voert uw bedrijf verschillende gevallen van Oracle, MySQL, MSSQL, DB2 of andere RDBMS.
• SQL heeft een structuur en syntaxis. Het mag niet worden uitgedrukt met behulp van “low-level” String-aaneenschakeling in JDBC – of “high-level” String-concatenatie in HQL – die beide gevoelig zijn voor syntaxisfouten.
• Het binden van variabelen is vaak erg complex bij het behandelen van grote vragen. DAT moet geabstraheerd worden.
• POJO’s zijn geweldig bij het schrijven van Java-code en het manipuleren van databasegegevens.
• POJO’s zijn lastig om handmatig te schrijven en te onderhouden. Code generatie is de manier om te gaan. Je hebt compile-safe queries inclusief datatype-safety.
• De database komt op de eerste plaats. Hoewel de applicatie bovenop uw database in de loop van de tijd kan veranderen, zal de database zelf waarschijnlijk langer meegaan.
• Ja, u hebt opgeslagen procedures en door de gebruiker gedefinieerde typen (UDT’s) in uw oude database. Je database-tool zou dat moeten ondersteunen.

Er zijn veel andere goede ORM’s. Vooral Hibernate of iBATIS hebben een geweldige community. Maar als je op zoek bent naar een intuïtieve, eenvoudige, zou ik zeggen: probeer jOOQ eens. Je zult het geweldig vinden! 🙂

Bekijk dit voorbeeld 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);

En hoe het kan worden uitgedrukt 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))))));

Antwoord 4, autoriteit 23%

Sluimerstand, omdat het in feite de defacto standaard in Java is en een van de drijvende krachten was bij de totstandkoming van de JPA. Het heeft uitstekende ondersteuning in Spring en bijna elk Java-framework ondersteunt het. Ten slotte is GORM een heel coole verpakking eromheen met dynamische vinders enzovoort met Groovy.

Het is zelfs overgezet naar .NET (NHibernate), zodat je het daar ook kunt gebruiken.

Antwoord 5, autoriteit 21%

Sluimerstand, omdat het:

• is stabiel – bestaat al zoveel jaren, het heeft geen grote problemen
• dicteert de normen in het ORM-veld
• implementeert de standaard (JPA), naast het dicteren ervan.
• heeft er veel informatie over op internet. Er zijn veel tutorials, veelvoorkomende probleemoplossingen, enz.
• is krachtig – u kunt een zeer complex objectmodel vertalen naar een relationeel model.
• het heeft ondersteuning voor alle grote en middelgrote RDBMS
• is gemakkelijk om mee te werken, als je het eenmaal goed leert

Een paar punten over waarom (en wanneer) ORM moet worden gebruikt:

• je werkt met objecten in je systeem (als je systeem goed is ontworpen). Zelfs als u JDBC gebruikt, maakt u uiteindelijk een vertaallaag, zodat u uw gegevens naar uw objecten overdraagt. Maar ik durf te wedden dat hibernate beter is in vertalen dan welke op maat gemaakte oplossing dan ook.
• het ontneemt je niet de controle. Je kunt dingen tot in de kleinste details regelen, en als de API geen externe functie heeft, voer dan een native query uit en je hebt het.
• elk middelgroot of groter systeem kan het zich niet veroorloven een hoop vragen te hebben (op één plaats of verspreid over), als het onderhoudbaar wil zijn
• als prestaties niet essentieel zijn. Hibernate voegt prestatieoverhead toe, wat in sommige gevallen niet kan worden genegeerd.

Antwoord 6, autoriteit 11%

Ik raad aan om MyBatiste gebruiken. Het is een dunne laag bovenop JDBC, het is heel gemakkelijk om objecten toe te wijzen aan tabellen en toch gewone SQL te gebruiken, alles is onder jouw controle.

Antwoord 7, autoriteit 8%

Ik had een hele goede ervaring met Avaje Ebeantoen ik een middelgrote JavaSE-toepassing aan het schrijven was.

Het gebruikt standaard JPA-annotaties om entiteiten te definiëren, maar stelt een veel eenvoudigere API bloot (Geen EntityManager of een van die bijgevoegde/losgemaakte entiteiten onzin). Het laat je ook gemakkelijk SQL-query’s of gewone JDBC-aanroepen gebruiken als dat nodig is.

Het heeft ook een zeer mooie, vloeiende en typeveilige API voor zoekopdrachten. Je kunt dingen schrijven als:

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

Antwoord 8, autoriteit 4%

SimpleORM, omdat het eenvoudig en niet-magisch is. Het definieert alle metadatastructuren in Java-code en is zeer flexibel.

SimpleORM biedt vergelijkbare
functionaliteit om te sluimeren door in kaart te brengen
gegevens in een relationele database naar Java
objecten in het geheugen. Query’s kunnen zijn:
gespecificeerd in termen van Java-objecten,
objectidentiteit is afgestemd op
databasesleutels, relaties tussen
objecten worden onderhouden en gewijzigd
Objecten worden automatisch gespoeld naar
de database met optimistische sloten.

Maar in tegenstelling tot hibernate, gebruikt Simpleorm een
Zeer eenvoudige objectstructuur en
Architectuur die de behoefte aan vermijdt
Complexe parsing, byte code verwerking
enz. Simple is klein en
transparant, verpakt in twee potten
slechts 79K en 52K in grootte, met alleen
een kleine en optionele afhankelijkheid
(SLF4J). (Slaapnationaal is meer dan 2400k
plus ongeveer 2000K van afhankelijke potten.)
Dit maakt Simpleorm eenvoudig
begrijpen en vermindert zo enorm
technisch risico.

Antwoord 9, Autoriteit 4%

Eclipse Link , om vele redenen, maar met name het gevoel heeft dat het minder blop heeft dan andere main Streamoplossingen (ten minste minder in-u-gezichtsblok).

OH en Eclipse Link is gekozen om de referentie-implementatie voor JPA 2.0

te zijn

Antwoord 10, Autoriteit 2%

Terwijl ik de bezorgdheid over Java-vervangingen deel voor vrijvormige SQL-query’s, denk ik echt dat mensen kritiek op ORM het doen vanwege een over het algemeen slechte aanvraagontwerp.

True OOD wordt aangedreven door klassen en relaties en ORM geeft u consistente in kaart brengen van verschillende relatietypen en objecten.
Als u een ORM-tool gebruikt en uiteindelijk query-expressies codeert in welke zoektaal dan ook die het ORM-framework ondersteunt (inclusief, maar niet beperkt tot Java-expressiebomen, querymethoden, OQL enz.), doet u absoluut iets verkeerd, namelijk uw klassenmodel hoogstwaarschijnlijk niet uw vereisten ondersteunt zoals het zou moeten. Een schoon applicatieontwerp heeft niet echt vragen op applicatieniveau nodig. Ik heb veel projecten gerefactord die mensen begonnen met het gebruik van een ORM-framework op dezelfde manier als ze werden gebruikt om SQL-stringconstanten in hun code in te bedden, en uiteindelijk was iedereen verrast over hoe eenvoudig en onderhoudbaar de hele applicatie wordt als je eenmaal matcht uw klassenmodel op met het gebruiksmodel. Toegegeven, voor zaken als zoekfunctionaliteit enz. heb je een querytaal nodig, maar zelfs dan zijn query’s zo beperkt dat het maken van een zelfs complexe VIEW en het toewijzen daarvan aan een alleen-lezen persistente klasse veel leuker is om te onderhouden en naar te kijken dan het bouwen van expressies in een of andere querytaal in de code van uw toepassing. De VIEW-benadering maakt ook gebruik van databasemogelijkheden en kan, via materialisatie, qua prestaties veel beter zijn dan elke handgeschreven SQL in uw Java-bron.
Ik zie dus geen enkele reden waarom een niet-triviale toepassing ORM NIET zou gebruiken.