Datenzugriffsobjekt (DAO) in Java

Ich habe ein Dokument durchgesehen und bin auf einen Begriff namens gestoßen DAO. Ich habe herausgefunden, dass es sich um ein Datenzugriffsobjekt handelt. Kann mir bitte jemand erklären, was das eigentlich ist?

Ich weiß, dass es eine Art Schnittstelle für den Zugriff auf Daten aus verschiedenen Arten von Quellen ist. Während meiner kleinen Recherche bin ich auf ein Konzept gestoßen, das als Datenquelle oder Datenquellenobjekt bezeichnet wird, und die Dinge sind in meinem Kopf durcheinander geraten.

Ich möchte wirklich wissen, was a DAOprogrammatisch in Bezug auf den Verwendungszweck ist. Wie wird es verwendet? Alle Links zu Seiten, die dieses Konzept aus den Grundzügen erklären, sind ebenfalls willkommen.

Das Datenzugriffsobjekt ist im Grunde ein Objekt oder eine Schnittstelle, die den Zugriff auf eine zugrunde liegende Datenbank oder einen anderen Persistenzspeicher ermöglicht.

Diese Definition von: http://en.wikipedia.org/wiki/Data_access_object

Überprüfen Sie auch das Sequenzdiagramm hier: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

Vielleicht kann Ihnen ein einfaches Beispiel helfen, das Konzept zu verstehen:

Angenommen, wir haben eine Einheit, die einen Mitarbeiter vertritt:

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

}

Die Mitarbeiterentitäten werden in einer entsprechenden EmployeeTabelle in einer Datenbank gespeichert. Eine einfache DAO-Schnittstelle zur Verarbeitung der Datenbankoperation, die zum Manipulieren einer Mitarbeiterentität erforderlich ist, sieht folgendermaßen aus:

interface EmployeeDAO {

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

}

Als nächstes müssen wir eine konkrete Implementierung für diese Schnittstelle bereitstellen, um mit SQL Server umzugehen, und eine andere, um mit Flatfiles usw. umzugehen.

Was ist Data Access Object (DAO) -

Es ist ein Objekt / eine Schnittstelle , mit der auf Daten aus der Datenbank der Datenspeicherung zugegriffen wird.

WARUM WIR DAO VERWENDEN:

Es abstrahiert das Abrufen von Daten aus einer Datenressource wie einer Datenbank. Das Konzept besteht darin, "die Client-Schnittstelle einer Datenressource von ihrem Datenzugriffsmechanismus zu trennen".

Das Problem beim direkten Zugriff auf Daten besteht darin, dass sich die Datenquelle ändern kann. Angenommen, Ihre Anwendung wird in einer Umgebung bereitgestellt, die auf eine Oracle-Datenbank zugreift. Anschließend wird es in einer Umgebung bereitgestellt, die Microsoft SQL Server verwendet. Wie gehen Sie in Ihrer Anwendung damit um, wenn Ihre Anwendung gespeicherte Prozeduren und datenbankspezifischen Code verwendet (z. B. das Generieren einer Zahlenfolge)? Sie haben zwei Möglichkeiten:

• Schreiben Sie Ihre Anwendung neu, um SQL Server anstelle von Oracle zu verwenden (oder fügen Sie bedingten Code hinzu, um die Unterschiede zu beheben), oder
• Erstellen Sie eine Ebene zwischen Ihrer Anwendungslogik und dem Datenzugriff

Es wird insgesamt als DAO-Muster bezeichnet und besteht aus folgenden Elementen :

• Datenzugriffsobjektschnittstelle - Diese Schnittstelle definiert die Standardoperationen , die an einem oder mehreren Modellobjekten ausgeführt werden sollen.
• Konkrete Klasse des Datenzugriffsobjekts - Diese Klasse implementiert die obige Schnittstelle. Diese Klasse ist dafür verantwortlich, Daten aus einer Datenquelle abzurufen, die Datenbank / XML oder ein anderer Speichermechanismus sein kann.
• Modellobjekt oder Wertobjekt - Dieses Objekt ist ein einfaches POJO mit Get / Set-Methoden zum Speichern von Daten, die mit der DAO-Klasse abgerufen wurden.

Bitte überprüfen Sie dieses Beispiel. Dadurch werden die Dinge klarer.

Beispiel
Ich gehe davon aus, dass diese Dinge Ihr Verständnis von DAO bis zu einem gewissen Grad geklärt haben müssen.

DAO (Data Access Object) ist ein sehr verbreitetes Entwurfsmuster in Unternehmensanwendungen. Grundsätzlich ist es das Modul, mit dem auf Daten aus jeder Quelle (DBMS, XML usw.) zugegriffen wird. Ich empfehle Ihnen, einige Beispiele wie dieses zu lesen:

DAO Beispiel

Bitte beachten Sie, dass es verschiedene Möglichkeiten gibt, das ursprüngliche DAO-Muster zu implementieren , und dass es viele Frameworks gibt, die Ihre Arbeit vereinfachen können. Beispielsweise werden ORM-Frameworks (Object Relational Mapping) wie iBatis oder Hibernate verwendet, um das Ergebnis von SQL-Abfragen Java-Objekten zuzuordnen.

