How to remove/replace existing annotations?

[initshdb]

Thank you for this wonderful library. However, I am stuck at one point. I am able to add annotations to a field/method, but not able to replace or remove existing annotation.

I have the following requirement, on a method,

@OneToOne (fetch = FetchType.LAZY) // I want to remove / replace annotation values 
public Employee getEmployee()

I would like to,

1. Remove the existing annotation @OneToOne (fetch = FetchType.LAZY)
2. Replace the existing annotation's values with @OneToOne (fetch = FetchType.EAGER)

I am using the bytebuddy maven plugin, using the DynamicType.Builder to visit the method to add new annotation using MemberAttributeExtension.ForMethod().annotateMethod(), but not sure how to remove or replace existing annotations.

I tried using MemberSubstitution, but did not get that to work for removing / replacing annotations

For your help I will be immensely grateful.

[raphw]

Thanks, glad you like it. Member removal is unfortunately not supported overly well. You'd need to register a AsmClassVisitorWrapper and override the visitAnnotation method to return null if such an annotation is discovered.

[initshdb]

With your suggestion and the below code, using AsmVisitorWrapper I am able to remove an existing annotation from a method, however, I also want to replace the removed annotation with a new annotation or just replace the value of the annotation from @OneToOne(fetch = "oldValue") to @OneToOne(fetch = "newValue") instead of removing the annotation completely.
How can I do that?

     // Registered a new AsmVisitorWrapper 
     builder.visit(new AsmVisitorWrapper.ForDeclaredMethods()
                        .method(ElementMatchers.nameStartsWith("getEmployee"),  // METHOD TO MATCH
                        new AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper() {

                            @Override
                            public MethodVisitor wrap(TypeDescription typeDescription, MethodDescription methodDescription, 
                                       MethodVisitor methodVisitor, Implementation.Context context,
                                       TypePool typePool, int i, int i1) {

                                return new MethodVisitor(OpenedClassReader.ASM_API, methodVisitor) {
                                    public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {

                                       // THE ANNOTATION TO MATCH
                                       if(Type.getDescriptor(OneToOne.class).equals(descriptor)) {
                                            return null; // REMOVES THE ANNOTATION
                                            // HOW CAN I REPLACE ANNOTATION VALUE ???
                                       }
                                       return super.visitAnnotation(descriptor, visible);
                                    }
                                };
                            }
                     }));

[raphw]

So, if you wanted to avoid the visitor, you can set AnnotationRetention.DISABLED in ByteBuddy and apply a Transformer in the method to change the method in question by replacing the entire method object.

Alternatively, you'd need to drop the first annotation of that type being visited. Byte Buddy always plays the preexisting annotations down the visitor chain first.

[initshdb]

I was able to replace the annotation value of the existing annotation on a method by using an AnnotationVisitor.
@OneToOne (fetch = FetchType.LAZY)
Replaced to
@OneToOne (fetch = FetchType.EAGER)

The below works, but is it the right way to do using an AnnotationVisitor? Is it the same as what you suggested? or how does it differ from using a transformer?

new AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper() {

           @Override
            public MethodVisitor wrap(TypeDescription typeDescription, MethodDescription methodDescription,
MethodVisitor methodVisitor, Implementation.Context context, TypePool typePool, int i, int i1) {
                         return new MethodVisitor(OpenedClassReader.ASM_API, methodVisitor) {
                            public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
                              // Match the annotation  
                              if (Type.getDescriptor(OneToOne.class).equals(descriptor)) {
                                    
                                    return new AnnotationVisitor(OpenedClassReader.ASM_API, visitor) {
                                        
                                        // In my case, it is an Enum Value I want to replace
                                        @Override
                                        public void visitEnum(String name, String descriptor, String value) {

                                            // If matches the annotation value to replace, the replace by visiting 
                                           //  and returning with a new value
                                            if("fetch".equals(name) && 
                                                          Type.getDescriptor(FetchType.class).equals(descriptor)) {
                                                super.visitEnum(name, descriptor, FetchType.EAGER.toString());
                                                return;
                                            }

                                            // Else return existing annotation
                                            super.visitEnum(name, descriptor, value);
                                        }
                                    };
                                }
                                return super.visitAnnotation(descriptor, visible);
                            }
                        };
                    }
               }));

[raphw]

Yes, absolutely. If your replacement is that simple, then using ASM is the best option!

[initshdb]

Thank you so much for your help.
Can you point or tell me how instead of ASM, could I use the Transformer? I'd like to try using the Transformer as well to remove/replace annotations.

[raphw]

The transformer can be added in the .method(...)....transform(...) and .field(...).transform(...) steps. The idea is to return an alternative representation of the method or field that you'd like Byte Buddy to materialize. This does however require you to set AnnotationRetention.DISABLED.

Byte Buddy should really offer a convenience DSL here to make these removals simple. I'll leave this ticket open as an enhancement for a future version.

[chaudharydeepak]

Hi, checking in to see if this feature is since available in bytebuddy? Basically i am trying to replace class level annotation - and I wrote custom AsmVisitorWrapper following notes above -

.transform((builder, typeDescription, classLoader, module) ->
                            {
                                return builder.visit(new AsmVisitorWrapper() {
                                    @Override
                                    public int mergeWriter(int flags) {
                                        return 0;
                                    }

                                    @Override
                                    public int mergeReader(int flags) {
                                        return 0;
                                    }

                                    @Override
                                    public ClassVisitor wrap(TypeDescription instrumentedType, ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags) {
                                        return new ClassVisitor(ASM4, classVisitor) {
                                            @Override
                                            public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
                                                if (descriptor.equals("Lio/cucumber/junit/CucumberOptions;")) {
                                                   return null;
                                                }
                                                return super.visitAnnotation(descriptor, visible);
                                            }
                                        };
                                    }
                                }).annotateType(
                                        AnnotationDescription.Builder.ofType(CucumberOptions.class)
                                                .defineArray("plugin", "org.deployd.agent.ListenerPlugin")
                                                .build());

I was expecting this would remove initial annotation at class level and then create new one - however this complains of duplicate annotation - possibly the initial annotation isn't getting removed. Secondly, I tried to change the annotation inside visitAnnotation method but could'nt find API to do so. any pointers are much appreciated. Thank you.

[raphw]

Try disabling annotation retention: https://github.com/raphw/byte-buddy/blob/master/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/attribute/AnnotationRetention.java#L34

Otherwise, Byte Buddy copies the original annotation to retain the definition of default values compared to explicitly set defaults.