Java 用ByteBuddy装饰一个方法

如何定义一个方法，然后用ByteBuddy（多次）修饰它？ 这是我的例子

Builder=newbytebuddy（）.subclass（Object.class）.name（“动态”）；
builder=builder.defineMethod（“方法”，void.class，Visibility.PUBLIC）
.intercept（MethodDelegation.to）（新对象（）{
@运行时类型
公共无效截获（@This Object o）{
System.out.println（“执行代码…”）；
}
}));
builder=builder.method（ElementMatchers.named（“method”））。
拦截（MethodDelegation.to）（新对象（）{
@运行时类型
公共无效截获（@This Object o）{
System.out.println（“执行其他代码…”）；
}
}));
试一试{
类cls=builder.make（）
.load（StructClassBuilder.class.getClassLoader（））
.getLoaded（）；
Object obj=cls.newInstance（）；
cls.getDeclaredMethod（“方法”）.invoke（obj，args）；
}捕获（异常e1）{
e1.printStackTrace（）；
}

输出是

正在执行其他代码

我希望输出是

正在执行代码

正在执行其他代码

---

谢谢

一个选项是使用MethodDelegation.to（…）.addThen（…）方法链接拦截器

公共类ByteBuddyTest{
公共静态void main（字符串[]args）引发异常{
DynamicType.Builder=newbyteBuddy（）.subclass（Object.class）.name（“Dynamic”）；
建筑商
.defineMethod（“方法”，void.class，Visibility.PUBLIC）
.intercept（MethodDelegation.to（Interceptor1.class.）和MethodDelegation.to（Interceptor2.class））；
试一试{
类clazz=builder.make（）.include（）.load（ByteBuddyTest.Class.getClassLoader（））.getLoaded（）；
Object obj=clazz.newInstance（）；
clazz.getDeclaredMethod（“方法”）.invoke（obj，args）；
}捕获（异常e1）{
e1.printStackTrace（）；
}
}
公共静态类拦截器1{
公共静态无效截获（）{
System.out.println（“执行代码…”）；
}
}
公共静态类拦截器2{
公共静态无效截获（）{
System.out.println（“执行其他代码…”）；
}
}
}

我将使用decorator模式来修饰拦截器，现在它按预期工作。 我分享我的解决方案：

专用静态接口拦截器{
公共无效截获（@This Object o）；
}
私有抽象静态类拦截器Decorator实现拦截器{
受保护拦截器；
公共拦截器拦截器（拦截器拦截器）{
this.interceptor=拦截器；
}
公共无效截获（@This Object o）{
if（拦截器！=null）{
拦截器。拦截器（o）；
}
}
}
私有静态类Interceptor1扩展了InterceptorDecorator{
公共拦截器1（拦截器拦截器）{
超级（拦截器）；
}
公共无效截获（@This Object o）{
超级拦截（o）；
System.out.println（“执行代码…”）；
}
}
私有静态类Interceptor2扩展了InterceptorDecorator{
公共拦截器2（拦截器拦截器）{
超级（拦截器）；
}
公共无效截获（@This Object o）{
超级拦截（o）；
System.out.println（“执行其他代码…”）；
}
}
公共静态void main（字符串[]args）{
拦截器拦截器=新拦截器1（空）；
拦截器=新拦截器2（拦截器）；
Builder=newbytebuddy（）.subclass（Object.class）.name（“动态”）；
builder=builder.defineMethod（“方法”，void.class，Visibility.PUBLIC）
.截取（方法委托给（截取者））；
试一试{
类cls=builder.make（）
.load（StructClassBuilder.class.getClassLoader（））
.getLoaded（）；
Object obj=cls.newInstance（）；
cls.getDeclaredMethod（“方法”）.invoke（obj，args）；
}捕获（异常e1）{
e1.printStackTrace（）；
}
}

我有一个约束，我不能多次子类化。我将使用decorator模式来装饰拦截器。谢谢，我明白了。我用一个替代方案更新了我的答案。

public class ByteBuddyTest {

  public static void main(String[] args) throws Exception {
    DynamicType.Builder<Object> builder = new ByteBuddy().subclass(Object.class).name("Dynamic");
    builder = builder
        .defineMethod("method", void.class, Visibility.PUBLIC)
        .intercept(MethodDelegation.to(Interceptor1.class).andThen(MethodDelegation.to(Interceptor2.class)));

    try {
        Class<?> clazz = builder.make().include().load(ByteBuddyTest.class.getClassLoader()).getLoaded();

        Object obj = clazz.newInstance();
        clazz.getDeclaredMethod("method").invoke(obj, args);
    } catch (Exception e1) {
        e1.printStackTrace();
    }
  }

  public static class Interceptor1 {

      public static void intercept() {
          System.out.println("Executing code...");
      }
  }

  public static class Interceptor2 {

      public static void intercept() {
          System.out.println("Executing other code...");
      }
  }
}