我将是一般的，而不是特定于Java，因为DAO和ORM在所有语言中都使用。

要理解DAO，首先需要理解ORM(对象关系映射)。这意味着如果你有一个名为“person”的表，列为“name”和“age”，那么你将为这个表创建object-template:

type Person {
name
age
}

现在，在DAO的帮助下，而不是编写一些特定的查询，以获取所有人，对于任何类型的db，你正在使用(这可能是容易出错的)，而是:

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

DAO抽象不是您自己编写的，相反，它通常是一些开源项目的一部分，这取决于您使用的语言和框架。

现在回到主要的问题。“. .在使用的地方……”。通常情况下，如果您正在编写复杂的业务和领域特定代码，那么没有DAO将会非常困难。当然，您不需要使用提供的ORM和DAO，相反，您可以编写自己的抽象查询和本机查询。我以前也这么做过，后来几乎总是后悔。

什么是数据访问对象(DAO) -

它是一个对象/接口，用于从数据存储的数据库中访问数据。

为什么使用dao:

从数据资源(如数据库)中提取数据的方法。 其概念是“将数据资源的客户端接口与其数据访问机制分离”。  

直接访问数据的问题是数据的来源可能会改变。例如，假设您的应用程序部署在访问Oracle数据库的环境中。然后将其部署到使用Microsoft SQL Server的环境中。如果应用程序使用存储过程和特定于数据库的代码(比如生成一个数字序列)，在应用程序中如何处理?你有两个选择:

重写应用程序以使用SQL Server而不是Oracle(或添加条件代码来处理差异)，或者 在应用程序逻辑和数据访问层之间创建一个层

DAO模式由以下内容组成:

数据访问对象接口——这个接口定义了要在模型对象上执行的标准操作。 数据访问对象具体类——这个类实现了上面的接口。该类负责从数据源获取数据 它可以是数据库/ XML或任何其他存储机制。 模型对象或值对象——该对象是简单的POJO，包含get/set方法，用于存储使用DAO类检索到的数据。

看例子

我希望这已经澄清了您对DAO的理解!

Pojo也可以作为Java中的Model类，我们可以在其中为私有定义的特定变量创建getter和setter。 记住所有变量都是用私有修饰符声明的

Spring JPA DAO

例如，我们有一些实体Group。

对于这个实体，我们创建存储库GroupRepository。

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

然后，我们需要创建一个服务层，我们将使用这个存储库。

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

在控制器中，我们使用这个服务。

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

数据访问对象基本上是一个对象或接口，它提供对底层数据库或任何其他持久性存储的访问。

这个定义来自: http://en.wikipedia.org/wiki/Data_access_object

也可以查看这里的序列图: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

也许一个简单的例子可以帮助你理解这个概念:

假设我们有一个实体来代表一个雇员:

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

}

员工实体将被持久化到数据库中相应的employee表中。 一个简单的DAO接口来处理操作员工实体所需的数据库操作，如下所示:

interface EmployeeDAO {

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

}

接下来，我们必须为该接口提供一个具体的实现，以处理SQL server，以及另一个处理平面文件等。

不要被太多的解释弄糊涂了。DAO:从名称本身来看，它的意思是使用对象访问数据。DAO与其他业务逻辑分离。