<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/><!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>axon-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>axon-demo</name>
    <description>Demo project for Spring Boot and Axon Framework with MySQL</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.axonframework</groupId>
            <artifactId>axon-spring-boot-starter</artifactId>
            <version>4.6.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.axonframework</groupId>
            <artifactId>axon-test</artifactId>
            <version>4.6.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package com.example.axondemo.aggregate;

import lombok.extern.slf4j.Slf4j;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventsourcing.EventSourcingHandler;
import org.axonframework.modelling.command.AggregateIdentifier;
import org.axonframework.spring.stereotype.Aggregate;
import org.axonframework.modelling.command.AggregateLifecycle;

@Slf4j
@Aggregate
public class BankAccountAggregate {

    @AggregateIdentifier
    private String accountId; // 賬戶ID，作為聚合根的標(biāo)識(shí)符
    private double balance; // 賬戶余額

    public BankAccountAggregate() {} // 默認(rèn)構(gòu)造函數(shù)

    // 處理創(chuàng)建賬戶命令
    @CommandHandler
    public BankAccountAggregate(com.example.axondemo.command.CreateBankAccountCommand command) {
        if (command.getInitialDeposit() < 0) {
            throw new IllegalArgumentException("初始存款必須為正數(shù)");
        }
        log.info("處理創(chuàng)建賬戶命令，賬戶ID: {}", command.getAccountId());
        // 應(yīng)用事件來(lái)更改狀態(tài)
        AggregateLifecycle.apply(new com.example.axondemo.event.BankAccountCreatedEvent(command.getAccountId(), command.getInitialDeposit()));
    }

    // 處理存款命令
    @CommandHandler
    public void handle(com.example.axondemo.command.DepositMoneyCommand command) {
        if (command.getAmount() <= 0) {
            throw new IllegalArgumentException("存款金額必須為正數(shù)");
        }
        log.info("處理存款命令，賬戶ID: {}", command.getAccountId());
        // 應(yīng)用事件來(lái)更改狀態(tài)
        AggregateLifecycle.apply(new com.example.axondemo.event.MoneyDepositedEvent(command.getAccountId(), command.getAmount()));
    }

    // 處理取款命令
    @CommandHandler
    public void handle(com.example.axondemo.command.WithdrawMoneyCommand command) {
        if (command.getAmount() > balance || command.getAmount() <= 0) {
            throw new IllegalArgumentException("無(wú)效的取款金額");
        }
        log.info("處理取款命令，賬戶ID: {}", command.getAccountId());
        // 應(yīng)用事件來(lái)更改狀態(tài)
        AggregateLifecycle.apply(new com.example.axondemo.event.MoneyWithdrewEvent(command.getAccountId(), command.getAmount()));
    }

    // 處理賬戶創(chuàng)建事件
    @EventSourcingHandler
    protected void on(com.example.axondemo.event.BankAccountCreatedEvent event) {
        this.accountId = event.getAccountId();
        this.balance = event.getInitialDeposit();
        log.info("應(yīng)用賬戶創(chuàng)建事件，賬戶ID: {}", event.getAccountId());
    }

    // 處理存款事件
    @EventSourcingHandler
    protected void on(com.example.axondemo.event.MoneyDepositedEvent event) {
        this.balance += event.getAmount();
        log.info("應(yīng)用存款事件，賬戶ID: {}, 金額: {}", event.getAccountId(), event.getAmount());
    }

    // 處理取款事件
    @EventSourcingHandler
    protected void on(com.example.axondemo.event.MoneyWithdrewEvent event) {
        this.balance -= event.getAmount();
        log.info("應(yīng)用取款事件，賬戶ID: {}, 金額: {}", event.getAccountId(), event.getAmount());
    }
}

package com.example.axondemo.command;

import lombok.Builder;
import lombok.Data;
import org.axonframework.modelling.command.TargetAggregateIdentifier;

@Data
@Builder
public class CreateBankAccountCommand {
    @TargetAggregateIdentifier // 標(biāo)記目標(biāo)聚合根的標(biāo)識(shí)符
    private final String accountId; // 賬戶ID
    private final double initialDeposit; // 初始存款
}

package com.example.axondemo.command;

import lombok.Builder;
import lombok.Data;
import org.axonframework.modelling.command.TargetAggregateIdentifier;

@Data
@Builder
public class DepositMoneyCommand {
    @TargetAggregateIdentifier // 標(biāo)記目標(biāo)聚合根的標(biāo)識(shí)符
    private final String accountId; // 賬戶ID
    private final double amount; // 存款金額
}

package com.example.axondemo.command;

import lombok.Builder;
import lombok.Data;
import org.axonframework.modelling.command.TargetAggregateIdentifier;

