Euonia Java 框架

// 五种策略，一种门面
var id1 = ObjectId.snowflake();                 // Snowflake 64-bit → long
var id2 = ObjectId.guid();                      // UUID (标准)
var id3 = ObjectId.guid(GuidType.SEQUENTIAL_AS_STRING); // .NET 兼容顺序 GUID
var id4 = ObjectId.random();                    // 随机字符串
var id5 = ObjectId.ulid();                      // 字典序可排序 ULID

// 类型安全取值
Long val = id1.getValue(Long.class);            // Long↔Integer 自动拆箱

var pool = DefaultObjectPoolProvider.getInstance().create(policy, 10);
var obj = pool.acquire();
// ... 使用 ...
pool.release(obj);
// 超限行为: THROW_EXCEPTION / RETURN_NULL / CREATE_NEW / WAIT_FOR_AVAILABLE

var pair = Duet.of("key", 42);                  // Duet<String, Integer>
var t3   = Trio.of("a", 1, true);               // Trio<String, Integer, Boolean>

@Required(message = "名称不能为空")
private String name;

@StringLength(min = 6, max = 20)
private String password;

@Range(min = 0, max = 150, inclusiveMax = true)
private int age;

@RegularExpression(value = "^[\\w.-]+@[\\w.-]+\\.[a-z]{2,}$")
private String email;

public interface ServiceProvider {
    <T> Optional<T> getService(Class<T> type);
    <T> T getRequiredService(Class<T> type);
    <T> T createInstance(Class<T> type, Object... args);
}
// 内置: SimpleServiceProvider (Map注册) / DelegateServiceProvider (委托)
// Spring: ApplicationContextServiceProvider (ApplicationContext 桥接)

// 声明属性（自动注册到 FieldDataManager）
@DisplayName("用户姓名")
@Required(message = "姓名不能为空")
private final PropertyInfo<String> name = registerProperty(String.class, "name");

// 类型安全的属性访问
public String getName() { return getProperty(this.name); }
public void setName(String value) { setProperty(this.name, value); }  // 追踪变更

// 标记为"已加载"（从持久层恢复时使用，不视为变更）
public void loadName(String value) { loadProperty(this.name, value); }

// 聚合根 — 内置领域事件管理
public class Order extends AggregateBase<Long> {
    public Order(Long id) {
        setId(id);
        // 注册事件处理器
        registerEvent(OrderCreatedEvent.class, e -> this.status = OrderStatus.CREATED);
    }

    public void create(Customer customer, Money total) {
        this.total = total;
        // 触发事件（自动存储到事件列表）
        raiseEvent(new OrderCreatedEvent(getId(), total));
    }
}

// 命令 — 通过消息总线的 Unicast 分发
public class CreateOrderCommand extends CommandBase {
    // HashMap-based 属性存储
}

// 用例 — 响应式结果通知
var presenter = new UseCasePresenter<OrderResult>();
presenter.subscribe(
    result -> log.info("成功: {}", result),
    error  -> log.error("失败", error)
);

public class Money extends ValueObject<Money> {
    private final BigDecimal amount;
    private final String currency;
    // equals/hashCode/compareTo 自动基于所有字段
}

// 编程式
try (var uow = manager.begin(new UnitOfWorkOptions(true), false)) {
    uow.addContext("db", jdbcContext);
    uow.addContext("mq", kafkaContext);

    uow.addCompletedListener(e -> log.info("UoW {} 完成", e.getUnitOfWork().getId()));
    uow.addFailedListener(e -> log.error("UoW 失败", e.getException()));

    // ... 业务逻辑 ...

    await uow.completeAsync();  // saveChanges → commit → fire completed
}

// 声明式 (Spring AOP)
@Service
public class OrderService {
    @UnitOfWork(isTransactional = true, isolationLevel = READ_COMMITTED)
    public Order createOrder(CreateOrderCommand cmd) { ... }
}

Request → [Behavior 1] → [Behavior 2] → [Terminal] → Response
              ↑              ↑               ↑
          可以短路      可以转换响应       最终处理器

