原文地址，轉載請註明出處，謝謝
前言
一年半前寫了一篇文章Spring3：AOP，是當時學習如何使用Spring AOP的時候寫的，比較基礎。這篇文章最後的推薦以及回覆認為我寫的對大家有幫助的評論有很多，但是現在從我個人的角度來看，這篇文章寫得併不好，甚至可以說是沒有太多實質性的內容，因此這些推薦和評論讓我覺得受之有愧。
基於上述原因，更新一篇文章，從最基礎的原始程式碼-->使用設計模式（裝飾器模式與代理）-->使用AOP三個層次來講解為什麼我們要使用AOP，希望這篇文章可以對網友朋友有益。
原始程式碼的寫法
#既然要透過程式碼來示範，那就必須有例子，這裡我的例子為：
<span style="color: #000000">有一个接口Dao有insert、delete、update三个方法，在insert与update被调用的前后，打印调用前的毫秒数与调用后的毫秒数<br></span>
先定義一個Dao介面：
##
1 /** 2 * @author 五月的仓颉 3 */ 4 public interface Dao { 5 6 public void insert(); 7 8 public void delete(); 9 10 public void update();11 12 }接著定義一個實作類別DaoImpl：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class DaoImpl implements Dao { 5 6 @Override 7 public void insert() { 8 System.out.println("DaoImpl.insert()"); 9 }10 11 @Override12 public void delete() {13 System.out.println("DaoImpl.delete()");14 }15 16 @Override17 public void update() {18 System.out.println("DaoImpl.update()");19 }20 21 }最原始的寫法，我要在呼叫insert()與update()方法前後分別列印時間，就只能定義一個新的類別包一層，在呼叫insert()方法與update()方法前後分別處理一下，新的類別我命名為ServiceImpl，其實作為：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class ServiceImpl { 5 6 private Dao dao = new DaoImpl(); 7 8 public void insert() { 9 System.out.println("insert()方法开始时间：" + System.currentTimeMillis());10 dao.insert();11 System.out.println("insert()方法结束时间：" + System.currentTimeMillis());12 }13 14 public void delete() {15 dao.delete();16 }17 18 public void update() {19 System.out.println("update()方法开始时间：" + System.currentTimeMillis());20 dao.update();21 System.out.println("update()方法结束时间：" + System.currentTimeMillis());22 }23 24 }這是最原始的寫法，這種寫法的缺點也是一目了然：
方法呼叫前後輸出時間的邏輯無法重複使用，如果有別的地方要增加這段邏輯就得再寫一遍
#如果Dao有其它實現類，那麼必須新增一個類去包裝該實作類，這將導致類別數量不斷膨脹
使用裝飾模式
接著我們使用上設計模式，先用裝飾器模式，看看能解決多少問題。裝飾器模式的核心是實作Dao介面並持有Dao介面的引用，我將新增的類別命名為LogDao，其實作為：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class LogDao implements Dao { 5 6 private Dao dao; 7 8 public LogDao(Dao dao) { 9 this.dao = dao;10 }11 12 @Override13 public void insert() {14 System.out.println("insert()方法开始时间：" + System.currentTimeMillis());15 dao.insert();16 System.out.println("insert()方法结束时间：" + System.currentTimeMillis());17 }18 19 @Override20 public void delete() {21 dao.delete();22 }23 24 @Override25 public void update() {26 System.out.println("update()方法开始时间：" + System.currentTimeMillis());27 dao.update();28 System.out.println("update()方法结束时间：" + System.currentTimeMillis());29 }30 31 }Dao dao = new LogDao(new DaoImpl())"的方式，這種方式的優點為：
使用代理模式
#接著我們使用代理模式嘗試實現最原始的功能，使用代理模式，那麼我們就要定義一個InvocationHandler，我將它命名為LogInvocationHandler，其實作為：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class LogInvocationHandler implements InvocationHandler { 5 6 private Object obj; 7 8 public LogInvocationHandler(Object obj) { 9 this.obj = obj;10 }11 12 @Override13 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {14 String methodName = method.getName();15 if ("insert".equals(methodName) || "update".equals(methodName)) {16 System.out.println(methodName + "()方法开始时间：" + System.currentTimeMillis());17 Object result = method.invoke(obj, args);18 System.out.println(methodName + "()方法结束时间：" + System.currentTimeMillis());19 20 return result;21 }22 23 return method.invoke(obj, args);24 }25 26 } 1 /** 2 * @author 五月的仓颉 3 */ 4 public static void main(String[] args) { 5 Dao dao = new DaoImpl(); 6 7 Dao proxyDao = (Dao)Proxy.newProxyInstance(LogInvocationHandler.class.getClassLoader(), new Class<?>[]{Dao.class}, new LogInvocationHandler(dao)); 8 9 proxyDao.insert();10 System.out.println("----------分割线----------");11 proxyDao.delete();12 System.out.println("----------分割线----------");13 proxyDao.update();14 }
结果就不演示了，这种方式的优点为：
输出日志的逻辑被复用起来，如果要针对其他接口用上输出日志的逻辑，只要在newProxyInstance的时候的第二个参数增加Class数组中的内容即可
这种方式的缺点为：
JDK提供的动态代理只能针对接口做代理，不能针对类做代理
代码依然有耦合，如果要对delete方法调用前后打印时间，得在LogInvocationHandler中增加delete方法的判断
使用CGLIB
接着看一下使用CGLIB的方式，使用CGLIB只需要实现MethodInterceptor接口即可：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class DaoProxy implements MethodInterceptor { 5 6 @Override 7 public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable { 8 String methodName = method.getName(); 9 10 if ("insert".equals(methodName) || "update".equals(methodName)) {11 System.out.println(methodName + "()方法开始时间：" + System.currentTimeMillis());12 proxy.invokeSuper(object, objects);13 System.out.println(methodName + "()方法结束时间：" + System.currentTimeMillis());14 15 return object;16 }17 18 proxy.invokeSuper(object, objects);19 return object;20 }21 22 }代码调用方式为：
1 /** 2 * @author 五月的仓颉 3 */ 4 public static void main(String[] args) { 5 DaoProxy daoProxy = new DaoProxy(); 6 7 Enhancer enhancer = new Enhancer(); 8 enhancer.setSuperclass(DaoImpl.class); 9 enhancer.setCallback(daoProxy);10 11 Dao dao = (DaoImpl)enhancer.create();12 dao.insert();13 System.out.println("----------分割线----------");14 dao.delete();15 System.out.println("----------分割线----------");16 dao.update();17 }使用CGLIB解决了JDK的Proxy无法针对类做代理的问题，但是这里要专门说明一个问题：使用装饰器模式可以说是对使用原生代码的一种改进，使用Java代理可以说是对于使用装饰器模式的一种改进，但是使用CGLIB并不是对于使用Java代理的一种改进。
前面的可以说改进是因为使用装饰器模式比使用原生代码更好，使用Java代理又比使用装饰器模式更好，但是Java代理与CGLIb的对比并不能说改进，因为使用CGLIB并不一定比使用Java代理更好，这两种各有优缺点，像Spring框架就同时支持Java Proxy与CGLIB两种方式。
从目前看来代码又更好了一些，但是我认为还有两个缺点：
无论使用Java代理还是使用CGLIB，编写这部分代码都稍显麻烦
代码之间的耦合还是没有解决，像要针对delete()方法加上这部分逻辑就必须修改代码
使用AOP
最后来看一下使用AOP的方式，首先定义一个时间处理类，我将它命名为TimeHandler：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class TimeHandler { 5 6 public void printTime(ProceedingJoinPoint pjp) { 7 Signature signature = pjp.getSignature(); 8 if (signature instanceof MethodSignature) { 9 MethodSignature methodSignature = (MethodSignature)signature;10 Method method = methodSignature.getMethod();11 System.out.println(method.getName() + "()方法开始时间：" + System.currentTimeMillis());12 13 try {14 pjp.proceed();15 System.out.println(method.getName() + "()方法结束时间：" + System.currentTimeMillis());16 } catch (Throwable e) {17 18 }19 }20 }21 22 }到第8行的代码与第12行的代码分别打印方法开始执行时间与方法结束执行时间。我这里写得稍微复杂点，使用了
这里多说一句，切面方法printTime本身可以不用定义任何的参数，但是有些场景下需要获取调用方法的类、方法签名等信息，此时可以在printTime方法中定义JointPoint，Spring会自动将参数注入，可以通过JoinPoint获取调用方法的类、方法签名等信息。由于这里我用的
接着看一下aop.xml的配置：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:aop="http://www.springframework.org/schema/aop" 5 xmlns:tx="http://www.springframework.org/schema/tx" 6 xsi:schemaLocation="http://www.springframework.org/schema/beans 7 8 9 ">10 11 <bean id="daoImpl" class="org.xrq.spring.action.aop.DaoImpl" />12 <bean id="timeHandler" class="org.xrq.spring.action.aop.TimeHandler" />13 14 <aop:config>15 <aop:pointcut id="addAllMethod" expression="execution(* org.xrq.spring.action.aop.Dao.*(..))" />16 <aop:aspect id="time" ref="timeHandler">17 <aop:before method="printTime" pointcut-ref="addAllMethod" />18 <aop:after method="printTime" pointcut-ref="addAllMethod" />19 </aop:aspect>20 </aop:config>21 22 </beans>
我不大会写expression，也懒得去百度了，因此这里就拦截Dao下的所有方法了。测试代码很简单：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class AopTest { 5 6 @Test 7 @SuppressWarnings("resource") 8 public void testAop() { 9 ApplicationContext ac = new ClassPathXmlApplicationContext("spring/aop.xml");10 11 Dao dao = (Dao)ac.getBean("daoImpl");12 dao.insert();13 System.out.println("----------分割线----------");14 dao.delete();15 System.out.println("----------分割线----------");16 dao.update();17 }18 19 }结果就不演示了。到此我总结一下使用AOP的几个优点：
切面的内容可以复用，比如TimeHandler的printTime方法，任何地方需要打印方法执行前的时间与方法执行后的时间，都可以使用TimeHandler的printTime方法
避免使用Proxy、CGLIB生成代理，这方面的工作全部框架去实现，开发者可以专注于切面内容本身
代码与代码之间没有耦合，如果拦截的方法有变化修改配置文件即可
下面用一张图来表示一下AOP的作用：
我们传统的编程方式是垂直化的编程，即A-->B-->C-->D这么下去，一个逻辑完毕之后执行另外一段逻辑。但是AOP提供了另外一种思路，它的作用是在业务逻辑不知情（即业务逻辑不需要做任何的改动）的情况下对业务代码的功能进行增强，这种编程思想的使用场景有很多，例如事物提交、方法执行之前的权限检测、日志打印、方法调用事件等等。
AOP使用场景举例
上面的例子纯粹为了演示使用，为了让大家更加理解AOP的作用，这里以实际场景作为例子。
第一个例子，我们知道MyBatis的事物默认是不会自动提交的，因此在编程的时候我们必须在增删改完毕之后调用SqlSession的commit()方法进行事物提交，这非常麻烦，下面利用AOP简单写一段代码帮助我们自动提交事物（这段代码我个人测试过可用）：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class TransactionHandler { 5 6 public void commit(JoinPoint jp) { 7 Object obj = jp.getTarget(); 8 if (obj instanceof MailDao) { 9 Signature signature = jp.getSignature();10 if (signature instanceof MethodSignature) {11 SqlSession sqlSession = SqlSessionThrealLocalUtil.getSqlSession();
12 13 MethodSignature methodSignature = (MethodSignature)signature;14 Method method = methodSignature.getMethod();15 16 String methodName = method.getName();17 if (methodName.startsWith("insert") || methodName.startsWith("update") || methodName.startsWith("delete")) {18 sqlSession.commit();19 }20 21 sqlSession.close();22 }23 }24 }25 26 }这种场景下我们要使用的aop标签为
这里我做了一个SqlSessionThreadLocalUtil，每次打开会话的时候，都通过SqlSessionThreadLocalUtil把当前会话SqlSession放到ThreadLocal中，看到通过TransactionHandler，可以实现两个功能：
insert、update、delete操作事物自动提交
对SqlSession进行close()，这样就不需要在业务代码里面关闭会话了，因为有些时候我们写业务代码的时候会忘记关闭SqlSession，这样可能会造成内存句柄的膨胀，因此这部分切面也一并做了
整个过程，业务代码是不知道的，而TransactionHandler的内容可以充分再多处场景下进行复用。
第二个例子是权限控制的例子，不管是从安全角度考虑还是从业务角度考虑，我们在开发一个Web系统的时候不可能所有请求都对所有用户开放，因此这里就需要做一层权限控制了，大家看AOP作用的时候想必也肯定会看到AOP可以做权限控制，这里我就演示一下如何使用AOP做权限控制。我们知道原生的Spring MVC，Java类是实现Controller接口的，基于此，利用AOP做权限控制的大致代码如下（这段代码纯粹就是一段示例，我构建的Maven工程是一个普通的Java工程，因此没有验证过）：
1 /** 2 * @author 五月的仓颉 3 */ 4 public class PermissionHandler { 5 6 public void hasPermission(JoinPoint jp) throws Exception { 7 Object obj = jp.getTarget(); 8 9 if (obj instanceof Controller) {10 Signature signature = jp.getSignature();11 MethodSignature methodSignature = (MethodSignature)signature;12 13 // 获取方法签名14 Method method = methodSignature.getMethod();15 // 获取方法参数16 Object[] args = jp.getArgs();17 18 // Controller中唯一一个方法的方法签名ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;19 // 这里对这个方法做一层判断20 if ("handleRequest".equals(method.getName()) && args.length == 2) {21 Object firstArg = args[0];22 if (obj instanceof HttpServletRequest) {23 HttpServletRequest request = (HttpServletRequest)firstArg;24 // 获取用户id25 long userId = Long.parseLong(request.getParameter("userId"));26 // 获取当前请求路径27 String requestUri = request.getRequestURI();28 29 if(!PermissionUtil.hasPermission(userId, requestUri)) {30 throw new Exception("没有权限");31 }32 }33 }34 }35 36 }37 38 }毫無疑問這種場景下我們要使用的aop標籤為
後記
#文章示範了從原生程式碼到使用AOP的過程，一點一點地介紹了每次演化的優缺點，最後以實際例子分析了AOP可以做什麼事情。
之前的那篇AOP入門的文章Spring3：AOP再結合上這篇文章，希望可以真正對網友朋友們有益。
以上是為什麼要使用AOP的詳細內容。更多資訊請關注PHP中文網其他相關文章！
