是否有一种“Spring 方式”从带注释的接口获取实现？

Question

我想废弃一些样板文件。假设我有一个带有自定义注释的自定义界面：

interface MyInterface {
    @DoSomething("crazy")
    public String aMethod(int numberOfJumps); 
}

现在我可以编写一个InvocationHandler, 并生成一个Proxy实现，该实现根据注释和方法参数执行或多或少有用的操作，并返回适当的结果。这很好用。

我的问题是我是否可以使用 Spring 的某种机制来获得相同的结果，但也许更安全、更快、更灵活和/或更可配置。Spring AOP 注释看起来很有前途，但它们似乎需要一个类，而不是一个接口。

[更新]

为了清楚地说明我想要什么，我当前代码的概要：

public interface TestInterface {
    @MyAnnotation(name = "foo")
    public void testMethod(String arg);
}

public class AnnotationProxy {
    @SuppressWarnings("unchecked")
    public static <T> T getImplementation(Class<T> annotatedInterface) {
       return (T) Proxy.newProxyInstance(annotatedInterface.getClassLoader(),
               new Class<?>[]{annotatedInterface},
               new AnnotationHandler());
    }

    private static class AnnotationHandler implements InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Args " + Arrays.toString(args));
            System.out.println("Annotations" + Arrays.toString(method.getAnnotations()));
            return "useful value";
        }
    }
}

TestInterface ti = getImplementation(TestInterface.class);
String s = ti.testMethod("xyz"); //"useful value"

正如你所看到的，我凭空创造了一个物体（以及一些丑陋的反射东西）。我想知道我是否可以用更文明、更春天的方式来做这件事。

Answer 1

一种方法是扫描具有您喜欢的注释的方法的接口，在 Spring 应用程序上下文中创建并注册代理。

例子

让我们有一个Test要为其创建和注册代理的接口：

package com.test;

public interface Test {
    @DoSomething(pattern = "[%s]")
    void print(String value);
}

我们的注释看起来像这样：

package com.test;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface DoSomething {

    String pattern();

}

我们想在这样的应用程序中使用它：

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.test.Test;

public class Main {
    public static void main(final String[] args) throws Exception {
        final ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("test.xml");
        final Test test = ctx.getBean(Test.class);
        test.print("Hello");
    }
}

我们的test.xml Spring 配置文件仅包含组件扫描：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <context:component-scan base-package="com.test"/>
</beans>

不着边际。为了创建和注册代理，我们必须实现BeanFactoryPostProcessor来扫描接口并创建代理：

package com.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
import org.springframework.stereotype.Component;

@Component
public class DoSomethingPostprocessor implements BeanFactoryPostProcessor, ApplicationContextAware {

    private ApplicationContext applicationContext;

    private Object createDoSomethingBean(final MethodMetadata mmd, final Map<String, Object> attributes)
            throws Exception {
        final String pattern = (String) attributes.get("pattern");
        final Class<?> clazz = Class.forName(mmd.getDeclaringClassName());
        return Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz },
                new InvocationHandler() {

                    @Override
                    public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
                        System.out.println(String.format(pattern, args[0]));

                        return null;
                    }
                });
    }

    @Override
    public void postProcessBeanFactory(final ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
            final String packageSearchPath = "classpath*:com/**/*.class";

            final Resource[] resources =
                    applicationContext.getResources(packageSearchPath);
            final SimpleMetadataReaderFactory factory = new
                    SimpleMetadataReaderFactory(applicationContext);

            for (final Resource resource : resources) {
                final MetadataReader mdReader = factory.getMetadataReader(resource);

                final AnnotationMetadata am = mdReader.getAnnotationMetadata();
                final Set<MethodMetadata> methodMetadata =
                        am.getAnnotatedMethods(DoSomething.class.getName());
                for (final MethodMetadata mmd : methodMetadata) {
                    final Map<String, Object> attributes =
                            mmd.getAnnotationAttributes(DoSomething.class.getName());
                    final String beanName = mmd.getDeclaringClassName();
                    beanFactory.registerSingleton(beanName, createDoSomethingBean(mmd, attributes));
                }
            }
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }

    }

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}