Corak DAO di Jawa

1. Gambaran keseluruhan

Pola Objek Akses Data (DAO) adalah pola struktur yang memungkinkan kita untuk mengasingkan lapisan aplikasi / perniagaan dari lapisan kegigihan (biasanya pangkalan data relasional, tetapi mungkin mekanisme ketekunan lain) menggunakan API abstrak .

Fungsi API ini adalah untuk menyembunyikan dari aplikasi semua kerumitan yang terlibat dalam melakukan operasi CRUD dalam mekanisme penyimpanan yang mendasari. Ini membolehkan kedua-dua lapisan berkembang secara berasingan tanpa mengetahui tentang satu sama lain.

Dalam tutorial ini, kita akan menyelidiki implementasi pola tersebut, dan kita akan belajar bagaimana menggunakannya untuk mengaburkan panggilan ke pengurus entiti JPA.

2. Pelaksanaan Yang Mudah

Untuk memahami bagaimana corak DAO berfungsi, mari buat contoh asas.

Katakan bahawa kami ingin mengembangkan aplikasi yang menguruskan pengguna. Untuk memastikan model domain aplikasi benar-benar agnostik mengenai pangkalan data, kami akan membuat kelas DAO ringkas yang akan memastikan komponen-komponen ini dipisahkan dengan rapi antara satu sama lain .

2.1. Kelas Domain

Oleh kerana aplikasi kita akan berfungsi dengan pengguna, kita perlu menentukan satu kelas untuk melaksanakan model domainnya:

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

The pengguna kelas hanya bekas kosong untuk data pengguna, jadi ia tidak melaksanakan apa-apa bernilai tingkah laku lain menekankan.

Sudah tentu, pilihan reka bentuk yang paling relevan yang perlu kita buat di sini adalah bagaimana memastikan aplikasi yang menggunakan kelas ini terpencil daripada mekanisme ketekunan yang dapat dilaksanakan pada suatu ketika.

Nah, itulah masalah yang cuba ditangani oleh corak DAO.

2.2. API DAO

Mari tentukan lapisan DAO asas, sehingga kita dapat melihat bagaimana ia dapat memastikan model domain dipisahkan sepenuhnya dari lapisan kegigihan.

Inilah 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, ia adalah jelas untuk melihat bahawa Dao muka mentakrifkan API abstrak yang operasi Melakukan CRUD pada objek jenis T .

Kerana tahap abstraksi yang tinggi yang disediakan antara muka, mudah untuk membuat pelaksanaan konkrit dan halus yang berfungsi dengan objek Pengguna .

2.3. The UserDao Kelas

Mari tentukan pelaksanaan khusus pengguna antara muka 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); } }

The UserDao alat kelas semua fungsi yang diperlukan untuk semasa mengambil, mengemaskini, dan mengeluarkan Pengguna objek.

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

Sudah tentu, mudah untuk membuat refleksi kaedah lain, sehingga mereka dapat berfungsi, misalnya, dengan pangkalan data hubungan.

Walaupun kedua-dua kelas User dan UserDao wujud secara bebas dalam aplikasi yang sama, kami masih perlu melihat bagaimana yang terakhir dapat digunakan untuk menjaga lapisan ketekunan tersembunyi dari logik 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")); } }

Contohnya dibuat, tetapi ini menunjukkan, secara ringkas, motivasi di sebalik corak DAO. Dalam kes ini, kaedah utama hanya menggunakan instance UserDao untuk melakukan operasi CRUD pada beberapa objek Pengguna .

Fasa yang paling relevan dari proses ini adalah bagaimana UserDao menyembunyikan dari aplikasi semua butiran tahap rendah mengenai bagaimana objek itu bertahan, dikemas kini dan dihapus .

3. Menggunakan Corak Dengan JPA

Terdapat kecenderungan umum di kalangan pembangun untuk berfikir bahawa pelepasan JPA diturunkan menjadi sifar fungsi corak DAO, kerana corak itu menjadi lapisan abstraksi dan kerumitan lain yang dilaksanakan di atas yang disediakan oleh pengurus entiti 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.

Titik paling berkaitan dengan tekanan di sini ialah bagaimana yang JpaUserDao kelas menolong menjadikan UserApplication kelas sepenuhnya agnostik tentang bagaimana lapisan kegigihan operasi Melakukan Makanan Tak .

Di samping itu, kami dapat menukar MySQL untuk RDBMS lain (dan bahkan untuk pangkalan data rata) lebih jauh, dan tetap saja, aplikasi kami akan terus berfungsi seperti yang diharapkan, berkat tahap abstraksi yang disediakan oleh antara muka Dao dan pengurus entiti .

4. Kesimpulan

Dalam artikel ini, kami melihat konsep-konsep utama corak DAO, bagaimana menerapkannya di Java, dan bagaimana menggunakannya di atas pengurus entiti JPA.

Seperti biasa, semua contoh kod yang ditunjukkan dalam artikel ini terdapat di GitHub.