AOP

• AOP：面向方面编程（Aspect Oriented Programming），它可以更好的将本不该彼此粘合在一起的功能分离开。
• 使用AOP，就不用在业务逻辑中实现与业务功能关系不大的代码（如日志、权限、异常处理、事务处理等），从而降低两种代码的耦合性，达到易于维护和重要的目的。
• AOP的思想：假设每个对象都有记录日志这样的行为，那么要在每个方法里添加日志信息，必然会产生大量重复代码。此时可以将记录日志看作是一个横切面，所有对这些方法的调用都要经过这个横切面，然后在这个横切面进行记录日志的操作，这样就达到代码重用和易于维护的目的。
• AOP是一种思想，与具体实现技术无关。Java提供了动态代理的机制，通过这个机制就可以很容易的实现AOP思想。
• Spring的AOP实际上也是建立在Java的动态代理机制上的。

AOP的3个关键概念

AOP的3个关键概念：Pointcut（切入点）、Advice（通知）、Adviser（Pointcut与Advice的配置器）。

（一）Pointcut（切入点）

• Join Point（连接点）：指程序运行中的某个阶段点（如某个方法调用、异常抛出等）。
• Pointcut是Join Point的集合，是程序中需要注入Advice的位置的集合，指明Advice触发的条件。
• org.springframework.aop.Pointcut接口用来指定通知到特定的类和方法。其Pointcut.java源码如下：

//***********Pointcut.java************
package org.springframework.aoppublic interface Pontcut {//用来将切入点限定在给定的目标类中ClassFilter getClassFilter();//用来判断切入点是否匹配目标类给定的方法MethodMatcher getMethodMatcher();Pointcut TRUE = TruePointcut.INSTANCE;
}

Spring主要提供了3种切入点（Pointcut）的实现：静态切入点、动态切入点、自定义切入点。

（1）静态切入点

• 大多数切入点可以使用静态切入点。
• 静态切入点只限于给定的方法和目标类，不考虑方法的参数。
• 在调用静态切入点时，只在第一次的时候计算静态切入点的位置，然后缓存起来，之后就不需再计算。
• 使用 org.springframework.aop.support.RegexpMethodPointcut 可以实现静态切入点。
• RegexpMethodPointcut 是一个通用的正则表达式切入点。

<bean id="settersAndAbsquatulatePointcut" class="org.springframework.aop.support.RegexpMethodPointcut"><property name="patterns"><!--设定切入点--><list><value>.*save.*</value>    <!--表示所有以save开头的方法都是切入点--><value>.*do.*</value>      <!--表示所有以do开头的方法都是切入点--></list></property>
</bean>

（2）动态切入点

• 动态切入点可以设定方法和类，也可以指定方法的参数。
• 由于参数的变化性，所以动态切入点不能缓存，每次调用都需要计算，因此会产生很大的性能损耗。
• 当切入点需要在执行时根据参数值来调用通知时，需要使用动态切入点。
• Spring提供了一个内建的动态切入点：控制流切入点。此切入点匹配基于当前线程的调用堆栈。
• 只有在当前线程执行时特定的类和特定的方法才返回true。

（3）自定义切入点

Spring中的切入点是Java类，而不是语言特征，因此其可以定义自定义切入点。

（二）Advice（通知）

• Advice是某个连接点所采用的处理逻辑，也就是向连接点注入的代码，表示要在Join Point加入这段代码。
• Advice共有5种类型：Interception Around、Before、After Returning、Throw、Introduction。
• 分别在JointPoint前后、JointPoint前、JointPoint后、JointPoint抛出异常时、JointPoint调用完毕后执行。

（1）Interception Around通知

• 通知会在JointPoint的前后都执行。
• 该类型是Spring中最基本的通知类型。
• 实现Interception Around通知的类需要实现接口MethodInterceptor。

（2）Before通知

• 通知只在JointPoint前执行。
• 实现Before通知的类需要实现接口MethodBeforeAdvice。

（3）After Returning通知

• 通知只在JointPoint后执行。
• 实现Before通知的类需要实现接口MethodReturningAdvice。

（4）Throw通知

