AOP的好处与之前DAO和DAOIMPL的对比

原始代码的写法

既然要通过代码来演示，那必须要有例子，这里我的例子为：

有一个接口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 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()"); } }

最原始的写法，我要在调用insert()与update()方法前后分别打印时间，就只能定义一个新的类包一层，在调用insert()方法与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生成代理，这方面的工作全部框架去实现，开发者可以专注于切面内容本身 
代码与代码之间没有耦合，如果拦截的方法有变化修改配置文件即可。