Oggetto di accesso ai dati (DAO) in Java

Stavo leggendo un documento e mi sono imbattuto in un termine chiamato DAO. Ho scoperto che si tratta di un oggetto di accesso ai dati. Qualcuno può spiegarmi cosa sia in realtà?

So che è una sorta di interfaccia per accedere ai dati da diversi tipi di fonti, nel mezzo di questa mia piccola ricerca ho scoperto un concetto chiamato origine dati o oggetto sorgente dati, e le cose mi sono incasinate.

Voglio davvero sapere che cosa DAOè a livello di codice in termini di dove viene utilizzato. Come si usa Anche i collegamenti a pagine che spiegano questo concetto dalle cose di base sono apprezzati.

L'oggetto di accesso ai dati è fondamentalmente un oggetto o un'interfaccia che fornisce l'accesso a un database sottostante o qualsiasi altro archivio di persistenza.

Quella definizione da: http://en.wikipedia.org/wiki/Data_access_object

Controlla anche il diagramma di sequenza qui: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

Forse un semplice esempio può aiutarti a capire il concetto:

Diciamo che abbiamo un'entità per rappresentare un dipendente:

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

}

Le entità dipendenti saranno mantenute in un corrispondente Employee tabella in un database. Una semplice interfaccia DAO per gestire l'operazione di database richiesta per manipolare un'entità dipendente sarà come:

interface EmployeeDAO {

    List<Employee> findAll();
    List<Employee> findById();
    List<Employee> findByName();
    boolean insertEmployee(Employee employee);
    boolean updateEmployee(Employee employee);
    boolean deleteEmployee(Employee employee);

}

Successivamente dobbiamo fornire un'implementazione concreta per quell'interfaccia per gestire il server SQL e un'altra per gestire file flat, ecc.

Che cos'è DATA ACCESS OBJECT (DAO) -

È un oggetto / interfaccia , che viene utilizzato per accedere ai dati dal database di archiviazione dei dati.

PERCHÉ USIAMO DAO:

impedisce il recupero di dati da una risorsa di dati come un database. Il concetto è quello di "separare l'interfaccia client di una risorsa dati dal suo meccanismo di accesso ai dati".

Il problema con l'accesso diretto ai dati è che la fonte dei dati può cambiare. Si consideri, ad esempio, che l'applicazione sia distribuita in un ambiente che accede a un database Oracle. Quindi viene successivamente distribuito in un ambiente che utilizza Microsoft SQL Server. Se l'applicazione utilizza procedure memorizzate e codice specifico del database (come la generazione di una sequenza numerica), come lo gestisci nella tua applicazione? Hai due opzioni:

• Riscrivi l'applicazione per utilizzare SQL Server anziché Oracle (o aggiungi il codice condizionale per gestire le differenze) oppure
• Crea un livello tra la logica dell'applicazione e l'accesso ai dati

È in tutto indicato come DAO Pattern , consiste nel seguente:

• Interfaccia oggetto di accesso ai dati : questa interfaccia definisce le operazioni standard da eseguire su uno o più oggetti modello.
• Classe concreta dell'oggetto di accesso ai dati -Questa classe implementa sopra l'interfaccia. Questa classe è responsabile per ottenere dati da un'origine dati che può essere database / xml o qualsiasi altro meccanismo di archiviazione.
• Oggetto modello o oggetto valore : questo oggetto è un semplice POJO contenente metodi get / set per archiviare i dati recuperati utilizzando la classe DAO.

Controlla questo esempio, questo chiarirà le cose più chiaramente.

Esempio
Presumo che queste cose debbano aver chiarito la tua comprensione di DAO fino a un certo punto.

DAO (Data Access Object) è un modello di progettazione molto utilizzato nelle applicazioni aziendali. Fondamentalmente è il modulo utilizzato per accedere ai dati da ogni sorgente (DBMS, XML e così via). Ti consiglio di leggere alcuni esempi, come questo:

Esempio DAO

Si noti che esistono diversi modi per implementare il modello DAO originale e ci sono molti framework che possono semplificare il tuo lavoro. Ad esempio, i framework ORM (Object Relational Mapping) come iBatis o Hibernate, vengono utilizzati per mappare il risultato delle query SQL sugli oggetti Java.

Spero che ti aiuti, ciao!

