Java 它有一个；“春天之路”；从带注释的接口获取实现？

我想扔掉一些样板。假设我有一个带有自定义注释的自定义接口：

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

现在我可以编写一个

InvocationHandler

，并生成一个

Proxy

实现，它根据注释和方法参数执行一些或多或少有用的操作，并返回一个适当的结果。这个很好用

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

[更新]

为了明确我在这里想要的是我当前代码的概要：

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"

公共接口测试界面{
@MyAnnotation（name=“foo”）
公共void testMethod（字符串arg）；
}
公共类注释代理{
@抑制警告（“未选中”）
公共静态GetT实现（类annotatedInterface）{
return（T）Proxy.newProxyInstance（annotatedInterface.getClassLoader（），
新类[]{annotatedInterface}，
新的AnnotationHandler（））；
}
私有静态类AnnotationHandler实现InvocationHandler{
公共对象调用（对象代理、方法、对象[]args）抛出Throwable{
System.out.println（“Args”+Arrays.toString（Args））；
System.out.println（“Annotations”+Arrays.toString（method.getAnnotations（））；
返回“有用值”；
}
}
}
TestInterface ti=getImplementation（TestInterface.class）；
字符串s=ti.testMethod（“xyz”）//“有用价值”

---

如你所见，我用稀薄的空气创建了一个对象（还有一些丑陋的反射）。我想知道我是否可以用一种更文明、更像spring的方式来实现这一点。

您可以使用spring AOP来拦截和后期处理带注释的方法：

@Aspect
public class ProcessDoSomethingAspect {

    @AfterReturning(value = "execution(@annotation(doSomething) * *.*(..))", returning = "result")
    public String processResult(my.package.DoSomething doSomething, String result) {
        // process result here
        return result;
    }   

}

---

一种方法是扫描具有您喜欢的注释方法的接口，在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");
    }
}

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

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>

不中肯。为了创建和注册代理，我们必须实现扫描接口和创建代理：

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;
    }
}

package.com.test；
导入java.lang.reflect.InvocationHandler；
导入java.lang.reflect.Method；
导入java.lang.reflect.Proxy；
导入java.util.Map；
导入java.util.Set；
导入org.springframework.beans.BeansException；
导入org.springframework.beans.factory.config.BeanFactoryPostProcessor；
导入org.springframework.beans.factory.config.ConfigurableListableBeanFactory；
导入org.springframework.context.ApplicationContext；
导入org.springframework.context.ApplicationContextAware；
导入org.springframework.core.io.Resource；
导入org.springframework.core.type.AnnotationMetadata；
导入org.springframework.core.type.MethodMetadata；
导入org.springframework.core.type.classreading.MetadataReader；
导入org.springframework.core.type.classreading.SimpleMetadataReaderFactory；
导入org.springframework.stereotype.Component；
@组成部分
公共类DoSomethingPostprocessor实现BeanFactoryPostProcessor，ApplicationContextAware{
私有应用程序上下文应用程序上下文；
私有对象createDoSomethingBean（最终方法元数据mmd，最终映射属性）
抛出异常{
final String pattern=（String）attributes.get（“pattern”）；
最终类clazz=Class.forName（mmd.getDeclaringClassName（））；
返回Proxy.newProxyInstance（clazz.getClassLoader（），新类[]{clazz}，
新的调用处理程序（）{
@凌驾
公共对象调用（最终对象代理、最终方法、最终对象[]args）抛出Throwable{
System.out.println（String.format（pattern，args[0]）；
返回null；
}
});
}
@凌驾
public void后处理beanFactory（最终可配置的ListableBeanFactory beanFactory）引发BeanException{
试一试{
最终字符串包searchpath=“classpath*：com/***/*.class”；
最终资源[]资源=
获取资源（packageSearchPath）；
最终SimpleMetadataReaderFactory工厂=新建
SimpleMetadataReaderFactory（applicationContext）；
for（最终资源：资源）{
final MetadataReader mdReader=factory.getMetadataReader（资源）；
final AnnotationMetadata am=mdReader.getAnnotationMetadata（）；
最终设置方法元数据=
am.getAnnotatedMethods（DoSomething.class.getName（））；
对于（最终MethodMetadata mmd:MethodMetadata）{
最终地图属性=
mmd.getAnnotationAttributes（DoSomething.class.getName（））；
最后一个字符串beanName=mmd.getDeclaringClassName（）；
registerSingleton（beanName，createDoSomethingBean（mmd，attributes））；
}
}
}捕获（最终异常e）{
抛出新的运行时异常（e）；
}
}
@凌驾
public void setApplicationContext（最终ApplicationContext ApplicationContext）引发BeansException{
this.applicationContext=applicationContext；
}
}

不确定，但您可以将spring aop的xml方法用于接口方法。我不确定使用带注释的接口是否是一种好的做法，例如，当使用CGLIB代理时，我相信有关接口方法的信息