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

Answer 2

您可以使用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方式”从注释界面获得实现吗？

2 个答案: