What's Changed

• refactor: Enhance MethodAccessor.invoke performance. by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/36
• fix(deps): update dependency org.springframework.boot:spring-boot-dependencies to v2.7.12 by @renovate in https://github.com/Ahoo-Wang/Wow/pull/37

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.9.1...v1.9.2

What's Changed

• feat: add AutoCloseable to MessageBus by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/35

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.9.0...v1.9.1

What's Changed

• feat: support ElasticsearchSnapshotRepository.scrollAggregateId by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/34

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.25...v1.9.0

What's Changed

• feat: Automatically create snapshot indexes. by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/33

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.24...v1.8.25

What's Changed

• refactor: wow.parallelism for MessageDispatcher by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/32

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.23...v1.8.24

What's Changed

• refactor: TracingLocalCommandBus and TracingLocalEventBus by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/31

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.22...v1.8.23

What's Changed

• feat: support customize BloomFilterIdempotencyChecker by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/30
• fix(deps): update dependency org.testcontainers:testcontainers-bom to v1.18.1 by @renovate in https://github.com/Ahoo-Wang/Wow/pull/26

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.21...v1.8.22

What's Changed

• feat: support TracingLocalMessageBus by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/29

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.20...v1.8.21

What's Changed

• feat: support LocalFirstCommandBus by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/25
• fix(deps): update dependency io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom to v1.26.0 by @renovate in https://github.com/Ahoo-Wang/Wow/pull/27
• feat: support Tracing for MessageBus by @Ahoo-Wang in https://github.com/Ahoo-Wang/Wow/pull/28

Full Changelog: https://github.com/Ahoo-Wang/Wow/compare/v1.8.18...v1.8.20

Wow

A Modern Reactive CQRS Architecture Microservice development framework based on DDD and EventSourcing.

Architecture

Event Sourcing

Preconditions

• Understanding Domain Driven Design：《Implementing Domain-Driven Design》,《Domain-Driven Design: Tackling Complexity
  in the Heart of Software》
• Understanding Command Query Responsibility Segregation(CQRS)
• Understanding EventSourcing
• Understanding Reactive Programming

Features

• Aggregate Modeling
  • Single Class
  • Inheritance Pattern
  • Aggregation Pattern
• Saga Modeling
  • StatelessSaga
  • StatefulSaga
• Test Suite
  • Test Specification
  • AggregateVerifier
  • StatelessSagaVerifier
• EventSourcing
  • EventStream
    • MongoDB (Recommend)
    • R2dbc
      • Database Sharding
      • Table Sharding
  • Snapshot
    • MongoDB (Recommend)
    • R2dbc
      • Database Sharding
      • Table Sharding
    • ElasticSearch
• Kafka Integration
  • CommandBus
  • DomainEventBus
• Spring Integration
  • Spring Boot Auto Configuration
  • Automatically register CommandAggregate to RouterFunction
• Observability
  • OpenTelemetry
• OpenApi
• WowMetadata Generator
  • wow-compiler

Example

Example

Aggregate Unit Test

80% test coverage is a breeze.

Given -> When -> Expect .

internal class OrderTest {

    companion object {
        val SHIPPING_ADDRESS = ShippingAddress("China", "ShangHai", "ShangHai", "HuangPu", "001")
    }

    private fun mockCreateOrder(): VerifiedStage<OrderState> {
        val tenantId = GlobalIdGenerator.generateAsString()
        val customerId = GlobalIdGenerator.generateAsString()

        val orderItem = OrderItem(
            GlobalIdGenerator.generateAsString(),
            GlobalIdGenerator.generateAsString(),
            BigDecimal.valueOf(10),
            10
        )
        val orderItems = listOf(orderItem)
        val inventoryService = object : InventoryService {
            override fun getInventory(productId: String): Mono<Int> {
                return orderItems.toFlux().filter { it.productId == productId }.map { it.quantity }.last()
            }
        }
        val pricingService = object : PricingService {
            override fun getProductPrice(productId: String): Mono<BigDecimal> {
                return orderItems.toFlux().filter { it.productId == productId }.map { it.price }.last()
            }
        }
        return aggregateVerifier<Order, OrderState>(tenantId = tenantId)
            .inject(DefaultCreateOrderSpec(inventoryService, pricingService))
            .given()
            .`when`(CreateOrder(customerId, orderItems, SHIPPING_ADDRESS))
            .expectEventCount(1)
            .expectEventType(OrderCreated::class.java)
            .expectStateAggregate {
                assertThat(it.aggregateId.tenantId, equalTo(tenantId))
            }
            .expectState {
                assertThat(it.id, notNullValue())
                assertThat(it.customerId, equalTo(customerId))
                assertThat(it.address, equalTo(SHIPPING_ADDRESS))
                assertThat(it.items, equalTo(orderItems))
                assertThat(it.status, equalTo(OrderStatus.CREATED))
            }
            .verify()
    }

