public interface Outboxable {

    /**
     * DDD聚合Id，The id of the aggregate affected by a given event. This is also used to ensure strict
     * ordering of events belonging to one and the same aggregate.
     */
    String getAggregateId();

    /**
     * The type of the aggregate affected by a given event. This needs to be the same type string for all
     * related parts of one an the same aggregate that might get changed.
     */
    String getAggregateType();

    /**
     * The actual event payload as String e.g. JSON serialization.
     */
    String getPayload();

    /**
     * The (sub)type of an actual event which causes any changes to a specific aggregate type.
     */
    String getType();

    /**
     * The application timestamp at which the event has happened.
     */
    Long getTimestamp();
}

@Entity
public class OutboxEvent {

    @Id
    @GeneratedValue
    @Type(type = "uuid-char")
    private UUID id;

    @NotNull
    private String aggregateType;

    @NotNull
    private String aggregateId;

    @NotNull
    private String type;

    @NotNull
    private Long timestamp;

    @NotNull
    @Column(length = 1048576) //e.g. 1 MB max
    private String payload;

    private OutboxEvent() {
    }

    //...
}

@Component
public class OutboxListener {

    private OutboxEventRepository repository;

    public OutboxListener(OutboxEventRepository repository) {
        this.repository = repository;
    }

    @EventListener
    public void onExportedEvent(Outboxable event) {

        OutboxEvent outboxEvent = OutboxEvent.from(event);

        // The outbox event will be written to the "outbox" table
        // and immediately afterwards removed again. Thus the
        // "outbox" table is effectively empty all the time. From a
        // CDC perspective this will produce an INSERT operation
        // followed by a DELETE operation of the same record such that
        // both events are captured from the database log by Debezium.
        repository.save(outboxEvent);
        repository.delete(outboxEvent);

    }

}

@Entity
public class PurchaseOrder {

    //...

    @DomainEvents
    private Collection<Outboxable> triggerOutboxEvents() {
        return Arrays.asList(OrderUpsertedEvent.of(this));
    }

    //...

}

public class OrderUpsertedEvent implements Outboxable {

    private static ObjectMapper MAPPER = new ObjectMapper();

    private final Long id;
    private final JsonNode payload;
    private final Long timestamp;

    static {
        MAPPER.registerModule(new JavaTimeModule());
    }

    private OrderUpsertedEvent(Long id, JsonNode payload) {
        this.id = id;
        this.payload = payload;
        this.timestamp = Instant.now().getEpochSecond();
    }

    public static OrderUpsertedEvent of(PurchaseOrder order) {
        return new OrderUpsertedEvent(order.getId(), MAPPER.valueToTree(order));
    }

    @Override
    public String getAggregateId() {
        return String.valueOf(id);
    }

    @Override
    public String getAggregateType() {
        return PurchaseOrder.class.getName();
    }

    @Override
    public String getType() {
        return this.getClass().getName();
    }

    @Override
    public Long getTimestamp() {
        return timestamp;
    }

    @Override
    public String getPayload() {
        try {
            return MAPPER.writeValueAsString(payload);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }

}

@Service
public class OrderService {

  //...

  @Transactional
  public PurchaseOrder placeOrder(PurchaseOrder order) {
    repository.save(order); //NOTE: OrderUpsertedEvent automatically published behind the scenes
    return order;
  }

  //...

}

@Service
public class OrderService {

    //... 

    @Transactional
    public PurchaseOrder updateOrderLineStatus(long orderId, long orderLineId, OrderLineStatus newStatus) {
        PurchaseOrder po = repository.findById(orderId)
                .orElseThrow(() -> new EntityNotFoundException("order with id " + orderId + " doesn't exist!"));
        OrderLineStatus oldStatus = po.updateOrderLine(orderLineId, newStatus);
        eventBus.publishEvent(OrderLineUpdatedEvent.of(orderId, orderLineId, newStatus, oldStatus));
        repository.save(po);
        return po;
    }

    //...

}

{
  “ name ”： “ mysql-outbox-src-connector-01 ”，
  “ config ”：{
    “ connector.class ”： “ io.debezium.connector.mysql.MySqlConnector ”，
    “ tasks.max ”： “ 1 ”，
    “ database.hostname ”： “ localhost ”，
    “ database.port ”： “ 3306 ”，
    “ database.user ”： “ debezium ”，
    “ database.password ”： “ dbz ”，
    “ database.server.id ”： “ 12345 ”，
    “ database.server.name ”： “ dbserver1 ”，
    “ database.whitelist ”： “ outbox-demo ”，
    “ database.serverTimezone ”： “歐洲/維也納”，
    “ table.whitelist ”： “ outbox-demo.outbox_event ”，
    “ database.history.kafka.bootstrap.servers ”： “ localhost：9092 ”，
    “ database.history.kafka.topic ”： “ schema-changes.outbox-demo ”，
    “ tombstones.on.delete ”： “ false ”
  }
}

bin/kafka-avro-console-consumer --bootstrap-server localhost:9092 --topic dbserver1.outbox-demo.outbox_event --from-beginning | jq

{
  “ name ”： “ mdb-sink-outbox-raw ”，
  “ config ”：{
    “ key.converter ”： “ io.confluent.connect.avro.AvroConverter ”，
    “ key.converter.schema.registry.url ”： “ http：// localhost：8081 ”，
    “ value.converter ”： “ io.confluent.connect.avro.AvroConverter ”，
    “ value.converter.schema.registry.url ”： “ http：// localhost：8081 ”，
    “ connector.class ”： “ at.grahsl.kafka.connect.mongodb.MongoDbSinkConnector ”，
    “ topics ”： “ dbserver1.outbox-demo.outbox_event ”，
    “ mongodb.connection.uri ”： “ mongodb：// localhost：27017 / outboxed ”，
    “ mongodb.collections ”： “發件箱，原料”，
    “ mongodb.collection.dbserver1.outbox-demo.outbox_event ”： “ outbox -raw ”，
    “ mongodb.change.data.capture.handler.outbox-raw ”： “ at.grahsl.kafka.connect.mongodb.cdc.debezium.rdbms.RdbmsHandler ”，
    “ mongodb.change.data.capture.handler.operations.outbox-raw ”： “ c ”
  }
}