Comment utiliser Java pour développer une application événementielle basée sur Axon Framework

Comment utiliser Java pour développer une application basée sur des événements basée sur Axon Framework

1 Introduction de base
Axon Framework est un framework Java permettant de créer des applications basées sur des événements. Il fournit des fonctions et des outils de base pour la mise en œuvre du CQRS (Command Query Responsibility Segregation) et de l'architecture basée sur les événements (EDA). Axon Framework offre une bonne évolutivité et flexibilité, permettant aux développeurs de créer et de maintenir facilement des applications complexes.

2. Configuration de l'environnement
Avant de commencer le développement, nous devons configurer l'environnement. Tout d’abord, confirmez que le SDK Java et les outils de build Maven ont été installés. Ensuite, introduisez les dépendances nécessaires en suivant les étapes suivantes :

1. Ajoutez les dépendances suivantes dans le pom du projet. Définition des événements et des commandes

   Dans Axon Framework, les événements et les commandes sont des concepts fondamentaux dans les applications. Les événements sont des faits qui se produisent dans le système, tandis que les commandes sont des actions utilisées pour modifier l'état du système.

2. Créez une classe Java nommée OrderCreatedEvent et définissez-y les propriétés :

<dependencies>
 <dependency>
     <groupId>org.axonframework</groupId>
     <artifactId>axon-spring-boot-starter</artifactId>
     <version>4.1.3</version>
 </dependency>
 <dependency>
     <groupId>org.axonframework</groupId>
     <artifactId>axon-test</artifactId>
     <version>4.1.3</version>
     <scope>test</scope>
 </dependency>
</dependencies>

Créez une classe Java nommée CreateOrderCommand et définissez-la Attributs :

spring.datasource.driverClassName=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:test
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

1. 4. Créer une racine agrégée OrderCreatedEvent的Java类，并定义其中的属性：

   public class OrderCreatedEvent {
   
    private String orderId;
    private String customerName;
   
    // Getter and Setter
   }

2. 创建一个名为CreateOrderCommand的Java类，并定义其中的属性：

   public class CreateOrderCommand {
   
    private String orderId;
    private String customerName;
   
    // Getter and Setter
   }

四、创建聚合根
聚合根是一个具有唯一标识的领域对象，它负责处理外部命令并生成相应的事件。

1. 创建一个名为OrderAggregate的Java类，并定义其中的字段和方法：

   @Aggregate
   public class OrderAggregate {
   
    @AggregateIdentifier
    private String orderId;
    private String customerName;
   
    public OrderAggregate() {
    }
   
    @CommandHandler
    public OrderAggregate(CreateOrderCommand command) {
        AggregateLifecycle.apply(new OrderCreatedEvent(command.getOrderId(), command.getCustomerName()));
    }
   
    @EventSourcingHandler
    public void on(OrderCreatedEvent event) {
        this.orderId = event.getOrderId();
        this.customerName = event.getCustomerName();
    }
   }

2. 创建一个名为OrderAggregateIdentifierResolver的Java类，并实现AggregateIdentifierResolver接口：

   @Component
   public class OrderAggregateIdentifierResolver implements AggregateIdentifierResolver {
   
    @Override
    public String resolveId(Object command) {
        if (command instanceof CreateOrderCommand) {
            return ((CreateOrderCommand) command).getOrderId();
        }
        return null;
    }
   }

五、创建命令处理器
命令处理器负责处理外部命令，并将其分发给相应的聚合根。

1. 创建一个名为OrderCommandHandler的Java类，并定义其中的方法：

   @Component
   public class OrderCommandHandler {
   
    private final CommandGateway commandGateway;
   
    public OrderCommandHandler(CommandGateway commandGateway) {
        this.commandGateway = commandGateway;
    }
   
    @CommandHandler
    public void handle(CreateOrderCommand command) {
        commandGateway.send(new CreateOrderCommand(command.getOrderId(), command.getCustomerName()));
    }
   }

六、创建查询模型
查询模型负责处理外部查询，并返回适当的结果。

1. 创建一个名为OrderQueryModel的Java类，并定义其中的字段和方法：

   @Entity
   public class OrderQueryModel {
   
    @Id
    private String orderId;
    private String customerName;
   
    // Getter and Setter
   }

2. 创建一个名为OrderQueryModelRepository的Java接口，并继承CrudRepository：

   @Repository
   public interface OrderQueryModelRepository extends CrudRepository<OrderQueryModel, String> {
   }

3. 创建一个名为OrderQueryHandler的Java类，并定义其中的方法：

   @Component
   public class OrderQueryHandler {
   
    private final OrderQueryModelRepository orderQueryModelRepository;
   
    public OrderQueryHandler(OrderQueryModelRepository orderQueryModelRepository) {
        this.orderQueryModelRepository = orderQueryModelRepository;
    }
   
    @QueryHandler
    public OrderQueryModel handle(GetOrderQuery query) {
        return orderQueryModelRepository.findById(query.getOrderId()).orElse(null);
    }
   }

