Pola DAO di Jawa

1. Ikhtisar

Pola Objek Akses Data (DAO) adalah pola struktural yang memungkinkan kita mengisolasi lapisan aplikasi / bisnis dari lapisan persistensi (biasanya database relasional, tetapi bisa juga mekanisme persistensi lainnya) menggunakan API abstrak .

Fungsionalitas API ini adalah untuk menyembunyikan dari aplikasi semua kerumitan yang terlibat dalam menjalankan operasi CRUD dalam mekanisme penyimpanan yang mendasarinya. Ini memungkinkan kedua lapisan berevolusi secara terpisah tanpa mengetahui apa pun tentang satu sama lain.

Dalam tutorial ini, kita akan mendalami implementasi pola, dan kita akan belajar bagaimana menggunakannya untuk mengabstraksi panggilan ke manajer entitas JPA.

2. Implementasi Sederhana

Untuk memahami cara kerja pola DAO, mari buat contoh dasar.

Katakanlah kita ingin mengembangkan aplikasi yang mengelola pengguna. Untuk menjaga agar model domain aplikasi benar-benar agnostik tentang database, kita akan membuat kelas DAO sederhana yang akan menjaga agar komponen-komponen ini dipisahkan dengan rapi satu sama lain .

2.1. Kelas Domain

Karena aplikasi kita akan bekerja dengan pengguna, kita hanya perlu mendefinisikan satu kelas untuk mengimplementasikan model domainnya:

