Comment implémenter une architecture hexagonale en utilisant Java ?
- WBOYavant
- 2023-04-23 13:25:071359parcourir
L'architecture hexagonale est un style de conception qui utilise la superposition pour isoler la logique centrale des objets externes. Sa logique centrale est le module métier, et les éléments externes sont des points d'intégration, tels que des bases de données, des API externes, des interfaces, etc. Il divise le logiciel en parties internes et externes. La partie interne contient la logique métier principale et la couche de domaine (ce que l'on appelle l'architecture en couches), et la partie externe contient les interfaces, les bases de données, la messagerie et d'autres contenus. Les internes et les externes communiquent entre eux via des ports et des adaptateurs.
*Note de traduction : L'architecture hexagonale a été proposée par Alistair Cockburn pour résoudre les problèmes causés par l'architecture en couches traditionnelle. *
1. Avantages
Les logiciels développés à l'aide d'une architecture hexagonale sont indépendants des canaux, ils peuvent donc prendre en charge plusieurs canaux
Facile à remplacer les points d'intégration entrants et sortants
Les logiciels de test deviennent plus simples car les points d'intégration peuvent être facilement simulés
2. Implémentation Java
Comme décrit ci-dessus, l'architecture hexagonale fonctionne davantage autour des ports et des adaptateurs. En Java, les interfaces sont utilisées pour définir les ports et les classes d'implémentation agissent comme des adaptateurs. Utilisons un exemple simple d'application Spring Boot pour comprendre comment appliquer l'architecture hexagonale.
La fonction principale de l'exemple d'application est de créer et d'afficher les informations sur les employés. La logique métier de base est implémentée dans EmployeeService. L'objet de domaine est défini comme Employee. Ceux-ci peuvent être considérés comme des modules internes.
**EmployeeService.java**
——java
@Service
classe publique EmployeeService {
@Autowired
private EmployeeRepositoryPort EmployeeRepository ;
public void create（Nom de chaîne, rôle de chaîne, salaire long）{
employeRepository.create(nom, rôle, salaire);
}
vue publique des employés (Integer userId){
return employeRepository.getEmployee(userId);
}
}
—-
**Employé.java**
——java
@Entité
@Table（name = "employé")
employé de classe publique{
@Id
@GeneratedValue
@Column（name = "id")
identifiant entier privé ;
@Column（name = "name", nullable = false)
nom de chaîne privé ;
@Column（name = "role", nullable = false)
rôle de chaîne privé ;
@Column（name = "salary", nullable = false)
salaire long privé ;
//Méthodes Setter, Getter
}
Désormais, l’exemple d’application peut fournir des services via REST ou des mécanismes de messagerie. Créez une classe EmployeeControllerAdapter qui implémente l'interface EmployeeUIPort pour fournir des services REST.
**EmployeeControllerAdapter.java**
——java
RestController
@RequestMapping（"/employees/"）
classe publique EmployeeControllerAdapter implémente EmployeeUIPort{
@Autowired
privé EmployeeService employéService ;
@Override
public void create（@RequestBody Demande d'employé） {
employeService.create(request.getName(), request.getRole(), request.getSalary());
}
@Override
Vue publique des employés (@PathVariable Integer id) {
Employé employé = employeService.view(id);
retour employé;
}
}
——
——java
interface publique EmployeeUIPort {
@PostMapping（"créer"）
public void create（@RequestBody Demande d'employé）;
@GetMapping("view/{id}")
vue publique des employés (@PathVariable Integer userId);
}
Dans le cadre de la logique métier, EmployeeService doit également appeler le point d'intégration de base de données externe. Par conséquent, nous avons créé un EmployeeRepositoryPort et un EmployeeServiceAdapter qui implémentent cette interface.
**EmployeeServiceAdapter.java**
——java
@Service
classe publique EmployeeServiceAdapter implémente EmployeeRepositoryPort {
@PersistenceContext
EntityManager privé EntityManager ;
@Transactionnel
@Override
public void create（Nom de chaîne, rôle de chaîne, salaire long） {
Employé employé = nouvel employé();
employe.setName(nom);
employe.setRole(role);
employe.setSalary(salaire);
entityManager.persist(employé);
}
@Override
public Employee getEmployee (Integer userId) {
retournerentityManager.find(Employee.class, userId);
}
}
——
**EmployeeRepositoryPort.java**
——java
interface publique EmployeeRepositoryPort {
void create （Nom de la chaîne, rôle de la chaîne, salaire long）;
Employé getEmployee（Integer userId）;
}
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!