如何创建Java注解以注册被注解类的实例？

可行，但单纯的自定义注解本身无法直接完成这个需求——Java注解本质是元数据，不会主动触发任何逻辑，必须结合其他机制来监听实例创建事件，进而调用B类的注册方法。下面是几种常用的实现方案：

1. 构造器嵌入注册逻辑（最简单的手动方式） #

给被@MyAnnotation标记的类添加构造器，在构造器里主动调用B的注册方法。缺点是每个被注解类都需要修改构造器，灵活性一般。

// 先定义自定义注解（需要保留到运行时）
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyAnnotation {}

@MyAnnotation
class A {
    public A() {
        // 假设B是单例模式，方便全局调用
        B.getInstance().registeringMethod(this);
    }
}

// 将B改为单例
class B {
    private static final B INSTANCE = new B();
    private List<Object> registeredInstances = new ArrayList<>();
    
    public static B getInstance() {
        return INSTANCE;
    }
    
    public void registeringMethod(Object instance) {
        registeredInstances.add(instance);
    }
}

2. 反射+工厂模式（无需修改被注解类） #

写一个统一的实例工厂，所有被@MyAnnotation标记的类都通过该工厂创建实例，工厂在创建后自动执行注册逻辑。这种方式不需要修改被注解类的代码，但要求必须通过工厂创建实例，不能直接new。

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

@MyAnnotation
class A {}

class B {
    private List<Object> registeredInstances = new ArrayList<>();
    
    public void registeringMethod(Object instance) {
        registeredInstances.add(instance);
    }
}

// 实例工厂类
class InstanceFactory {
    private static final B B_INSTANCE = new B();
    
    @SuppressWarnings("unchecked")
    public static <T> T createInstance(Class<T> clazz) throws Exception {
        T instance = clazz.getDeclaredConstructor().newInstance();
        // 检查类是否被@MyAnnotation标记
        if (clazz.isAnnotationPresent(MyAnnotation.class)) {
            B_INSTANCE.registeringMethod(instance);
        }
        return instance;
    }
}

// 使用方式
// A a = new A(); // 不会触发注册
A a = InstanceFactory.createInstance(A.class); // 自动完成注册

3. 字节码增强（最接近“自动”的需求） #

使用ASM、CGLIB或ByteBuddy这类字节码操作库，在JVM加载被@MyAnnotation标记的类时，动态修改其构造器的字节码，自动插入注册逻辑。这种方式不需要修改被注解类，也不需要通过工厂创建实例，直接new就能触发注册，但需要额外引入字节码库。

以ByteBuddy为例的简化实现：

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

@MyAnnotation
class A {}

class B {
    private List<Object> registeredInstances = new ArrayList<>();
    
    public void registeringMethod(Object instance) {
        registeredInstances.add(instance);
    }
}

// 字节码增强拦截器
class ConstructorInterceptor {
    private static final B B_INSTANCE = new B();
    
    // 拦截构造器调用，执行注册逻辑
    public static void intercept(@This Object instance) {
        B_INSTANCE.registeringMethod(instance);
    }
}

// 程序启动时执行增强逻辑
public class Bootstrap {
    public static void main(String[] args) throws Exception {
        new ByteBuddy()
            .rebase(ElementMatchers.isAnnotatedWith(MyAnnotation.class))
            .constructor(ElementMatchers.any())
            .intercept(MethodDelegation.to(ConstructorInterceptor.class))
            .make()
            .load(MyAnnotation.class.getClassLoader(), ClassLoadingStrategy.Default.INJECTION);
        
        // 此时new A()会自动触发注册
        A a1 = new A();
        A a2 = new A();
    }
}

4. 依赖注入框架（如Spring） #

如果项目使用Spring这类依赖注入框架，可以利用其Bean生命周期钩子实现自动注册。通过BeanPostProcessor在Bean初始化完成后，检查是否带有@MyAnnotation，如果是则调用B的注册方法。

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.List;

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

@MyAnnotation
@Component
class A {}

@Component
class B {
    private List<Object> registeredInstances = new ArrayList<>();
    
    public void registeringMethod(Object instance) {
        registeredInstances.add(instance);
    }
}

// 自定义Bean后置处理器
@Component
class InstanceRegisterProcessor implements BeanPostProcessor {
    private final B b;
    
    // 构造器注入B的实例
    public InstanceRegisterProcessor(B b) {
        this.b = b;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 检查Bean是否带有@MyAnnotation
        if (bean.getClass().isAnnotationPresent(MyAnnotation.class)) {
            b.registeringMethod(bean);
        }
        return bean;
    }
}

内容的提问来源于stack exchange，提问作者Flo Flo