• 通知只在JointPoint抛出异常时执行。
• 实现Before通知的类需要实现接口ThrowsAdvice。
• 该接口无必须实现的函数，afterThrowing()为自定义函数。

（5）Introduction通知

• 通知只在JointPoint调用完毕后执行。
• 实现Introduction通知的类需要实现接口IntroductionAdvisor和IntroductionInterceptor。

（三）Adviser（Pointcut与Advice的配置器）

• Adviser是Pointcut与Advice的配置器，它包括Pointcut和Advice，将Advice注入程序中Pointcut位置的代码。
• org.springframework.aop.support.DefaultPointcutAdvisor是最通用的Advisor类。
• 在Spring中，主要通过XML的方式来配置Pointcut和Advice。

  ---

  用ProxyFactoryBean创建AOP代理

使用Spring提供的org.springframework.aop.framework.ProxyFactoryBean是创建AOP的最基本的方式。

（1）使用ProxyFactoryBean代理目标类的所有方法

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--log是程序中的Advice--><bean id="log" class="com.gc.action.LogAround"/><!--timeBook是ProxyFactoryBean要代理的目标类--><bean id="timeBook" class="com.gc.action.TimeBook"/><!--设定代理类--><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><!--proxyInterface属性指明要代理的接口--><property name="proxyInterface"><value>com.gc.impl.TimeBookInterface</value></property><!--target指明要代理的目标类,这个目标类实现了上面proxyInterface属性指定的接口--><property name="target"><ref bean="timeBook"/></property><!--interceptorNames属性，指明要在代理的目标类中插入的Adivce--><property name="interceptorNames"><list><value>log</value></list></property></bean>
</beans>

这里的Advice会代理目标类的所有方法。

ProxyFactoryBean还有一个proxyTargetClass属性，如果被设定为“true”，说明ProxyFactoryBean要代理的不是接口类，而是使用CGLIB方式来进行代理。proxyTargetClass属性只支持使用字符串的方式进行注入，不支持使用Bean的依赖方式进行注入。

（2）使用ProxyFactoryBean代理目标类的指定方法

需要使用Spring提供的org.springframework.aop.support.RegexpMethodPointcutAdvisor类。

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><bean id="log" class="com.gc.action.LogAround"/><bean id="timeBook" class="com.gc.action.TimeBook"/><!--logAdvisor设定Advice和要指定的方法--><bean id="logAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice"><ref bean="log"/></property><property name="patterns"><value>.*doAuditing.*</value></property></bean><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><!--proxyInterface属性指明要代理的接口--><property name="proxyInterface"><value>com.gc.impl.TimeBookInterface</value></property><!--target指明要代理的目标类,这个目标类实现了上面proxyInterface属性指定的接口--><property name="target"><ref bean="timeBook"/></property><!--interceptorNames属性，指明要在代理的目标类中插入的Adivce--><property name="interceptorNames"><list><value>logAdvisor</value></list></property></bean>
</beans>

patterns属性值使用的是正则表达式。

（3）正则表达式简介

正则表达式可用于在一个文件中查找字符。

• （1）“.”，可以用来匹配任何一个字符。g.f：gaf、glf、g*f、g#f
• （2）“[ ]”，只有[ ]里指定的字符才能匹配。g[abc]f：gaf、gbf、gcf。
• （3）“*”，表示匹配次数，可以任意次，用来确定紧靠该符号左边的符号出现的次数。g.*f：gaaf、gaf、gf、g*f等。
• （4）“？”，可以匹配0或1次，用来确定仅靠该符号左边的符号出现的次数。g.?f：gaf、g*f等。
• （5）“\”，是正则表达式的连接符。g.\-f：g-f、ga-f、g*-f等

注：包的路径要用“\”连接符来表示“.”，不能用正则表达式的“.”。

<value>.*com\.gc\.impl\.TimeBookInterface.*<value>

Spring的AOP实现输出日志

（一）采用Interception Around通知的形式实现

• （1）实现接口MethodInterceptor，在invoke()方法里编写负责输出日志信息的代码
• （2）实现接口TimeBookInterface，在TimeBook()方法中实现具体的业务逻辑
• （3）在Spring的配置文档中定义Pointcut
• （4）编写测试类

下面程序实现两个关联程序实现日志输出。

