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'agit d'un objet d'accès aux données. Quelqu'un peut-il m'expliquer ce que c'est réellement?

Je sais que c'est une sorte d'interface pour accéder aux données de différents types de sources.Au milieu de mes petites recherches, je suis tombé sur un concept appelé source de données ou objet de source de données, et les choses se sont brouillées dans mon esprit.

Je veux vraiment savoir ce qu'est un DAOprogramme par rapport à son 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 donne accès à 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

Consultez également le diagramme de séquence ici: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

Un exemple simple peut peut-être 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 des employés seront conservées dans une Employeetable correspondante dans une base de données. Une interface DAO simple pour gérer l'opération de base de données requise pour manipuler une entité d'employé sera comme:

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 les fichiers plats, etc.

Qu'est-ce que DATA ACCESS OBJECT (DAO) -

C'est un objet / interface , qui est utilisé pour accéder aux données de la base de données de stockage de données.

POURQUOI NOUS UTILISONS DAO:

il résume la récupération de données à partir 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 qui utilise Microsoft SQL Server. Si votre application utilise des procédures stockées et du code spécifique à la base de données (comme 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 utiliser SQL Server au lieu d'Oracle (ou ajoutez du code conditionnel pour gérer les différences), ou
• Créez une couche entre votre logique d'application et l'accès aux données

Son dans l'ensemble appelé modèle DAO , il se compose des éléments suivants:

• Interface d'objet d'accès aux données - Cette interface définit les opérations standard à effectuer sur un ou plusieurs objets modèle.
• Classe concrète d'objet d'accès aux données - Cette classe implémente l'interface ci-dessus. Cette classe est chargée d'obtenir des données à partir d'une source de données qui peut être une base de données / xml ou tout autre mécanisme de stockage.
• Objet de modèle ou objet de valeur - Cet objet est un POJO simple contenant des méthodes get / set pour stocker les données récupérées à 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 jusqu'à un certain point.

DAO (Data Access Object) est un modèle de conception très utilisé dans les applications d'entreprise. Il s'agit essentiellement du 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:

Exemple DAO

Veuillez noter qu'il existe différentes façons d'implémenter le modèle DAO d' origine , et il existe de nombreux cadres qui peuvent simplifier votre travail. Par exemple, les frameworks ORM (Object Relational Mapping) comme iBatis ou Hibernate, sont utilisés pour mapper le résultat des requêtes SQL aux objets java.

J'espère que ça aide, au revoir!

Le modèle d'objet d'accès aux données ou modèle DAO est utilisé pour séparer les opérations ou les API d'accès aux données de bas niveau des services métier de haut niveau. Voici les participants au modèle d'objet d'accès aux données.

Interface d'objet d'accès aux données - Cette interface définit les opérations standard à effectuer sur un ou des objets de modèle.

Classe concrète d'objet d'accès aux données - Cette classe implémente l'interface ci-dessus. Cette classe est chargée d'obtenir des données à partir d'une source de données qui peut être une base de données / xml ou tout autre mécanisme de stockage.

Objet de modèle ou objet de valeur - Cet objet est un POJO simple contenant des méthodes get / set pour stocker les données récupérées à l'aide de la classe DAO.

Exemple de code ici ..

Je vais être général et non 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 "personne" avec les colonnes "nom" et "âge", vous créerez 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 récupérer toutes les personnes, quel que soit le type de base de données que vous utilisez (qui peut être sujet aux erreurs), vous effectuez plutôt:

list persons = DAO.getPersons();
...
person = DAO.getPersonWithName("John");
age = person.age;

Vous n'écrivez pas l'abstraction DAO vous-même, mais elle fait généralement partie d'un projet open source, selon le langage et le framework que vous utilisez.

Passons maintenant à la question principale. " ..où il est utilisé .. ". Eh bien, généralement, si vous écrivez du code d'entreprise et de domaine complexe, votre vie sera très difficile sans DAO. Bien sûr, vous n'avez pas besoin d'utiliser ORM et DAO fournis, mais vous pouvez é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.

Je pense que le meilleur exemple (avec des explications) que vous pouvez trouver sur le site Web d'Oracle: ici . Un autre bon tutoriel pourrait être trouvé ici .

Ne vous confondez pas avec trop d'explications. DAO: Du nom lui-même, cela signifie accéder aux données à l'aide d'un objet. DAO est séparé des autres Business Logic.

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 n'importe quelle base de données telle qu'un SGBDR, un référentiel XML ou un système de fichiers plat, etc.

Spring 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 utiliserons 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();
    }    
}

DAO est un acte comme "Persistence Manager" dans une architecture à 3 niveaux ainsi que DAO a également un modèle de conception que vous pouvez consulter le livre "Gang of Four". Votre couche de service d'application doit simplement appeler la méthode de la classe DAO sans connaître les détails cachés et internes de la méthode DAO.

Les classes Dao sont utilisées pour réutiliser la logique jdbc et Dao (Data Access Object) est un modèle de conception. dao est une classe java simple qui contient la logique JDBC.

La couche d'accès aux données a fait ses preuves dans une couche de logique métier distincte et une couche persistante. Le modèle de conception DAO masque complètement l'implémentation de l'accès aux données à ses clients

L'objet d'accès aux données Java (Java DAO) est un composant important dans les applications d'entreprise. Les applications métier ont presque toujours besoin d'accéder aux données de bases de données relationnelles ou d'objets et la plate-forme Java propose de nombreuses techniques pour accéder à ces données. La technique la plus ancienne et la plus mature consiste à utiliser l'API Java Database Connectivity (JDBC), qui offre la possibilité d'exécuter des requêtes SQL sur une base de données, puis de récupérer les résultats, une colonne à la fois.

Pojo considère également comme classe Model en Java où nous pouvons créer des getter et setter pour une variable particulière définie en privé. N'oubliez pas que toutes les variables sont déclarées ici avec un modificateur privé