AOP的实现底层实际上即为反射，JDK中的反射类java.lang.reflect.Proxy是Java中唯一可以访问调度器的类。类似地，常见的动态代理库cglib也是通过反射机制实现了动态代理的封装。技术成熟度相对较高的AspectJ和Spring AOP会在底层实现一套reflect机制，区别是两者对规范实现如何定义而已。
无论是AspectJ还是Spring AOP，所有这些AOP编程都是基于反射和运行时的动态代理控制实现的。下面通过Proxy和Cglib来实现自己的动态代理切面。
假设我要实现一套基于注解的Trasaction事务管理，通过AOP动态代理来实现。注解和接口实现如下
/**
* @author Barudisshu
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TransactionAnn {
String[] name() default {};
boolean[] readonly() default false;
int[] level() default Connection.TRANSACTION_READ_COMMITTED;
String value() default "";
}
/**
* @author Barudisshu
*/
public interface Transaction {
void open();
void rollBack();
void commit();
void closeIfStillOpen();
}
Proxy动态代理
动态代理的机制如下
实现一个代理工厂
/**
* 代理工厂类
* @author Barudisshu
*/
public class AspectFactory {
/**单例实现*/
private AspectFactory(){
}
@SuppressWarnings("unchecked")
public static <T> T getInstance(T target,Aspect... aspects){
AspectHandler handler = new AspectHandler(target, aspects);
Class clazz = target.getClass();
return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), clazz.getInterfaces(), handler);
}
}
封装并继承调度器
/**
* @author Barudisshu
*/
public class AspectHandler implements InvocationHandler {
private Object target = null;
private Aspect[] aspects = null;
private int index = -1;
public AspectHandler(int index, Object target, Aspect[] aspects) {
this.index = index;
this.target = target;
this.aspects = aspects;
}
public AspectHandler(Object target, Aspect[] aspects) {
this.target = target;
this.aspects = aspects;
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
public Aspect[] getAspects() {
return aspects;
}
public void setAspects(Aspect... aspects) {
this.aspects = aspects;
}
/**
* 委托方法
*
* @param proxy 代理对象
* @param method 代理方法
* @param args 方法参数
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if (index == -1) {
return new AspectHandler(0, target, aspects).invoke(proxy, method, args);
}
Object result = null;
if (index < aspects.length) {
result = aspects[index++].aspect(this, proxy, method, args);
} else if (index++ == aspects.length) {
result = method.invoke(target, args);
}
return result;
}
}
/**
* @author Barudisshu
*/
public interface Aspect {
public Object aspect(InvocationHandler ih, Object proxy, Method method, Object[] args) throws Throwable;
}
实现真实对象，真实对象继承Aspect，并将通过AspectHandler被委托代理
/**
* @author Barudisshu
*/
public class TransactionAspect implements Aspect {
public Object aspect(InvocationHandler ih, Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
TransactionAnn transactionAnn = method.getAnnotation(TransactionAnn.class);
if (transactionAnn != null) {
Transaction transaction = new TransactionAdapter();
// TODO: 获取注解信息或设置值
String[] names = transactionAnn.name();
String values = transactionAnn.value();
int[] level = transactionAnn.level();
boolean[] readOnly = transactionAnn.readonly();
try {
//执行操作
result = ih.invoke(proxy, method, args);
// TODO: 处理
transaction.open();
transaction.commit();
}catch (Throwable t) {
// if exception
transaction.rollBack();
Throwable cause = t.getCause();
if (cause != null) {
// you should define your own Exception here
throw new TransactionException(cause.getMessage(), cause);
} else {
throw new TransactionException(t.getMessage(), t);
}
}finally {
// finally
transaction.closeIfStillOpen();
}
} else {
//执行操作
result = ih.invoke(proxy, method, args);
}
return result;
}
}
根据时序图，我们接下来只需要创建相应的客户端进行调度即可
/**
* @author Barudisshu
*/
public class AspectClient {
public static void main(String[] args) {
PersistenceService persistenceService = AspectFactory.getInstance(new PersistenceServiceImpl(), new TransactionAspect());
persistenceService.save(3,"321");
}
}
/**
* @author Barudisshu
*/
public interface PersistenceService {
@TransactionAnn(name = "save")
void save(long id,String data);
@TransactionAnn(level = Connection.TRANSACTION_READ_UNCOMMITTED)
String load(long id);
}
/**
* @author Barudisshu
*/
public class PersistenceServiceImpl implements PersistenceService {
@Override
public void save(long id, String data) {
throw new TransactionException("异常则回滚！！！");
}
@Override
public String load(long id) {
return null;
}
}
在这里，我们显示抛出一个
运行时异常TranscationException，运行客户端将执行transaction.rollBack()方法。
既然有JDK的Proxy代理了，为什么还需要使用CGLIB之类的其他外部库？实际上Proxy只是对代理的简单实现，在实际使用中还不能满足需求，如上述设计中，Proxy的newProxyInstance静态方法是通过clone实现的，可能需要考虑是浅拷贝还是深拷贝的问题。
若以CGLIB实现，则问题会显得简单的多。
CGLIB动态代理
创建单例的代理工厂
public class CGLIBProxyFactory {
private CGLIBProxyFactory() {
}
@SuppressWarnings("unchecked")
public static <T> T createProxy(T target, AOPInterceptor interceptor) {
MethodInterceptor methodInterceptor =
new CGLIBMethodInterceptor(interceptor);
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setInterfaces(target.getClass().getInterfaces());
enhancer.setCallback(methodInterceptor);
return (T) enhancer.create();
}
}
在Cglib则是通过方法拦截器直接实现，只需要继承拦截器即可
/**
* @author Barudisshu
*/
public class CGLIBMethodInterceptor implements MethodInterceptor {
private AOPInterceptor interceptor;
public CGLIBMethodInterceptor(AOPInterceptor interceptor) {
this.interceptor = interceptor;
}
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
try {
interceptor.before(method, args);
Object returnValue = methodProxy.invokeSuper(object, args);
interceptor.after(method, args);
return returnValue;
} catch (Throwable t) {
interceptor.afterThrowing(method, args, t);
throw t;
} finally {
interceptor.afterFinally(method, args);
}
}
}
/**
* @author Barudisshu
*/
public interface AOPInterceptor {
void before(Method method, Object[] args);
void after(Method method, Object[] args);
void afterThrowing(Method method, Object[] args, Throwable throwable);
void afterFinally(Method method, Object[] args);
}
添加事务处理的真实对象
/**
* @author Barudisshu
*/
public class TransactionCglib implements AOPInterceptor {
private Transaction transaction;
@Override
public void before(Method method, Object[] args) {
if (isRequiresNew(method)) {
transaction = new TransactionAdapter();
transaction.open();
}
}
@Override
public void after(Method method, Object[] args) {
if (transaction != null) {
transaction.commit();
}
}
@Override
public void afterThrowing(Method method, Object[] args, Throwable throwable) {
if (transaction != null) {
transaction.rollBack();
}
}
@Override
public void afterFinally(Method method, Object[] args) {
if (transaction != null) {
transaction.closeIfStillOpen();
transaction = null;
}
}
protected boolean isRequiresNew(Method method) {
TransactionAnn transactionAnnotation = method.getAnnotation(TransactionAnn.class);
if (transactionAnnotation != null) {
if ("REQUIRES_NEW".equals(transactionAnnotation.value())) {
return true;
}
}
return false;
}
}
OK，十分简单，Transaction真实对象将被MethodInterceptor封装，并在Enhancer中实现回调。下面只需要添加相应的客户端调用即可
/**
* @author Barudisshu
*/
public class CglibClient {
public static void main(String[] args) {
PersistenceService persistenceService = CGLIBProxyFactory.createProxy(new PersistenceServiceImpl(), new TransactionCglib());
persistenceService.save(3L, "321");
}
}
注意和Proxy中实现的不同
/**
* @author Barudisshu
*/
public class PersistenceServiceImpl implements PersistenceService {
@TransactionAnn("REQUIRES_NEW")
public void save(long id, String data) {
System.out.println("Generally save ... ");
}
@TransactionAnn("NOT_SUPPORTED")
public String load(long id) {
return null;
}
}
鉴于AspectJ和Spring AOP切面内容比较多，下面简单讲一下AspectJ的配置。
AspectJ部署
- 到eclipse官网下载http://www.eclipse.org/aspectj/downloads.php，直接用7zip解压或双击安装。
- 将aspectj1.x/lib/aspectjrt.jar拷贝到%JAVA_HOME%\jre\lib\ext中，注意这步很重要，否则会说找不到路径。
- 在IDE中设置Ajc编译器路径(编译器用于将aj文件编译成.class文件)，以IDEA为例
编译器一定是aspectjtools，不要选错。
OK，差不多了，写个测试例子
/**
* @author Barudisshu
*/
public aspect HelloWorld {
pointcut callPointcut():
call(void cn.barudisshu.aop.MyClass.foo(int,java.lang.String));
before():callPointcut(){
System.out.println("Hello World");
System.out.println("In the advice attached to the call pointcut");
}
after():callPointcut(){
System.out.println("All things has done");
}
}
方法切入点
/**
* @author Barudisshu
*/
public class MyClass {
public void foo(int number,String name){
System.out.println("Inside foo (int,String)");
}
public static void main(String[] args) {
// Create an instance of MyClass
MyClass myObject = new MyClass();
// Make the call to foo
myObject.foo(1,"Russ Miles");
}
}
如下代码将输出
Hello World In the advice attached to the call pointcut Inside foo (int,String) All things has done
时间： 2024-10-03 10:36:15