这是注释处理的好模式吗？

Question

我有一个相当标准的 Spring Web 应用程序，并且有许多自定义注释，我想用它们来表示应用于给定 Web 服务方法的要求和约束。例如，我可以将 @RequiresLogin 注释应用于任何需要有效用户会话的方法，并且 @RequiresParameters(paramNames = {"name", "email"})需要设置“姓名”和“电子邮件”的方法，等等。

为了支持这一点，我实现了一个临时实用程序，用于在运行时验证方法的带注释约束，它基本上遵循以下模式：

Map<Class<? extends Annotation>, Annotation> annotations = mergeConstraintsFromClassAndMethod(serviceClass, serviceMethod);
if (annotations.containsKey(AnnotationType1.class)) {
    AnnotationType1 annotation = (AnnotationType1)annotations.get(AnnotationType1.class);
    //do validation appropriate to 'AnnotationType1'
}
if (annotations.containsKey(AnnotationType2.class)) {
    AnnotationType2 annotation = (AnnotationType2)annotations.get(AnnotationType2.class);
    //do validation appropriate to 'AnnotationType2'
}
//...

这工作正常，但由于我添加了额外的注释而变得有点笨拙。我想用更易于维护的东西替换它。理想情况下，我希望能够做到：

List<ValidatableAnnotation> annotations = mergeConstraintsFromClassAndMethod(serviceClass, serviceMethod);
for (ValidatableAnnotation annotation : annotations) {
    annotation.validate(request);
}

但我很确定这是不可能的，因为注释本身不能包含可执行代码，并且编译器不会让我扩展 java.lang.annotation.Annotation （并不是说我知道如何允许可执行代码包含在注释中，即使编译器让我尝试）。

然而，注释可以包含嵌套内部类，并且该内部类可以执行普通 Java 类可以执行的任何操作。因此，我基于此得出的结论是，为了使我的验证代码与正在验证的注释尽可能紧密相关，我想到的是：

public interface AnnotationProcessor {
    public boolean processRequest(Annotation theAnnotation, HttpServletRequest request);
}

然后可以像这样实现注释：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RequiresLogin {

    public static class Processor implements AnnotationProcessor {

        @Override
        public boolean processRequest(Annotation theAnnotation, HttpServletRequest request) {
            if (! (theAnnotation instanceof RequiresLogin)) {
                //someone made an invalid call, just return true
                return true;
            }
            return request.getSession().getAttribute(Constants.SESSION_USER_KEY) != null;
        }
    }
}

这使验证逻辑保持良好且紧密耦合与正在验证的注释。然后，我所有的临时验证代码都可以替换为：

List<Annotation> annotations = mergeConstraintsFromClassAndMethod(serviceClass, serviceMethod);
for (Annotation annotation : annotations) {
    processAnnotation(annotation, request);
}


private static boolean processAnnotation(Annotation annotation, HttpServletRequest request) {
    AnnotationProcessor processor = null;
    for (Class<?> processorClass : annotation.annotationType().getDeclaredClasses()) {
        if (AnnotationProcessor.class.isAssignableFrom(processorClass)) {
            try {
                processor = (AnnotationProcessor)processorClass.newInstance();
                break;
            }
            catch (Exception ignored) {
                //couldn't create it, but maybe there is another inner 
                //class that also implements the required interface that 
                //we can construct, so keep going
            }
        }
    }
    if (processor != null) {
        return processor.processRequest(annotation, request);
    }

    //couldn't get a a processor and thus can't process the 
    //annotation, perhaps this annotation does not support
    //validation, return true
    return true;
}

这样就不再需要在每次添加新注释类型时修改临时代码了。我只是将验证器实现为注释的一部分，然后就完成了。

这看起来是一个合理的使用模式吗？如果没有，那么什么可能会更好呢？

Answer 1

您可能想研究 AOP。您可以建议公开某些注释并相应地执行前/后处理的方法。

Answer 2

我想补充一点，虽然 AOP 是一个很好的解决方案，但 Spring 框架已经通过 @Secured 注释提供了此功能。

@Secured("ROLE_USER")
public void foo() {

}

Spring 还支持使用 @Valid 注释的 JSR-303 验证。因此，至少对于这些用例，您似乎正在重新发明轮子。

Answer 3

恕我直言，人们可以考虑将访客模式与工厂结合起来。工厂将返回一个包装器对象，该对象知道确切的注释类型以及访问者将能够...

class MyVisitor {
    public void visit(VisitableAnnotationType1 at) {
        //something AnnotationType1 specific
    }
    public void visit(VisitableAnnotationType2 at) {
        //something AnnotationType2 specific
    }
    ... // put methods for further annotation types here
}

class VisitableFactory {
    public abstract class VisitableAnnotation {
        public abstract void accept(MyVisitor visitor);
    }

    class VisitableAnnotationType1 implements VisitableAnnotation {
        public void accept(MyVisitor visitor) {
            visitor.visit(this);
        }
    }

    public static VisitableAnnotation getVisitable(Annotation a) {
        if(AnnotationType1.class.isAssignableFrom(a.getClass()) {
            //explicitely cast to the respective AnnotationType
            return new VisitableAnnotationType1((AnnotationType1)a);
        } else if (AnnotationType2.class.isAssignableFrom(a.getClass()) {
            //explicitely cast to the respective AnnotationType
            return new VisitableAnnotationType1((AnnotationType1)a);
        }
    }
}

由于我们无法扩展注释，因此我们需要工厂中的这些包装器类。您还可以传递原始注释，然后将其包含在该包装类中。

您需要做什么：对于每个新的 AnnotationType，向工厂添加一个新的“包装器”类，

getVisitable()

相应地扩展工厂的方法，并向访问者添加相应的方法：

public void doSomething(VisitableAnnotationTypeXYZ at) {
    //something AnnotationTypeXYZ specific
}

现在通用验证（或其他）代码如下所示

List<ValidatableAnnotation> annotations = mergeConstraintsFromClassAndMethod(serviceClass, serviceMethod);
MyVisitor visitor = new MyVisitor();
for (ValidatableAnnotation annotation : annotations) {
    VisitableFactory.getVisitable(annotation).accept(visitor);
}

：通过被访问对象以自身作为参数来间接调用访问者来工作，因此将调用正确的访问方法。
希望有帮助;-)
不过，代码尚未经过测试...