Objet d'accès aux données (DAO) en Java
Je parcourais un document et je suis tombé sur un terme appelé DAO. J'ai découvert qu'il s'agissait d'un objet d'accès aux données. Quelqu'un peut-il m'expliquer s'il vous plaît ce que c'est réellement?
Je sais que c'est une sorte d'interface pour accéder à des données provenant de différents types de sources. Au cours de cette petite recherche, je suis tombé sur un concept appelé source de données ou objet source de données, et les choses se sont brouillées dans mon esprit.
Je veux vraiment savoir ce qu'est une DAO par programme en termes d'utilisation. Comment est-il utilisé? Tous les liens vers des pages qui expliquent ce concept à partir de choses très basiques sont également appréciés.
L'objet d'accès aux données est essentiellement un objet ou une interface qui permet d'accéder à une base de données sous-jacente ou à tout autre stockage de persistance.
Cette définition de: http://en.wikipedia.org/wiki/Data_access_object
Vérifiez également le diagramme de séquence ici: http://www.Oracle.com/technetwork/Java/dataaccessobject-138824.html
Peut-être qu'un exemple simple peut vous aider à comprendre le concept:
Disons que nous avons une entité pour représenter un employé:
public class Employee {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Les entités d'employé seront conservées dans la table Employee correspondante dans une base de données . Une interface DAO simple permettant de gérer l'opération de base de données requise pour manipuler une entité d'employé sera semblable à:
interface EmployeeDAO {
List<Employee> findAll();
List<Employee> findById();
List<Employee> findByName();
boolean insertEmployee(Employee employee);
boolean updateEmployee(Employee employee);
boolean deleteEmployee(Employee employee);
}
Ensuite, nous devons fournir une implémentation concrète pour que cette interface traite le serveur SQL, et une autre pour traiter les fichiers plats, etc.
Qu'est-ce que DATA ACCESS OBJECT (DAO) -
Il s'agit d'un objet/interface, utilisé pour accéder aux données à partir de la base de données de stockage.
POURQUOI WE UTILISER DAO:
il extrait la récupération de données d'une ressource de données telle qu'une base de données. Le concept consiste à "séparer l'interface client d'une ressource de données de son mécanisme d'accès aux données".
Le problème avec l'accès direct aux données est que la source des données peut changer. Considérez, par exemple, que votre application est déployée dans un environnement qui accède à une base de données Oracle. Il est ensuite déployé dans un environnement utilisant Microsoft SQL Server. Si votre application utilise des procédures stockées et du code spécifique à la base de données (telle que la génération d'une séquence de nombres), comment gérez-vous cela dans votre application? Vous avez deux options:
- Réécrivez votre application pour qu'elle utilise SQL Server au lieu d'Oracle (ou ajoutez du code conditionnel pour gérer les différences), ou
- Créez une couche entre la logique de votre application et l'accès aux données
Il est en tout appelé DAO Pattern, il se compose de ce qui suit:
- Interface d'accès aux données - Cette interface définit les opérations standard à exécuter sur un ou plusieurs objets du modèle.
- Data Access Object classe concrète - Cette classe implémente l'interface ci-dessus. Cette classe est responsable d'obtenir les données d'une source de données qui peut être base de données/xml ou tout autre mécanisme de stockage.
- Objet modèle ou objet valeur - Cet objet est un simple POJO contenant les méthodes get/set pour stocker les données extraites à l'aide de la classe DAO.
Veuillez vérifier cet exemple, cela clarifiera les choses plus clairement.
Exemple
Je suppose que cela a dû clarifier votre compréhension de DAO dans une certaine mesure.
DAO (Data Access Object) est un modèle de conception très utilisé dans les applications d'entreprise. C'est en gros le module utilisé pour accéder aux données de toutes les sources (SGBD, XML, etc.). Je vous suggère de lire quelques exemples, comme celui-ci:
Veuillez noter qu'il existe différentes manières de mettre en œuvre l'original DAO Pattern , et de nombreux cadres peuvent simplifier votre travail. Par exemple, les infrastructures ORM (Object Relational Mapping) telles que iBatis ou Hibernate permettent de mapper le résultat de requêtes SQL sur des objets Java.
J'espère que ça aide, Bye!
Le modèle d'objet d'accès aux données ou le modèle DAO est utilisé pour séparer les opérations de base de données d'accès à l'API ou les opérations des services métier de niveau supérieur. Voici les participants au modèle d’objet d’accès aux données.
Interface d'accès aux données - Cette interface définit les opérations standard à effectuer sur un ou plusieurs objets de modèle.
Classe concrète de Data Access Object - Cette classe implémente l'interface ci-dessus. Cette classe est chargée d’obtenir des données d’une source de données pouvant être la base de données/xml ou tout autre mécanisme de stockage.
Objet modèle ou objet valeur - Cet objet est un simple POJO contenant des méthodes get/set pour stocker les données extraites à l'aide de la classe DAO.
Exemple de code ici ..
Ne vous trompez pas avec trop d'explications. DAO: À partir du nom même, cela signifie accéder aux données en utilisant Object. DAO est séparé des autres Business Logics.
Je vais être général et pas spécifique à Java car DAO et ORM sont utilisés dans toutes les langues.
Pour comprendre DAO, vous devez d’abord comprendre ORM (Object Rational Mapping). Cela signifie que si vous avez une table appelée "patient" avec les colonnes "nom" et "âge", vous devez alors créer un modèle d'objet pour cette table:
type Person {
name
age
}
Maintenant, avec l'aide de DAO au lieu d'écrire des requêtes spécifiques, pour extraire toutes les personnes, quel que soit le type de base de données que vous utilisez (qui peut être sujet à des erreurs), utilisez plutôt:
list persons = DAO.getPersons();
...
person = DAO.getPersonWithName("John");
age = person.age;
Vous n'écrivez pas l'abstraction DAO vous-même, il fait généralement partie d'un projet opensource, en fonction du langage et de la structure que vous utilisez.
Passons maintenant à la question principale ici. " ..où il est utilisé .. ". Habituellement, si vous écrivez du code complexe pour des entreprises et des domaines spécifiques, votre vie sera très difficile sans DAO. Bien sûr, vous n'avez pas besoin d'utiliser ORM et DAO fournis, vous pouvez plutôt écrire votre propre abstraction et vos requêtes natives. Je l'ai fait par le passé et je l'ai presque toujours regretté plus tard.
L'objet d'accès aux données gère la connexion avec la source de données pour obtenir et stocker des données. Il résume l'implémentation d'accès aux données sous-jacente pour l'objet métier afin de permettre un accès transparent à la source de données. Une source de données peut être toute base de données telle qu'un SGBDR, un référentiel XML ou un système de fichiers à plat, etc.
DAO est un acte du type "Gestionnaire de persistance" dans une architecture à 3 niveaux, ainsi que DAO et son motif de conception, car vous pouvez consulter le livre "Gang of Four". Détails cachés et internes de la méthode de DAO.
Les classes Dao permettent de réutiliser la logique jdbc. Dao (Data Access Object) est un modèle de conception . Dao est une simple classe Java contenant la logique JDBC.
La couche d'accès aux données s'est révélée efficace dans les couches de logique métier et persistante séparées Le modèle de conception DAO masque complètement l'implémentation d'accès aux données de ses clients
Java DAO (Java Data Access Object) est un composant important des applications métier. Les applications métier ont presque toujours besoin d'accéder à des données provenant de bases de données relationnelles ou d'objets, et la plate-forme Java offre de nombreuses techniques pour accéder à ces données. La technique la plus ancienne et la plus aboutie consiste à utiliser l'API JDBC (Java Database Connectivity), qui permet d'exécuter des requêtes SQL sur une base de données, puis d'extraire les résultats, une colonne à la fois.
Pojo considère également comme classe modèle Java où nous pouvons créer un getter et un setter pour une variable particulière définie dans private .
Printemps JPA DAO
Par exemple, nous avons un groupe d'entités.
Pour cette entité, nous créons le référentiel GroupRepository.
public interface GroupRepository extends JpaRepository<Group, Long> {
}
Ensuite, nous devons créer une couche de service avec laquelle nous allons utiliser ce référentiel.
public interface Service<T, ID> {
T save(T entity);
void deleteById(ID id);
List<T> findAll();
T getOne(ID id);
T editEntity(T entity);
Optional<T> findById(ID id);
}
public abstract class AbstractService<T, ID, R extends JpaRepository<T, ID>> implements Service<T, ID> {
private final R repository;
protected AbstractService(R repository) {
this.repository = repository;
}
@Override
public T save(T entity) {
return repository.save(entity);
}
@Override
public void deleteById(ID id) {
repository.deleteById(id);
}
@Override
public List<T> findAll() {
return repository.findAll();
}
@Override
public T getOne(ID id) {
return repository.getOne(id);
}
@Override
public Optional<T> findById(ID id) {
return repository.findById(id);
}
@Override
public T editEntity(T entity) {
return repository.saveAndFlush(entity);
}
}
@org.springframework.stereotype.Service
public class GroupServiceImpl extends AbstractService<Group, Long, GroupRepository> {
private final GroupRepository groupRepository;
@Autowired
protected GroupServiceImpl(GroupRepository repository) {
super(repository);
this.groupRepository = repository;
}
}
Et dans le contrôleur, nous utilisons ce service.
@RestController
@RequestMapping("/api")
class GroupController {
private final Logger log = LoggerFactory.getLogger(GroupController.class);
private final GroupServiceImpl groupService;
@Autowired
public GroupController(GroupServiceImpl groupService) {
this.groupService = groupService;
}
@GetMapping("/groups")
Collection<Group> groups() {
return groupService.findAll();
}
@GetMapping("/group/{id}")
ResponseEntity<?> getGroup(@PathVariable Long id) {
Optional<Group> group = groupService.findById(id);
return group.map(response -> ResponseEntity.ok().body(response))
.orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
}
@PostMapping("/group")
ResponseEntity<Group> createGroup(@Valid @RequestBody Group group) throws URISyntaxException {
log.info("Request to create group: {}", group);
Group result = groupService.save(group);
return ResponseEntity.created(new URI("/api/group/" + result.getId()))
.body(result);
}
@PutMapping("/group")
ResponseEntity<Group> updateGroup(@Valid @RequestBody Group group) {
log.info("Request to update group: {}", group);
Group result = groupService.save(group);
return ResponseEntity.ok().body(result);
}
@DeleteMapping("/group/{id}")
public ResponseEntity<?> deleteGroup(@PathVariable Long id) {
log.info("Request to delete group: {}", id);
groupService.deleteById(id);
return ResponseEntity.ok().build();
}
}