Pengenalan kepada ORMLite

1. Gambaran keseluruhan

ORMLite adalah perpustakaan ORM ringan untuk aplikasi Java. Ia menyediakan ciri standard alat ORM untuk kes penggunaan yang paling biasa, tanpa kerumitan tambahan dan overhead kerangka ORM lain.

Ciri utamanya adalah:

  • menentukan kelas entiti dengan menggunakan anotasi Java
  • kelas DAO yang boleh dilanjutkan
  • yang QueryBuilder kelas bagi mewujudkan pertanyaan kompleks
  • kelas yang dihasilkan untuk membuat dan menjatuhkan jadual pangkalan data
  • sokongan untuk urus niaga
  • sokongan untuk hubungan entiti

Pada bahagian seterusnya, kita akan melihat bagaimana kita dapat menubuhkan perpustakaan, menentukan kelas entiti dan melakukan operasi pada pangkalan data menggunakan perpustakaan.

2. Pergantungan Maven

Untuk mula menggunakan ORMLite, kita perlu menambahkan kebergantungan ormlite-jdbc ke pom.xml kami :

 com.j256.ormlite ormlite-jdbc 5.0 

Secara lalai, ini juga membawa kebergantungan h2 . Dalam contoh kami, kami akan menggunakan pangkalan data dalam memori H2 , jadi kami tidak memerlukan pemacu JDBC lain.

Sekiranya anda ingin menggunakan pangkalan data yang berbeza, anda juga memerlukan pergantungan yang sesuai.

3. Mendefinisikan Kelas Entiti

Untuk menyediakan kelas model kami untuk bertahan dengan ORMLite, terdapat dua anotasi utama yang dapat kami gunakan:

  • @DatabaseTable untuk kelas entiti
  • @DatabaseField untuk harta tanah

Mari kita mulakan dengan menentukan entiti 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 anotasi mempunyai pilihan tableName atribut yang menentukan nama jadual jika kita tidak mahu bergantung kepada nama kelas lalai.

Untuk setiap bidang yang ingin kita teruskan sebagai lajur dalam jadual pangkalan data, kita harus menambahkan anotasi @DatabaseField .

Properti yang akan berfungsi sebagai kunci utama untuk jadual dapat ditandakan dengan atribut id , dihasilkanId atau dihasilkanSequence . Dalam contoh kami, kami memilih atribut dihasilkanId = true sehingga kunci utama akan meningkat secara automatik.

Juga, perhatikan bahawa kelas perlu mempunyai konstruktor tanpa argumen dengan sekurang-kurangnya penglihatan skop pakej .

Beberapa ciri-ciri biasa lain yang kita boleh gunakan untuk mengkonfigurasi ladang-ladang yang columnName , jenis data , defaultValue , canBeNull , unik .

3.1. Menggunakan Anotasi JPA

Sebagai tambahan kepada anotasi khusus ORMLite, kami juga dapat menggunakan anotasi gaya JPA untuk menentukan entiti kami .

Setara dengan entiti Perpustakaan yang kami tentukan sebelum menggunakan anotasi standard JPA adalah:

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

Walaupun ORMLite mengenali anotasi ini, kami masih perlu menambahkan pergantungan javax.persistence-api untuk menggunakannya.

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

4. ConnectionSource

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

Untuk ini, kita boleh menggunakan kelas JdbcConnectionSource yang membuat satu sambungan, atau JdbcPooledConnectionSource yang mewakili sumber sambungan gabungan:

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

Sumber data luaran lain dengan prestasi yang lebih baik juga dapat digunakan, dengan membungkusnya dalam objek DataSourceConnectionSource .

5. Kelas TableUtils

Berdasarkan ConnectionSource , kita dapat menggunakan kaedah statik dari kelas TableUtils untuk melakukan operasi pada skema pangkalan data :

  • createTable () - untuk membuat jadual berdasarkan definisi kelas entiti atau objek DatabaseTableConfig
  • createTableIfNotExists () - serupa dengan kaedah sebelumnya, kecuali ia hanya akan membuat jadual jika tidak ada; ini hanya berfungsi pada pangkalan data yang menyokongnya
  • dropTable () - untuk memadam jadual
  • clearTable () - untuk menghapus data dari jadual

Mari lihat bagaimana kita boleh menggunakan TableUtils untuk membuat jadual untuk kelas Perpustakaan kita :

TableUtils.createTableIfNotExists(connectionSource, Library.class);

6. Objek DAO

ORMLite mengandungi satu DaoManager kelas yang boleh membuat DAO objek untuk kita dengan fungsi CRUD :

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

Setiap DAO dapat digunakan untuk mendapatkan objek QueryBuilder yang kemudian dapat kita manfaatkan untuk membangun pertanyaan yang lebih kuat.

Kelas ini mengandungi kaedah yang sesuai dengan operasi biasa yang digunakan dalam pertanyaan SQL seperti: selectColumns (), di mana (), groupBy (), mempunyai (), countOf (), berbeza (), orderBy (), join ().

Mari lihat contoh bagaimana kita dapat menemui semua rekod Perpustakaan yang mempunyai lebih daripada satu Buku yang berkaitan:

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

9. Kesimpulannya

Dalam artikel ini, kami telah melihat bagaimana kami dapat menentukan entiti menggunakan ORMLite, serta ciri utama perpustakaan yang dapat kami gunakan untuk memanipulasi objek dan pangkalan data hubungannya yang berkaitan.

Kod sumber lengkap contoh boleh didapati di GitHub.