    /**
     * 创建订单
     */
    @Test
    fun createOrder() {
        mockCreateOrder()
    }

    /**
     * 创建订单-库存不足
     */
    @Test
    fun createOrderWhenInventoryShortage() {
        val customerId = GlobalIdGenerator.generateAsString()
        val orderItem = OrderItem(
            GlobalIdGenerator.generateAsString(),
            GlobalIdGenerator.generateAsString(),
            BigDecimal.valueOf(10),
            10
        )
        val orderItems = listOf(orderItem)
        val inventoryService = object : InventoryService {
            override fun getInventory(productId: String): Mono<Int> {
                return orderItems.toFlux().filter { it.productId == productId }
                    /*
                     * 模拟库存不足
                     */
                    .map { it.quantity - 1 }.last()
            }
        }
        val pricingService = object : PricingService {
            override fun getProductPrice(productId: String): Mono<BigDecimal> {
                return orderItems.toFlux().filter { it.productId == productId }.map { it.price }.last()
            }
        }

        aggregateVerifier<Order, OrderState>()
            .inject(DefaultCreateOrderSpec(inventoryService, pricingService))
            .given()
            .`when`(CreateOrder(customerId, orderItems, SHIPPING_ADDRESS))
            /*
             * 期望：库存不足异常.
             */
            .expectErrorType(InventoryShortageException::class.java)
            .expectStateAggregate {
                /*
                 * 该聚合对象处于未初始化状态，即该聚合未创建成功.
                 */
                assertThat(it.initialized, equalTo(false))
            }.verify()
    }

    /**
     * 创建订单-下单价格与当前价格不一致
     */
    @Test
    fun createOrderWhenPriceInconsistency() {
        val customerId = GlobalIdGenerator.generateAsString()
        val orderItem = OrderItem(
            GlobalIdGenerator.generateAsString(),
            GlobalIdGenerator.generateAsString(),
            BigDecimal.valueOf(10),
            10
        )
        val orderItems = listOf(orderItem)
        val inventoryService = object : InventoryService {
            override fun getInventory(productId: String): Mono<Int> {
                return orderItems.toFlux().filter { it.productId == productId }.map { it.quantity }.last()
            }
        }
        val pricingService = object : PricingService {
            override fun getProductPrice(productId: String): Mono<BigDecimal> {
                return orderItems.toFlux().filter { it.productId == productId }
                    /*
                     * 模拟下单价格、商品定价不一致
                     */
                    .map { it.price.plus(BigDecimal.valueOf(1)) }.last()
            }
        }
        aggregateVerifier<Order, OrderState>()
            .inject(DefaultCreateOrderSpec(inventoryService, pricingService))
            .given()
            .`when`(CreateOrder(customerId, orderItems, SHIPPING_ADDRESS))
            /*
             * 期望：价格不一致异常.
             */
            .expectErrorType(PriceInconsistencyException::class.java).verify()
    }

    private fun mockPayOrder(): VerifiedStage<OrderState> {
        val verifiedStageAfterCreateOrder = mockCreateOrder()
        val previousState = verifiedStageAfterCreateOrder.stateRoot
        val payOrder = PayOrder(
            previousState.id,
            GlobalIdGenerator.generateAsString(),
            previousState.totalAmount
        )

        return verifiedStageAfterCreateOrder
            .then()
            .given()
            /*
             * 2. 当接收到命令
             */
            .`when`(payOrder)
            /*
             * 3.1 期望将会产生1个事件
             */
            .expectEventCount(1)
            /*
             * 3.2 期望将会产生一个 OrderPaid 事件 (3.1 可以不需要)
             */
            .expectEventType(OrderPaid::class.java)
            /*
             * 3.3 期望产生的事件状态
             */
            .expectEventBody<OrderPaid> {
                assertThat(it.amount, equalTo(payOrder.amount))
            }
            /*
             * 4. 期望当前聚合状态
             */
            .expectState {
                assertThat(it.address, equalTo(SHIPPING_ADDRESS))
                assertThat(it.paidAmount, equalTo(payOrder.amount))
                assertThat(it.status, equalTo(OrderStatus.PAID))
            }
            /*
             * 完成测试编排后，验证期望.
             */
            .verify()
    }

