摘要：下例表示方法入参为的方法匹配该切点，并将和两个参数绑定到切面方法的入参中绑定代理对象使用或可以绑定被代理对象的实例。
1. 术语
连接点（JointPoint）：代码中具有边界性质特定点；Spring仅支持方法的连接点，包含方法和方位两方面信息
切点（Pointcut）：定位到某个方法
增强（Advice）：织入到目标连接点上的代码
目标对象（Target）：增强逻辑的目标织入类
引介（Introduction）：特殊的增强，为类添加一些属性和方法
织入（Weaving）：将增强添加到目标连接点上的过程：编译期织入、类装载期织入、动态代理织入（Spring的方案）
代理（Proxy）：被AOP织入增强后的结果类
切面（Aspect）：切点+增强
2. 动态代理的两种实现：JDK和CGLibJDK动态代理动态创建一个符合某一接口的实力，生成目标类的代理对象，缺点是需要提供接口；方法必须是public或public final的
CGLib采用底层的字节码技术，在子类中对父类的方法进行拦截，织入横切逻辑；不能为final和private方法代理
样例
package test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class ProxyTest {
public static void main(String[] args) {
ServiceImpl jdkTarget = new ServiceImpl();
ProxyHandler handler = new ProxyHandler(jdkTarget);
Service jdkProxy = (Service)Proxy.newProxyInstance(
jdkTarget.getClass().getClassLoader(),
jdkTarget.getClass().getInterfaces(),
handler);
jdkProxy.process("jdk proxy");
System.out.println();
CglibProxy cglibProxy = new CglibProxy();
ServiceImpl cglibTarget = (ServiceImpl)cglibProxy.getProxy(ServiceImpl.class);
cglibTarget.process("cglib proxy");
}
public interface Service {
public void process(String arg);
}
public static class ServiceImpl implements Service {
@Override
public void process(String arg) {
System.out.println("do something with " + arg);
}
}
//jdk proxy
public static class ProxyHandler implements InvocationHandler {
private Object target;
public ProxyHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("before process jdk proxy");
Object obj = method.invoke(target, args);
System.out.println("after process jdk proxy");
return obj;
}
}
//cglib proxy
public static class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz) {
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("before process cglib proxy");
Object result = proxy.invokeSuper(obj, args);
System.out.println("after process cglib proxy");
return result;
}
}
}
结果
before process jdk proxy do something with jdk proxy after process jdk proxy before process cglib proxy do something with cglib proxy after process cglib proxy
性能：CGLib所创建的动态代理对象性能比JDK方式高（约10倍），但CGLib在创建代理对象时所花费的时间比JDK方式多（约8倍）；CGLib适合Spring里singleton模式的bean管理
3. ProxyFactorySpring定义了org.springframework.aop.framework.AopProxy接口及Cglib2AopProxy和JdkDynamicAopProxy两个final实现类
如果通过ProxyFactory的setInterfaces(Class[] interfaces)指定针对接口代理，则使用JdkDynamicAopProxy；如果使用setOptimize(true)，使用Cglib2AopProxy
ProxyFacotry通过addAdvice(Advice)形成增强链
4. 增强类型 4.1 前置增强接口：org.springframework.aop.BeforeAdvice
样例
package com.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class BeforeAdvice implements MethodBeforeAdvice {
@Override
public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
String arg = (String)arg1[0];
System.out.println("before advice " + arg);
}
}
4.2 后置增强
接口：org.springframework.aop.AfterReturninigAdvice
样例
package com.aop;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class AfterAdvice implements AfterReturningAdvice {
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
String arg = (String)args[0];
System.out.println("after advice " + arg);
}
}
4.3 环绕增强
接口：org.aopalliance.intercept.MethodInterceptor
样例
package com.aop;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class AroundAdvice implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Object[] args = invocation.getArguments();
String arg = (String)args[0];
System.out.println("around advice: before " + arg);
Object obj = invocation.proceed();
System.out.println("around advice: after " + arg);
return obj;
}
}
4.4 异常抛出增强
接口：org.springframework.aop.ThrowsAdvice
样例
package com.aop;
import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
public class ExceptionAdvice implements ThrowsAdvice {
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
throws Throwable {
System.out.println("------");
System.out.println("throws exception, method=" + method.getName());
System.out.println("throws exception, message=" + ex.getMessage());
}
}
4.5 测试
TestAopAdvice
package com.aop;
import org.springframework.aop.ThrowsAdvice;
import org.springframework.aop.framework.ProxyFactory;
public class TestAopAdvice {
public static void main(String[] args) {
AopExample example = new AopExample();
BeforeAdvice beforeAdvice = new BeforeAdvice();
AfterAdvice afterAdvice = new AfterAdvice();
AroundAdvice aroundAdvice = new AroundAdvice();
ThrowsAdvice throwsAdvice = new ExceptionAdvice();
ProxyFactory pf = new ProxyFactory();
pf.setTarget(example);
pf.addAdvice(beforeAdvice);
pf.addAdvice(afterAdvice);
pf.addAdvice(aroundAdvice);
pf.addAdvice(throwsAdvice);
AopExample proxy = (AopExample)pf.getProxy();
proxy.handle("blabla");
System.out.println();
try{
proxy.throwExp("blabla");
} catch(Exception e) {
}
}
}
输出
before advice blabla around advice: before blabla aop example blabla around advice: after blabla after advice blabla before advice blabla around advice: before blabla ----after throwing---- throws exception, method=throwExp throws exception, message=try throws advice
springAop.xml
TestAopAdvice2
package com.aop;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAopAdvice2 {
public static void main(String[] args) {
ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("/springAop.xml");
AopExample aopExample = (AopExample)ctx.getBean("aopTest");
aopExample.handle("blabla");
System.out.println();
try{
aopExample.throwExp("blabla");
} catch(Exception e) {
}
ctx.close();
}
}
输出
二月 09, 2017 9:54:11 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@69d0a921: startup date [Thu Feb 09 21:54:11 CST 2017]; root of context hierarchy 二月 09, 2017 9:54:11 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions 信息: Loading XML bean definitions from class path resource [springAop.xml] before advice blabla around advice: before blabla aop example blabla around advice: after blabla after advice blabla before advice blabla around advice: before blabla ----after throwing---- throws exception, method=throwExp throws exception, message=try throws advice 二月 09, 2017 9:54:11 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose 信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@69d0a921: startup date [Thu Feb 09 21:54:11 CST 2017]; root of context hierarchy4.6 引介增强
接口：org.springframework.aop.IntroductionInterceptor
IntroductionAdvice
package com.aop;
public interface IntroductionAdvice {
public void setIntroductionActive(boolean active);
}
ConfigurableIntroduction
package com.aop;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;
public class ConfigurableIntroduction extends DelegatingIntroductionInterceptor implements IntroductionAdvice {
private ThreadLocal map = new ThreadLocal();
@Override
public void setIntroductionActive(boolean active) {
map.set(active);
}
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Object obj = null;
if(map.get() != null && map.get()) {
System.out.println("before monitor operation");
obj = super.invoke(invocation);
System.out.println("after monitor operation");
} else {
obj = super.invoke(invocation);
}
return obj;
}
}
TestIntroductionAdvice
package com.aop;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestIntroductionAdvice {
public static void main(String[] args) {
ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("/springAop.xml");
AopExample introductionAop = (AopExample)ctx.getBean("introductionAop");
introductionAop.handle("introduction advice");
IntroductionAdvice ci = (IntroductionAdvice)introductionAop;
ci.setIntroductionActive(true);
introductionAop.handle("introduction advice");
ctx.close();
}
}
springAop.xml添加
输出
二月 09, 2017 9:56:10 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@69d0a921: startup date [Thu Feb 09 21:56:10 CST 2017]; root of context hierarchy 二月 09, 2017 9:56:10 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions 信息: Loading XML bean definitions from class path resource [springAop.xml] aop example introduction advice ---- before monitor operation aop example introduction advice after monitor operation 二月 09, 2017 9:56:11 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose 信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@69d0a921: startup date [Thu Feb 09 21:56:10 CST 2017]; root of context hierarchy
须指定引介增强所实现的接口
只能通过为目标类创建子类的方式生成引介增强的代理，因此proxyTargeClass必须为true
5. Spring中的配置参数说明
target：代理的对象
proxyInterfaces：代理所要实现的接口
interceptorNames：需要织入目标对象的bean列表，这些bean必须是实现了org.aopalliance.intercept.MethodInterceptor或org.springframework.aop.Advisor的bean，配置中的顺序对应调用的顺序
singleton：返回的代理是否为单例，默认为true
optimize：为true时使用CGLib代理
proxyTargetClass：为true时使用CGLib代理，并覆盖proxyInterfaces设置
6. Java注解一个例子
package com.aspectj;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
@Target(ElementType.METHOD) //声明可以使用该注解的目标类型
@Retention(RetentionPolicy.RUNTIME)//声明注解的保留期限
public @interface Authority {
boolean value() default true;//声明注解成员
}
成员以无入参无抛出异常的方式声明
可以通过default为成员指定一个默认值
在方法上使用注解：@Authority(value=true)
如果注解只有一个成员，需命名为value()，使用时可以忽略成员名和赋值号(=)，如@Authority(true)
注解类拥有多个成员时，如果仅对value成员赋值，可以不适用赋值号；如果同时对多个成员赋值，则必须使用赋值号
注解类可以没有成员，称为标识注解
所有注解类隐式继承于java.lang.annotation.Annotation，注解不允许显式继承于其他接口
如果成员是数组类型，可以通过{}赋值
7. 基于AspectJ的AOP 7.1 一个例子定义切面
package com.aspectj;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class PreAspect {
@Before("execution(*handle(..))")
public void before() {
System.out.println("aspect: before processing");
}
}
测试
package com.aspectj;
import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
import com.aop.AopExample;
public class AspectJTest {
public static void main(String[] args) {
AspectJProxyFactory factory = new AspectJProxyFactory();
AopExample example = new AopExample();
factory.setTarget(example);
factory.addAspect(PreAspect.class);
AopExample proxy = factory.getProxy();
proxy.handle("pre aspect");
}
}
结果
aspect: before processing aop example pre aspect7.2 通过配置使用切面
springAspectj.xml
springAspectj.xml
