Pengantar ORMLite

1. Ikhtisar

ORMLite adalah pustaka ORM ringan untuk aplikasi Java. Ini menyediakan fitur standar alat ORM untuk kasus penggunaan yang paling umum, tanpa kerumitan dan overhead tambahan dari kerangka kerja ORM lainnya.

Fitur utamanya adalah:

  • mendefinisikan kelas entitas dengan menggunakan penjelasan Java
  • kelas DAO yang dapat diperluas
  • sebuah QueryBuilder kelas untuk menciptakan query yang kompleks
  • kelas yang dihasilkan untuk membuat dan menjatuhkan tabel database
  • dukungan untuk transaksi
  • dukungan untuk hubungan entitas

Di bagian selanjutnya, kita akan melihat bagaimana kita dapat mengatur perpustakaan, menentukan kelas entitas dan melakukan operasi pada database menggunakan perpustakaan.

2. Ketergantungan Maven

Untuk mulai menggunakan ORMLite, kita perlu menambahkan dependensi ormlite-jdbc ke pom.xml kita :

 com.j256.ormlite ormlite-jdbc 5.0 

Secara default, ini juga membawa ketergantungan h2 . Dalam contoh kami, kami akan menggunakan database H2 dalam memori, jadi kami tidak memerlukan driver JDBC lain.

Jika Anda ingin menggunakan database yang berbeda, Anda juga memerlukan dependensi yang sesuai.

3. Mendefinisikan Kelas Entitas

Untuk menyiapkan kelas model kami untuk persistensi dengan ORMLite, ada dua anotasi utama yang dapat kami gunakan:

  • @DatabaseTable untuk kelas entitas
  • @DatabaseField untuk properti

Mari kita mulai dengan mendefinisikan entitas Perpustakaan dengan bidang nama dan bidang libraryId yang juga merupakan kunci utama:

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

The @DatabaseTable penjelasan memiliki opsional tableName atribut yang menentukan nama tabel jika kita tidak ingin bergantung pada nama kelas default.

Untuk setiap bidang yang ingin kita pertahankan sebagai kolom dalam tabel database, kita harus menambahkan anotasi @DatabaseField .

Properti yang akan berfungsi sebagai kunci utama untuk tabel dapat ditandai dengan atribut id , generatedId , atau generatedSequence . Dalam contoh kami, kami memilih atribut generatedId = true sehingga kunci utama akan bertambah secara otomatis.

Juga, perhatikan bahwa kelas harus memiliki konstruktor tanpa argumen dengan setidaknya visibilitas cakupan paket .

Beberapa atribut familiar lain kita dapat menggunakan untuk mengkonfigurasi bidang yang columnName , dataType , defaultValue , canBeNull , unik .

3.1. Menggunakan Anotasi JPA

Selain anotasi khusus ORMLite, kita juga dapat menggunakan anotasi gaya JPA untuk menentukan entitas kita .

Yang setara dengan entitas Perpustakaan yang kami tentukan sebelum menggunakan anotasi standar JPA adalah:

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

Meskipun ORMLite mengenali anotasi ini, kita masih perlu menambahkan dependensi javax.persistence-api untuk menggunakannya.

Daftar lengkap anotasi JPA yang didukung adalah @ Entity , @Id, @Column, @GeneratedValue, @ OneToOne , @ManyToOne, @ JoinColumn , @ Version .

4. ConnectionSource

Untuk bekerja dengan objek yang ditentukan, kita perlu menyiapkan ConnectionSource .

Untuk ini, kita dapat menggunakan kelas JdbcConnectionSource yang membuat koneksi tunggal, atau JdbcPooledConnectionSource yang mewakili sumber koneksi gabungan sederhana:

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

Sumber data eksternal lain dengan kinerja yang lebih baik juga dapat digunakan, dengan menggabungkannya dalam objek DataSourceConnectionSource .

5. Kelas TableUtils

Berdasarkan ConnectionSource , kita dapat menggunakan metode statis dari kelas TableUtils untuk melakukan operasi pada skema database :

  • createTable () - untuk membuat tabel berdasarkan definisi kelas entitas atau objek DatabaseTableConfig
  • createTableIfNotExists () - mirip dengan metode sebelumnya, kecuali itu hanya akan membuat tabel jika tidak ada; ini hanya bekerja pada database yang mendukungnya
  • dropTable () - untuk menghapus tabel
  • clearTable () - untuk menghapus data dari tabel

Mari kita lihat bagaimana kita bisa menggunakan TableUtils untuk membuat tabel untuk kelas Library kita :

TableUtils.createTableIfNotExists(connectionSource, Library.class);

6. Objek DAO

ORMLite berisi sebuah DaoManager kelas yang dapat membuat DAO objek untuk kita dengan fungsi CRUD :

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

The DaoManager tidak menumbuhkan kelas untuk setiap panggilan berikutnya createDao (), melainkan menggunakan kembali untuk kinerja yang lebih baik.

Selanjutnya, kita dapat melakukan operasi CRUD pada objek Library :

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 juga merupakan iterator yang dapat loop melalui semua catatan:

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

Namun, ORMLite hanya akan menutup pernyataan SQL yang mendasarinya jika perulangan berjalan sampai akhir. Pengecualian atau pernyataan pengembalian dapat menyebabkan kebocoran sumber daya dalam kode Anda.

Oleh karena itu, dokumentasi ORMLite merekomendasikan agar kami menggunakan iterator secara langsung:

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

Dengan cara ini, kita bisa menutup iterator menggunakan coba-dengan-sumber daya atau blok terakhir dan menghindari kebocoran sumber daya.

6.1. Kelas DAO Kustom

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

Setiap DAO bisa digunakan untuk mendapatkan objek QueryBuilder yang kemudian bisa kita manfaatkan untuk membangun kueri yang lebih kuat.

Kelas ini berisi metode yang sesuai dengan operasi umum yang digunakan dalam kueri SQL seperti: selectColumns (), where (), groupBy (), having (), countOf (), different (), orderBy (), join ().

Mari kita lihat contoh bagaimana kita dapat menemukan semua catatan Perpustakaan yang memiliki lebih dari satu Buku terkait:

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

9. Kesimpulan

Di artikel ini, kita telah melihat bagaimana kita dapat mendefinisikan entitas menggunakan ORMLite, serta fitur utama perpustakaan yang dapat kita gunakan untuk memanipulasi objek dan database relasional yang terkait.

Kode sumber lengkap dari contoh tersebut dapat ditemukan di GitHub.