//第一个关联类的接口 TimeBookInterface.java
public interface TimeBookInterface {//负责具体的业务逻辑public void doAuditing(String name);
}

//第一个关联类的接口实现 TimeBook.java
import com.gc.impl.TimeBookInterface;public class TimeBook implements TimeBookInterface{//doAuditing()方法用来处理实际业务中的考勤审核//参数name，用来传入是谁执行了类TimeBook中的doAuditing()方法public void doAuditing(String name) {// 审核数据的相关程序}
}

//第二个关联类的接口 FinanceInterface.java
//定义接口是为了实现代理
public interface FinanceInterface {public void doCheck(String name);
}

//第二个关联类的接口实现 Finance.java
import com.gc.impl.FinanceInterface;public class Finance implements FinanceInterface {@Overridepublic void doCheck(String name) {// 关联的相关程序		}
}

//日志输出   LogAround.java
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;public class LogAround implements MethodInterceptor {private Logger logger = Logger.getLogger(this.getClass().getName());//负责输出日志信息的代码//通过参数MethodInvocation 可以获得方法的名称、程序传入的参数Object[]等@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {logger.log(Level.INFO, mi.getArguments()[0] + " 开始审核数据...");try {Object result = mi.proceed();	//通过proceed()方法即可执行被调用的方法//返回值即是被调用的方法的返回值return result;					//返回值是被调用的方法的返回值} finally {logger.log(Level.INFO, mi.getArguments()[0] + " 审核数据结束...");}}
}

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--以下是使用Spring AOP实现日志输出的Bean--><bean id="log" class="com.gc.action.LogAround"/>		<!--负责日志输出--><bean id="timeBook" class="com.gc.action.TimeBook"/>	<!--负责具体业务逻辑审核--><!--使用Spring提供的ProxyFactoryBean来实现代理--><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><!--proxyInterface属性指明要代理的接口--><property name="proxyInterfaces"><value>com.gc.impl.TimeBookInterface</value></property><!--Advice通知--><property name="target"><ref bean="timeBook"/></property><property name="interceptorNames"><list><value>log</value></list></property></bean>
<!--=====================上面是第一个关联类，下面是第二个关联类======================--><!--以下是财务关联--><bean id="finance" class="com.gc.action.Finance"/>	<!--负责具体业务逻辑审核--><!--使用Spring提供的ProxyFactoryBean来实现代理--><bean id="logProxy1" class="org.springframework.aop.framework.ProxyFactoryBean"><!--proxyInterface属性指明要代理的接口--><property name="proxyInterfaces"><value>com.gc.impl.FinanceInterface</value></property><!--Advice通知--><property name="target"><ref bean="finance"/></property><property name="interceptorNames"><list><value>log</value></list></property></bean>
</beans>

//测试程序   TestHelloWorld.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import com.gc.impl.FinanceInterface;
import com.gc.impl.TimeBookInterface;public class TestHelloWorld {public static void main(String[] args){ApplicationContext actx = new FileSystemXmlApplicationContext("config.xml");TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("logProxy");timeBookProxy.doAuditing("张三");FinanceInterface financeProxy = (FinanceInterface)actx.getBean("logProxy1");financeProxy.doCheck("李四");}
}结果
[ INFO ] 2020-04-20 21:41:23 [main] com.gc.action.LogAround  - 张三 开始审核数据...
[ INFO ] 2020-04-20 21:41:23 [main] com.gc.action.LogAround  - 张三 审核数据结束...
[ INFO ] 2020-04-20 21:41:23 [main] com.gc.action.LogAround  - 李四 开始审核数据...
[ INFO ] 2020-04-20 21:41:23 [main] com.gc.action.LogAround  - 李四 审核数据结束...

（二）采用Before通知的形式实现

• （1）实现接口MethodBeforeAdvice，在before()方法里编写负责输出日志信息的代码
• （2）实现接口TimeBookInterface，在TimeBook()方法中实现具体的业务逻辑
• （3）在Spring的配置文档中定义Pointcut
• （4）编写测试类

//关联类的接口 TimeBookInterface.java
public interface TimeBookInterface {//负责具体的业务逻辑public void doAuditing(String name);
}

//关联类的接口实现 TimeBook.java
import com.gc.impl.TimeBookInterface;public class TimeBook implements TimeBookInterface{//doAuditing()方法用来处理实际业务中的考勤审核//参数name，用来传入是谁执行了类TimeBook中的doAuditing()方法public void doAuditing(String name) {// 审核数据的相关程序}
}

//***************LogBefore.java********************
import java.lang.reflect.Method;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.aop.MethodBeforeAdvice;public class LogBefore implements MethodBeforeAdvice {private Logger logger = Logger.getLogger(this.getClass().getName());@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {logger.log(Level.INFO, args[0] + " 开始审核数据...");}
}

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--以下是使用Spring AOP实现日志输出的Bean--><bean id="log" class="com.gc.action.LogAround"/>	<!--负责具体业务逻辑审核--><bean id="timeBook" class="com.gc.action.TimeBook"/>	<!--以下是实现Before通知--><bean id="logBefore" class="com.gc.action.LogBefore"/><bean id="logBeforeAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice"><ref bean="logBefore"/></property><!--代理指定类中的doAuditing方法--><property name="patterns"><value>.*doAuditing.*</value></property></bean><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="proxyInterfaces"><value>com.gc.impl.TimeBookInterface</value></property><property name="target"><ref bean="timeBook"/></property><!--指定要代理的类--><property name="interceptorNames"><list><value>logBeforeAdvisor</value></list></property></bean>
</beans>

//测试 TestHelloWorld.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import com.gc.impl.TimeBookInterface;public class TestHelloWorld {public static void main(String[] args){ApplicationContext actx = new FileSystemXmlApplicationContext("config.xml");TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("logProxy");timeBookProxy.doAuditing("张三");}
}结果
[ INFO ] 2020-04-20 21:44:54 [main] com.gc.action.LogBefore  - 张三 开始审核数据...

