Data access object (DAO) in Java

Ik was een document aan het doornemen en ik kwam een ​​term tegen met de naam DAO. Ik kwam erachter dat het een Data Access Object is. Kan iemand mij uitleggen wat dit eigenlijk is?

Ik weet dat het een soort interface is om toegang te krijgen tot gegevens uit verschillende soorten bronnen. Midden in dit kleine onderzoek van mij kwam ik een concept tegen dat gegevensbron of gegevensbronobject heet, en de zaken liepen in de war mijn gedachten.

Ik wil echt weten wat een DAO programmatisch is in termen van waar het wordt gebruikt. Hoe wordt het gebruikt? Alle links naar pagina’s die dit concept vanaf de basis uitleggen, worden ook op prijs gesteld.


Antwoord 1, autoriteit 100%

Het gegevenstoegangsobject is in feite een object of een interface die toegang biedt tot een onderliggende database of een andere persistentieopslag.

Die definitie van:
http://en.wikipedia.org/wiki/Data_access_object

Bekijk hier ook het sequentiediagram:
http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

Misschien kan een eenvoudig voorbeeld u helpen het concept te begrijpen:

Stel dat we een entiteit hebben om een ​​werknemer te vertegenwoordigen:

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

De werknemersentiteiten worden bewaard in een overeenkomstige Employee-tabel in een database.
Een eenvoudige DAO-interface om de databasebewerking af te handelen die nodig is om een ​​werknemersentiteit te manipuleren, ziet er als volgt uit:

interface EmployeeDAO {
    List<Employee> findAll();
    List<Employee> findById();
    List<Employee> findByName();
    boolean insertEmployee(Employee employee);
    boolean updateEmployee(Employee employee);
    boolean deleteEmployee(Employee employee);
}

Vervolgens moeten we een concrete implementatie voor die interface bieden om met SQL-server om te gaan, en een andere om met platte bestanden om te gaan, enz.


Antwoord 2, autoriteit 19%

Wat is DATA ACCESS OBJECT (DAO)

Het is een object/interface, dat wordt gebruikt om toegang te krijgen tot gegevens uit de database met gegevensopslag.

WAAROM WE DAO GEBRUIKEN:

het abstraheert het ophalen van gegevens uit een gegevensbron zoals een database. Het concept is om “de clientinterface van een gegevensbron te scheiden van het mechanisme voor gegevenstoegang.”

Het probleem met rechtstreekse toegang tot gegevens is dat de bron van de gegevens kan veranderen. Bedenk bijvoorbeeld dat uw applicatie is geïmplementeerd in een omgeving die toegang heeft tot een Oracle-database. Vervolgens wordt het vervolgens geïmplementeerd in een omgeving die gebruikmaakt van Microsoft SQL Server. Als uw toepassing opgeslagen procedures en databasespecifieke code gebruikt (zoals het genereren van een nummerreeks), hoe gaat u daar dan mee om in uw toepassing? Je hebt twee opties:

  • Herschrijf uw toepassing om SQL Server te gebruiken in plaats van Oracle (of voeg voorwaardelijke code toe om de verschillen op te lossen), of
  • Creëer een laag tussen uw applicatielogica en de gegevenstoegang

Het wordt in het algemeen DAO-patroon genoemd en bestaat uit het volgende:

  • Interface voor gegevenstoegangsobject – Deze interface definieert de standaardbewerkingen die moeten worden uitgevoerd op (een) modelobject(en).
  • Gegevenstoegangsobject concrete klasse -Deze klasse implementeert bovenstaande interface. Deze klasse is verantwoordelijk voor het ophalen van gegevens uit een gegevensbron die database / xml of een ander opslagmechanisme kan zijn.
  • Modelobject of waardeobject – Dit object is eenvoudige POJO met get/set-methoden om gegevens op te slaan die zijn opgehaald met de DAO-klasse.

Controleer dit voorbeeld, dit zal alles duidelijker maken.

Voorbeeld
Ik neem aan dat deze dingen je begrip van DAO tot op zekere hoogte moeten hebben verduidelijkt.