@Data
@Builder
public class WithdrawMoneyCommand {
    @TargetAggregateIdentifier // 標(biāo)記目標(biāo)聚合根的標(biāo)識(shí)符
    private final String accountId; // 賬戶ID
    private final double amount; // 取款金額
}

package com.example.axondemo.controller;

import com.example.axondemo.command.*;
import com.example.axondemo.dto.CreateBankAccountRequest;
import com.example.axondemo.dto.DepositRequest;
import com.example.axondemo.dto.WithdrawRequest;
import com.example.axondemo.exception.InsufficientFundsException;
import com.example.axondemo.exception.InvalidAmountException;
import com.example.axondemo.repository.BankAccountRepository;
import lombok.RequiredArgsConstructor;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;

@RestController
@RequestMapping("/accounts")
@RequiredArgsConstructor
public class AccountController {

    private final CommandGateway commandGateway; // 命令網(wǎng)關(guān)，用于發(fā)送命令
    private final BankAccountRepository bankAccountRepository; // 銀行賬戶倉(cāng)庫(kù)

    // 創(chuàng)建賬戶
    @PostMapping("/")
    public ResponseEntity<String> createAccount(@Valid @RequestBody CreateBankAccountRequest request) {
        String accountId = UUID.randomUUID().toString(); // 生成唯一的賬戶ID
        CompletableFuture<Object> future = commandGateway.send(
                CreateBankAccountCommand.builder()
                        .accountId(accountId)
                        .initialDeposit(request.getInitialDeposit())
                        .build()
        );
        return future.thenApply(response -> ResponseEntity.ok(accountId)) // 成功時(shí)返回賬戶ID
                     .exceptionally(ex -> ResponseEntity.badRequest().body(ex.getMessage())) // 失敗時(shí)返回錯(cuò)誤信息
                     .join();
    }

    // 存款
    @PostMapping("/{accountId}/deposit")
    public ResponseEntity<Void> deposit(@PathVariable String accountId, @Valid @RequestBody DepositRequest request) {
        CompletableFuture<Object> future = commandGateway.send(
                DepositMoneyCommand.builder()
                        .accountId(accountId)
                        .amount(request.getAmount())
                        .build()
        );
        return future.thenApply(response -> ResponseEntity.ok().<Void>build()) // 成功時(shí)返回200 OK
                     .exceptionally(ex -> ResponseEntity.badRequest().body(null)) // 失敗時(shí)返回400 Bad Request
                     .join();
    }

    // 取款
    @PostMapping("/{accountId}/withdraw")
    public ResponseEntity<Void> withdraw(@PathVariable String accountId, @Valid @RequestBody WithdrawRequest request) {
        CompletableFuture<Object> future = commandGateway.send(
                WithdrawMoneyCommand.builder()
                        .accountId(accountId)
                        .amount(request.getAmount())
                        .build()
        );
        return future.thenApply(response -> ResponseEntity.ok().<Void>build()) // 成功時(shí)返回200 OK
                     .exceptionally(ex -> ResponseEntity.badRequest().body(null)) // 失敗時(shí)返回400 Bad Request
                     .join();
    }

    // 查詢賬戶余額
    @GetMapping("/{accountId}/balance")
    public ResponseEntity<Double> getBalance(@PathVariable String accountId) {
        Double balance = bankAccountRepository.findById(accountId).map(it -> it.getBalance()).orElse(0.0); // 獲取賬戶余額
        return ResponseEntity.ok(balance); // 返回賬戶余額
    }
}

package com.example.axondemo.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.DecimalMin;
import javax.validation.constraints.NotNull;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class CreateBankAccountRequest {
    @NotNull(message = "初始存款不能為空") // 驗(yàn)證初始存款不為空
    @DecimalMin(value = "0", message = "初始存款必須非負(fù)") // 驗(yàn)證初始存款非負(fù)
    private double initialDeposit; // 初始存款
}

package com.example.axondemo.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.DecimalMin;
import javax.validation.constraints.NotNull;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DepositRequest {
    @NotNull(message = "金額不能為空") // 驗(yàn)證金額不為空
    @DecimalMin(value = "0", message = "金額必須非負(fù)") // 驗(yàn)證金額非負(fù)
    private double amount; // 存款金額
}

package com.example.axondemo.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.DecimalMin;
import javax.validation.constraints.NotNull;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class WithdrawRequest {
    @NotNull(message = "金額不能為空") // 驗(yàn)證金額不為空
    @DecimalMin(value = "0", message = "金額必須非負(fù)") // 驗(yàn)證金額非負(fù)
    private double amount; // 取款金額
}

package com.example.axondemo.event;

import lombok.Builder;
import lombok.Data;
import org.axonframework.serialization.Revision;

@Data
@Builder
@Revision("1")
public class BankAccountCreatedEvent {
    private final String accountId; // 賬戶ID
    private final double initialDeposit; // 初始存款
}