public class User { private String name; private String email; // constructors / standard setters / getters }

Kelas User hanyalah wadah biasa untuk data pengguna, sehingga tidak mengimplementasikan perilaku lain yang perlu ditekankan.

Tentu saja, pilihan desain paling relevan yang perlu kita buat di sini adalah bagaimana menjaga aplikasi yang menggunakan kelas ini terisolasi dari mekanisme persistensi yang dapat diterapkan di beberapa titik.

Nah, itulah masalah yang coba diatasi oleh pola DAO.

2.2. API DAO

Mari kita definisikan lapisan DAO dasar, sehingga kita dapat melihat bagaimana model domain dapat sepenuhnya dipisahkan dari lapisan persistensi.

Berikut API DAO:

public interface Dao { Optional get(long id); List getAll(); void save(T t); void update(T t, String[] params); void delete(T t); }

Dari pandangan mata burung, jelas untuk melihat bahwa Dao antarmuka mendefinisikan sebuah API abstrak yang operasi Melakukan CRUD pada objek tipe T .

Karena tingkat abstraksi tinggi yang disediakan antarmuka, mudah untuk membuat implementasi konkret dan halus yang bekerja dengan objek User .

2.3. The UserDao Kelas

Mari tentukan implementasi khusus pengguna dari antarmuka Dao :

public class UserDao implements Dao { private List users = new ArrayList(); public UserDao() { users.add(new User("John", "[email protected]")); users.add(new User("Susan", "[email protected]")); } @Override public Optional get(long id) { return Optional.ofNullable(users.get((int) id)); } @Override public List getAll() { return users; } @Override public void save(User user) { users.add(user); } @Override public void update(User user, String[] params) { user.setName(Objects.requireNonNull( params[0], "Name cannot be null")); user.setEmail(Objects.requireNonNull( params[1], "Email cannot be null")); users.add(user); } @Override public void delete(User user) { users.remove(user); } }

Kelas User Dao mengimplementasikan semua fungsionalitas yang diperlukan untuk mengambil, memperbarui, dan menghapus objek User .

Demi kesederhanaan, Daftar pengguna bertindak seperti database dalam memori, yang diisi dengan beberapa objek Pengguna di konstruktor .

Tentu saja, mudah untuk memfaktorkan ulang metode lain, sehingga mereka dapat bekerja, misalnya, dengan database relasional.

Meskipun class User dan UserDao hidup berdampingan secara independen dalam aplikasi yang sama, kita masih perlu melihat bagaimana class yang terakhir dapat digunakan untuk menyembunyikan lapisan persistensi dari logika aplikasi:

public class UserApplication { private static Dao userDao; public static void main(String[] args) { userDao = new UserDao(); User user1 = getUser(0); System.out.println(user1); userDao.update(user1, new String[]{"Jake", "[email protected]"}); User user2 = getUser(1); userDao.delete(user2); userDao.save(new User("Julie", "[email protected]")); userDao.getAll().forEach(user -> System.out.println(user.getName())); } private static User getUser(long id) { Optional user = userDao.get(id); return user.orElseGet( () -> new User("non-existing user", "no-email")); } }

Contoh dibuat-buat, tetapi secara singkat menunjukkan motivasi di balik pola DAO. Dalam kasus ini, metode utama hanya menggunakan instance UserDao untuk melakukan operasi CRUD pada beberapa objek User .

Faset paling relevan dari proses ini adalah bagaimana User Dao menyembunyikan dari aplikasi semua detail tingkat rendah tentang bagaimana objek disimpan, diperbarui, dan dihapus .

3. Menggunakan Pola Dengan JPA

Ada kecenderungan umum di antara pengembang untuk berpikir bahwa rilis JPA diturunkan ke nol fungsi pola DAO, karena pola hanya menjadi lapisan abstraksi dan kompleksitas yang diterapkan di atas yang disediakan oleh manajer entitas JPA.

Unquestionably, in some scenarios this is true. Even so, sometimes we just want to expose to our application only a few domain-specific methods of the entity manager's API. In such cases, the DAO pattern has its place.

3.1. The JpaUserDao Class

With that said, let's create a new implementation of the Dao interface, so we can see how it can encapsulate the functionality that JPA's entity manager provides out of the box:

public class JpaUserDao implements Dao { private EntityManager entityManager; // standard constructors @Override public Optional get(long id) { return Optional.ofNullable(entityManager.find(User.class, id)); } @Override public List getAll() { Query query = entityManager.createQuery("SELECT e FROM User e"); return query.getResultList(); } @Override public void save(User user) { executeInsideTransaction(entityManager -> entityManager.persist(user)); } @Override public void update(User user, String[] params) { user.setName(Objects.requireNonNull(params[0], "Name cannot be null")); user.setEmail(Objects.requireNonNull(params[1], "Email cannot be null")); executeInsideTransaction(entityManager -> entityManager.merge(user)); } @Override public void delete(User user) { executeInsideTransaction(entityManager -> entityManager.remove(user)); } private void executeInsideTransaction(Consumer action) { EntityTransaction tx = entityManager.getTransaction(); try { tx.begin(); action.accept(entityManager); tx.commit(); } catch (RuntimeException e) { tx.rollback(); throw e; } } }

The JpaUserDao class is capable of working with any relational database supported by the JPA implementation.

Furthermore, if we look closely at the class, we'll realize how the use of Composition and Dependency Injection allows us to call only the entity manager methods required by our application.

Simply put, we have a domain-specific tailored API, rather than the entire entity manager's API.

3.2. Refactoring the User Class

In this case, we'll use Hibernate as the JPA default implementation, thus we'll refactor the User class accordingly:

@Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; private String name; private String email; // standard constructors / setters / getters }

3.3. Bootstrapping a JPA Entity Manager Programmatically

Assuming that we already have a working instance of MySQL running either locally or remotely and a database table “users” populated with some user records, we need to get a JPA entity manager, so we can use the JpaUserDao class for performing CRUD operations in the database.

In most cases, we accomplish this via the typical “persistence.xml” file, which is the standard approach.

In this case, we'll take an “xml-less” approach and get the entity manager with plain Java through Hibernate's handy EntityManagerFactoryBuilderImpl class.

For a detailed explanation on how to bootstrap a JPA implementation with Java, please check this article.

3.4. The UserApplication Class

Finally, let's refactor the initial UserApplication class, so it can work with a JpaUserDao instance and execute CRUD operations on the User entities:

public class UserApplication { private static Dao jpaUserDao; // standard constructors public static void main(String[] args) { User user1 = getUser(1); System.out.println(user1); updateUser(user1, new String[]{"Jake", "[email protected]"}); saveUser(new User("Monica", "[email protected]")); deleteUser(getUser(2)); getAllUsers().forEach(user -> System.out.println(user.getName())); } public static User getUser(long id) { Optional user = jpaUserDao.get(id); return user.orElseGet( () -> new User("non-existing user", "no-email")); } public static List getAllUsers() { return jpaUserDao.getAll(); } public static void updateUser(User user, String[] params) { jpaUserDao.update(user, params); } public static void saveUser(User user) { jpaUserDao.save(user); } public static void deleteUser(User user) { jpaUserDao.delete(user); } }

Even when the example is pretty limited indeed, it remains useful for demonstrating how to integrate the DAO pattern's functionality with the one that the entity manager provides.

In most applications, there's a DI framework, which is responsible for injecting a JpaUserDao instance into the UserApplication class. For simplicity's sake, we've omitted the details of this process.

Hal yang paling relevan untuk ditekankan di sini adalah bagaimana kelas JpaUserDao membantu menjaga agar kelas UserApplication benar-benar agnostik tentang bagaimana lapisan persistensi melakukan operasi CRUD .

Selain itu, kami dapat menukar MySQL untuk RDBMS lainnya (dan bahkan untuk database datar) di masa mendatang, dan tetap saja, aplikasi kami akan terus berfungsi seperti yang diharapkan, berkat tingkat abstraksi yang disediakan oleh antarmuka Dao dan manajer entitas .

4. Kesimpulan

Dalam artikel ini, kami melihat secara mendalam konsep utama pola DAO, cara menerapkannya di Java, dan cara menggunakannya di atas manajer entitas JPA.

Seperti biasa, semua contoh kode yang ditampilkan dalam artikel ini tersedia di GitHub.