Objeto de acesso a dados (DAO) em Java

Eu estava passando por um documento e me deparei com um termo chamado DAO. Eu descobri que é um objeto de acesso a dados. Alguém pode me explicar o que realmente é isso?

Eu sei que é algum tipo de interface para acessar dados de diferentes tipos de fontes. No meio dessa pequena pesquisa, encontrei um conceito chamado fonte de dados ou objeto de fonte de dados, e as coisas ficaram confusas em minha mente.

Eu realmente quero saber o que DAOé programaticamente em termos de onde é usado. Como é usado? Todos os links para páginas que explicam esse conceito a partir de coisas muito básicas também são apreciados.

O objeto de acesso a dados é basicamente um objeto ou uma interface que fornece acesso a um banco de dados subjacente ou a qualquer outro armazenamento de persistência.

Essa definição de: http://en.wikipedia.org/wiki/Data_access_object

Verifique também o diagrama de sequência aqui: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

Talvez um exemplo simples possa ajudá-lo a entender o conceito:

Digamos que temos uma entidade para representar um funcionário:

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

}

As entidades dos funcionários serão mantidas em uma Employeetabela correspondente em um banco de dados. Uma interface simples do DAO para lidar com a operação do banco de dados necessária para manipular uma entidade de funcionário será como:

interface EmployeeDAO {

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

}

Em seguida, precisamos fornecer uma implementação concreta para essa interface lidar com o SQL server e outra para lidar com arquivos simples, etc.

O que é DATA ACCESS OBJECT (DAO) -

É um objeto / interface , usado para acessar dados do banco de dados de armazenamento de dados.

POR QUE USAMOS DAO:

abstrai a recuperação de dados de um recurso de dados, como um banco de dados. O conceito é "separar a interface do cliente de um recurso de dados do seu mecanismo de acesso a dados".

O problema de acessar dados diretamente é que a fonte dos dados pode mudar. Considere, por exemplo, que seu aplicativo está implantado em um ambiente que acessa um banco de dados Oracle. Em seguida, é implantado em um ambiente que usa o Microsoft SQL Server. Se seu aplicativo usa procedimentos armazenados e código específico do banco de dados (como gerar uma sequência numérica), como você lida com isso no seu aplicativo? Você tem duas opções:

• Reescreva seu aplicativo para usar o SQL Server em vez do Oracle (ou adicione código condicional para lidar com as diferenças) ou
• Crie uma camada entre a lógica da sua aplicação e o acesso aos dados

É, em todos, referido como Padrão DAO , consiste no seguinte:

• Interface de objeto de acesso a dados - Essa interface define as operações padrão a serem executadas nos objetos de modelo.
• Classe concreta Data Access Object - Esta classe implementa a interface acima. Essa classe é responsável por obter dados de uma fonte de dados que pode ser database / xml ou qualquer outro mecanismo de armazenamento.
• Objeto de modelo ou objeto de valor - este objeto é um POJO simples que contém métodos get / set para armazenar dados recuperados usando a classe DAO.

Por favor, verifique este exemplo, Isso limpará as coisas com mais clareza.

Exemplo
Suponho que essas coisas devem ter esclarecido sua compreensão do DAO até certo ponto.

O DAO (Data Access Object) é um padrão de design muito usado em aplicativos corporativos. É basicamente o módulo usado para acessar dados de todas as fontes (DBMS, XML e assim por diante). Eu sugiro que você leia alguns exemplos, como este:

Exemplo DAO

Observe que existem diferentes maneiras de implementar o padrão DAO original e há muitas estruturas que podem simplificar seu trabalho. Por exemplo, as estruturas ORM (Object Relational Mapping), como iBatis ou Hibernate, são usadas para mapear o resultado de consultas SQL para objetos java.

Espero que ajude, tchau!

O Padrão de Objeto de Acesso a Dados ou padrão DAO é usado para separar API ou operações de acesso de dados de baixo nível dos serviços comerciais de alto nível. A seguir estão os participantes no Padrão de Objeto de Acesso a Dados.

