streamalism.org

1. Inleiding

Ebean is een object-relationele mappingtool geschreven in Java.

Het ondersteunt de standaard JPA-annotaties voor het declareren van entiteiten. Het biedt echter een veel eenvoudigere API om door te gaan. In feite is een van de vermeldenswaardige punten over de Ebean-architectuur dat het sessieloos is, wat betekent dat het entiteiten niet volledig beheert.

Daarnaast wordt het geleverd met een query-API en ondersteunt het het schrijven van query's in native SQL. Ebean ondersteunt alle grote databaseproviders zoals Oracle, Postgres, MySql, H2 etc.

In deze zelfstudie bekijken we hoe we entiteiten kunnen maken, behouden en opvragen met Ebean en H2.

2. Installatie

Laten we om te beginnen onze afhankelijkheden en enkele basisconfiguraties bekijken.

2.1. Afhankelijkheden van Maven

Laten we voordat we beginnen de vereiste afhankelijkheden importeren:

 io.ebean ebean 11.22.4 com.h2database h2 1.4.196 ch.qos.logback logback-classic 1.2.3 

De nieuwste versies van Ebean, H2 en Logback zijn te vinden op Maven Central.

2.2. Verbeteringen

Ebean moet entiteitsbeans aanpassen zodat ze door de server kunnen worden beheerd. Daarom voegen we een Maven-plug-in toe om die klus te klaren:

 io.ebean ebean-maven-plugin 11.11.2 hoofdprocesklassen debug = 1 verbeteren 

We moeten de Maven-plug-in ook voorzien van de namen van de pakketten die de entiteiten en klassen bevatten die transacties gebruiken. Om dat te doen, maken we het bestand aan ebean.mf:

entiteit-pakketten: com.baeldung.ebean.model transactionele-pakketten: com.baeldung.ebean.app

2.3. Logboekregistratie

Laten we ook creëren logback.xml en stel de logboekregistratieniveaus voor sommige pakketten in op SPOOR zodat we de verklaringen kunnen zien die worden uitgevoerd:

3. Configureren van een server

We moeten een EbeanServer instantie om entiteiten op te slaan of query's op een database uit te voeren. Er zijn twee manieren waarop we een serverinstantie kunnen maken: met behulp van een standaardeigenschappenbestand of via een programma.

3.1. Met behulp van een standaardeigenschappenbestand

Het standaardeigenschappenbestand kan van het type zijn eigendommen of yaml. Ebean zoekt naar configuratie in bestanden met namen application.properties, ebean.properties of application.yml.

Naast het verstrekken van de gegevens van de databaseverbinding, kunnen we Ebean ook opdracht geven om DDL-statements te maken en uit te voeren.

Laten we nu eens kijken naar een voorbeeldconfiguratie:

ebean.db.ddl.generate = true ebean.db.ddl.run = true datasource.db.username = sa datasource.db.password = datasource.db.databaseUrl = jdbc: h2: mem: customer datasource.db.databaseDriver = org.h2.Driver

3.2. Met behulp van ServerConfig

Laten we vervolgens kijken hoe we dezelfde server programmatisch kunnen maken met EbeanServerFactory en Serverconfiguratie:

