Modelul DAO în Java

1. Prezentare generală

Modelul Data Access Object (DAO) este un model structural care ne permite să izolăm stratul aplicație / business de stratul de persistență (de obicei o bază de date relațională, dar ar putea fi orice alt mecanism de persistență) folosind un API abstract .

Funcționalitatea acestui API este de a ascunde de aplicație toate complexitățile implicate în efectuarea operațiunilor CRUD în mecanismul de stocare subiacent. Acest lucru permite ambelor straturi să evolueze separat, fără să știe nimic unul despre celălalt.

În acest tutorial, vom face o scufundare profundă în implementarea tiparului și vom învăța cum să-l folosim pentru abstractizarea apelurilor către un manager de entitate JPA.

2. O implementare simplă

Pentru a înțelege cum funcționează modelul DAO, să creăm un exemplu de bază.

Să presupunem că vrem să dezvoltăm o aplicație care să gestioneze utilizatorii. Pentru a menține modelul de domeniu al aplicației complet agnostic cu privire la baza de date, vom crea o clasă DAO simplă care se va ocupa de menținerea acestor componente decuplate între ele .

2.1. Clasa domeniului

Deoarece aplicația noastră va funcționa cu utilizatorii, trebuie să definim o singură clasă pentru implementarea modelului său de domeniu:

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

Utilizator Clasa este doar un container simplu pentru datele de utilizator, astfel încât să nu pună în aplicare orice alt comportament care merită subliniat.

Desigur, cea mai relevantă alegere de proiectare pe care trebuie să o facem aici este cum să menținem aplicația care utilizează această clasă izolată de orice mecanism de persistență care ar putea fi implementat la un moment dat.

Ei bine, exact asta este problema pe care tiparul DAO încearcă să o abordeze.

2.2. API-ul DAO

Să definim un strat DAO de bază, astfel încât să putem vedea cum poate păstra modelul de domeniu complet decuplat de stratul de persistență.

Iată API-ul DAO:

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

De la o pasăre ochi vedere, este clar pentru a vedea că Dao interfață definește un API abstractă care operațiunile efectuează CRUD pe obiecte de tip T .

Datorită nivelului ridicat de abstractizare pe care îl oferă interfața, este ușor să creați o implementare concretă, cu granulație fină, care să funcționeze cu obiectele utilizatorului .

2.3. UserDao Clasa

Să definim o implementare specifică utilizatorului a interfeței 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); } }

La UserDao implementează clasa toate funcționalitățile necesare pentru preluarea, actualizarea și eliminarea utilizatorilor de obiecte.

Pentru simplitate, Lista utilizatorilor acționează ca o bază de date în memorie, care este populată cu câteva obiecte de utilizator în constructor .

Desigur, este ușor să refactorizați celelalte metode, astfel încât acestea să poată funcționa, de exemplu, cu o bază de date relațională.

În timp ce atât clasele User cât și UserDao coexistă independent în cadrul aceleiași aplicații, trebuie totuși să vedem cum acesta din urmă poate fi folosit pentru a păstra stratul de persistență ascuns de logica aplicației:

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")); } }

Exemplul este conceput, dar arată, pe scurt, motivațiile din spatele modelului DAO. În acest caz, metoda principală folosește doar o instanță UserDao pentru a efectua operații CRUD pe câteva obiecte User .

Cea mai relevantă fațetă a acestui proces este modul în care UserDao ascunde din aplicație toate detaliile la nivel scăzut despre modul în care obiectele sunt persistente, actualizate și șterse .

3. Utilizarea modelului cu JPA

Există o tendință generală în rândul dezvoltatorilor de a crede că lansarea JPA a redus la zero funcționalitatea modelului DAO, deoarece modelul devine doar un alt strat de abstractizare și complexitate implementat pe lângă cel furnizat de managerul entității 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.

Cel mai relevant punct de subliniat aici este modul în care clasa JpaUserDao ajută la menținerea clasei UserApplication complet agnostică cu privire la modul în care stratul de persistență efectuează operații CRUD .

În plus, am putea schimba MySQL cu orice alt RDBMS (și chiar cu o bază de date plană) mai departe, și totuși, aplicația noastră ar continua să funcționeze așa cum era de așteptat, datorită nivelului de abstractizare oferit de interfața Dao și de managerul entității .

4. Concluzie

În acest articol, am analizat în detaliu conceptele cheie ale modelului DAO, cum să-l implementăm în Java și cum să-l folosim pe lângă managerul de entitate al JPA.

Ca de obicei, toate exemplele de cod prezentate în acest articol sunt disponibile pe GitHub.