How to implement hexagonal architecture using Java?

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!