Antwoord 3, autoriteit 3%

DAO (Data Access Object) is een veelgebruikt ontwerppatroon in bedrijfsapplicaties. Het is in feite de module die wordt gebruikt om toegang te krijgen tot gegevens uit elke bron (DBMS, XML enzovoort). Ik raad je aan enkele voorbeelden te lezen, zoals deze:

DAO-voorbeeld

Houd er rekening mee dat er verschillende manieren zijn om het originele DAO-patroon te implementeren, en er zijn veel kaders die uw werk kunnen vereenvoudigen. De ORM-frameworks (Object Relational Mapping) zoals iBatis of Hibernate worden bijvoorbeeld gebruikt om het resultaat van SQL-query’s toe te wijzen aan Java-objecten.

Hopelijk helpt het,
Dag!


Antwoord 4, autoriteit 2%

Data Access Object Pattern of DAO-patroon wordt gebruikt om de toegang tot API’s of bewerkingen op laag niveau te scheiden van zakelijke services op hoog niveau. Hieronder volgen de deelnemers aan Data Access Object Pattern.

Interface voor gegevenstoegangsobject – Deze interface definieert de standaardbewerkingen die moeten worden uitgevoerd op (een) modelobject(en).

Data Access Object concrete klasse -Deze klasse implementeert bovenstaande interface. Deze klasse is verantwoordelijk voor het ophalen van gegevens uit een gegevensbron die database / xml of een ander opslagmechanisme kan zijn.

Modelobject of waardeobject – Dit object is een eenvoudige POJO met get/set-methoden om gegevens op te slaan die zijn opgehaald met de DAO-klasse.

Voorbeeldcode hier..


Antwoord 5

Ik zal algemeen zijn en niet specifiek voor Java, aangezien DAO en ORM in alle talen worden gebruikt.

Om DAO te begrijpen, moet u eerst ORM (Object Relational Mapping) begrijpen. Dit betekent dat als je een tabel hebt met de naam “persoon” met de kolommen “naam” en “leeftijd”, je een objectsjabloon voor die tabel zou maken:

type Person {
name
age
}

Nu met hulp van DAO in plaats van het schrijven van een aantal specifieke vragen, om alle personen op te halen, voor welk type db je ook gebruikt (wat foutgevoelig kan zijn) doe je in plaats daarvan:

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

Je schrijft de DAO-abstractie niet zelf, maar maakt meestal deel uit van een opensourceproject, afhankelijk van de taal en het framework dat je gebruikt.

Nu naar de hoofdvraag hier. “..waar het wordt gebruikt..“. Als je complexe zakelijke en domeinspecifieke code schrijft, zal je leven meestal erg moeilijk zijn zonder DAO. Natuurlijk hoeft u de verstrekte ORM en DAO niet te gebruiken, in plaats daarvan kunt u uw eigen abstractie en native queries schrijven. Ik heb dat in het verleden gedaan en kreeg er later bijna altijd spijt van.


Antwoord 6

Ik denk dat het beste voorbeeld (samen met uitleg) dat je kunt vinden op de Oracle-website: hier. Een andere goede tutorial is hier te vinden.


Antwoord 7

Laat u niet verwarren met te veel uitleg. DAO: Van de naam zelf betekent het toegang tot gegevens met behulp van Object. DAO is gescheiden van andere bedrijfslogica.


Antwoord 8

Het Data Access Object beheert de verbinding met de gegevensbron om gegevens te verkrijgen en op te slaan. Het abstraheert de onderliggende implementatie van gegevenstoegang voor het Business Object om transparante toegang tot de gegevensbron mogelijk te maken.
Een gegevensbron kan elke database zijn, zoals een RDBMS, XML-repository of plat bestandssysteem enz.


Antwoord 9

Lente JPA DAO

We hebben bijvoorbeeld een entiteit Groep.

Voor deze entiteit maken we de repository GroupRepository.

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

Vervolgens moeten we een servicelaag maken waarmee we deze repository gaan gebruiken.

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