Hoffe es hilft, Tschüss!

Das Datenzugriffsobjektmuster oder DAO-Muster wird verwendet, um Datenzugriffs-API oder Vorgänge auf niedriger Ebene von Geschäftsdiensten auf hoher Ebene zu trennen. Im Folgenden sind die Teilnehmer am Datenzugriffsobjektmuster aufgeführt.

Datenzugriffsobjektschnittstelle - Diese Schnittstelle definiert die Standardoperationen, die an einem oder mehreren Modellobjekten ausgeführt werden sollen.

Konkrete Klasse des Datenzugriffsobjekts - Diese Klasse implementiert die obige Schnittstelle. Diese Klasse ist dafür verantwortlich, Daten aus einer Datenquelle abzurufen, die Datenbank / XML oder ein anderer Speichermechanismus sein kann.

Modellobjekt oder Wertobjekt - Dieses Objekt ist ein einfaches POJO mit Get / Set-Methoden zum Speichern von Daten, die mit der DAO-Klasse abgerufen wurden.

Beispielcode hier ..

Ich werde allgemein und nicht spezifisch für Java sein, da DAO und ORM in allen Sprachen verwendet werden.

Um DAO zu verstehen, müssen Sie zuerst ORM (Object Rational Mapping) verstehen. Dies bedeutet, dass Sie, wenn Sie eine Tabelle mit dem Namen "Person" mit den Spalten "Name" und "Alter" haben, eine Objektvorlage für diese Tabelle erstellen würden:

type Person {
name
age
}

Jetzt mit Hilfe von DAO, anstatt einige spezifische Abfragen zu schreiben, um alle Personen für jede Art von Datenbank abzurufen, die Sie verwenden (was fehleranfällig sein kann), tun Sie stattdessen:

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

Sie schreiben die DAO-Abstraktion nicht selbst, sondern sie ist normalerweise Teil eines OpenSource-Projekts, je nachdem, welche Sprache und welches Framework Sie verwenden.

Nun zur Hauptfrage hier. " ..wo wird es verwendet .. ". Wenn Sie komplexen geschäfts- und domänenspezifischen Code schreiben, ist Ihr Leben ohne DAO normalerweise sehr schwierig. Natürlich müssen Sie ORM und DAO nicht verwenden, sondern können Ihre eigene Abstraktion und native Abfragen schreiben. Ich habe das in der Vergangenheit getan und es später fast immer bereut.

Ich denke, das beste Beispiel (zusammen mit Erklärungen) finden Sie auf der Orakel-Website: hier . Ein weiteres gutes Tutorial finden Sie hier .

Verwechseln Sie sich nicht mit zu vielen Erklärungen. DAO: Aus dem Namen selbst geht hervor, dass mit Object auf Daten zugegriffen wird. DAO ist von anderen Geschäftslogiken getrennt.

Das Datenzugriffsobjekt verwaltet die Verbindung mit der Datenquelle, um Daten abzurufen und zu speichern. Es abstrahiert die zugrunde liegende Datenzugriffsimplementierung für das Geschäftsobjekt, um einen transparenten Zugriff auf die Datenquelle zu ermöglichen. Eine Datenquelle kann eine beliebige Datenbank wie ein RDBMS, ein XML-Repository oder ein Flatfile-System usw. sein.

Frühling JPA DAO

Zum Beispiel haben wir eine Entitätsgruppe.

Für diese Entität erstellen wir das Repository GroupRepository.

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

Dann müssen wir eine Service-Schicht erstellen, mit der wir dieses Repository verwenden werden.

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

Und in der Steuerung nutzen wir diesen 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 ist ein Act wie "Persistence Manager" in 3-Tier-Architektur sowie DAO Design Design, wie Sie in "Gang of Four" Buch lesen können. Ihre Anwendungsservice-Schicht muss nur die Methode der DAO-Klasse aufrufen, ohne versteckte und interne Details der DAO-Methode zu kennen.

Dao-Klassen werden verwendet, um die JDBC-Logik wiederzuverwenden. Dao (Datenzugriffsobjekt) ist ein Entwurfsmuster. dao ist eine einfache Java-Klasse, die JDBC-Logik enthält.

Die Datenzugriffsschicht hat sich in einer separaten Geschäftslogikschicht und einer beständigen Schicht als gut erwiesen. Das DAO-Entwurfsmuster verbirgt die Datenzugriffsimplementierung vollständig vor seinen Clients

Das Java Data Access Object (Java DAO) ist eine wichtige Komponente in Geschäftsanwendungen. Geschäftsanwendungen benötigen fast immer Zugriff auf Daten aus relationalen oder Objektdatenbanken, und die Java-Plattform bietet viele Techniken für den Zugriff auf diese Daten. Die älteste und ausgereifteste Technik ist die Verwendung der JDBC-API (Java Database Connectivity), mit der SQL-Abfragen für eine Datenbank ausgeführt und die Ergebnisse dann spaltenweise abgerufen werden können.

Pojo wird auch als Modellklasse in Java betrachtet, in der wir Getter und Setter für bestimmte Variablen erstellen können, die privat definiert sind. Denken Sie daran, dass alle Variablen hier mit dem privaten Modifikator deklariert werden