中台架构实现

目录

• 背景和价值
• 可扩展的模式有哪些？
  • 拦截器模式/AOP
  • 模板方法
  • 事件驱动/观察者模式
  • 策略模式
  • 接口回调
• 动态植入扩展点实现
  • SPI （推荐）
  • 方式二：Spring 类路径扫描
  • 配置驱动扩展
    • 规则引擎
    • 配置表
  • 注解驱动的钩子（AOP方式）
  • OSGI
  • Spring Plugin

背景和价值

从业务视角来看，中台架构要支持业务灵活扩展

1. 业务流程可编排。 使用企业级架构通用流程建模，领域模型设计等

2. 审批流可编排
   流程引擎
   而流程引擎实现了将多个业务参与者之间按照某种预定义的规则进行流转，通常需要涉及到角色信息。
   简单来说就是，流程引擎主要解决业务在不同角色之间的流转问题，如请假流程，审批流程，往往要经过多个角色。规则驱动角色流转。

3. 能力可扩展/定制 （微内核架构）
   在中台架构中，扩展点设计是一种在业务流程、系统功能等关键位置预留的可扩展接口或机制，旨在允许企业在不大规模修改现有系统架构的基础上，灵活地添加新功能、引入新业务逻辑或对接新的业务场景，以满足不断变化的业务需求。

可扩展的模式有哪些？

拦截器模式/AOP

是一种行为设计模式，允许在不修改原有对象的情况下，在其前后插入额外的逻辑。

模板方法

父类中定义一个算法的骨架，将一些步骤延迟到子类中实现

事件驱动/观察者模式

数据变更时触发事件

策略模式

策略模式是定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。比如计算折扣，不同的促销策略（如满减、打折、赠品）作为不同的策略类，客户端根据情况选择使用哪一个。这里强调的是算法的互换性，同一问题的不同解决方案可以动态切换。
模板方法 VS 策略模式
模板方法更侧重于流程的固定，而允许某些步骤变化。策略模式则是完全不同的算法之间的替换，每个策略都是独立的，可以在运行时改变。模板方法通常在一个继承体系中，子类必须遵循父类的结构，而策略模式可以通过组合或者接口来实现，不需要继承。

接口回调

在核心方法前后植入扩展逻辑.

拦截器 VS 接口回调
拦截器主要用于流程中的横切关注点，如日志、安全等；而回调则是为了处理特定的事件或结果。其次，结构不同：拦截器通常是链式的，按顺序执行；而回调可能更直接，一个事件触发一个回调函数的执行。再者，控制流不同：拦截器可以修改或终止流程，而回调更多是被动响应事件。

动态植入扩展点实现

SPI （推荐）

https://www.cnblogs.com/aibi1/p/18753155

方式二：Spring 类路径扫描

步骤：

1. 在 Spring Boot 中通过 @ComponentScan 扫描钩子实现类所在的包。
2. 将钩子实例注册为 Spring Bean：

@Configuration
@ComponentScan(basePackages = "com.example.hooks")
public class HookConfig {
    
    @Bean
    public List<OrderHook> orderHooks() {
        return Arrays.asList(
            new EnterpriseOrderValidationHook(),
            new RetailOrderDiscountHook()
        );
        // 或通过反射动态加载（推荐）
        // ClassPathScanningCandidateComponentProvider provider = ...;
        // return provider.findCandidateComponents("com.example.hooks").stream()
        //         .map(c -> (OrderHook) c.getBeanDefinition().getBeanClass().newInstance())
        //         .collect(Collectors.toList());
    }
}

4. 注册钩子到中台系统
将动态加载的钩子实例保存到中台系统的管理器中，供后续调用：

public class OrderService {
    private List<OrderHook> hooks;
    
    @Autowired
    public OrderService(List<OrderHook> hooks) {
        this.hooks = hooks;
    }
    
    public void createOrder(Order order) {
        // 执行所有钩子的 beforeCreateOrder 逻辑
        for (OrderHook hook : hooks) {
            hook.beforeCreateOrder(order);
        }
        
        // 核心订单创建逻辑...
        
        // 执行所有钩子的 afterPaymentSuccess 逻辑
        for (OrderHook hook : hooks) {
            hook.afterPaymentSuccess(order);
        }
    }
}

配置驱动扩展

规则引擎

规则引擎通常是嵌入在应用程序组件中的，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据业务规则做出业务决策。简单来说就是，规则引擎主要解决易变逻辑和业务耦合的问题，规则驱动逻辑。以前项目内写死在代码里的逻辑用规则引擎可以提出来，随时热变更。

https://www.cnblogs.com/aibi1/p/18736933

配置表

自己通过配置表维护 业务场景和 业务活动/任务/步骤的编排关系。

比如订单评审业务活动下的规则有：通用校验，额度占用，分货占用，推送履约系统。 这些规则组件是可编排的
自己实现
通过组合模式+策略模式实现
通用校验一个基类，一些扩展类。额度占用，分货占用，推送履约系统也是类似

注解驱动的钩子（AOP方式）

利用Spring AOP在方法前后插入钩子逻辑，适合无侵入式扩展。

// 定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Hook {
    String value(); // 钩子名称，如 "payment_before"
}

// 核心业务代码
@Service
public class PaymentService {
    @Hook("payment_before")
    public void processPayment(PaymentRequest request) {
        // 核心支付逻辑...
    }
}

// AOP切面实现钩子
@Aspect
@Component
public class HookAspect {
    @Around("@annotation(hook)")
    public Object around(ProceedingJoinPoint joinPoint, Hook hook) throws Throwable {
        // 执行前置钩子
        executeHook("payment_before", joinPoint.getArgs());
        
        Object result = joinPoint.proceed();
        
        // 执行后置钩子
        executeHook("payment_after", result);
        
        return result;
    }

    private void executeHook(String hookName, Object... args) {
        // 动态查找并执行所有注册的钩子实现
        List<HookHandler> handlers = HookHandlerRegistry.getHandlers(hookName);
        for (HookHandler handler : handlers) {
            handler.handle(args);
        }
    }
}

OSGI

Spring Plugin

利用Spring的@Conditional和动态Bean注册。