資訊專欄INFORMATION COLUMN
摘要：下例表示方法入參為的方法匹配該切點，并將和兩個參數綁定到切面方法的入參中綁定代理對象使用或可以綁定被代理對象的實例。
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
