标签：spring-aop interface annotations spring java
我想刮一些样板.假设我有一个带有自定义注释的自定义界面：
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"
如您所见,我凭空创建了一个对象(以及一些丑陋的反射材质).我想知道我是否可以以更加文明和类似春天的方式来做到这一点.
解决方法:
一种方法是扫描具有您喜欢的批注的方法的接口,在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;
}
}
标签：spring-aop,interface,annotations,spring,java 来源： https://codeday.me/bug/20191031/1977106.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。