Interface de objeto de acesso a dados - Essa interface define as operações padrão a serem executadas nos objetos de modelo.

Classe concreta Data Access Object - Esta classe implementa a interface acima. Essa classe é responsável por obter dados de uma fonte de dados que pode ser database / xml ou qualquer outro mecanismo de armazenamento.

Objeto de modelo ou Objeto de valor - este objeto é um POJO simples que contém métodos get / set para armazenar dados recuperados usando a classe DAO.

Exemplo de código aqui ..

Vou ser geral e não específico para Java, pois o DAO e o ORM são usados ​​em todas as linguagens.

Para entender o DAO, primeiro você precisa entender o ORM (Object Rational Mapping). Isso significa que, se você tiver uma tabela chamada "pessoa" com as colunas "nome" e "idade", crie um modelo de objeto para essa tabela:

type Person {
name
age
}

Agora, com a ajuda do DAO, em vez de escrever algumas consultas específicas, para buscar todas as pessoas, para qualquer tipo de banco de dados que você esteja usando (que pode ser propenso a erros), em vez disso:

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

Você não escreve a abstração do DAO, ela geralmente faz parte de algum projeto de código-fonte aberto, dependendo do idioma e da estrutura que você está usando.

Agora para a questão principal aqui. " ..onde é usado .. ". Bem, normalmente, se você estiver escrevendo códigos complexos para negócios e domínios específicos, sua vida será muito difícil sem o DAO. Obviamente, você não precisa usar o ORM e o DAO, mas pode escrever sua própria abstração e consultas nativas. Eu fiz isso no passado e quase sempre me arrependi depois.

Acho que o melhor exemplo (junto com explicações) você pode encontrar no site da oracle: aqui . Outro bom tutor poderia ser encontrado aqui .

Não se confunda com muitas explicações. DAO: A partir do próprio nome, significa Acessando Dados usando Objeto. O DAO é separado de outra lógica de negócios.

O Objeto de Acesso a Dados gerencia a conexão com a fonte de dados para obter e armazenar dados. Abstrai a implementação de acesso a dados subjacente ao Objeto de Negócios para permitir acesso transparente à fonte de dados. Uma fonte de dados pode ser qualquer banco de dados, como um RDBMS, repositório XML ou sistema de arquivos simples etc.

Spring JPA DAO

Por exemplo, temos algum grupo de entidades.

Para essa entidade, criamos o repositório GroupRepository.

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

Então, precisamos criar uma camada de serviço com a qual usaremos esse repositório.

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 no controlador, usamos este serviço.

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

O DAO é um ato como "Persistence Manager" na arquitetura de três camadas, bem como o DAO também cria padrões de design, pois você pode consultar o livro "Gang of Four". Sua camada de serviço de aplicativo só precisa chamar o método da classe DAO sem conhecer detalhes ocultos e internos do método DAO.

As classes Dao são usadas para reutilizar a lógica jdbc e o Dao (Data Access Object) é um padrão de design. dao é uma classe java simples que contém lógica JDBC.

A Camada de Acesso a Dados provou ser boa na camada lógica de negócios separada e na camada persistente. O padrão de design do DAO oculta completamente a implementação de acesso a dados de seus clientes

O Java Data Access Object (Java DAO) é um componente importante em aplicativos de negócios. Os aplicativos de negócios quase sempre precisam acessar dados de bancos de dados relacionais ou de objetos e a plataforma Java oferece muitas técnicas para acessar esses dados. A técnica mais antiga e mais madura é usar a API Java Database Connectivity (JDBC), que fornece a capacidade de executar consultas SQL em um banco de dados e buscar os resultados, uma coluna por vez.

O Pojo também considera como classe Model em Java, onde podemos criar getter e setter para determinada variável definida em particular. Lembre-se de que todas as variáveis ​​são aqui declaradas com modificador privado