En in de controller gebruiken we deze 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();
    }    
}

Antwoord 10

DAO is een act als “Persistence Manager” in 3-tier architectuur en DAO ontwerpt ook patronen zoals u het boek “Gang of Four” kunt raadplegen.
Uw applicatieservicelaag hoeft alleen de methode van de DAO-klasse aan te roepen zonder verborgen & interne details van de methode van DAO.


Antwoord 11

Dao-klassen worden gebruikt om de jdbc-logica & Dao (Data Access Object) is een ontwerppatroon.
dao is een eenvoudige Java-klasse die JDBC-logica bevat.

Data Access Layer is goed gebleken in een afzonderlijke bedrijfslogicalaag en een persistente laag. Het DAO-ontwerppatroon verbergt de implementatie van gegevenstoegang volledig voor zijn klanten

Het Java Data Access Object (Java DAO) is een belangrijk onderdeel van bedrijfsapplicaties. Zakelijke applicaties hebben bijna altijd toegang nodig tot data uit relationele of objectdatabases en het Java-platform biedt veel technieken om toegang te krijgen tot deze data. De oudste en meest volwassen techniek is om de Java Database Connectivity (JDBC) API te gebruiken, die de mogelijkheid biedt om SQL-query’s uit te voeren op een database en vervolgens de resultaten op te halen, kolom voor kolom.


Antwoord 12

Pojo wordt ook beschouwd als een modelklasse in Java, waar we getter en setter kunnen maken voor een bepaalde variabele die is gedefinieerd in private .
Onthoud dat alle variabelen hier gedeclareerd worden met private modifier


Antwoord 13

Ik wil het gewoon op mijn eigen manier uitleggen met een klein verhaal dat ik heb meegemaakt in een van mijn projecten. Eerst wil ik uitleggen Waarom DAO belangrijk is? in plaats van naar Wat is DAO? te gaan voor een beter begrip.

Waarom is DAO belangrijk?
In mijn ene project van mijn project gebruikte ik Client.class die alle basisinformatie van onze systeemgebruikers bevat. Waar ik een klant nodig heb, moet ik elke keer een lelijke query doen waar dat nodig is. Toen vond ik dat de leesbaarheid afnam en veel overbodige boilerplate-code maakte.

Toen introduceerde een van mijn senior ontwikkelaars een QueryUtils.class waar alle zoekopdrachten worden toegevoegd met behulp van de public static toegangsmodifier en dan hoef ik niet overal een query uit te voeren. Stel dat ik geactiveerde klanten nodig heb, dan bel ik gewoon –

QueryUtils.findAllActivatedClients();

Op deze manier heb ik enkele optimalisaties van mijn code gemaakt.

Maar er was nog een probleem !!!

Ik voelde dat de QueryUtils.class enorm groeide. 100+ methoden waren opgenomen in die klasse, die ook erg omslachtig was om te lezen en te gebruiken. Omdat deze klasse andere zoekopdrachten van een ander domein bevat, modelleert u (bijvoorbeeld producten, categorieën, locaties, enz.).

Toen de superheld Mr. CTO introduceerde een nieuwe oplossing genaamd DAO die het probleem uiteindelijk oploste. Ik voelde dat DAO erg domeinspecifiek is. Hij heeft bijvoorbeeld een DAO gemaakt met de naam ClientDAO.class waar alle Client.class-gerelateerde zoekopdrachten worden gevonden, wat voor mij heel gemakkelijk lijkt te gebruiken en te onderhouden. De gigantische QueryUtils.class werd opgesplitst in vele andere domeinspecifieke DAO’s, bijvoorbeeld – ProductsDAO.class, CategoriesDAO.class, enz. de code meer Leesbaar, meer Onderhoudbaar, meer Ontkoppeld.

Wat is DAO?

Het is een object of interface die een gemakkelijke manier maakte om toegang te krijgen tot gegevens uit de database zonder telkens opnieuw complexe en lelijke queries te schrijven op een herbruikbare manier.

p>

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes