Application scenarios and usage methods of VO PO DTO POJO BO DO objects in java

Application of VO PO DTO POJO BO DO object in java

In Java development, especially in enterprise-level application development, in order to better follow the principle of hierarchical architecture, different objects are designed for interaction and data transmission between different levels.

The following is a brief description of the application scenarios and usage examples of VO (View Object), PO (Persistent Object), DTO (Data Transfer Object), POJO (Plain Old Java Object):

VO (View Object) - View Object

Application scenarios:

VO mainly serves the presentation layer (such as web pages and mobile interfaces), and is used to encapsulate the data returned from the server to the front-end display.

Example:

public class UserVO {
    private String username;
    private String displayName;
    private String email;

    // Getters and setters...
}

In a scenario where the user list is displayed, the server may obtain user information from the database that contains sensitive or does not need to display fields such as passwords and creation time, and then convert it into UserVO objects that only contain necessary display information such as username, display name and email address, and then pass it to the front-end for rendering.

PO (Persistent Object) - Persistent Object

Application scenarios:

PO usually corresponds to the database table structure, mainly used to represent records in the database, and implement ORM (object relational mapping).

Example:

@Entity
public class UserPO {
    @Id
    @GeneratedValue(strategy = )
    private Long id;
    private String username;
    private String password;
    private Date createdAt;

    // Getters and setters along with any necessary annotations for ORM.
}

The UserPO class here corresponds to the "users" table in the database. Each attribute represents a database field and can be used for database operations such as JPA and Hibernate.

DTO (Data Transfer Object) - Data Transfer Object

Application scenarios:

DTO is used to transmit data between different services or between services and clients, decouple each service or module, and can hide internal implementation details.

Example:

public class UserDTO {
    private String username;
    private String hashedPassword; // May contain encrypted password    private String role;

    // Constructor, getters, setters...
}

When the user registers, the front-end sends a UserDTO containing the original password to the back-end service. After the back-end receives it, it encrypts and stores it into the database. The UserDTO here does not care about the specific storage method of the database and is only responsible for the data carrier function during the transmission process.

POJO (Plain Old Java Object) - Simple Old Java Object

Application scenarios:

POJO is the most basic object type, does not inherit any special classes, nor does it implement a specific interface, just some fields plus getter/setter methods.

Example:

public class SimplePojo {
    private String name;
    private int age;

    public SimplePojo(String name, int age) {
         = name;
         = age;
    }

    // Getter and Setter methods
}

POJO can be any of the above types of objects (VO, PO, DTO), as long as they meet simple and no special agreements. For example, the SimplePojo above can be used as both VO and DTO depending on how it is actually used below.

To sum up, in a typical three-layer or multi-layer architecture system, PO is used for database-level operations, VO is used for front-end presentation, and DTO is used for data exchange between services, and all these objects can be POJO, that is, pure Java classes without additional framework dependencies and special tags.

In addition to VO, PO, DTO and POJO, there are some object types that are widely used in specific scenarios:

BO (Business Object) - Business Object

Application scenarios:

BO mainly carries business logic, which may be a complex object composed of multiple POs to express business concepts or entities.

Example:

public class OrderBO {
    private UserBO user;
    private List<OrderItemBO> items;
    private BigDecimal totalAmount;

    // Business methods like calculateTotalAmount(), placeOrder(), etc.
}

In an e-commerce system, an order may contain purchaser information, line item lists, etc. OrderBO is used to aggregate this information and execute relevant business logic.

DO (Domain Object) - Domain Object

Application scenarios:

DO is used in Domain Driven Design (DDD), representing the core concept of the domain model and includes domain logic and rules.

Example:

public class AccountDO {
    private Money balance;
    private boolean isLocked;

    public void deposit(Money amount) {
        // Implement deposit business logic, such as: check whether the account is locked, update the balance, etc.    }

    // Other domain logic methods}

AccountDO not only contains the attributes of the account, but also implements the core behavior of the field.

Summarize

The above is personal experience. I hope you can give you a reference and I hope you can support me more.