SPI动态注入

为了实现SPI（Service Provider Interface）注入，你需要遵循以下步骤：

创建一个接口，定义你的拦截器（Interceptor）接口：

public interface Interceptor {
    Object intercept(Invocation invocation);
    ProtocolAdaptor proxyProtocol(ProtocolAdaptor protocolAdaptor);
    int sort();
}

创建一个自定义注解 @Intercept，用于标记拦截器实现类：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Intercept {
}

创建一个类 MessageProxy，用于管理和调用拦截器：

public class MessageProxy {
    private final List<Interceptor> interceptors = DynamicLoader.findAll(Interceptor.class)
            .sorted(Comparator.comparing(Interceptor::sort))
            .collect(Collectors.toList());

    public ProtocolAdaptor proxy(ProtocolAdaptor protocolAdaptor) {
        for (Interceptor interceptor : interceptors) {
            protocolAdaptor = interceptor.proxyProtocol(protocolAdaptor);
        }
        return protocolAdaptor;
    }
}

创建一个类 InterceptorHandler，用于处理拦截逻辑：

public class InterceptorHandler implements InvocationHandler {

    private final Interceptor interceptor;

    private final Object target;

    public InterceptorHandler(Interceptor interceptor, Object target) {
        this.interceptor = interceptor;
        this.target = target;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        Intercept intercept = method.getAnnotation(Intercept.class);
        if (intercept == null) {
            return method.invoke(proxy, args);
        } else {
            return interceptor.intercept(new Invocation(method, target, args));
        }
    }
}

在你的拦截器实现类中，添加 @Intercept 注解，并实现 Interceptor 接口：

@Intercept
public class YourInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) {
        // 实现拦截逻辑
    }

    @Override
    public ProtocolAdaptor proxyProtocol(ProtocolAdaptor protocolAdaptor) {
        return (ProtocolAdaptor) Proxy.newProxyInstance(protocolAdaptor.getClass().getClassLoader(), new Class[]{ProtocolAdaptor.class}, new InterceptorHandler(this, protocolAdaptor));
    }

    @Override
    public int sort() {
        return 0; // 返回排序值
    }
}

确保在你的项目中有一个SPI配置文件 META-INF/services/com.yourpackage.Interceptor，其中包含你的拦截器实现类的全限定名。
通过以上步骤，你可以实现SPI注入，动态地加载和调用拦截器。

勘误：
如果你已经使用了自定义的 @Intercept 注解来标记拦截器实现类，并且在 MessageProxy 类中使用了动态加载机制来获取所有实现了 Interceptor 接口的类，那么你可以不再需要使用 META-INF/services/com.yourpackage.Interceptor 文件来配置SPI。

使用 @Intercept 注解并结合动态加载机制，可以更加灵活地管理和调用拦截器，而不需要依赖于SPI配置文件。这种方式可以让你在代码中直接指定哪些类是拦截器，而不需要在单独的配置文件中列出。

因此，如果你已经使用了 @Intercept 注解和动态加载机制来管理拦截器，那么你可以不再需要 META-INF/services/com.yourpackage.Interceptor 文件。