Einführung in ORMLite

1. Übersicht

ORMLite ist eine kompakte ORM-Bibliothek für Java-Anwendungen. Es bietet Standardfunktionen eines ORM-Tools für die häufigsten Anwendungsfälle, ohne die zusätzliche Komplexität und den zusätzlichen Aufwand anderer ORM-Frameworks.

Die Hauptmerkmale sind:

  • Definieren von Entitätsklassen mithilfe von Java-Annotationen
  • erweiterbare DAO- Klassen
  • eine QueryBuilder- Klasse zum Erstellen komplexer Abfragen
  • generierte Klassen zum Erstellen und Löschen von Datenbanktabellen
  • Unterstützung für Transaktionen
  • Unterstützung für Entitätsbeziehungen

In den nächsten Abschnitten werden wir uns ansehen, wie wir die Bibliothek einrichten, Entitätsklassen definieren und Operationen an der Datenbank mithilfe der Bibliothek ausführen können.

2. Maven-Abhängigkeiten

Um ORMLite verwenden zu können, müssen wir unserer pom.xml die Abhängigkeit ormlite-jdbc hinzufügen :

 com.j256.ormlite ormlite-jdbc 5.0 

Standardmäßig bringt dies auch die h2- Abhängigkeit mit sich. In unseren Beispielen verwenden wir eine H2- In-Memory-Datenbank, sodass wir keinen weiteren JDBC-Treiber benötigen.

Wenn Sie eine andere Datenbank verwenden möchten, benötigen Sie auch die entsprechende Abhängigkeit.

3. Entitätsklassen definieren

Um unsere Modellklassen für die Persistenz mit ORMLite einzurichten, können wir zwei primäre Annotationen verwenden:

  • @DatabaseTable für die Entitätsklasse
  • @DatabaseField für die Eigenschaften

Beginnen wir mit einer Definition von Bibliothek Entität mit einem Namen Feld und ein libraryId Feld , das auch ein Primärschlüssel ist:

@DatabaseTable(tableName = "libraries") public class Library { @DatabaseField(generatedId = true) private long libraryId; @DatabaseField(canBeNull = false) private String name; public Library() { } // standard getters, setters }

Die Annotation @DatabaseTable verfügt über ein optionales Attribut tableName , das den Namen der Tabelle angibt, wenn wir uns nicht auf einen Standardklassennamen verlassen möchten.

Für jedes Feld, das als Spalte in der Datenbanktabelle beibehalten werden soll , müssen wir die Annotation @DatabaseField hinzufügen .

Die Eigenschaft, die als Primärschlüssel für die Tabelle dient, kann entweder mit den Attributen id , generateId oder generateSequence gekennzeichnet werden. In unserem Beispiel wählen wir das Attribut generateId = true , damit der Primärschlüssel automatisch inkrementiert wird.

Beachten Sie außerdem, dass die Klasse einen Konstruktor ohne Argumente mit mindestens Sichtbarkeit des Paketbereichs haben muss .

Einige andere bekannte Eigenschaften , die wir für die Konfiguration der Felder verwenden können , sind column , datatype , default , canBeNull , einzigartig .

3.1. Verwenden von JPA- Anmerkungen

Zusätzlich zu den ORMLite-spezifischen Annotationen können wir auch Annotationen im JPA-Stil verwenden , um unsere Entitäten zu definieren .

Das Äquivalent der Bibliotheksentität , die wir vor der Verwendung von JPA- Standardanmerkungen definiert haben, lautet :

@Entity public class LibraryJPA { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private long libraryId; @Column private String name; // standard getters, setters }

Obwohl ORMLite diese Anmerkungen erkennt, müssen wir noch die Abhängigkeit javax.persistence-api hinzufügen , um sie zu verwenden.

Die vollständige Liste der unterstützten JPA- Anmerkungen lautet @ Entity , @Id, @Column, @GeneratedValue, @ OneToOne , @ManyToOne, @ JoinColumn , @ Version .

4. ConnectionSource

Um mit den definierten Objekten arbeiten zu können, müssen wir eine ConnectionSource einrichten .

Hierfür können wir die JdbcConnectionSource- Klasse verwenden, die eine einzelne Verbindung erstellt, oder die JdbcPooledConnectionSource, die eine einfache Poolverbindungsquelle darstellt:

JdbcPooledConnectionSource connectionSource = new JdbcPooledConnectionSource("jdbc:h2:mem:myDb"); // work with the connectionSource connectionSource.close();

Andere externe Datenquellen mit besserer Leistung können ebenfalls verwendet werden, indem sie in ein DataSourceConnectionSource- Objekt eingeschlossen werden.

5. TableUtils- Klasse

Basierend auf der ConnectionSource können wir statische Methoden aus der TableUtils- Klasse verwenden, um Operationen am Datenbankschema auszuführen :

