In Spring Boot, the terms Model and Entity are commonly used interchangeably but used for different purposes in application architecture. An Entity term is used for creating database table persistence using JPA annotation while Model is a more generic term used to represent business logic, DTOs, or view models. In this topic, we will understand the difference between Model and Entity terms, their use cases, and best practices for using them effectively in Spring Boot applications.
What is Entity in Spring Boot?
An Entity in Spring Boot class represents a database table using @Entity annotation. It is mapped to a table using JPA (Java Persistence API) and allows CRUD operations through repositories.
Key Features of Entity
✔ It represents a table in the database.
✔ It uses JPA annotations like @Entity, @Table, @Id.
✔ It is used for persistence and database transactions.
✔ It can be used in Spring Data JPA repositories.
Example: Entity in Spring Boot
import javax.persistence.*;
@Entity
@Table(name = "users")
public class UserEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true, length = 100)
private String username;
@Column(nullable = false)
private String password;
// Getters and Setters
}Generated SQL Table
CREATE TABLE users (
id BIGINT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(100) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL
);Entity is Best for
✔ Database tables and persistence.
✔ CRUD operations via JPA repositories.
✔ It is used to handle relational mappings (e.g., @OneToMany, @ManyToOne).
What is a Model in Spring Boot?
A Model in Spring Boot is a generic term used for data structures representing business logic, DTOs, request/response objects, or view models. A Model is not necessarily tied to the database.
Key Features of Model
✔ It is used for business logic, DTOs, and API responses.
✔ It does not always have JPA annotations.
✔ It can be used for data transfer between layers (Service, Controller).
✔ It helps in separating concerns between database and API models.
Example: Model (DTO) in Spring Boot
public class UserDTO {
private String username;
private String email;
// Constructor
public UserDTO(String username, String email) {
this.username = username;
this.email = email;
}
// Getters and Setters
}Model is Best for
✔ DTOs (Data Transfer Objects) – transferring data between Controller and Service.
✔ Request/Response Objects – mapping JSON API requests to Java objects.
✔ View Models – defining objects specific to front-end views.
✔ Business Logic Models – models that do not need database persistence.
Key Difference Between Model and Entity in Spring Boot
| Feature | Entity | Model |
| Purpose | Represents a database table (persistent). | Represents business logic, DTOs, and API models. |
| Persistence | Stored in the database. | Not stored in the database (transient). |
| Annotations | Uses JPA annotations like @Entity, @Table, @Id. | Do not use JPA annotations (unless necessary). |
| Use Case | Used for CRUD operations via JPA repositories. | Used for DTOs, API responses, and business logic. |
| Data Scope | Represents complete data from the database. | It can contain partial, transformed, or derived data. |
| Modification | Changes in Entity affect database schema. | Changes in the Model do not affect the database. |
When to Use Model and Entity in Spring Boot?
Use Entity When
✔ You need to store data persistently in the database.
✔ You require JPA annotations (@Entity, @Table, @Id).
✔ You need Spring Data JPA repository methods to fetch data.
✔ You are implementing relational mappings (@OneToMany, @ManyToOne).
Example: UserEntity Stored in the Database
@Entity
@Table(name = "users")
public class UserEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
}Use Model When
✔ You need a DTO (Data Transfer Object) to send data in an API response.
✔ You want to avoid exposing Entity structure directly in APIs.
✔ You need a View Model to format data before sending it to the UI.
✔ You require data transformation between layers (e.g., mapping entities to DTOs).
Example: UserDTO for API Response
public class UserDTO {
private String username;
private String email;
public UserDTO(String username, String email) {
this.username = username;
this.email = email;
}
}How to Convert Between Entity and Model (DTO)?
Since Entities are used for persistence and Models (DTOs) are used for API responses, we often need to convert between them using manual or automatic conversion.
Example: Mapping Entity to DTO in Service Layer
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public UserDTO getUserById(Long id) {
UserEntity user = userRepository.findById(id)
.orElseThrow(() -> new RuntimeException("User not found"));
// Convert Entity to DTO
return new UserDTO(user.getUsername(), user.getEmail());
}
}Using ModelMapper for Automatic Conversion
import org.modelmapper.ModelMapper;
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Autowired
private ModelMapper modelMapper;
public UserDTO getUserById(Long id) {
UserEntity user = userRepository.findById(id)
.orElseThrow(() -> new RuntimeException("User not found"));
// Auto-convert Entity to DTO
return modelMapper.map(user, UserDTO.class);
}
}Practical Comparison Table
| Scenario | Use Entity | Use Model (DTO) |
| Storing data in the database | ✅ Yes | ❌ No |
| Performing CRUD operations | ✅ Yes (Spring Data JPA) | ❌ No |
| Sending data in API responses | ❌ No (Avoid exposing entities directly) | ✅ Yes (Use DTOs for APIs) |
| Transferring data between layers | ❌ No | ✅ Yes (Use DTOs or View Models) |
| Relational mapping | ✅ Yes (@OneToMany, @ManyToOne) | ❌ No |
| Business logic models | ❌ No (Entities should focus on persistence) | ✅ Yes |
Conclusion
In Spring Boot, both Model and Entity serve important roles:
✔ Use Entity for database persistence – Entities represent database tables and are used with JPA repositories.
✔ Use Model (DTO) for API responses – DTOs help in data transfer, and keeping API responses clean.
✔ Convert between Entity and Model using manual mapping or libraries like ModelMapper.
By following this approach, we can create clean, maintainable, and efficient Spring Boot applications.