// 即发即忘
Pipeline<Object, Void> pipe = new DefaultPipelineProvider<>(resolver)
    .use(LoggingBehavior.class)
    .use((ctx, next) -> next.invoke(ctx).thenRun(() -> log.info("Done")));
pipe.runAsync("Hello").join();

// 类型化请求/响应
Pipeline<Integer, Integer> pipe = new DefaultPipelineProvider<>(resolver);
pipe.use(PlusOneBehavior.class);
int result = pipe.runAsync(2, x -> CompletableFuture.completedFuture(x * 2)).join();
// result == 5 (2*2 + 1)

// 路径A: @Subscribe 注解
public class OrderHandler {
    @Subscribe(channel = "orders", group = "processor")
    public void handle(CreateOrderCommand cmd, MessageContext ctx) { ... }
}

// 路径B: Handler<M,R> 接口
public class OrderHandler implements Handler<CreateOrderCommand, Void> {
    @Override
    public Void handle(CreateOrderCommand cmd, MessageContext ctx) { ... }
}

// IdempotentHandler 装饰器 — 基于 InboxStore 防重复
// InboxPipelineBehavior — 处理后自动更新收件箱状态
handlerContext.register(messageType, IdempotentHandler.wrap(handler, inboxStore));

// 零配置使用
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    // 所有 Euonia 组件自动配置完成
}

// 值对象
public class Money extends ValueObject<Money> { ... }
public class OrderLine extends ValueObject<OrderLine> { ... }

// 聚合根
public class Order extends AggregateBase<Long> {
    private Money total;
    private List<OrderLine> lines;

    public Order(Long id) {
        setId(id);
        registerEvent(OrderCreatedEvent.class, e -> this.status = OrderStatus.CREATED);
    }
}

@Unicast
@Channel("orders")
public class CreateOrderCommand extends CommandBase {
    // HashMap properties: customerId, lines, total
}

public class CreateOrderHandler implements Handler<CreateOrderCommand, Void> {
    @Override
    public Void handle(CreateOrderCommand cmd, MessageContext ctx) {
        var order = new Order(ObjectId.snowflake().getValue(Long.class));
        order.create(cmd.getCustomerId(), cmd.getLines(), cmd.getTotal());
        repository.save(order);
        // 发布领域事件
        order.getEvents().forEach(event -> bus.publishAsync(event));
        ctx.response(order.getId());
        return null;
    }
}

// 流式 API
bus.send(new CreateOrderCommand(...))
    .toChannel("orders")
    .executeAsync()
    .join();

// 或异步订阅响应
bus.send(new CreateOrderCommand(...))
    .pipeTo(response -> log.info("订单ID: {}", response))
    .executeAsync();

@UnitOfWork(isTransactional = true)
public void handle(CreateOrderCommand cmd, MessageContext ctx) {
    // 方法内的所有持久化操作在同一个事务中
}

var resolver = new SimpleServiceProvider();
Pipeline<Object, Void> pipeline = new DefaultPipelineProvider<>(resolver)
    .use((ctx, next) -> {
        System.out.println("Before: " + ctx);
        return next.invoke(ctx).thenRun(() -> System.out.println("After: " + ctx));
    });
pipeline.runAsync("Hello, Pipeline!").toCompletableFuture().join();

// 配置
var configurator = new DefaultConfigurator();
configurator.setConvention(b -> b.add(new DefaultMessageConvention()));
configurator.registerHandlers(OrderHandler.class);

// 创建传输
var transport = new InMemoryTransport(handlerContext);
var provider = new SimpleServiceProvider();
provider.register(Transport.class, transport);

// 发送
var bus = new MessageBus(provider, dispatcher, options);
bus.send(new CreateOrderCommand(...)).executeAsync().join();

@SpringBootApplication  // 自动配置所有 Euonia 组件
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class OrderService {
    @Autowired private Bus bus;
    @Autowired private PipelineFactory pipelineFactory;

    public void createOrder(CreateOrderCommand cmd) {
        bus.send(cmd).executeAsync();
    }
}