How to implement hexagonal architecture using Java?
- WBOYforward
- 2023-04-23 13:25:071358browse
Hexagonal architecture is a design style that uses layering to isolate core logic from external objects. Its core logic is the business module, and external elements are integration points, such as databases, external APIs, interfaces, etc. It divides the software into internal and external parts. The internal part contains the core business logic and domain layer (the so-called layered architecture), and the external part contains interfaces, databases, messaging and other contents. Internals and externals communicate with each other through ports and adapters.
*Translation Note: Hexagonal Architecture was proposed by Alistair Cockburn to solve the problems caused by the traditional layered architecture. *
1. Advantages
Software developed using hexagonal architecture is independent of channels and therefore can support multiple channels
Easy replacement of inbound and outbound integration points
Testing software becomes easier because integration points can be easily mocked
2. Java implementation
As described above, the hexagonal architecture works more around ports and adapters. In Java, interfaces are used to define ports and implementation classes act as adapters. Let’s use a simple Spring Boot application example to understand how to apply the hexagonal architecture.
The main function of the sample application is to create and view employee information. The core business logic is implemented in EmployeeService. The domain object is defined as Employee. These can be regarded as internal modules.
**EmployeeService.java**
——java
@Service
public class EmployeeService {
@Autowired
private EmployeeRepositoryPort employeeRepository;
public void create（String name, String role, long salary）{
employeeRepository.create(name, role, salary);
}
public Employee view(Integer userId){
return employeeRepository.getEmployee(userId);
}
}
——
**Employee.java**
——java
@Entity
@Table（name = "employee")
public class Employee{
@Id
@GeneratedValue
@Column（name = "id")
private Integer id;
@Column（name = "name", nullable = false)
private String name;
@Column（name = "role", nullable = false)
private String role;
@Column（name = "salary", nullable = false)
private long salary;
//Setter, Getter methods
}
Now, the sample application can provide services through REST or messaging mechanisms. Create an EmployeeControllerAdapter class that implements the EmployeeUIPort interface to provide REST services.
**EmployeeControllerAdapter.java**
——java
RestController
@RequestMapping（"/employees/"）
public class EmployeeControllerAdapter implements EmployeeUIPort{
@Autowired
private EmployeeService employeeService;
@Override
public void create（@RequestBody Employee request） {
employeeService.create(request.getName(), request.getRole(), request.getSalary());
}
@Override
public Employee view (@PathVariable Integer id) {
Employee employee = employeeService.view(id);
return employee;
}
}
——
——java
public interface EmployeeUIPort {
@PostMapping（"create"）
public void create（@RequestBody Employee request）;
@GetMapping（"view/{id}"）
public Employee view(@PathVariable Integer userId);
}
As part of the business logic, EmployeeService; also needs to call the external DB integration point. Therefore, we created an EmployeeRepositoryPort and an EmployeeServiceAdapter that implements this interface.
**EmployeeServiceAdapter.java**
——java
@Service
public class EmployeeServiceAdapter implements EmployeeRepositoryPort {
@PersistenceContext
private EntityManager entityManager;
@Transactional
@Override
public void create（String name, String role, long salary） {
Employee employee = new Employee();
employee.setName(name);
employee.setRole(role);
employee.setSalary(salary);
entityManager.persist(employee);
}
@Override
public Employee getEmployee(Integer userId) {
return entityManager.find(Employee.class, userId);
}
}
——
**EmployeeRepositoryPort.java**
——java
public interface EmployeeRepositoryPort {
void create（String name, String role, long salary）;
Employee getEmployee（Integer userId）;
}
The above is the detailed content of How to implement hexagonal architecture using Java?. For more information, please follow other related articles on the PHP Chinese website!