Il modello di oggetti di accesso ai dati o il modello DAO viene utilizzato per separare l'API o le operazioni di accesso ai dati di basso livello dai servizi aziendali di alto livello. Di seguito sono riportati i partecipanti al modello di oggetti di accesso ai dati.

Interfaccia oggetto di accesso ai dati: questa interfaccia definisce le operazioni standard da eseguire su uno o più oggetti modello.

Classe concreta dell'oggetto di accesso ai dati -Questa classe implementa sopra l'interfaccia. Questa classe è responsabile per ottenere dati da un'origine dati che può essere database / xml o qualsiasi altro meccanismo di archiviazione.

Oggetto modello o oggetto valore: questo oggetto è un semplice POJO contenente metodi get / set per archiviare i dati recuperati utilizzando la classe DAO.

Codice di esempio qui ..

Sarò generale e non specifico di Java poiché DAO e ORM sono usati in tutte le lingue.

Per capire DAO devi prima capire ORM (Object Rational Mapping). Ciò significa che se si dispone di una tabella denominata "persona" con colonne "nome" ed "età", è necessario creare un modello oggetto per quella tabella:

type Person {
name
age
}

Ora con l'aiuto di DAO invece di scrivere alcune query specifiche, per recuperare tutte le persone, per qualunque tipo di db stai usando (che può essere soggetto a errori) invece fai:

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

Non scrivi tu stesso l'astrazione DAO, invece di solito fa parte di alcuni progetti opensource, a seconda della lingua e del framework che stai utilizzando.

Ora alla domanda principale qui. " ..qui è usato .. ". Bene, di solito se stai scrivendo un codice aziendale e di dominio specifico, la tua vita sarà molto difficile senza DAO. Ovviamente non è necessario utilizzare ORM e DAO forniti, invece è possibile scrivere le proprie astrazioni e query native. L'ho fatto in passato e quasi sempre me ne sono pentito in seguito.

Penso che il miglior esempio (insieme alle spiegazioni) che puoi trovare sul sito web di Oracle: qui . Un altro buon tutoriale può essere trovato qui .

Non confonderti con troppe spiegazioni. DAO: Dal nome stesso significa Accesso ai dati tramite Object. DAO è separato dalle altre logiche aziendali.

L'oggetto di accesso ai dati gestisce la connessione con l'origine dati per ottenere e archiviare i dati e astrae l'implementazione dell'accesso ai dati sottostante per l'oggetto business per consentire un accesso trasparente all'origine dati. Un'origine dati può essere qualsiasi database come un RDBMS, un repository XML o un file system piatto ecc.

Primavera JPA DAO

Ad esempio abbiamo un gruppo di entità.

Per questa entità creiamo il repository GroupRepository.

public interface GroupRepository extends JpaRepository<Group, Long> {   
}

Quindi dobbiamo creare un livello di servizio con il quale utilizzeremo questo repository.

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

E nel controller utilizziamo questo servizio.

@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 è un atto come "Persistence Manager" nell'architettura a 3 livelli, così come DAO progetta anche modelli come puoi consultare il libro "Gang of Four". Il tuo livello di servizio dell'applicazione deve solo chiamare il metodo della classe DAO senza conoscere i dettagli nascosti e interni del metodo DAO.

I clasi Dao sono usati per riutilizzare la logica jdbc e Dao (Data Access Object) è un modello di progettazione. dao è una semplice classe java che contiene la logica JDBC.

Il livello di accesso ai dati si è dimostrato valido nel livello di logica aziendale separato e nel livello persistente. Il modello di progettazione DAO nasconde completamente l'implementazione dell'accesso ai dati dai suoi client

Java DAO (Java Data Access Object) è un componente importante nelle applicazioni aziendali. Le applicazioni aziendali hanno quasi sempre bisogno di accedere ai dati da database relazionali o di oggetti e la piattaforma Java offre molte tecniche per accedere a questi dati. La tecnica più antica e più matura consiste nell'utilizzare l'API JDBC (Java Database Connectivity), che offre la possibilità di eseguire query SQL su un database e quindi recuperare i risultati, una colonna alla volta.

Pojo considera anche come classe Model in Java dove possiamo creare getter e setter per particolari variabili definite in privato. Ricorda che tutte le variabili sono qui dichiarate con modificatore privato