Clean Architecture & Design Patterns in Practice · 课时

数据映射器与 DTO

学习在内部实体与外部数据结构（DTO）之间映射数据，以支持数据库或 API 交互。

第 3 / 4 课11 个步骤

数据映射器与 DTO 是 CoddyKit 上的免费 Clean Architecture & Design Patterns in Practice 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Clean Architecture & Design Patterns in Practice 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Clean Architecture & Design Patterns in Practice 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Mapping Data: Why We Need It

In Clean Architecture, your core business logic (Entities and Use Cases) should be independent of external details like databases or web frameworks.

But how do your internal data structures communicate with the outside world? This is where Data Mappers and Data Transfer Objects (DTOs) come in.

Entities vs. External Data

Your Entities contain crucial business rules and are designed for your domain logic. They often have methods and complex relationships.

Exposing these entities directly to external layers (like a database or an API) can lead to:

Tight Coupling: Changes in your database or API might force changes in your core entities.
Security Risks: You might expose sensitive internal data.
Data Shape Mismatch: External systems often need data in a different format than your internal domain model.

Introducing Data Transfer Objects (DTOs)

A Data Transfer Object (DTO) is a simple object used to transfer data between different layers or processes. Think of it as a plain data container.

Key characteristics of DTOs:

They only hold data, typically public fields or simple getters/setters.
They contain no business logic.
They are designed for specific external communication needs (e.g., API request/response, database record).

DTOs in Action: An Example

Let's imagine a Product entity in our core domain and a ProductDto for communicating with an external API.

Notice how the DTO fields might be named differently or represent a subset of the entity's data.

class Product { // Internal Entity
  private String id;
  private String name;
  private double price;
  // ... business methods
}

class ProductDto { // External DTO
  public String productId;
  public String productName;
  public double productPrice;
  // No business logic here
}

The Role of Data Mappers

A Data Mapper is an object responsible for converting data between your internal Entities and external DTOs (and vice-versa).

It acts as a translator, ensuring your core domain remains clean and isolated. Mappers protect your entities from changes in external data formats.

Implementing a Simple Data Mapper

A data mapper typically has methods to convert from an entity to a DTO, and from a DTO back to an entity.

This allows controlled data flow and transformation.

class ProductMapper {
  public ProductDto toDto(Product product) {
    if (product == null) return null;
    return new ProductDto(
      product.getId(),
      product.getName(),
      product.getPrice()
    );
  }

  public Product toEntity(ProductDto dto) {
    if (dto == null) return null;
    return new Product(
      dto.productId,
      dto.productName,
      dto.productPrice
    );
  }
}

Using the Data Mapper

Here's how you'd use a ProductMapper to convert between your internal Product entity and its external ProductDto representation.

Try running this example!

public class Main {
  // Product Entity (simplified for demo)
  static class Product {
    private String id;
    private String name;
    private double price;

    public Product(String id, String name, double price) {
      this.id = id;
      this.name = name;
      this.price = price;
    }
    public String getId() { return id; }
    public String getName() { return name; }
    public double getPrice() { return price; }
  }

  // Product DTO (simplified for demo)
  static class ProductDto {
    public String productId;
    public String productName;
    public double productPrice;

    public ProductDto(String productId, String productName, double productPrice) {
      this.productId = productId;
      this.productName = productName;
      this.productPrice = productPrice;
    }
  }

  // Data Mapper
  static class ProductMapper {
    public ProductDto toDto(Product product) {
      if (product == null) return null;
      return new ProductDto(
        product.getId(),
        product.getName(),
        product.getPrice()
      );
    }

    public Product toEntity(ProductDto dto) {
      if (dto == null) return null;
      return new Product(
        dto.productId,
        dto.productName,
        dto.productPrice
      );
    }
  }

  public static void main(String[] args) {
    Product originalProduct = new Product("A101", "Keyboard", 75.00);
    ProductMapper mapper = new ProductMapper();

    ProductDto productDto = mapper.toDto(originalProduct);
    System.out.println("DTO Name: " + productDto.productName);

    Product convertedProduct = mapper.toEntity(productDto);
    System.out.println("Entity Name: " + convertedProduct.getName());
  }
}

DTOs for Different Contexts

You don't just need one DTO per entity! Different external interactions might require different data shapes:

ProductRequestDto: For creating or updating a product via an API.
ProductResponseDto: For sending product details back from an API.
ProductSummaryDto: For a list view, only showing ID, name, and a short description.

Each DTO serves a specific purpose, keeping data transfer lean and relevant.

Benefits of Mappers and DTOs

Using Data Mappers and DTOs offers significant advantages in Clean Architecture:

Decoupling: Protects your core domain from external changes.
Flexibility: Easily adapt to new external data formats without altering entities.
Security: Control exactly what data is exposed or accepted.
Clear Contracts: DTOs define explicit contracts for external communication.
Testability: Mappers are simple to unit test in isolation.

Test Your Knowledge

Which of the following best describes the primary purpose of a Data Transfer Object (DTO) in Clean Architecture?

在交互式课程中回答

Recap: Mappers & DTOs

You've learned how Data Mappers and Data Transfer Objects (DTOs) are vital for maintaining the independence of your core domain in Clean Architecture.

DTOs are plain data structures for external communication.
Data Mappers translate between your internal Entities and these external DTOs.

This pattern ensures your business logic remains pure, flexible, and decoupled from external concerns.

免费开始

用 AI 导师学习 Clean Architecture & Design Patterns in Practice — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 12
课程: 48

免费开始学习查看完整课程

常见问题解答

「数据映射器与 DTO」课时是免费的吗？

是的 — 「数据映射器与 DTO」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Clean Architecture & Design Patterns in Practice 课程的其余内容，请升级到 CoddyKit PRO。 Clean Architecture & Design Patterns in Practice 课程共包含 4 节课。

「数据映射器与 DTO」这节课中我会学到什么？

学习在内部实体与外部数据结构（DTO）之间映射数据，以支持数据库或 API 交互。你通过在浏览器中直接运行的动手代码来练习 Clean Architecture & Design Patterns in Practice，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Clean Architecture & Design Patterns in Practice 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Clean Architecture & Design Patterns in Practice 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「数据映射器与 DTO」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Clean Architecture & Design Patterns in Practice 课中编写并运行代码吗？

能。每节 Clean Architecture & Design Patterns in Practice 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Clean Architecture & Design Patterns in Practice