关于node.js:从Spring源码中学习如何查找自定义注解

看几个根底的注解

@AliasFor

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface AliasFor {@AliasFor("attribute")
    String value() default "";
 
    @AliasFor("value")
    String attribute() default "";
 
    Class<? extends Annotation> annotation() default Annotation.class;}

AliasFor 这个注解很奇怪，value 的别名是 attribute，attribute 的别名是 value

那么它的行为在哪里被定义的呢？在 AnnotationTypeMapping 中咱们能够找到答案

// 这里应用了 AnnotationsScanner 的 getDeclaredAnnotation 办法来获取所有的 AliasFor 注解的办法
// AnnotationsScanner 是 spring 中的非公开抽象类，在咱们的代码中不能间接进行应用
// Spring 中没有提供子类
private Map<Method, List<Method>> resolveAliasedForTargets() {Map<Method, List<Method>> aliasedBy = new HashMap<>();
    for (int i = 0; i < this.attributes.size(); i++) {Method attribute = this.attributes.get(i);
        AliasFor aliasFor = AnnotationsScanner.getDeclaredAnnotation(attribute, AliasFor.class);
        if (aliasFor != null) {Method target = resolveAliasTarget(attribute, aliasFor);
            aliasedBy.computeIfAbsent(target, key -> new ArrayList<>()).add(attribute);
        }
    }
    return Collections.unmodifiableMap(aliasedBy);
}
 
// 为了简洁，我将源代码中其余部分省略掉了，能够看到，这里应用用反射失去的 Method 的 getAnnotation 办法失去实例
private Method resolveAliasTarget(Method attribute, AliasFor aliasFor, boolean checkAliasPair) {
    // ... ...
    Method target = AttributeMethods.forAnnotationType(targetAnnotation).get(targetAttributeName);
    // ... ...
    if (isAliasPair(target) && checkAliasPair) {AliasFor targetAliasFor = target.getAnnotation(AliasFor.class);
        if (targetAliasFor != null) {Method mirror = resolveAliasTarget(target, targetAliasFor, false);
            if (!mirror.equals(attribute)) {
                throw new AnnotationConfigurationException(String.format(
                    "%s must be declared as an @AliasFor %s, not %s.",
                    StringUtils.capitalize(AttributeMethods.describe(target)),
                    AttributeMethods.describe(attribute), AttributeMethods.describe(mirror)));
            }
        }
    }
    return target;
}

通过学习 @AliasFor，咱们晓得了能够通过先流动 Method，再或得其润饰的注解的办法。

依据这样的办法，咱们能够应用上面的代码，找到类 DockingHandlers 中所有被注解 @DockIngMessage 润饰的办法

// DockIngMessage 是自定义的注解
Method[] methods = DockingHandlers.class.getMethods();
for (Method method : methods) {DockIngMessage dockIngMessage = method.getAnnotation(DockIngMessage.class);
    if (dockIngMessage != null) {System.out.println(dockIngMessage.name());
    }
}

@Bean

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {@AliasFor("name")
    String[] value() default {};
 
    @AliasFor("value")
    String[] name() default {};
    
    @Deprecated
    Autowire autowire() default Autowire.NO;
    
    boolean autowireCandidate() default true;
    String initMethod() default "";
    String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;}

@Bean 注解是 Spring 中用得比拟宽泛的注解之一，来看看 Spring 源码中是怎么查找 @Bean 注解的

public static boolean isBeanAnnotated(Method method) {return AnnotatedElementUtils.hasAnnotation(method, Bean.class);
}

应用了 AnnotatedElementUtils 工具类，那么咱们就能够把下面的代码革新一下

Method[] methods = DockingHandlers.class.getMethods();
for (Method method : methods) {if (AnnotatedElementUtils.hasAnnotation(method, DockIngMessage.class)) {DockIngMessage dockIngMessage = AnnotatedElementUtils.getMergedAnnotation(method,DockIngMessage.class);
        System.out.println(dockIngMessage.name());
    }
}
// 相比于判断 != null , 这样的写法绝对优雅了许多 

至于 Bean 到底是怎么失效的，咱们须要留到当前钻研 Spring 容器的时候再探讨

@Controller

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {@AliasFor(annotation = Component.class)
    String value() default "";}

在 Controller 的 test 外面有这么一段代码

@Test
public void testWithComponentAnnotationOnly() {ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
    provider.addIncludeFilter(new AnnotationTypeFilter(Component.class));
    provider.addExcludeFilter(new AnnotationTypeFilter(Repository.class));
    provider.addExcludeFilter(new AnnotationTypeFilter(Service.class));
    provider.addExcludeFilter(new AnnotationTypeFilter(Controller.class));
    Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE);
    assertThat(candidates.size()).isEqualTo(3);
    assertThat(containsBeanClass(candidates, NamedComponent.class)).isTrue();
    assertThat(containsBeanClass(candidates, ServiceInvocationCounter.class)).isTrue();
    assertThat(containsBeanClass(candidates, BarComponent.class)).isTrue();
    assertThat(containsBeanClass(candidates, FooServiceImpl.class)).isFalse();
    assertThat(containsBeanClass(candidates, StubFooDao.class)).isFalse();
    assertThat(containsBeanClass(candidates, NamedStubDao.class)).isFalse();}

也就是说，能够利用扫包的形式来获取某个包下被某个注解润饰的类。

总结

查找某注解润饰的所有类就应用 ClassPathScanningCandidateComponentProvider 进行扫描。

查找某注解润饰的办法，就先找到那个类，而后失去所有的办法，应用 AnnotatedElementUtils.hasAnnotation 判断办法是否被某注解润饰即可

上面是一个简略的例子

ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
provider.addIncludeFilter(new AnnotationTypeFilter(DockingAnnotation.class));
Set<BeanDefinition> candidates = provider.findCandidateComponents("package_name");
for (BeanDefinition definition : candidates){
    try {Class clz = Class.forName(definition.getBeanClassName());
        Method[] methods = clz.getMethods();
        for (Method method : methods){if (AnnotatedElementUtils.hasAnnotation(method,DockIngMessage.class)){DockIngMessage dockIngMessage = AnnotatedElementUtils.getMergedAnnotation(method,DockIngMessage.class);
                System.out.println(dockIngMessage.name());
            }
        }
    } catch (ClassNotFoundException e) {e.printStackTrace();
    }
}

炒鸡辣鸡原创文章，转载请注明起源