AOP を使用する理由

原文アドレス、転載の際は出典を明記してください、ありがとうございます

前書き

1年半前に Spring3: AOP という記事を書き、勉強していました当時の Spring AOP の使用方法 当時書かれたもので、比較的基本的なものです。この記事の最後にある推奨事項と返信には、皆さんにとって役立つと思われるコメントがたくさん含まれていますが、個人的な観点から見ると、この記事はよく書かれておらず、内容が不十分であるとも言えます。非常に内容が充実しているので、これらの推奨事項やレビューは当然だと思います。

上記の理由を踏まえ、最も基本的なオリジナルコードから、デザインパターン（デコレータパターンとプロキシ）を使用し、3つのレベルの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. Dao に他の実装クラスがある場合は、実装クラスをラップする新しいクラスを追加する必要があります。これにより、クラスの数が増え続けます

2. デコレータモードを使用します

次に、デザインモードを使用します。最初にデコレータモードを使用します。どれだけの問題を解決できるか見てみましょう。デコレータ パターンの核心は、Dao インターフェイスを実装し、Dao インターフェイスへの参照を保持することです。新しいクラスに LogDao という名前を付けました。その実装は次のとおりです。 Dao dao = new LogDao(new DaoImpl())" メソッド。このメソッドの利点は次のとおりです。

透過的で、呼び出し元にとっては Dao のみがわかりますが、ログが関数

クラスは無限に拡張されません。Daoの他の実装クラスがログを出力する必要がある場合、LogDaoのコンストラクターに別のDao実装クラスを渡すだけです

しかし、この方法では欠点も明らかです:
出力ログのロジックは再利用できません
前と同じ時間を出力したい場合、出力ログのロジックはコードと結合されます。 delete() メソッドの後に、LogDao を変更する必要があります

ただし、このアプローチは、最もオリジナルのコード記述方法と比較して大幅に改善されています。
2. プロキシ モードの使用

次に、プロキシ モードを使用して、最も独創的な関数を実装してみます。次に、InvocationHandler を定義する必要があります。それに LogInvocationHandler という名前を付けました。その実装は次のとおりです:

 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 }

呼び出しメソッドは非常に簡単で、メイン関数を書きます:

 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 }

结果就不演示了，这种方式的优点为：

1. 输出日志的逻辑被复用起来，如果要针对其他接口用上输出日志的逻辑，只要在newProxyInstance的时候的第二个参数增加Class数组中的内容即可

这种方式的缺点为：

1. JDK提供的动态代理只能针对接口做代理，不能针对类做代理

2. 代码依然有耦合，如果要对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两种方式。

从目前看来代码又更好了一些，但是我认为还有两个缺点：

1. 无论使用Java代理还是使用CGLIB，编写这部分代码都稍显麻烦

2. 代码之间的耦合还是没有解决，像要针对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获取调用方法的类、方法签名等信息。由于这里我用的，要保证方法的调用，这样才能在方法调用前后输出时间，因此不能直接使用JoinPoint，因为JoinPoint没法保证方法调用。此时可以使用ProceedingJoinPoint，ProceedingPointPoint的proceed()方法可以保证方法调用，但是要注意一点，ProceedingJoinPoint只能和搭配，换句话说，如果aop.xml中配置的是，然后printTime的方法参数又是JoinPoint的话，Spring容器启动将报错。

接着看一下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的几个优点：

1. 切面的内容可以复用，比如TimeHandler的printTime方法，任何地方需要打印方法执行前的时间与方法执行后的时间，都可以使用TimeHandler的printTime方法

2. 避免使用Proxy、CGLIB生成代理，这方面的工作全部框架去实现，开发者可以专注于切面内容本身

3. 代码与代码之间没有耦合，如果拦截的方法有变化修改配置文件即可

下面用一张图来表示一下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，可以实现两个功能：

1. insert、update、delete操作事物自动提交

2. 对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 タグは であることに疑いの余地はありません。ここで書いたことは非常に単純で、現在のユーザーIDとリクエストパスを取得することで、そのユーザーにリクエストへのアクセス権限があるかどうかを判断することができます。

追記

この記事では、ネイティブ コードから AOP を使用するまでのプロセスを示し、それぞれの進化の長所と短所を少しずつ紹介し、最後に AOP で何ができるかを実際の例を用いて分析します。

前回の AOP 紹介記事 Spring3: AOP とこの記事を組み合わせることで、ネチズンや友人にとって真に有益であることを願っています。

以上がAOP を使用する理由の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。