package com.example.axondemo.event;

import lombok.Builder;
import lombok.Data;
import org.axonframework.serialization.Revision;

@Data
@Builder
@Revision("1")
public class MoneyDepositedEvent {
    private final String accountId; // 賬戶ID
    private final double amount; // 存款金額
}

package com.example.axondemo.event;

import lombok.Builder;
import lombok.Data;
import org.axonframework.serialization.Revision;

@Data
@Builder
@Revision("1")
public class MoneyWithdrewEvent {
    private final String accountId; // 賬戶ID
    private final double amount; // 取款金額
}

package com.example.axondemo.exception;

public class InsufficientFundsException extends RuntimeException {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

package com.example.axondemo.exception;

public class InvalidAmountException extends RuntimeException {
    public InvalidAmountException(String message) {
        super(message);
    }
}

package com.example.axondemo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 處理驗(yàn)證異常
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Map<String, String> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error ->
                errors.put(error.getField(), error.getDefaultMessage()));
        return errors;
    }

    // 處理非法參數(shù)異常
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException ex) {
        return ResponseEntity.badRequest().body(ex.getMessage());
    }

    // 處理資金不足異常
    @ExceptionHandler(InsufficientFundsException.class)
    public ResponseEntity<String> handleInsufficientFundsException(InsufficientFundsException ex) {
        return ResponseEntity.status(HttpStatus.CONFLICT).body(ex.getMessage());
    }

    // 處理解析金額異常
    @ExceptionHandler(InvalidAmountException.class)
    public ResponseEntity<String> handleInvalidAmountException(InvalidAmountException ex) {
        return ResponseEntity.badRequest().body(ex.getMessage());
    }
}

package com.example.axondemo.projection;

import com.example.axondemo.event.BankAccountCreatedEvent;
import com.example.axondemo.event.MoneyDepositedEvent;
import com.example.axondemo.event.MoneyWithdrewEvent;
import com.example.axondemo.repository.BankAccountEntity;
import com.example.axondemo.repository.BankAccountRepository;
import lombok.extern.slf4j.Slf4j;
import org.axonframework.eventhandling.EventHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class BankAccountProjection {

    @Autowired
    private BankAccountRepository bankAccountRepository; // 銀行賬戶倉(cāng)庫(kù)

    // 處理賬戶創(chuàng)建事件
    @EventHandler
    public void on(BankAccountCreatedEvent event) {
        BankAccountEntity bankAccountEntity = BankAccountEntity.builder()
                .accountId(event.getAccountId())
                .balance(event.getInitialDeposit())
                .build();
        bankAccountRepository.save(bankAccountEntity);
        log.info("投影賬戶創(chuàng)建事件，賬戶ID: {}", event.getAccountId());
    }

    // 處理存款事件
    @EventHandler
    public void on(MoneyDepositedEvent event) {
        bankAccountRepository.findById(event.getAccountId())
                .ifPresentOrElse(
                        bankAccountEntity -> {
                            bankAccountEntity.setBalance(bankAccountEntity.getBalance() + event.getAmount());
                            bankAccountRepository.save(bankAccountEntity);
                            log.info("投影存款事件，賬戶ID: {}, 金額: {}", event.getAccountId(), event.getAmount());
                        },
                        () -> log.error("未找到賬戶ID: {}", event.getAccountId())
                );
    }

    // 處理取款事件
    @EventHandler
    public void on(MoneyWithdrewEvent event) {
        bankAccountRepository.findById(event.getAccountId())
                .ifPresentOrElse(
                        bankAccountEntity -> {
                            bankAccountEntity.setBalance(bankAccountEntity.getBalance() - event.getAmount());
                            bankAccountRepository.save(bankAccountEntity);
                            log.info("投影取款事件，賬戶ID: {}, 金額: {}", event.getAccountId(), event.getAmount());
                        },
                        () -> log.error("未找到賬戶ID: {}", event.getAccountId())
                );
    }
}

package com.example.axondemo.repository;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BankAccountEntity {
    @Id
    private String accountId; // 賬戶ID
    private double balance; // 賬戶余額
}

package com.example.axondemo.repository;

import org.springframework.data.jpa.repository.JpaRepository;

public interface BankAccountRepository extends JpaRepository<BankAccountEntity, String> {
}

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/banktest?useSSL=false&serverTimezone=UTC
    username: root
    password: 12345678

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

logging:
  level:
    org.axonframework: INFO

package com.example.axondemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AxonDemoApplication {

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

{
    "initialDeposit": 100
  }

9f4c1b8e-2a0f-4e5f-b2f2-f8f1e5f1e5f1

{
    "amount": 50
  }

{
    "amount": 30
  }

120.0