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!