ServerConfig cfg = nieuwe ServerConfig (); Eigenschappen properties = nieuwe Eigenschappen (); properties.put ("ebean.db.ddl.generate", "true"); properties.put ("ebean.db.ddl.run", "true"); properties.put ("datasource.db.username", "sa"); properties.put ("datasource.db.password", ""); properties.put ("datasource.db.databaseUrl", "jdbc: h2: mem: app2"; properties.put ("datasource.db.databaseDriver", "org.h2.Driver"); cfg.loadFromProperties (properties); EbeanServer-server = EbeanServerFactory.create (cfg);

3.3. Standaard serverinstantie

Een EbeanServer instantie wordt toegewezen aan een enkele database. Afhankelijk van onze vereisten kunnen we er meer dan één maken EbeanServer instantie ook.

Als er slechts één serverinstantie wordt gemaakt, wordt deze standaard geregistreerd als de standaardserverinstantie. Het is overal in de applicatie toegankelijk met een statische methode op het Ebean klasse:

EbeanServer-server = Ebean.getDefaultServer ();

Als er meerdere databases zijn, is het mogelijk om een ​​van de serverinstanties als standaard te registreren:

cfg.setDefaultServer (true);

4. Entiteiten maken

Ebean biedt volledige ondersteuning voor JPA-annotaties, evenals extra functies met behulp van zijn eigen annotaties.

Laten we enkele entiteiten maken met zowel JPA- als Ebean-annotaties. Eerst maken we een BaseModel die eigenschappen bevat die gemeenschappelijk zijn tussen entiteiten:

@MappedSuperclass openbare abstracte klasse BaseModel {@Id beschermde lange id; @Version beveiligde lange versie; @WhenCreated beschermd Instant createdOn; @WhenModified beschermd Instant modifiedOn; // getters en setters}

Hier hebben we de MappedSuperClass JPA-annotatie om het BaseModel. En twee Ebean-annotaties io.ebean.annotation.WhenCreated en io.ebean.annotation.WhenModified voor controledoeleinden.

Vervolgens maken we twee entiteiten Klant en Adres welke zich uitstrekken BaseModel:

@ Entity openbare klasse Klant breidt BaseModel uit {openbare klant (tekenreeksnaam, adresadres) {super (); this.name = naam; this.address = adres; } private String naam; @OneToOne (cascade = CascadeType.ALL) Adresadres; // getters en setters} 

@ Entity public class Address breidt BaseModel uit {public Address (String addressLine1, String addressLine2, String city) {super (); this.addressLine1 = addressLine1; this.addressLine2 = addressLine2; this.city = stad; } private String addressLine1; privé String addressLine2; particuliere String stad; // getters en setters}

In Klant, we hebben een een-op-een mapping gedefinieerd met Adres en set cascade-type toegevoegd aan ALLE zodat onderliggende entiteiten ook worden bijgewerkt samen met de bovenliggende entiteiten.

5. Basis CRUD-bewerkingen

Eerder hebben we gezien hoe we het EbeanServer en creëerde twee entiteiten. Nu, laten we enkele basis CRUD-bewerkingen uitvoeren op hen.

We gebruiken de standaardserverinstantie om te behouden en toegang te krijgen tot de gegevens. De Ebean class biedt ook statische methoden voor persistentie en toegang tot gegevens die het verzoek naar de standaardserverinstantie proxy:

Adres a1 = nieuw adres ("5, Wide Street", null, "New York"); Klant c1 = nieuwe klant ("John Wide", a1); EbeanServer-server = Ebean.getDefaultServer (); server.save (c1); c1.setName ("Jane Wide"); c1.setAddress (null); server.save (c1); Klant gevonden C1 = Ebean.find (Customer.class, c1.getId ()); Ebean.delete (gevonden C1);

Eerst maken we een Klant object en gebruikte de standaardserverinstantie om het op te slaan met sparen().

Vervolgens werken we de klantgegevens bij en slaan we deze opnieuw op met sparen().

Ten slotte gebruiken we de statische methode vind() Aan Ebean om de klant op te halen en te verwijderen met verwijderen ().

6. Vragen

Query-API's kunnen ook worden gebruikt om een ​​objectgrafiek met filters en predikaten te maken. We kunnen beide gebruiken Ebean of EbeanServer om query's te maken en uit te voeren.

Laten we eens kijken naar een zoekopdracht die een Klant per stad en retourneert een Klant en Adres object waarin slechts enkele velden zijn ingevuld:

Klant klant = Ebean.find (Customer.class) .select ("naam") .fetch ("adres", "stad") .where () .eq ("stad", "San Jose") .findOne ();

Hier, met vind() we geven aan dat we entiteiten van het type willen vinden Klant. Vervolgens gebruiken we selecteer () om de eigenschappen op te geven die in het Klant voorwerp.

Later gebruiken we ophalen () om aan te geven dat we het Adres object behorend tot de Klant en dat we het stad veld-.

Ten slotte voegen we een predikaat toe en beperken we de grootte van het resultaat tot 1.

7. Transacties

Ebean voert standaard elke instructie of query in een nieuwe transactie uit.

Hoewel dit in sommige gevallen misschien geen probleem is. Het kan voorkomen dat we een reeks instructies binnen een enkele transactie willen uitvoeren.

Als we in dergelijke gevallen de methode annoteren met io.ebean.annotations.Transactional, alle instructies binnen de methode worden uitgevoerd binnen dezelfde transactie:

@Transactional openbare statische ongeldige insertAndDeleteInsideTransaction () {Klant c1 = getCustomer (); EbeanServer-server = Ebean.getDefaultServer (); server.save (c1); Klant gevondenC1 = server.find (Customer.class, c1.getId ()); server.delete (gevondenC1); }

8. Bouwen van het project

Ten slotte kunnen we het Maven-project bouwen met behulp van de opdracht:

compileer io.ebean: ebean-maven-plugin: verbeteren

9. Conclusie

Samenvattend hebben we gekeken naar de basisfuncties van Ebean die kunnen worden gebruikt om entiteiten in een relationele database te behouden en te doorzoeken.

Eindelijk is deze code beschikbaar op Github.