AOP是拦截的方法后要做对应的织入,那么先定义几种通知:前置通知、后置通知、异常通知、结束通知,代码如下:
public interface AopAdvice {
public void before(Proxy proxy);
public void after(Proxy proxy);
public void exception(Proxy proxy);
public void end(Proxy proxy);
}
接下来看,哪些类里的哪些方法要被拦截呢?我们需要定义一个表达式,这么使用正则表达式,相对来说比较简单,也是一个通用的规范。只有配到正则的方法,才会执行对应织入的增强。
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Aspect {
public String classRegex();
public String beforeRegex() default "";
public String afterRegex() default "";
public String exceptionRegex() default "";
public String endRegex() default "";
public int order() default 0;
}
classRegex定义要拦截的class正则
beforeRegex定义需要前置增强的方法的正则匹配
afterRegex定义需要后置增强的方法的正则匹配
exceptionRegex定义需要进行异常处理增强方法的正则匹配
endRegex定义在方法执行完成之后需要额外处理方法的正则匹配
order表示排序,有多个aop规则命中时,就需要排序,这里是升序排列,order越大,该aop越靠后执行
AOP实现的本质是动态代理,那么我们需要定义一个代理接口
public interface Proxy {
public void invoke(Proxy proxy) throws Throwable;
}
这个接口里定义了一个方法invoke(Proxy proxy),参数是它自己,那么什么这样定义呢?这里就要谈到一种设计模式“责任链”,由于被cglib代理过的类不能再次被代理,所以这里才用责任链模式来解决。具体来看责任链在这里怎么运作的。
public class BeanProxy implements Proxy {
private Object obj;
private Object[] args;
private Method method;
private MethodProxy methodProxy;
private boolean invokeSuper = true;
private int proxyIndex = -1;
private Object result = null;
private InterfaceExecutor interfaceExecutor;
private List<Proxy> proxyList = new ArrayList<Proxy>();
public BeanProxy() {
}
public BeanProxy(Object obj, Object[] args, Method method, MethodProxy methodProxy) {
this.obj = obj;
this.args = args;
this.method = method;
this.methodProxy = methodProxy;
}
@Override
public void invoke(Proxy proxy) throws Throwable {
proxyIndex++;
if (proxyIndex < proxyList.size()) {
proxyList.get(proxyIndex).invoke(this);
} else if (invokeSuper) {
result = methodProxy.invokeSuper(obj, args);
} else {
result = interfaceExecutor.invoke(obj, method, args, methodProxy);
}
}
public BeanProxy addProxyChain(Proxy proxy) {
proxyList.add(proxy);
return this;
}
public BeanProxy setInterfaceExecutor(InterfaceExecutor interfaceExecutor) {
this.interfaceExecutor = interfaceExecutor;
return this;
}
………………省略了一些set方法
}
BeanProxy实现了invoke方法,上游节点将调用权给下游节点,直到指针指向链的末尾,当指针指向链尾端是,如果设置的invokeSuper为true(invokeSuper表示是否执行被代理的父类方法),则执行父类方法,如果父类方法是接口,则一定要设置为false。在《TeaFramework——ORM框架的实现(一)》留了一个InterfaceExecutor的疑问,InterfaceExecutor是专门为被代理的类是接口的场景准备的,当被代理的类为接口,但是又想执行一些原本想实现的额外操作,就可以用InterfaceExecutor来实现,例如ORM中OrmProxy就是一个典型的例子。
特别说明:对于链式调用,invoke方法之前的方法是正序调用,invoke方法之后是逆序。这一点和所有责任链调用过程一致,例如Filter、Struts2的拦截等。
对于AOP代理,TeaFramework中实现了一个抽象代理类,要编写自己的AOP只需继承这个抽象类,实现对应的前置、后置等方法。
public abstract class AbstractProxy implements Proxy, AopAdvice {
private Pattern beforePattern;
private Pattern afterPattern;
private Pattern exceptionPattern;
private Pattern endPattern;
@Override
public void invoke(Proxy proxy) throws Throwable {
BeanProxy beanProxy = (BeanProxy) proxy;
try {
if (beforePattern != null && beforePattern.matcher(beanProxy.getMethod().getName()).find()) {
before(proxy);
}
proxy.invoke(proxy);
if (afterPattern != null && afterPattern.matcher(beanProxy.getMethod().getName()).find()) {
after(proxy);
}
} catch (Throwable e) {
if (exceptionPattern != null && exceptionPattern.matcher(beanProxy.getMethod().getName()).find()) {
exception(proxy);
}
throw e;
} finally {
if (endPattern != null && endPattern.matcher(beanProxy.getMethod().getName()).find()) {
end(beanProxy);
}
}
}
@Override
public void before(Proxy proxy) {
}
@Override
public void after(Proxy proxy) {
}
@Override
public void exception(Proxy proxy) {
}
@Override
public void end(Proxy proxy) {
}
public final void setBeforePattern(Pattern beforePattern) {
this.beforePattern = beforePattern;
}
public final void setAfterPattern(Pattern afterPattern) {
this.afterPattern = afterPattern;
}
public final void setExceptionPattern(Pattern exceptionPattern) {
this.exceptionPattern = exceptionPattern;
}
public void setEndPattern(Pattern endPattern) {
this.endPattern = endPattern;
}
}
有了这些工具,我们就可以实现自己的AOP业务了,看个例子,比方说对应新增和修改而言,我们需要把CCUU值填充进去,这个时候就可以用AOP了,请看下面的代码
@Aspect(classRegex = "org.teaframework.erp.*.dao.*", beforeRegex = "add.*|update.*")
public class DomainAspect extends AbstractProxy {
@Override
public void before(Proxy proxy) {
BeanProxy beanProxy = (BeanProxy) proxy;
if (beanProxy.getArgs() != null && beanProxy.getArgs()[0] instanceof BaseDomain) {
BaseDomain domain = (BaseDomain) beanProxy.getArgs()[0];
domain.setCreateDate(new Date());
domain.setCreateUser(ThreadVariable.getUser().getUserName());
domain.setUpdateDate(new Date());
domain.setUpdateUser(ThreadVariable.getUser().getUserName());
}
}
}
classRegex定义了要拦截所有dao包里的类,beforeRegex定义具体拦截add或者upate开头的方法进行前置增强织入,重写AbstractProxy的before方法即可实现前置增强了。
接下来问题来了,DomainAspect等自己实现的AOP类,怎么和bean容器的bean关联起来的呢?我们接着看。
框架启动时,有一个AopBeanInitialization,这个类将所有加了Aspect注解的类扫描到,然后实例化,根据order升序排列,放到一个Map里。
public class AopBeanInitialization implements Initialization {
public static final List<AspectClassMapping> AOP_BEAN_LIST = new ArrayList<AspectClassMapping>();
public static final Map<Class<?>, Pattern> PATTERN_MAPPING = new HashMap<Class<?>, Pattern>();
@Override
public void init() throws Exception {
for (String classPath : ScanPackageInitialization.classPaths) {// aop
Class<?> clazz = ClassLoaderUtil.loadClass(classPath);
if (clazz.isAnnotationPresent(Aspect.class)) {
AbstractProxy aspectBean = (AbstractProxy) clazz.newInstance();
Aspect aspect = clazz.getAnnotation(Aspect.class);
PATTERN_MAPPING.put(clazz, Pattern.compile(aspect.classRegex()));
if (!"".equals(aspect.beforeRegex())) {
aspectBean.setBeforePattern(Pattern.compile(aspect.beforeRegex()));
}
if (!"".equals(aspect.afterRegex())) {
aspectBean.setAfterPattern(Pattern.compile(aspect.afterRegex()));
}
if (!"".equals(aspect.exceptionRegex())) {
aspectBean.setExceptionPattern(Pattern.compile(aspect.exceptionRegex()));
}
if (!"".equals(aspect.endRegex())) {
aspectBean.setEndPattern(Pattern.compile(aspect.endRegex()));
}
AOP_BEAN_LIST.add(new AspectClassMapping(clazz, aspectBean, aspect.order()));
}
}
Collections.sort(AOP_BEAN_LIST, new Comparator<AspectClassMapping>() {
public int compare(AspectClassMapping o1, AspectClassMapping o2) {
return o2.getOrder() - o1.getOrder();
}
});
}
}
AopBeanInitialization执行完成之后,BeanContainerInitialization开始执行,对于命中了正则规则的类就需要动态代理了,然后将对应的AOP代理对象add到代理链中,请看下来的代码
private void addProxy(BeanProxy beanProxy, Class<?> clazz) {
for (AspectClassMapping aspectClassMapping : AopBeanInitialization.AOP_BEAN_LIST) {
Class<?> proxyClass = aspectClassMapping.getClazz();
Matcher matcher = AopBeanInitialization.PATTERN_MAPPING.get(proxyClass).matcher(clazz.getName());
if (matcher.find()) {
beanProxy.addProxyChain(aspectClassMapping.getAspectBean());
}
}
if (clazz.isAnnotationPresent(Transcation.class)) {
beanProxy.addProxyChain(transcationProxy);
} else {
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if (method.isAnnotationPresent(Transcation.class)) {
beanProxy.addProxyChain(transcationProxy);
break;
}
}
}
}
一旦AOP代理对象被放入对应的代理链中,就可以链式调用了,便发挥出了AOP的作用,上面的代码还有关于事物Transcation的代码,本篇博客先不做介绍,将会有单独的一篇博客讲事物控制的设计。
项目地址:https://git.oschina.net/lxkm/teaframework
博客:https://blog.csdn.net/dong_lxkm