（三）采用After Returning通知的形式实现

• （1）实现接口AfterReturningAdvice，在afterReturning()方法里编写负责输出日志信息的代码
• （2）实现接口TimeBookInterface，在TimeBook()方法中实现具体的业务逻辑
• （3）在Spring的配置文档中定义Pointcut
• （4）编写测试类

//关联类的接口 TimeBookInterface.java
public interface TimeBookInterface {//负责具体的业务逻辑public void doAuditing(String name);
}

//关联类的接口实现 TimeBook.java
import com.gc.impl.TimeBookInterface;public class TimeBook implements TimeBookInterface{//doAuditing()方法用来处理实际业务中的考勤审核//参数name，用来传入是谁执行了类TimeBook中的doAuditing()方法public void doAuditing(String name) {// 审核数据的相关程序}
}

//***************LogAfter.java********************
import java.lang.reflect.Method;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.aop.AfterReturningAdvice;public class LogAfter implements AfterReturningAdvice {private Logger logger = Logger.getLogger(this.getClass().getName());@Overridepublic void afterReturning(Object object, Method method, Object[] args, Object target) throws Throwable {logger.log(Level.INFO, args[0] + " 审核数据结束...");		}
}

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--负责具体业务逻辑审核--><bean id="timeBook" class="com.gc.action.TimeBook"/>	<!--以下是实现After Returning通知--><bean id="logAfter" class="com.gc.action.LogAfter"/><bean id="logAfterAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice"><ref bean="logAfter"/></property><!--代理指定类中的doAuditing方法--><property name="patterns"><value>.*doAuditing.*</value></property></bean><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="proxyInterfaces"><value>com.gc.impl.TimeBookInterface</value></property><property name="target"><ref bean="timeBook"/></property><!--指定要代理的类--><property name="interceptorNames"><list><value>logAfterAdvisor</value></list></property></bean>
</beans>

//测试程序   TestHelloWorld.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import com.gc.impl.TimeBookInterface;public class TestHelloWorld {public static void main(String[] args){ApplicationContext actx = new FileSystemXmlApplicationContext("config.xml");TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("logProxy");timeBookProxy.doAuditing("张三");}
}结果
[ INFO ] 2020-04-20 21:51:06 [main] com.gc.action.LogAfter  - 张三 审核数据结束...

