原始代码的写法
既然要通过代码来演示，那必须要有例子，这里我的例子为：
有一个接口Dao有insert、delete、update三个方法，在insert与update被调用的前后，打印调用前的毫秒数与调用后的毫秒数
首先定义一个Dao接口：
public interface Dao {
public void insert();
public void delete();
public void update();
}
然后定义一个实现类DaoImpl：public class DaoImpl implements Dao { @Override最原始的写法，我要在调用insert()与update()方法前后分别打印时间，就只能定义一个新的类包一层，在调用insert()方法与update()方法前后分别处理一下
public void insert() {
System.out.println("DaoImpl.insert()");
} @Override
public void delete() {
System.out.println("DaoImpl.delete()");
} @Override
public void update() {
System.out.println("DaoImpl.update()");
} }
，新的类我命名为ServiceImpl，其实现为：
public class ServiceImpl {
private Dao dao = new DaoImpl();
public void insert() {
System.out.println("insert()方法开始时间：" + System.currentTimeMillis());
dao.insert();
System.out.println("insert()方法结束时间：" + System.currentTimeMillis());
}
public void delete() {
dao.delete();
}
public void update() {
System.out.println("update()方法开始时间：" + System.currentTimeMillis());
dao.update();
System.out.println("update()方法结束时间：" + System.currentTimeMillis());
}
}
这是最原始的写法，这种写法的缺点也是一目了然：
方法调用前后输出时间的逻辑无法复用，如果有别的地方要增加这段逻辑就得再写一遍
如果Dao有其它实现类，那么必须新增一个类去包装该实现类，这将导致类数量不断膨胀。
使用AOP
最后来看一下使用AOP的方式，首先定义一个时间处理类，我将它命名为TimeHandler：
public class TimeHandler {
public void printTime(ProceedingJoinPoint pjp) {
Signature signature = pjp.getSignature();
if (signature instanceof MethodSignature) {
MethodSignature methodSignature = (MethodSignature)signature;
Method method = methodSignature.getMethod();
System.out.println(method.getName() + "()方法开始时间：" + System.currentTimeMillis());
try {
pjp.proceed();
System.out.println(method.getName() + "()方法结束时间：" + System.currentTimeMillis());
} catch (Throwable e) {
e.printStackTrace();
}
}
}
}
切面方法printTime本身可以不用定义任何的参数，但是有些场景下需要获取调用方法的类、方法签名等信息，此时可以
在printTime方法中定义JointPoint，Spring会自动将参数注入，可以通过JoinPoint获取调用方法的类、方法签名等信息
。由于这里我用的aop:around，要保证方法的调用，这样才能在方法调用前后输出时间，因此不能直接使用JoinPoint，
因为JoinPoint没法保证方法调用。此时可以使用ProceedingJoinPoint，ProceedingPointPoint的proceed()方法可以保
证方法调用，但是要注意一点，ProceedingJoinPoint只能和aop:around搭配，换句话说，如果aop.xml中配置的是aop:before，
然后printTime的方法参数又是ProceedingJoinPoint的话，Spring容器启动将报错。
接着看一下ApplicationContext.xml的配置：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<bean id="daoImpl" class="org.xrq.spring.action.aop.DaoImpl" />
<bean id="timeHandler" class="org.xrq.spring.action.aop.TimeHandler" />
<aop:config>
<aop:pointcut id="addAllMethod" expression="execution(* org.xrq.spring.action.aop.Dao.*(..))" />
<aop:aspect id="time" ref="timeHandler">
<aop:before method="printTime" pointcut-ref="addAllMethod" />
<aop:after method="printTime" pointcut-ref="addAllMethod" />
</aop:aspect>
</aop:config>
</beans>
测试代码很简单：
public class AopTest {
@Test
@SuppressWarnings("resource")
public void testAop() {
ApplicationContext ac = new ClassPathXmlApplicationContext("spring/aop.xml");
Dao dao = (Dao)ac.getBean("daoImpl");
dao.insert();
System.out.println("----------分割线----------");
dao.delete();
System.out.println("----------分割线----------");
dao.update();
}
}
到此我总结一下使用AOP的几个优点： 切面的内容可以复用，比如TimeHandler的printTime方法，任何地方需要打印方法执行前的时间与方法执行后的时间，都可以使用TimeHandler的printTime方法
避免使用Proxy、CGLIB生成代理，这方面的工作全部框架去实现，开发者可以专注于切面内容本身
代码与代码之间没有耦合，如果拦截的方法有变化修改配置文件即可。