  • createTable () - Zum Erstellen einer Tabelle basierend auf einer Entitätsklassendefinition oder einem DatabaseTableConfig- Objekt
  • createTableIfNotExists () - ähnlich der vorherigen Methode, außer dass die Tabelle nur erstellt wird, wenn sie nicht vorhanden ist. Dies funktioniert nur in Datenbanken, die dies unterstützen
  • dropTable () - um eine Tabelle zu löschen
  • clearTable () - um die Daten aus einer Tabelle zu löschen

Mal sehen, wie wir mit TableUtils die Tabelle für unsere Library- Klasse erstellen können :

TableUtils.createTableIfNotExists(connectionSource, Library.class);

6. DAO- Objekte

ORMLite enthält eine DaoManager- Klasse, die DAO- Objekte mit CRUD-Funktionalität für uns erstellen kann :

Dao libraryDao = DaoManager.createDao(connectionSource, Library.class);

The DaoManager doesn't regenerate the class for each subsequent call of createDao(), but instead reuses it for better performance.

Next, we can perform CRUD operations on Library objects:

Library library = new Library(); library.setName("My Library"); libraryDao.create(library); Library result = libraryDao.queryForId(1L); library.setName("My Other Library"); libraryDao.update(library); libraryDao.delete(library);

The DAO is also an iterator that can loop through all the records:

libraryDao.forEach(lib -> { System.out.println(lib.getName()); });

However, ORMLite will only close the underlying SQL statement if the loop goes all the way to the end. An exception or a return statement may cause a resource leak in your code.

For that reason, the ORMLite documentation recommends we use the iterator directly:

try (CloseableWrappedIterable wrappedIterable = libraryDao.getWrappedIterable()) { wrappedIterable.forEach(lib -> { System.out.println(lib.getName()); }); }

This way, we can close the iterator using a try-with-resources or a finally block and avoid any resource leak.

6.1. Custom DAO Class

If we want to extend the behavior of the DAO objects provided, we can create a new interface which extends the Dao type:

public interface LibraryDao extends Dao { public List findByName(String name) throws SQLException; }

Then, let's add a class that implements this interface and extends the BaseDaoImpl class:

public class LibraryDaoImpl extends BaseDaoImpl implements LibraryDao { public LibraryDaoImpl(ConnectionSource connectionSource) throws SQLException { super(connectionSource, Library.class); } @Override public List findByName(String name) throws SQLException { return super.queryForEq("name", name); } }

Note that we need to have a constructor of this form.

Finally, to use our custom DAO, we need to add the class name to the Library class definition:

@DatabaseTable(tableName = "libraries", daoClass = LibraryDaoImpl.class) public class Library { // ... }

This enables us to use the DaoManager to create an instance of our custom class:

LibraryDao customLibraryDao = DaoManager.createDao(connectionSource, Library.class);

Then we can use all the methods from the standard DAO class, as well as our custom method:

Library library = new Library(); library.setName("My Library"); customLibraryDao.create(library); assertEquals( 1, customLibraryDao.findByName("My Library").size());

7. Defining Entity Relationships

ORMLite uses the concept of “foreign” objects or collections to define relationships between entities for persistence.

Let's take a look at how we can define each type of field.

7.1. Foreign Object Fields

We can create a unidirectional one-to-one relationship between two entity classes by using the foreign=true attribute on a field annotated with @DatabaseField. The field must be of a type that's also persisted in the database.

First, let's define a new entity class called Address:

@DatabaseTable(tableName="addresses") public class Address { @DatabaseField(generatedId = true) private long addressId; @DatabaseField(canBeNull = false) private String addressLine; // standard getters, setters }

Next, we can add a field of type Address to our Library class which is marked as foreign:

@DatabaseTable(tableName = "libraries") public class Library { //... @DatabaseField(foreign=true, foreignAutoCreate = true, foreignAutoRefresh = true) private Address address; // standard getters, setters }

Notice that we've also added two more attributes to the @DatabaseField annotation: foreignAutoCreate and foreignAutoRefresh, both set to true.

The foreignAutoCreate=true attribute means that when we save a Library object with an address field, the foreign object will also be saved, provided its id is not null and has a generatedId=true attribute.

If we set foreignAutoCreate to false, which is the default value, then we'd need to persist the foreign object explicitly before saving the Library object that references it.

Similarly, the foreignAutoRefresh=true attribute specifies that when retrieving a Library object, the associated foreign object will also be retrieved. Otherwise, we'd need to refresh it manually.

Let's add a new Library object with an Address field and call the libraryDao to persist both:

Library library = new Library(); library.setName("My Library"); library.setAddress(new Address("Main Street nr 20")); Dao libraryDao = DaoManager.createDao(connectionSource, Library.class); libraryDao.create(library);

Then, we can call the addressDao to verify that the Address has also been saved:

Dao addressDao = DaoManager.createDao(connectionSource, Address.class); assertEquals(1, addressDao.queryForEq("addressLine", "Main Street nr 20") .size());

7.2. Foreign Collections

For the many side of a relationship, we can use the types ForeignCollection or Collection with a @ForeignCollectionField annotation.

Let's create a new Book entity like the ones above, then add a one-to-many relationship in the Library class:

@DatabaseTable(tableName = "libraries") public class Library { // ... @ForeignCollectionField(eager=false) private ForeignCollection books; // standard getters, setters }

In addition to this, it's required that we add a field of type Library in the Book class:

@DatabaseTable public class Book { // ... @DatabaseField(foreign = true, foreignAutoRefresh = true) private Library library; // standard getters, setters }

The ForeignCollection has add() and remove() methods that operate on the records of type Book:

Library library = new Library(); library.setName("My Library"); libraryDao.create(library); libraryDao.refresh(library); library.getBooks().add(new Book("1984"));

Here, we've created a library object, then added a new Book object to the books field, which also persists it to the database.

Note that since our collection is marked as lazily loaded (eager=false), we need to call the refresh() method before being able to use the book field.

We can also create the relationship by setting the library field in the Book class:

Book book = new Book("It"); book.setLibrary(library); bookDao.create(book);

To verify that both Book objects are added to the library we can use the queryForEq() method to find all the Book records with the given library_id:

assertEquals(2, bookDao.queryForEq("library_id", library).size());

Here, the library_id is the default name of the foreign key column, and the primary key is inferred from the library object.

8. QueryBuilder

Jedes DAO kann verwendet werden, um ein QueryBuilder- Objekt zu erhalten, das wir dann zum Erstellen leistungsfähigerer Abfragen nutzen können.

Diese Klasse enthält Methoden, entspricht die gemeinsame Operationen in einer SQL - Abfrage verwendet , wie zum Beispiel: selectColumns (), wobei (), groupBy (), mit (), countOf (), distinct (), orderBy (), join ().

Sehen wir uns ein Beispiel an, wie wir alle Bibliothekseinträge finden können, denen mehr als ein Buch zugeordnet ist:

List libraries = libraryDao.queryBuilder() .where() .in("libraryId", bookDao.queryBuilder() .selectColumns("library_id") .groupBy("library_id") .having("count(*) > 1")) .query();

9. Fazit

In diesem Artikel haben wir gesehen, wie wir Entitäten mit ORMLite definieren können, sowie die Hauptfunktionen der Bibliothek, mit denen wir Objekte und die zugehörigen relationalen Datenbanken bearbeiten können.

Den vollständigen Quellcode des Beispiels finden Sie auf GitHub.