数据访问对象模式

作者likuolei

数据访问对象模式（Data Access Object Pattern，简称 DAO 模式）是一种结构型设计模式，用于将业务逻辑与数据访问逻辑分离，提供统一的数据操作接口，屏蔽底层数据存储的实现细节（如数据库、文件系统等）。它通过封装数据访问操作，简化客户端代码，提高系统的可维护性和可移植性，常用于企业级应用（如 Java EE）中。

DAO 模式的组成

DAO 模式通常包含以下几个角色：

  1. 数据访问对象接口（DAO Interface）：定义数据操作的标准方法，如增删改查（CRUD）。
  2. 具体数据访问对象（Concrete DAO）：实现 DAO 接口，包含与特定数据源交互的逻辑。
  3. 数据传输对象（DTO，Data Transfer Object）：用于在业务层和数据访问层之间传递数据，通常是一个简单的 POJO（Plain Old Java Object）。
  4. 业务对象（Business Object）：调用 DAO 接口执行业务逻辑的客户端代码。
  5. 数据源（Data Source）：实际存储数据的底层系统，如数据库、文件或其他存储介质。

工作原理

  1. 业务对象通过 DAO 接口调用数据操作方法。
  2. 具体 DAO 实现与数据源交互，执行查询、插入、更新或删除操作。
  3. DAO 使用 DTO 将数据传递给业务对象，或从业务对象接收数据。
  4. 客户端（业务对象）无需关心数据源的实现细节，只需通过 DAO 接口操作数据。

UML 类图

┌────────────────┐       ┌────────────────┐
│ BusinessObject │       │     DAO        │
├────────────────┤       ├────────────────┤
│                │<----->│ create()       │
└────────────────┘       │ read()         │
                         │ update()       │
                         │ delete()       │
                         └────────────────┘
                                ↑
                                │
┌────────────────┐       ┌────────────────┐
│  ConcreteDAO   │<----->│      DTO       │
├────────────────┤       ├────────────────┤
│ create()       │       │ data           │
│ read()         │       └────────────────┘
│ update()       │
│ delete()       │
└────────────────┘
       ↑
       │
┌────────────────┐
│   DataSource   │
├────────────────┤
│ (Database, etc.)│
└────────────────┘

代码示例（以 Java 为例）

以下是一个 DAO 模式的实现，模拟学生信息的管理：

// 数据传输对象（DTO）
class StudentDTO {
    private int id;
    private String name;

    public StudentDTO(int id, String name) {
        this.id = id;
        this.name = 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;
    }
}

// DAO 接口
interface StudentDAO {
    void create(StudentDTO student);
    StudentDTO read(int id);
    void update(StudentDTO student);
    void delete(int id);
}

// 具体 DAO 实现（模拟数据库操作）
class StudentDAOImpl implements StudentDAO {
    // 模拟数据库
    private Map<Integer, StudentDTO> database = new HashMap<>();

    @Override
    public void create(StudentDTO student) {
        database.put(student.getId(), student);
        System.out.println("创建学生: " + student.getName());
    }

    @Override
    public StudentDTO read(int id) {
        StudentDTO student = database.get(id);
        System.out.println("读取学生: " + (student != null ? student.getName() : "未找到"));
        return student;
    }

    @Override
    public void update(StudentDTO student) {
        if (database.containsKey(student.getId())) {
            database.put(student.getId(), student);
            System.out.println("更新学生: " + student.getName());
        } else {
            System.out.println("学生 ID " + student.getId() + " 不存在");
        }
    }

    @Override
    public void delete(int id) {
        if (database.remove(id) != null) {
            System.out.println("删除学生 ID: " + id);
        } else {
            System.out.println("学生 ID " + id + " 不存在");
        }
    }
}

// 业务对象
class StudentService {
    private StudentDAO studentDAO;

    public StudentService(StudentDAO studentDAO) {
        this.studentDAO = studentDAO;
    }

    public void addStudent(int id, String name) {
        StudentDTO student = new StudentDTO(id, name);
        studentDAO.create(student);
    }

    public void getStudent(int id) {
        StudentDTO student = studentDAO.read(id);
        if (student != null) {
            System.out.println("学生信息: ID=" + student.getId() + ", 姓名=" + student.getName());
        }
    }

    public void updateStudent(int id, String name) {
        StudentDTO student = new StudentDTO(id, name);
        studentDAO.update(student);
    }

    public void deleteStudent(int id) {
        studentDAO.delete(id);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        StudentDAO studentDAO = new StudentDAOImpl();
        StudentService service = new StudentService(studentDAO);

        // 创建学生
        service.addStudent(1, "张三");

        // 读取学生
        service.getStudent(1);

        // 更新学生
        service.updateStudent(1, "李四");

        // 删除学生
        service.deleteStudent(1);

        // 尝试读取已删除的学生
        service.getStudent(1);
    }
}

输出：

创建学生: 张三
读取学生: 张三
学生信息: ID=1, 姓名=张三
更新学生: 李四
删除学生 ID: 1
读取学生: 未找到

DAO 模式的特点

  • 优点：
  • 分离业务逻辑与数据访问：业务逻辑与数据访问解耦，客户端无需关心数据源细节。
  • 提高可维护性：数据访问逻辑集中在 DAO 层，便于修改和维护。
  • 可移植性：更换数据源（如从 MySQL 切换到 PostgreSQL）只需修改具体 DAO 实现。
  • 代码复用：DAO 接口提供统一操作，多个业务对象可复用。
  • 缺点：
  • 增加了代码层级，可能在简单应用中显得复杂。
  • 需要为每个实体设计对应的 DAO 和 DTO，增加开发工作量。
  • 如果数据源复杂，DAO 实现可能变得繁琐。

使用场景

  1. 需要隔离业务逻辑与数据访问逻辑的场景：
  • 企业级应用中的数据库操作（如 Java EE、Spring 框架）。
  • 文件系统或外部 API 的数据访问。
  1. 需要支持多种数据源或切换数据源的场景：
  • 数据库迁移（如从 Oracle 到 MySQL）。
  • 测试环境中使用内存数据库，生产环境中使用真实数据库。
  1. 需要统一数据操作接口的场景：
  • 复杂的 CRUD 操作。
  • 多表关联或复杂查询的封装。

注意事项

  • 与 DTO 的结合：DAO 模式通常与 DTO 结合使用，DTO 负责数据传递，避免直接暴露数据库实体。
  • 与组合实体模式的区别：
  • DAO 模式关注数据访问逻辑的封装，处理单一实体或简单关系的 CRUD 操作。
  • 组合实体模式关注复杂业务实体及其依赖对象的生命周期管理。
  • 异常处理：DAO 应捕获底层数据源异常并转换为业务友好的异常。
  • 事务管理：在复杂操作中，DAO 需与事务管理机制（如 Spring 的事务注解）结合，确保数据一致性。
  • 与 ORM 的关系：在现代框架（如 Hibernate、MyBatis）中，DAO 模式常与 ORM 结合，简化数据库操作。

总结

DAO 模式通过将数据访问逻辑封装在独立层中，实现了业务逻辑与数据操作的解耦，提高了系统的可维护性和可移植性。它广泛应用于企业级应用，特别是在需要处理数据库或其他数据源的场景。设计时需注意 DAO 接口的通用性和 DTO 的合理设计，以确保系统的灵活性和高效性。

类似文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注