java - 在 Byte Buddy 中动态设置 @FieldProxy 字段

Question

我必须实现一个可用于动态指定字段的拦截器，无论字段名称如何。

关于此处答案的评论 https://stackoverflow.com/a/35113359/11390192我读过

you can really just use reflection on a @This object. As long as you cache the Field instances, this has no relevance to performance.

但是我怀疑以下拦截器实现是否有效(如果我理解正确的话)。

public static class DynamicFieldInterceptor {
    private final String fieldName;

    public DynamicFieldInterceptor(String fieldName) {
        this.fieldName = fieldName;
    }

    public void intercept(@This Object thiz) throws NoSuchFieldException, IllegalAccessException {
        Field field = thiz.getClass().getDeclaredField(fieldName);
        boolean oldAccessible = field.isAccessible();
        field.setAccessible(true);
        Long fieldValue = (Long)field.get(thiz);
        field.set(thiz, fieldValue + 1L);       // !< Instead of my business logic
        field.setAccessible(oldAccessible);
    }
}

我还尝试了以下想法:为每个字段生成拦截器类，并在 @FieldProxy 参数上使用不同的注释。然后使用生成的类作为目标类的拦截器。

public interface Metaclass {
    void intercept(GetterAndSetter field);
}

public static class MetaclassInterceptor implements Metaclass{
    @Override
    public void intercept(GetterAndSetter field) {
        field.set((Long)field.get() + 1L);
    }
}

public static Class<?> annotateInterceptorClass(final String annotation)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    return new ByteBuddy()
            .subclass(MetaclassInterceptor.class)
            .topLevelType()
            .name("ClassForIntercepting_" + annotation + "_Field")
            .modifiers(Visibility.PUBLIC, Ownership.STATIC)

            .defineMethod("intercept", void.class, Visibility.PUBLIC)
            .withParameter(GetterAndSetter.class, "intercept")
            .annotateParameter(AnnotationDescription.Builder.ofType(FieldProxy.class)
                    .define("value", annotation).build())

            .intercept(SuperMethodCall.INSTANCE)
            .make()
            .load(MetaclassInterceptor.class.getClassLoader())
            .getLoaded();
}

该类似乎生成得很好。生成的类中的方法存在，并且参数使用预期的注释进行注释。

但是，当我尝试使用生成的类作为拦截器时，出现了异常。

Class<?> klass = new ByteBuddy()
            .subclass(Object.class)

            .defineProperty("index0", Long.class, false)
            .defineProperty("index1", Long.class, false)

            .defineMethod("doSomeActions", void.class, Visibility.PUBLIC)
            .intercept(
                    MethodDelegation
                            .withDefaultConfiguration()
                            .withBinders(FieldProxy.Binder.install(GetterAndSetter.class))

                            // Use dynamically generated interceptor, see abode
                            .to(annotateInterceptor("index0"))
                    .andThen(
                            MethodDelegation
                                    .withDefaultConfiguration()
                                    .withBinders(FieldProxy.Binder.install(GetterAndSetter.class))

                                    // Use dynamically generated interceptor, see abode
                                    .to(annotateInterceptor("index1"))
                    )

            )
            .make()
            .load(MetaclassInterceptor.class.getClassLoader())
            .getLoaded();

Exception in thread "main" java.lang.NoClassDefFoundError: LClassForIntercepting_index0_Field;
    at java.base/java.lang.Class.getDeclaredFields0(Native Method)
    at java.base/java.lang.Class.privateGetDeclaredFields(Class.java:3062)
    at java.base/java.lang.Class.getDeclaredField(Class.java:2410)
    at net.bytebuddy.implementation.LoadedTypeInitializer$ForStaticField.onLoad(LoadedTypeInitializer.java:120)
    at net.bytebuddy.implementation.LoadedTypeInitializer$Compound.onLoad(LoadedTypeInitializer.java:187)
    at net.bytebuddy.dynamic.TypeResolutionStrategy$Passive.initialize(TypeResolutionStrategy.java:102)
    at net.bytebuddy.dynamic.DynamicType$Default$Unloaded.load(DynamicType.java:5662)
    at net.bytebuddy.dynamic.DynamicType$Default$Unloaded.load(DynamicType.java:5651)
    at MainClass4.main(MainClass4.java:107)

即使我成功地动态实现了拦截器，我也确信这不是完美的方法。我认为必须有可能以更简单的方式做到这一点。实际上，如果未指定注释中的字段名称，@FieldProxy 注解可以从显式指定的名称和 bean 属性中获取字段，因此我认为这是将其映射到任何其他字段的技术机会。

Answer 1

当您使用 load(MetaclassInterceptor.class.getClassLoader()) 加载类时，您正在创建一个新的类加载器，该类加载器不会对其他加载器上的任何其他类可见，除非您重用它。

你可以:

a) 合并由 make 步骤创建的两个 DynamicType 并将它们加载在一起。这样，它们最终将位于同一个类加载器中。

b) 获取第一个生成的类的类加载器并将其转换为 InjectionClassLoader。您还需要指定 ClassLoadingStrategy.WRAPPER.opened() 并将其与 InjectionClassLoader.Strategy.INSTANCE 一起使用。请注意，这将允许任何引用生成的类的实例的人在同一包中定义类。

c) 使用 ClassLoadingStrategy.Default.INJECTION 在原始类加载器中定义类，而不创建包装器。并不是说该策略依赖于 Unsafe API。