（四）采用Throw通知的形式实现

• （1）实现接口ThrowAdvice，在afterThrowing()方法里编写负责输出日志信息的代码
• （2）实现接口TimeBookInterface，在TimeBook()方法中实现具体的业务逻辑
• （3）在Spring的配置文档中定义Pointcut
• （4）编写测试类

//关联类的接口 TimeBookInterface.java
public interface TimeBookInterface {//负责具体的业务逻辑public void doAuditing(String name);
}

//关联类的接口实现 TimeBook.java
import com.gc.impl.TimeBookInterface;public class TimeBook implements TimeBookInterface{//doAuditing()方法用来处理实际业务中的考勤审核//参数name，用来传入是谁执行了类TimeBook中的doAuditing()方法public void doAuditing(String name) {// 审核数据的相关程序int m = 1 / 0;    //此处添加一个除数为0的异常}
}

//***************LogThrow.java********************
import java.lang.reflect.Method;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.aop.ThrowsAdvice;public class LogThrow implements ThrowsAdvice {private Logger logger = Logger.getLogger(this.getClass().getName());public void afterThrowing(Method method, Object[] args, Object target, Throwable subclass) throws Throwable {logger.log(Level.INFO, args[0] + " 审核数据有异常抛出...");		}
}

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--负责具体业务逻辑审核--><bean id="timeBook" class="com.gc.action.TimeBook"/>	<!--以下是实现After Returning通知--><bean id="logThrow" class="com.gc.action.LogThrow"/><bean id="logThrowAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice"><ref bean="logThrow"/></property><!--代理指定类中的doAuditing方法--><property name="patterns"><value>.*doAuditing.*</value></property></bean><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="proxyInterfaces"><value>com.gc.impl.TimeBookInterface</value></property><property name="target"><ref bean="timeBook"/></property><!--指定要代理的类--><property name="interceptorNames"><list><value>logThrowAdvisor</value></list></property></bean>
</beans>

//测试程序   TestHelloWorld.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import com.gc.impl.TimeBookInterface;public class TestHelloWorld {public static void main(String[] args){ApplicationContext actx = new FileSystemXmlApplicationContext("config.xml");TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("logProxy");timeBookProxy.doAuditing("张三");}
}结果
[ INFO ] 2020-04-20 22:03:17 [main] com.gc.action.LogThrow  - 张三 审核数据有异常抛出...
Exception in thread "main" java.lang.ArithmeticException: / by zeroat com.gc.action.TimeBook.doAuditing(TimeBook.java:9)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)at java.lang.reflect.Method.invoke(Unknown Source)at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:338)at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:197)at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)at org.springframework.aop.framework.adapter.ThrowsAdviceInterceptor.invoke(ThrowsAdviceInterceptor.java:127)at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:212)at com.sun.proxy.$Proxy4.doAuditing(Unknown Source)at com.gc.test.TestHelloWorld.main(TestHelloWorld.java:13)

上面讲的都是Java的动态代理，AOP中还有另外一种代理方式，即CGLIB代理。

Spring中的CGLIB代理

• 主要改变就是设定ProxyFactoryBean的proxyTargetClass属性，将该属性设定为“true”即可。
• ★★★使用CGLIB代理的好处就是不在像使用Java动态代理一样需要去实现特定的接口，只需要一个普通的类就可以。

示例：以Around通知实现。

//不需要接口，直接实现类TimeBook.java
public class TimeBook{//doAuditing()方法用来处理实际业务中的考勤审核//参数name，用来传入是谁执行了类TimeBook中的doAuditing()方法public void doAuditing(String name) {// 审核数据的相关程序}
}

//***************LogBefore.java********************
import java.lang.reflect.Method;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.aop.MethodBeforeAdvice;public class LogBefore implements MethodBeforeAdvice {private Logger logger = Logger.getLogger(this.getClass().getName());@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {logger.log(Level.INFO, args[0] + " 开始审核数据...");}
}