    /**
     * 支付订单
     */
    @Test
    fun payOrder() {
        mockPayOrder()
    }

    /**
     * 支付订单-超付
     */
    @Test
    fun payOrderWhenOverPay() {
        val verifiedStageAfterCreateOrder = mockCreateOrder()
        val previousState = verifiedStageAfterCreateOrder.stateRoot
        val payOrder = PayOrder(
            previousState.id,
            GlobalIdGenerator.generateAsString(),
            previousState.totalAmount.plus(
                BigDecimal.valueOf(1)
            )
        )
        verifiedStageAfterCreateOrder
            .then()
            .given()
            /*
             * 2. 处理 PayOrder 命令
             */
            .`when`(payOrder)
            /*
             * 3.1 期望将会产生俩个事件分别是： OrderPaid、OrderOverPaid
             */
            .expectEventType(OrderPaid::class.java, OrderOverPaid::class.java)
            /*
             * 3.2 期望产生的事件状态
             */
            .expectEventStream {
                val itr = it.iterator()
                /*
                 * OrderPaid
                 */
                val orderPaid = itr.next().body as OrderPaid
                assertThat(orderPaid.paid, equalTo(true))
                /*
                 * OrderOverPaid
                 */
                val orderOverPaid = itr.next().body as OrderOverPaid
                assertThat(
                    orderOverPaid.overPay,
                    equalTo(payOrder.amount.minus(previousState.totalAmount))
                )
            }
            /*
             * 4. 期望当前聚合状态
             */
            .expectState {
                assertThat(it.paidAmount, equalTo(previousState.totalAmount))
                assertThat(it.status, equalTo(OrderStatus.PAID))
            }
            .verify()
    }

    /**
     * 发货
     */
    @Test
    fun ship() {
        val verifiedStageAfterPayOrder = mockPayOrder()
        val shipOrder = ShipOrder(verifiedStageAfterPayOrder.stateRoot.id)
        verifiedStageAfterPayOrder
            .then().given()
            .`when`(shipOrder)
            .expectEventType(OrderShipped::class.java)
            /*
             * 4. 期望当前聚合状态
             */
            .expectState {
                assertThat(it.status, equalTo(OrderStatus.SHIPPED))
            }
            .verify()
    }

    @Test
    fun shipGivenUnpaid() {
        val verifiedStageAfterCreateOrder = mockCreateOrder()
        val shipOrder = ShipOrder(verifiedStageAfterCreateOrder.stateRoot.id)
        verifiedStageAfterCreateOrder.then().given()
            .`when`(shipOrder)
            .expectErrorType(IllegalStateException::class.java)
            .expectState {
                /*
                 * 验证聚合状态[未]发生变更.
                 */
                assertThat(it.paidAmount, equalTo(BigDecimal.ZERO))
                assertThat(it.status, equalTo(OrderStatus.CREATED))
            }
            .verify()
    }

    private fun mockDeleteOrder(): VerifiedStage<OrderState> {
        val verifiedStageAfterCreateOrder = mockCreateOrder()
        return verifiedStageAfterCreateOrder.then().given()
            .`when`(DeleteAggregate)
            .expectEventType(AggregateDeleted::class.java)
            .expectStateAggregate {
                assertThat(it.deleted, equalTo(true))
            }
            .verify()
    }

    @Test
    fun deleteOrder() {
        mockDeleteOrder()
    }

    @Test
    fun deleteGivenDeleted() {
        val verifiedStageAfterDelete = mockDeleteOrder()
        verifiedStageAfterDelete.then().given()
            .`when`(DeleteAggregate)
            .expectErrorType(IllegalAccessDeletedAggregateException::class.java)
            .expectError<IllegalAccessDeletedAggregateException> {
                assertThat(it.aggregateId, equalTo(verifiedStageAfterDelete.stateAggregate.aggregateId))
            }.expectStateAggregate {
                assertThat(it.deleted, equalTo(true))
            }
            .verify()
    }
}

Design

Modeling

Single Class	Inheritance Pattern	Aggregation Pattern

Load Aggregate

Aggregate State Flow

Send Command

Command And Event Flow

Saga - OrderProcessManager (Demo)