七、创建REST API
创建REST API以供外部调用。

1. 创建一个名为OrderController的Java类，并定义其中的方法：

   @RestController
   @RequestMapping("/orders")
   public class OrderController {
   
    private final CommandGateway commandGateway;
    private final QueryGateway queryGateway;
   
    public OrderController(CommandGateway commandGateway, QueryGateway queryGateway) {
        this.commandGateway = commandGateway;
        this.queryGateway = queryGateway;
    }
   
    @PostMapping
    public ResponseEntity<String> create(@RequestBody CreateOrderDTO createOrderDTO) {
        String orderId = UUID.randomUUID().toString();
        commandGateway.send(new CreateOrderCommand(orderId, createOrderDTO.getCustomerName()));
        return ResponseEntity.ok(orderId);
    }
   
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderQueryModel> get(@PathVariable String orderId) throws ExecutionException, InterruptedException {
        OrderQueryModel order = queryGateway.query(new GetOrderQuery(orderId), ResponseTypes.instanceOf(OrderQueryModel.class)).get();
        if (order == null) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(order);
    }
   }

2. 创建一个名为CreateOrderDTO的Java类，并定义其中的属性：

   public class CreateOrderDTO {
   
    private String customerName;
   
    // Getter and Setter
   }

3. 创建一个名为GetOrderQuery的Java类，并定义其中的属性：

   public class GetOrderQuery {
   
    private String orderId;
   
    // Getter and Setter
   }

八、启动应用程序

1. 创建一个名为Application的Java类，并添加@SpringBootApplication注解：

   @SpringBootApplication
   public class Application {
   
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
   }

2. 运行Application类的mainLa racine agrégée est un objet de domaine avec une identité unique, qui est responsable du traitement des commandes externes et de la génération des événements correspondants.

Créez une classe Java nommée OrderAggregate et définissez les champs et les méthodes qu'elle contient :

URL: http://localhost:8080/orders
Method: POST
Body: {"customerName": "John Doe"}

1. Créez une classe Java nommée OrderAggregateIdentifierResolver et implémentez le Interface AggregateIdentifierResolver :

   URL: http://localhost:8080/orders/{orderId}
   Method: GET

2. 5. Créez un processeur de commandes

   Le processeur de commandes est responsable du traitement des commandes externes et de leur distribution à la racine d'agrégat correspondante.

Créez une classe Java nommée OrderCommandHandler et définissez les méthodes qu'elle contient :

rrreee🎜🎜🎜 6. Créez un modèle de requête 🎜Le modèle de requête est responsable du traitement des requêtes externes et du renvoi des résultats appropriés. 🎜🎜🎜🎜Créez une classe Java nommée OrderQueryModel et définissez les champs et les méthodes qu'elle contient : 🎜rrreee🎜🎜🎜Créez une interface Java nommée OrderQueryModelRepository et héritez de CrudRepository  : 🎜rrreee🎜🎜🎜Créez une classe Java nommée OrderQueryHandler et définissez les méthodes qu'elle contient : 🎜rrreee🎜🎜🎜 7. Créez une API REST🎜Créez une API REST pour les appels externes. 🎜🎜🎜🎜Créez une classe Java nommée OrderController et définissez les méthodes qu'elle contient : 🎜rrreee🎜🎜🎜Créez une classe Java nommée CreateOrderDTO et définissez-la Attributs : 🎜rrreee🎜 🎜🎜Créez une classe Java nommée GetOrderQuery et définissez ses attributs : 🎜rrreee🎜🎜🎜 8. Démarrez l'application 🎜🎜🎜🎜Créez une classe nommée Classe Java de Application , et ajoutez l'annotation @SpringBootApplication : 🎜rrreee🎜🎜Exécutez la méthode main de la classe Application pour démarrer le programme d'application. 🎜🎜🎜9. Testez l'application🎜Utilisez Postman ou un outil similaire pour envoyer des requêtes HTTP afin de tester la fonctionnalité de l'application. 🎜🎜🎜🎜Envoyez une requête POST pour créer une commande : 🎜rrreee🎜🎜🎜Envoyez une requête GET pour obtenir des informations sur la commande : 🎜rrreee🎜🎜🎜Résumé🎜Cet article présente comment utiliser Java pour développer une application basée sur des événements. basé sur le framework Axon. En définissant des événements et des commandes, en créant des racines agrégées, des gestionnaires de commandes, des modèles de requête et des API REST, nous pouvons utiliser le framework Axon pour créer des applications événementielles efficaces et évolutives. 🎜

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!