Wie implementiert man eine hexagonale Architektur mit Java?

Sechseckige Architektur ist ein Designstil, der Schichten verwendet, um die Kernlogik von externen Objekten zu isolieren. Seine Kernlogik ist das Geschäftsmodul, und externe Elemente sind Integrationspunkte wie Datenbanken, externe APIs, Schnittstellen usw. Es unterteilt die Software in interne und externe Teile. Der interne Teil enthält die Kerngeschäftslogik und die Domänenschicht (die sogenannte Schichtarchitektur), und der externe Teil enthält Schnittstellen, Datenbanken, Nachrichten und andere Inhalte. Interne und externe Geräte kommunizieren über Ports und Adapter miteinander.

*Übersetzungshinweis: Die sechseckige Architektur wurde von Alistair Cockburn vorgeschlagen, um die Probleme zu lösen, die durch die traditionelle Schichtarchitektur verursacht werden. *

1. Vorteile

Mithilfe einer hexagonalen Architektur entwickelte Software ist unabhängig von Kanälen und kann daher mehrere Kanäle unterstützen

​Einfach zu ersetzende eingehende und ausgehende Integrationspunkte

Das Testen von Software wird einfacher, da Integrationspunkte leicht verspottet werden können

​2. Java-Implementierung

Wie oben beschrieben, funktioniert die hexagonale Architektur eher rund um Ports und Adapter. In Java werden Schnittstellen zum Definieren von Ports verwendet und Implementierungsklassen fungieren als Adapter. Lassen Sie uns anhand eines einfachen Spring Boot-Anwendungsbeispiels verstehen, wie die hexagonale Architektur angewendet wird.

Die Hauptfunktion der Beispielanwendung besteht darin, Mitarbeiterinformationen zu erstellen und anzuzeigen. Die Kerngeschäftslogik ist in EmployeeService definiert. Diese können als interne Module betrachtet werden.

​**EmployeeService.java**

––Java

​@Service

​öffentliche Klasse EmployeeService {

​@Autowired

​private EmployeeRepositoryPort EmployeeRepository;

public void create（String-Name, String-Rolle, langes Gehalt）{

EmployeeRepository.create(Name, Rolle, Gehalt);

}

​öffentliche Mitarbeiteransicht (Ganzzahlige Benutzer-ID){

Rückkehr EmployeeRepository.getEmployee(userId);

}

}

––

​**Employee.java**

––Java

​@Entity

​@Table（name = "Mitarbeiter")

​Mitarbeiter der öffentlichen Klasse{

​@Id

​@GeneratedValue

​@Column（name = "id")

private Ganzzahl-ID;

​@Column（name = "name", nullable = false)

privater String-Name;

​@Column（name = "role", nullable = false)

private Streichrolle;

​@Column（name = "Gehalt", nullable = false)

privates Langzeitgehalt;

//Setter-, Getter-Methoden

}

Jetzt kann die Beispielanwendung Dienste über REST- oder Messaging-Mechanismen bereitstellen. Erstellen Sie eine EmployeeControllerAdapter-Klasse, die die EmployeeUIPort-Schnittstelle implementiert, um REST-Dienste bereitzustellen.

​**EmployeeControllerAdapter.java**

––Java

RestController

​@RequestMapping（"/employees/"）

Die öffentliche Klasse EmployeeControllerAdapter implementiert EmployeeUIPort{

​@Autowired

privat EmployeeService EmployeeService;

​@Override

​public void create（@RequestBody Employee request） {

EmployeeService.create(request.getName(), request.getRole(), request.getSalary());

}

​@Override

​öffentliche Mitarbeiteransicht (@PathVariable Integer id) {

Mitarbeiter Mitarbeiter = EmployeeService.view(id);

Rückkehrmitarbeiter;

}

}

––

––Java

​öffentliche Schnittstelle EmployeeUIPort {

​@PostMapping（„erstellen“）

​public void create（@RequestBody Employee request）;

​@GetMapping("view/{id}")

​öffentliche Mitarbeiteransicht(@PathVariable Integer userId);

}

Als Teil der Geschäftslogik muss EmployeeService auch den externen DB-Integrationspunkt aufrufen. Daher haben wir den EmployeeRepositoryPort und den EmployeeServiceAdapter erstellt, die diese Schnittstelle implementieren.

​**EmployeeServiceAdapter.java**

––Java

​@Service

Die öffentliche Klasse EmployeeServiceAdapter implementiert EmployeeRepositoryPort {

​@PersistenceContext

privater EntityManager entityManager;

​@Transactional

​@Override

public void create (String-Name, String-Rolle, langes Gehalt) {

Mitarbeiter Mitarbeiter = neuer Mitarbeiter();

mitarbeiter.setName(name);

Employee.setRole(role);

Employee.setSalary(Gehalt);

​entityManager.persist(mitarbeiter);

}

​@Override

​öffentlicher Mitarbeiter getEmployee(Integer userId) {

​EntityManager.find(Employee.class, userId) zurückgeben;

}

}

　　––

　　**EmployeeRepositoryPort.java**

　　––Java

　　öffentliche Schnittstelle EmployeeRepositoryPort {

　　void create（String-Name, String-Rolle, langes Gehalt）;

　　Mitarbeiter getEmployee（Integer userId）;

　　}

Das obige ist der detaillierte Inhalt vonWie implementiert man eine hexagonale Architektur mit Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!