Leitfaden für Ebean ORM

1. Einleitung

Ebean ist ein in Java geschriebenes objektrelationales Mapping-Tool.

Es unterstützt die Standard-JPA-Annotationen zum Deklarieren von Entitäten. Es bietet jedoch eine viel einfachere API zum Fortbestehen. In der Tat ist einer der erwähnenswerten Punkte bei der Ebean-Architektur, dass sie sitzungslos ist, was bedeutet, dass Entitäten nicht vollständig verwaltet werden.

Außerdem wird eine Abfrage-API mitgeliefert, die das Schreiben von Abfragen in nativem SQL unterstützt. Ebean unterstützt alle wichtigen Datenbankanbieter wie Oracle, Postgres, MySql, H2 usw.

In diesem Tutorial sehen wir uns an, wie wir mit Ebean und H2 Entitäten erstellen, beibehalten und abfragen können.

2. Setup

Lassen Sie uns zunächst unsere Abhängigkeiten sowie einige grundlegende Konfigurationen abrufen.

2.1. Maven-Abhängigkeiten

Bevor wir beginnen, importieren wir die erforderlichen Abhängigkeiten:

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

Die neuesten Versionen von Ebean, H2 und Logback finden Sie auf Maven Central.

2.2. Verbesserungen

Ebean muss Entity Beans so ändern, dass sie vom Server verwaltet werden können. Daher fügen wir ein Maven-Plugin hinzu, um diesen Job zu erledigen:

 io.ebean ebean-maven-plugin 11.11.2   main process-classes  debug=1   enhance    

Wir müssen dem Maven-Plugin auch die Namen der Pakete bereitstellen, die die Entitäten und Klassen enthalten, die Transaktionen verwenden. Dazu erstellen wir die Datei ebean.mf:

entity-packages: com.baeldung.ebean.model transactional-packages: com.baeldung.ebean.app

2.3. Protokollierung

Lassen Sie uns auch logback.xml erstellen und die Protokollierungsstufen für einige Pakete auf TRACE setzen, damit wir die Anweisungen sehen können, die ausgeführt werden:

3. Server konfigurieren

Wir müssen eine EbeanServer- Instanz erstellen , um Entitäten zu speichern oder Abfragen in einer Datenbank auszuführen. Es gibt zwei Möglichkeiten, wie wir eine Serverinstanz erstellen können - mithilfe einer Standardeigenschaftendatei oder programmgesteuert.

3.1. Verwenden einer Standardeigenschaftendatei

Die Standardeigenschaftendatei kann vom Typ Eigenschaften oder Yaml sein . Ebean sucht nach Konfigurationen in Dateien mit den Namen application.properties , ebean.properties oder application.yml .

Neben der Angabe der Datenbankverbindungsdetails können wir Ebean auch anweisen, DDL-Anweisungen zu erstellen und auszuführen.

Schauen wir uns nun eine Beispielkonfiguration an:

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. Verwenden von ServerConfig

Schauen wir uns als nächstes an, wie wir denselben Server programmgesteuert mit EbeanServerFactory und ServerConfig erstellen können :

ServerConfig cfg = new ServerConfig(); Properties properties = new Properties(); 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. Standard-Serverinstanz

Eine einzelne EbeanServer- Instanz wird einer einzelnen Datenbank zugeordnet. Abhängig von unseren Anforderungen können wir auch mehr als eine EbeanServer- Instanz erstellen .

Wenn nur eine einzelne Serverinstanz erstellt wird, wird diese standardmäßig als Standardserverinstanz registriert. Es kann überall in der Anwendung mit einer statischen Methode für die Ebean- Klasse zugegriffen werden :

EbeanServer server = Ebean.getDefaultServer();

Wenn mehrere Datenbanken vorhanden sind, kann eine der Serverinstanzen als Standardinstanz registriert werden:

cfg.setDefaultServer(true);

4. Entitäten erstellen

Ebean bietet vollständige Unterstützung für JPA-Anmerkungen sowie zusätzliche Funktionen mithilfe eigener Anmerkungen.

Erstellen wir einige Entitäten mit JPA- und Ebean-Annotationen. Zuerst erstellen wir ein BaseModel, das Eigenschaften enthält, die für alle Entitäten gleich sind :