<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--以下是使用Spring AOP实现日志输出的Bean--><bean id="log" class="com.gc.action.LogAround"/>		<!--负责日志输出--><bean id="timeBook" class="com.gc.action.TimeBook"/>	<!--负责具体业务逻辑审核--><!--使用Spring提供的ProxyFactoryBean来实现代理--><bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><!--proxyInterface属性指明要代理的接口--><property name="proxyTargetClass"><value>true</value></property><!--Advice通知--><property name="target"><ref bean="timeBook"/></property><property name="interceptorNames"><list><value>log</value></list></property></bean>
</beans>

//测试程序   TestHelloWorld.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import com.gc.action.TimeBook;public class TestHelloWorld {public static void main(String[] args){ApplicationContext actx = new FileSystemXmlApplicationContext("config.xml");TimeBook timeBookProxy = (TimeBook)actx.getBean("logProxy");timeBookProxy.doAuditing("张三");}
}结果
[ INFO ] 2020-04-20 22:24:06 [main] com.gc.action.LogAround  - 张三 开始审核数据...
[ INFO ] 2020-04-20 22:24:06 [main] com.gc.action.LogAround  - 张三 审核数据结束...

Spring中的自动代理

对应大型企业应用，工作量太大，重复性工作很多，可以使用自动代理减轻工作量。

• （1）在接口TimeBookInterface中加入方法
• （2）在实现了TimeBook中实现方法
• （3）设置Before和After通知
• （4）修改配置文件，增加自动代理
• （5）测试程序

public interface TimeBookInterface {//负责具体的业务逻辑public void doAuditing(String name);public void doCheck(String name);
}

import com.gc.impl.TimeBookInterface;public class TimeBook implements TimeBookInterface{@Overridepublic void doAuditing(String name) {// 审核数据的相关程序System.out.println("审核数据的相关程序正在执行...");}@Overridepublic void doCheck(String name) {// 关账的相关程序System.out.println("财务关账的相关程序正在执行...");}	
}

import java.lang.reflect.Method;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.aop.MethodBeforeAdvice;public class LogBefore implements MethodBeforeAdvice {private Logger logger = Logger.getLogger(this.getClass().getName());@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {logger.log(Level.INFO, args[0] + " 开始审核数据...");}
}

import java.lang.reflect.Method;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.aop.AfterReturningAdvice;public class LogAfter implements AfterReturningAdvice {private Logger logger = Logger.getLogger(this.getClass().getName());@Overridepublic void afterReturning(Object object, Method method, Object[] args, Object target) throws Throwable {logger.log(Level.INFO, args[0] + " 审核数据结束...");		}
}

<!--config.xml-->
<?xml version="1.0" encoding="UTF8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans><bean id="timeBook" class="com.gc.action.TimeBook"/><bean id="autoProxyCreator" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/><!--以下是实现Before通知--><bean id="logBefore" class="com.gc.action.LogBefore"/><bean id="logBeforeAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice"><ref bean="logBefore"/></property><!--指定do开头的方法--><property name="patterns"><list><value>.*do.*</value><!--可以把Before指定为doCheck()方法：<value>.*doCheck.*</value>--></list></property></bean><!--以下是实现After通知--><bean id="logAfter" class="com.gc.action.LogAfter"/><bean id="logAfterAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="advice"><ref bean="logAfter"/></property><!--指定do开头的方法--><property name="patterns"><list><value>.*do.*</value><!--可以把After指定为doAuditing()方法：<value>.*doAuditing.*</value>--></list></property></bean>
</beans>

//测试程序   TestHelloWorld.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;import com.gc.impl.TimeBookInterface;public class TestHelloWorld {public static void main(String[] args){ApplicationContext actx = new FileSystemXmlApplicationContext("config.xml");TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("timeBook");timeBookProxy.doAuditing("张三");timeBookProxy.doCheck("李四");}
}结果
[ INFO ] 2020-04-20 22:53:09 [main] com.gc.action.LogBefore  - 张三 开始审核数据...
审核数据的相关程序正在执行...
[ INFO ] 2020-04-20 22:53:09 [main] com.gc.action.LogAfter  - 张三 审核数据结束...
[ INFO ] 2020-04-20 22:53:09 [main] com.gc.action.LogBefore  - 李四 开始审核数据...
财务关账的相关程序正在执行...
[ INFO ] 2020-04-20 22:53:09 [main] com.gc.action.LogAfter  - 李四 审核数据结束...