@MappedSuperclass public abstract class BaseModel { @Id protected long id; @Version protected long version; @WhenCreated protected Instant createdOn; @WhenModified protected Instant modifiedOn; // getters and setters }

Hier haben wir die JPA-Annotation MappedSuperClass verwendet , um das BaseModel zu definieren . Und zwei Ebean-Anmerkungen io.ebean.annotation.WhenCreated und io.ebean.annotation.WhenModified für Prüfungszwecke.

Als Nächstes erstellen wir zwei Entitäten Customer und Address , die BaseModel erweitern :

@Entity public class Customer extends BaseModel { public Customer(String name, Address address) { super(); this.name = name; this.address = address; } private String name; @OneToOne(cascade = CascadeType.ALL) Address address; // getters and setters } 
@Entity public class Address extends BaseModel{ public Address(String addressLine1, String addressLine2, String city) { super(); this.addressLine1 = addressLine1; this.addressLine2 = addressLine2; this.city = city; } private String addressLine1; private String addressLine2; private String city; // getters and setters }

In Customer haben wir eine Eins-zu-Eins-Zuordnung mit Adresse definiert und ALL den festgelegten Kaskadentyp hinzugefügt, damit auch untergeordnete Entitäten zusammen mit den übergeordneten Entitäten aktualisiert werden.

5. Grundlegende CRUD-Operationen

Zuvor haben wir gesehen, wie der EbeanServer konfiguriert und zwei Entitäten erstellt. Nun, lassen Sie uns einige grundlegende CRUD - Operationen durchführen auf ihnen.

Wir werden die Standardserverinstanz verwenden, um die Daten beizubehalten und darauf zuzugreifen. Die Ebean- Klasse bietet auch statische Methoden zum Speichern und Zugreifen auf Daten, die die Anforderung an die Standardserverinstanz weiterleiten:

Address a1 = new Address("5, Wide Street", null, "New York"); Customer c1 = new Customer("John Wide", a1); EbeanServer server = Ebean.getDefaultServer(); server.save(c1); c1.setName("Jane Wide"); c1.setAddress(null); server.save(c1); Customer foundC1 = Ebean.find(Customer.class, c1.getId()); Ebean.delete(foundC1);

Zuerst erstellen wir ein Kundenobjekt und verwenden die Standardserverinstanz, um es mit save () zu speichern .

Next, we're updating the customer details and saving it again using save().

Finally, we're using the static method find() on Ebean to fetch the customer and delete it using delete().

6. Queries

Query APIs can also be used to create an object graph with filters and predicates. We can either use Ebean or EbeanServer to create and execute queries.

Let's look at a query which finds a Customer by city and returns a Customer and Address object with only some fields populated:

Customer customer = Ebean.find(Customer.class) .select("name") .fetch("address", "city") .where() .eq("city", "San Jose") .findOne();

Here, with find() we indicate that we want to find entities of type Customer. Next, we use select() to specify the properties to populate in the Customer object.

Later, we use fetch() to indicate that we want to fetch the Address object belonging to the Customer and that we want to fetch the city field.

Finally, we add a predicate and restrict the size of the result to 1.

7. Transactions

Ebean executes each statement or query in a new transaction by default.

Although this may not be an issue in some cases. There are times when we may want to execute a set of statements within a single transaction.

Wenn wir in solchen Fällen die Methode mit io.ebean.annotations.Transactional kommentieren , werden alle Anweisungen innerhalb der Methode innerhalb derselben Transaktion ausgeführt:

@Transactional public static void insertAndDeleteInsideTransaction() { Customer c1 = getCustomer(); EbeanServer server = Ebean.getDefaultServer(); server.save(c1); Customer foundC1 = server.find(Customer.class, c1.getId()); server.delete(foundC1); }

8. Erstellen des Projekts

Zuletzt können wir das Maven-Projekt mit dem folgenden Befehl erstellen:

compile io.ebean:ebean-maven-plugin:enhance

9. Fazit

Zusammenfassend haben wir uns die Grundfunktionen von Ebean angesehen, mit denen Entitäten in einer relationalen Datenbank beibehalten und abgefragt werden können.

Schließlich ist dieser Code auf Github verfügbar.