12
返回列表 回复 发帖

1#
打印
tT
onions发表于 2007-4-24 15:11 | 只看该作者

Spring的AOP

5.1  AOP基本思想
* C, L( d+ T) r. LAOP的意思是面向方面编程，英文全称是Aspect Oriented Programming，它使开发人员可以更好地将本不该彼此粘合在一起的功能分离开。
3 s8 {" @( F) uwww.huuoo.com
$ |: i% T* D: p. b4 x忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。5.1.1  认识AOP
  {: c! H! k7 M/ K4 L( f忽悠,忽悠社区,忽悠论坛.开发人员在编写应用程序时，通常包含两种代码：一种是和业务系统有关的代码，一是和业务系统关系不大的代码，例如日志、权限、异常处理、事务处理等。以前编写代码时，这两种代码基本是写在一起的，这样在程序中，到处充满着相同或类似的代码，例如日志信息的输出，每个方法都要写日志的输出，不利于程序的维护。而AOP就是使这两种代码分离的思想。使用AOP，就不用在业务逻辑中实现与业务功能关系不大的代码，从而降低了两种代码的耦合性，达到易于维护和重用的目的。
0 J8 K5 S5 }0 D) z* Wwww.huuoo.com
- W! {, q& P' g' o/ G忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。AOP，从字面的意思来理解就是面向方面编程，但却容易让初学者一头雾水，很多资料也都对AOP进行过解释，但过多地从理论的角度进行讲解其实用性，这里不再多讲，仅用一个例子来说明：基本上每个方法都要用日志进行记录，那么如果按照面向对象的思路来说，就是每个对象都有记录日志这样一个行为。要在每个方法里添加日志的信息，必然会产生大量的重复代码，但可以将记录日志看作是一个横切面，所有对这些方法的调用都要经过这个横切面，然后在这个横切面进行记录日志的操作，这样就达到代码重用和易于维护的目的了，这就是AOP的思想。
2 P) b& V6 |8 A& Z# Q) M
; m5 s" H) k) Q1 h. n- w忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。5.1.2  AOP与OOP对比分析
: ~! s7 i" E: }0 Y0 g- ]5 S忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。OOP（面向对象编程）对现代编程产生了深远的影响，经过多年的发展，目前已日趋成熟，它能很好地解决软件系统中角色划分的问题，借助于面向对象的分析、设计和实现，开发人员可以将现实领域的实体转换成软件系统中的对象，从而很自然地完成从现实到软件的转换。但OOP并不是一种完美的思想，在某些方面，OOP也有其不足之处。比如在日志、事务处理、权限管理等方面，当应用OOP将这些内容封装为对象的行为时，会产生大量的重复代码，虽然通过一些方法可以减少这种重复，但却不能彻底地解决该问题，于是AOP出现了。前面讲过AOP能够降低代码的耦合性，使得代码易于维护和重用。一个应用程序分为核心关注点和横切关注点。核心关注点和具体应用的功能相关，而横切关注点存在于整个系统的范围内。
  J! \0 o1 m. _0 ^( y- y$ Y7 `2 bwww.huuoo.com0 m2 q* u6 t/ I: B9 ~0 H
在AOP里，每个关注点的实现并不知道是否有其他关注点关注它，这是AOP和OOP的主要区别。在AOP里，组合的流向是从横切关注点到主关注点，而OOP中组合的流向则是从主关注点到横切关注点。从这点可以看出AOP和OOP它们所关注的对象是不同的，所以AOP可以和OOP很好地共存，AOP是OOP的有益补充，而不是其对立面。忽悠社区7 T  q6 G6 l# N5 C( C) `2 R
$ n! r* H( v- D  A
5.1.3  AOP与Java的代理机制忽悠,忽悠社区,忽悠论坛., H" }3 |2 d6 W3 R: V$ C
AOP是一种思想，它和具体的实现技术无关。任何一种符合AOP思想的技术实现，都可以看作是AOP的实现。
" V2 g3 G: y- F/ \www.huuoo.comJDK 1.3以后，Java提供了动态代理的机制。通过Java的动态代理机制，就可以很容易地实现AOP的思想。实际上Spring的AOP也是建立在Java的代理机制之上的。要理解Spring的AOP，先来了解Java的代理机制。下面主要通过一个输出日志的实例来使读者先了解Java的代理机制，从而引出AOP的几个关键点。
! z; w  A$ j4 o  h" b% U( ^忽悠,忽悠社区,忽悠论坛.5 k$ y9 \$ k8 S# S' i. Y" A4 l1 V" X
5.2  从一个输出日志的实例分析Java的代理机制忽悠,忽悠社区,忽悠论坛.4 M5 F* u- j5 ~. F3 F
上面讲到，要了解Spring的AOP，先来了解Java的代理机制。本节主要通过一个输出日志的实例来分析Java的代理机制。首先介绍以前写日志的时候是怎么实现的，然后讲解使用Java的代理机制怎么实现日志的输出，接着讲解怎样通过Java的动态代理机制把这个日志输出改成通用的，最后引出AOP的几个关键点。
8 {) T1 r- K2 G+ O- p6 Z0 _4 H+ O忽悠,忽悠社区,忽悠论坛.www.huuoo.com7 T4 g8 @! U1 A" d% f4 q( P
5.2.1  通用的日志输出方法
  }7 Y* ~# `& _2 @! b" q忽悠,忽悠社区,忽悠论坛.在笔者使用Spring以前开发的程序中，不管是使用Java自动的日志工具，还是使用Log4j，或是自己编写的日志工具，都要在每一个业务逻辑方法里编写记录日志的代码。使用AOP就可以使业务逻辑和记录日志这两件事情分离开。这个输出日志实例的实现思路是：首先给出原来在程序中编写日志的方法，然后编写测试程序，查看输出结果，最后对这种方法进行总结，指出这种方法的缺点。具体编写步骤如下：
3 M- r0 \* V+ c忽悠,忽悠社区,忽悠论坛.（1）打开Eclipse，在com.gc.action包中建立一个Java文件TimeBook.java，用来模拟实际业务中考勤审核的业务逻辑。
- G2 g. _1 V" E忽悠社区（2）原来在程序中编写日志时，都要在每一个业务逻辑方法里编写记录日志的代码。TimeBook.java的示例代码如下：
  1. //******* TimeBook.java**************
  2. import org.apache.log4j.Level;
  3. import org.apache.log4j.Logger;
  4. public class TimeBook {
  5.          private Logger logger = Logger.getLogger(this.getClass().getName());
  6.          //审核数据的相关程序
  7.          public void doAuditing(String name) {
  8.                   logger.log(Level.INFO, name + " 开始审核数据....");
  9.                   //审核数据的相关程序
  10.                   ……   
  11.                   logger.log(Level.INFO, name + " 审核数据结束....");
  12.          }
  13. }
复制代码
代码说明：8 a$ C  I% u" P9 r
  ●       在业务逻辑中使用log4j作为日志输出的工具。
# S! d; r- x* v3 Z' Awww.huuoo.com  ●       doAuditing()方法用来处理实际业务中的考勤审核。
+ L  y8 Z/ B+ P! X2 l9 K' o, V; [" }忽悠,忽悠社区,忽悠论坛.  ●       参数name，用来传入是谁执行了类TimeBook中的doAuditing()方法。
4 [) o0 Y/ o: q' y* B) O  ●       在审核代码的前后添加了用logger.log()方法实现日志输出的功能。
9 }% ?7 R% D: z- Q# k( f" ?. \" c; P（3）编写测试程序，继续在以前的测试程序TestHelloWorld的基础上进行修改，TestHelloWorld.java的示例代码如下：
  1. //******* TestHelloWorld.java**************
  2. package com.gc.test;
  3. import com.gc.action.TimeBook;
  4. public class TestHelloWorld {
  5.          public static void main(String[] args) {
  6.                    TimeBook timeBook = new TimeBook();
  7.                    timeBook.doAuditing("张三");
  8.     }
  9. }
复制代码
代码说明：timeBook.doAuditing("张三")表示该程序的执行人是“张三”。
( m1 o7 C/ s+ X（4）运行测试程序，查看通过TimeBook类输出的日志信息，如图5.1所示。
+ l( e7 m& j7 g- M7 N& nwww.huuoo.com

图5.1  通过TimeBook类输出日志信息

在上面的示例中，笔者把日志信息添加在了具体的业务逻辑中，假如程序中其他的代码都需要日志输出的功能，那么每个程序就都要添加和上面类似的代码。这样，在程序中，就会存在很多类似的日志输出代码，造成了很大的耦合，通过什么方法可以使业务逻辑和输出日志的代码分离呢？通过面向接口编程可以改进这个问题。


# L* a) G/ V8 m% J, {3 }

5.2.2  通过面向接口编程实现日志输出

忽悠社区0 \9 Y) e- h# }6 D# N
通过前面的示例程序，读者可以了解到以前添加日志信息方法的缺点。下面主要通过面向接口编程来改进这个缺点。其实现思路是：首先把执行考勤审核的doAuditing()方法提取出来成为接口，然后通过一个实体类来实现这个方法，在这个方法里编写具体的考勤审核的业务逻辑，接着通过一个代理类来进行日志输出，最后编写测试程序，查看输出结果。具体步骤如下：

（1）在com.gc.impl包中，建立一个接口TimeBookInterface。TimeBookInterface.java的示例代码如下：

  1. //******* TimeBookInterface.java**************
  2. package com.gc.impl;
  3. import org.apache.log4j.Level;
  4. //通过面向接口编程实现日志输出
  5. public interface TimeBookInterface
  6. {
  7.          public void doAuditing(String name);
  8. }
复制代码

（2）在com.gc.action包中，使前面已经建立好的类TimeBook实现接口TimeBookInterface，在doAuditing()方法中编写具体的考勤审核代码。TimeBook.java的示例代码如下：

  1. //******* TimeBook.java**************
  2. package com.gc.action;
  3. import com.gc.impl.TimeBookInterface;
  4. public class TimeBook implements TimeBookInterface
  5. {
  6. public void doAuditing(String name) {
  7. //审核数据的相关程序
  8. ……   
  9. }
  10. }
复制代码

（3）编写一个代理类，用来实现日志的输出，在该类中针对前面的接口TimeBookInterface编程，而不针对具体的类，从而实现具体业务逻辑与日志输出代码。TimeBookProxy.java的示例代码如下：

  1. //******* TimeBookProxy.java**************
  2. package com.gc.action;
  3. import org.apache.log4j.Level;
  4. import org.apache.log4j.Logger;
  5. import com.gc.impl.TimeBookInterface;
  6. public class TimeBookProxy
  7. {
  8.    private Logger logger = Logger.getLogger(this.getClass().getName());
  9.    private TimeBookInterface timeBookInterface;
  10.    //在该类中针对前面的接口TimeBookInterface编程，而不针对具体的类
  11.      public TimeBookProxy(TimeBookInterface timeBookInterface)
  12.      {
  13.          this.timeBookInterface = timeBookInterface;
  14.      }
  15.           //实际业务处理
  16.           public void doAuditing(String name)
  17.            {
  18.                    logger.log(Level.INFO, name + " 开始审核数据....");
  19.                    timeBookInterface.doAuditing(name);    //调用方法
  20.                    logger.log(Level.INFO, name + " 审核数据结束....");
  21.           }
  22. }
复制代码

（4）修改测试程序TestHelloWorld，把类TimeBook当作参数传入代理类TimeBookProxy中，从而实现对具体负责考勤审核类TimeBook的调用。TestHelloWorld.java的示例代码如下：

  1. //******* TestHelloWorld.java**************
  2. package com.gc.test;
  3. import com.gc.action.TimeBook;
  4. import com.gc.action.TimeBookProxy;
  5. public class TestHelloWorld {
  6.          public static void main(String[ ] args)
  7.              {
  8.                      //这里针对接口进行编程
  9.                      TimeBookProxy timeBookProxy  = new TimeBookProxy(new TimeBook());
  10.                      timeBookProxy .doAuditing("张三");
  11.              }
  12. }
复制代码

（5）运行测试程序，可以得到通过TimeBookProxy类输出日志信息，如图5.2所示。

图5.2  通过TimeBookProxy类输出日志信息

和前面一个日志输出做对比，可以看到，在这个示例中，具体负责考勤审核的业务逻辑代码和日志信息的代码分离开了，并且以后只要实现了接口TimeBookInterface的类，都可以通过代理类TimeBookProxy实现日志信息的输出，而不用再每个类里面都写日志信息输出的代码，从而实现了日志信息的代码重用。


( X5 i7 O7 r( A

5.2.3  使用Java的代理机制进行日志输出

忽悠,忽悠社区,忽悠论坛., N$ A7 `  H, J! v, u, B$ z" `9 g
前面的代码虽然有了一些改进，但是仍然有一定局限性，因为要使用代理类，就必须要实现固定的接口，有没有一种通用的机制，不管是不是实现这个接口，都可以实现日志信息的输出呢？


% V) N( Q" O, n1 V; q  n2 T" Y2 w8 _忽悠社区

Java提供的InvocationHandler接口可以实现这种功能，首先编写一个日志信息的代理类，这个代理类实现了接口InvocationHandler，然后和前面一个实例类似，编写一个接口，并实现这个接口，在实现类中编写具体的考勤审核代码，最后针对接口编写测试类，查看测试结果。具体步骤如下：

忽悠,忽悠社区,忽悠论坛.9 m# }$ H' }8 G
（1）编写一个日志信息的代理类LogProxy，这个代理类实现了接口InvocationHandler，可以对任何接口实现日志信息的输出。LogProxy.java的示例代码如下：

  1. //******* LogProxy.java**************
  2. package com.gc.action;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  6. import org.apache.log4j.Level;
  7. import org.apache.log4j.Logger;
  8. //代理类实现了接口InvocationHandler
  9. public class LogProxy implements InvocationHandler
  10. {
  11.          private Logger logger = Logger.getLogger(this.getClass().getName());
  12.          private Object delegate;
  13.          //绑定代理对象
  14.          public Object bind(Object delegate)
  15.              {
  16.                      this.delegate = delegate;
  17.                      return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),
  18.                      delegate.getClass().
  19.                      getInterfaces(), this);
  20.              }
  21.         //针对接口编程
  22.          public Object invoke(Object proxy, Method method, Object[ ] args) throws Throwable
  23.              {
  24.                      Object result = null;
  25.                               try {
  26.                                          //在方法调用前后进行日志输出
  27.                                         logger.log(Level.INFO, args[0] + " 开始审核数据....");
  28.                                         result = method.invoke(delegate, args); //调用绑定对象的方法
  29.                                         logger.log(Level.INFO, args[0] + " 审核数据结束....");
  30.                                   }
  31.                             catch (Exception e)
  32.                                  {
  33.                                        logger.log(Level.INFO, e.toString());
  34.                                  }
  35.                       return result;
  36.            }
  37. }
复制代码

（2）使用com.gc.impl包中的接口TimeBookInterface。TimeBookInterface.java的示例代码如下：

  1. //******* TimeBookInterface.java**************
  2. package com.gc.impl;
  3. import org.apache.log4j.Level;
  4. //针对接口编程
  5. public interface TimeBookInterface
  6. {
  7.          public void doAuditing(String name);
  8. }
复制代码

（3）使用com.gc.action包中的类TimeBook，doAuditing()方法中编写具体的考勤审核代码。TimeBook.java的示例代码如下：

  1. //******* TimeBook.java**************
  2. package com.gc.action;
  3. import com.gc.impl.TimeBookInterface;
  4. public class TimeBook implements TimeBookInterface
  5. {
  6.         public void doAuditing(String name)
  7.              {
  8.                     //审核数据的相关程序
  9.                     ……   
  10.             }
  11. }
复制代码

（4）修改测试代码TestHelloWorld，使用日志代理类LogProxy 实现日志的输出。TestHelloWorld.java的示例代码如下：

  1. //******* TestHelloWorld.java**************
  2. package com.gc.test;
  3. import com.gc.action.TimeBook;
  4. import com.gc.action.TimeBookProxy;
  5. import com.gc.impl.TimeBookInterface;
  6. import com.gc.action.LogProxy;
  7. public class TestHelloWorld {
  8.          public static void main(String[ ] args)
  9.                 {
  10.                       //实现了对日志类的重用
  11.                       LogProxy logProxy  = new LogProxy();
  12.                       TimeBookInterface timeBookProxy = (TimeBookInterface)logProxy.bind(new TimeBook());
  13.                       timeBookProxy.doAuditing("张三");
  14.                 }
  15. }
复制代码

（5）运行测试程序，可以得到通过LogProxy类输出日志信息，如图5.3所示。

这种方式，对于其他的类也同样适用，这样就真正地实现了业务逻辑和输出日志信息代码的分离。

忽悠,忽悠社区,忽悠论坛., O% F2 z; g: F7 t6 ^
5.2.4  对这3种实现方式进行总结


+ a2 U  n* H/ z& _4 C, Z' Y0 f第一种方式，需要在每个类里都增加对输出日志信息的代码；

第二种方式，虽然实现了业务逻辑与输出日志信息代码的分离，但还是必须依赖于固定的接口；

第三种方式，真正实现了对输出日志信息代码的重用，并且不依赖于固定的接口实现。


: w% e, m& X% [7 I3 `& E) |从第三种方式中，也可以看出Java动态代理机制的强大，而Spring的AOP正是建立在Java动态代理的基础上的，当读者通过上面的示例一步一步地对Java的动态代理机制有了一定的了解后，接下来就可以逐渐地进入AOP了。

收藏 分享 评分
回复 引用

订阅 TOP

2#
onions发表于 2007-4-24 16:18 | 只看该作者
5.3  AOP的3个关键概念忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。; w& l: v, `/ k$ J3 @4 A
因为AOP的概念难于理解，所以在前面首先对Java动态代理机制进行了一下讲解，从而使读者能够循序渐进地来理解AOP的思想。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。2 Y1 [. J( }( d7 \
学习AOP，关键在于理解AOP的思想，能够使用AOP。对于AOP众多的概念，读者只要理解3个重要的概念即可。这3个概念是Pointcut、Advice和Advisor。忽悠社区- A! a  F: I9 |* ^

/ `9 y+ J3 `2 h3 U  F! F) k$ d忽悠,忽悠社区,忽悠论坛.5.3.1  切入点（Pointcut）
- Z1 C2 m7 o) ]  h0 z忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。在介绍Pointcut前，有必要先介绍一下Join Point（连接点）的概念。Join 忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。% l* M7 D" L' T; `
Point指的是程序运行中的某个阶段点，如某个方法调用、异常抛出等。前面示例中的doAuditing()方法就是一个Join 忽悠社区! {( z" R3 R( W2 g% ~! [$ H
Point，表示程序是要在这个地方加入Advice。
- m7 D  u: E! g( d' [www.huuoo.comPointcut是Join Point的集合，它是程序中需要注入Advice的位置的集合，指明Advice要在什么样的条件下才能被触发。
+ v, D8 T3 ?- i0 O2 a7 [" `' k忽悠,忽悠社区,忽悠论坛.
. T8 q0 V# N1 \1 l忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。org.springframework.aop.Pointcut
# k9 `! i% q: K; F# {" }5 |* }9 \# v7 J
接口用来指定通知到特定的类和方法。查看Spring下载包里的源文件Pointcut.java，路径是spring-framework-2.0-m1\src\org\springframework\aop，可以看到Pointcut.java.源代码如下：
  1. //******* Pointcut.java**************
  2. package org.springframework.aop;
  3. public interface Pointcut
  4. {
  5.          //用来将切入点限定在给定的目标类中
  6.          ClassFilter getClassFilter();
  7.          //用来判断切入点是否匹配目标类给定的方法
  8.          MethodMatcher getMethodMatcher();
  9.          Pointcut TRUE = TruePointcut.INSTANCE;
  10. }
复制代码
代码说明：- ~  k6 X  x. O# K- ]
  ●       接口ClassFilter，用来将切入点限定在给定的目标类中。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。6 g4 a9 v4 Z+ y, t; n
  ●       接口MethodMatcher，用来判断切入点是否匹配目标类给定的方法。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。+ p3 f' V' l" A$ e
从上面可以看出，在接口Pointcut中，主要包含两个接口：ClassFilter和MethodMatcher，有利于代码的重用。
6 j9 ]: S# S6 e$ b& F忽悠,忽悠社区,忽悠论坛.忽悠,忽悠社区,忽悠论坛.3 E( e6 A6 I1 ^: W2 c# i
5.3.2  通知（Advice）忽悠,忽悠社区,忽悠论坛.3 M9 I. P  |4 [9 ^4 f
Advice是某个连接点所采用的处理逻辑，也就是向连接点注入的代码。前面示例中提取出来输出日志信息的代码就是一个Advice，表示要在Join Point加入这段代码。忽悠,忽悠社区,忽悠论坛.5 q( v3 \2 A) V9 Z8 d6 e2 a

# I2 B) D& j# m! o, Z; o* q忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。5.3.3  Advisor
- H5 E$ C4 @. u/ r9 ~. h) s9 M5 R8 a
6 K6 G/ d1 o0 H4 U5 Ewww.huuoo.comAdvisor是Pointcut和Advice的配置器，它包括Pointcut和Advice，是将Advice注入程序中Pointcut位置的代码。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。8 D3 o  j) a3 g  G2 [
上面只是粗略地对AOP的3个概念进行一下说明，目的是让读者能够较快地进入到AOP中，接下来将会分别对这3个概念进行更加详细的讲解。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。. M" q& Q$ o  y5 r8 T2 Y- _% {

; I* k1 R* ^, ^# ^6 [www.huuoo.com5.4  Spring的3种切入点（Pointcut）实现, k+ t: j( f. k! D2 ~
上节讲过，Pointcut是Join , e* ^- Y% s" v- G* _' \" b% j6 x
Point的集合，它是程序中需要注入Advice的位置的集合。Spring主要提供了3种切入点（Pointcut）的实现：静态切入点、动态切入点和自定义切入点，下面分别进行讲解。
) z% _' v, B/ H; N; v8 M' ]+ `3 _) V& c' n; a, J8 d4 m
5.4.1  静态切入点) Z( y% N3 N7 P. h/ K: V7 `
静态切入点只限于给定的方法和目标类，而不考虑方法的参数。
2 e, f; x* v/ T1 I忽悠社区Spring在调用静态切入点时只在第一次的时候计算静态切入点的位置，然后把它缓存起来，以后就不需要再进行计算。
- r% j( ^( H# R; u: e/ E; E忽悠,忽悠社区,忽悠论坛.忽悠社区# t/ p( E4 l' a2 p
使用org.springframework.aop.support.RegexpMethodPointcut
9 J. I, t4 H0 u( S2 N( I忽悠,忽悠社区,忽悠论坛.www.huuoo.com4 m. h2 Z+ f8 f" ]! f5 m
可以实现静态切入点，RegexpMethodPointcut是一个通用的正则表达式切入点，它是通过Jakarta ORO来实现的，需要把jakarta-oro-2.0.8.jar加入到ClassPath中，它的正则表达式语法和Jakarta ORO的正则表达式语法是一样的。使用RegexpMethodPointcut的一个示例代码如下：
  1. <bean id="settersAndAbsquatulatePointcut"  class="org.springframework.aop.support.RegexpMethodPointcut">
  2.     <property name="patterns">
  3.         <!--设定切入点-->
  4.         <list>
  5.             <value>.*save.*</value>
  6.             <value>.*do.* </value>
  7.         </list>
  8.     </property>
  9. </bean>
复制代码
代码说明：忽悠社区4 }2 z( }3 s: h1 M
  ●       .*save.*，表示所有以save开头的方法都是切入点。
8 I0 X# j* c1 y7 E  ●       .* do.*，表示所有以do开头的方法都是切入点。
" \: W- D. |8 O' t0 H忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。
/ y$ {6 X5 T7 O1 S5.4.2  动态切入点
5 h" X+ O" e$ X* {忽悠社区动态切入点与静态切入点的区别是，它不仅限定于给点的方法和类，动态切入点还可以指定方法的参数。
" S. O! B# j! q% `3 F7 _因为参数的变化性，所以动态切入点不能缓存，需要每次调用的时候都进行计算，因此使用动态切入点有很大的性能损耗。
8 p: m% N( l! X# B2 R4 y& ]. q( W! Bwww.huuoo.com当切入点需要在执行时根据参数值来调用通知时，就需要使用动态切入点。
! F1 v! G" F$ s. p忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。Spring提供了一个内建的动态切入点：控制流切入点。此切入点匹配基于当前线程的调用堆栈。开发人员只有在当前线程执行时找到特定的类和特定的方法才返回true。
) J  [9 ^5 g. c+ m( o! W其实大多数的切入点可以使用静态切入点，所以很少有机会创建动态切入点。
9 Q2 z9 o. i6 i( s$ h+ S# b. l忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。
: g3 ?4 g2 P5 e& M0 j; x, _  `5.4.3  自定义切入点4 g2 G' v" S% Z: @0 D" N) P1 n
因为Spring中的切入点是Java类，而不是语言特性（如AspectJ），因此可以定义自定义切入点。
$ W# k( l' ~" p( ]www.huuoo.com因为AOP还没有完全成熟，Spring提供的文档在这方面也没有提供更详细的解释，所以这里将不再对动态切入点和自定义切入点进行更加详细的介绍。& x8 W5 I2 T5 ~$ q
忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。- V  z8 @. o  g5 C, D+ ~
5.5  Spring的通知（Advice）www.huuoo.com' ?1 g$ I# X6 r" R1 ^) ^2 a# Y
Spring提供了5种Advice类型：
: \# D1 U( s/ Y; i8 a+ d忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。Interception Around   (在JointPoint前后)' I5 Q5 @7 @- N; l; A
Before                            (JointPoint前)
3 U8 R  W0 O& xAfter Returning             (JointPoint后)0 P7 Z3 @+ E/ F0 y2 V* H  G
Throw                           (JointPoint抛出异常时)
, v6 l- i  U6 k" {1 |! ZIntroduction                (JointPoint调用完毕后)
* m* v# b3 g' K* y; b忽悠,忽悠社区,忽悠论坛.它们分别在以下情况下被调用：在JointPoint前后、JointPoint前、JointPoint后、JointPoint抛出异常时、JointPoint调用完毕后。下面来进行更详细的讲解。! E' o' U3 V  _* K$ g% O8 C+ f

1 E- N- h/ S6 g; x: A7 ?5 A  I5.5.1  Interception Around通知
( i; L8 O- y1 A# lInterception Around通知会在JointPoint的前后执行，前面示例中的LogProxy就是一个Interception Around通知，它在考勤审核程序的前后都执行了。0 y- H+ N. Q, m9 G% E
Spring中最基本的通知类型便是Interception Around通知。实现Interception Around通知的类需要实现接口MethodInterceptor，示例代码如下：
  1. public class LogInterceptor implements MethodInterceptor
  2. {
  3.         public Object invoke(MethodInvocation invocation) throws Throwable
  4.               {
  5.                        System.out.println(" 开始审核数据...");
  6.                        Object rval = invocation.proceed();
  7.                        System.out.println(" 审核数据结束…");
  8.                        return rval;
  9.               }
  10. }
复制代码
5.5.2  Before通知
( X6 A0 H1 A+ P# p$ awww.huuoo.comBefore通知只在JointPoint前执行，实现Before通知的类需要实现接口MethodBeforeAdvice，示例代码如下：
  1. public class LogBeforeAdvice implements MethodBeforeAdvice
  2. {
  3.     public void before(Method m, Object[] args, Object target) throws Throwable
  4.          {
  5.                 System.out.println(" 开始审核数据...");
  6.          }
  7. }
复制代码
5.5.3  After Returning通知忽悠,忽悠社区,忽悠论坛.% B& T+ E8 ^" k4 h9 y
After Returning通知只在JointPoint后执行，实现After Returning通知的类需要实现接口AfterReturningAdvice，示例代码如下：
  1. public class LogAfterAdvice implements AfterReturningAdvice
  2. {
  3.     public void afterReturning (Method m, Object[] args, Object target) throws Throwable
  4.          {
  5.                  System.out.println(" 审核数据结束...");
  6.          }
  7. }
复制代码
5.5.4  Throw通知
+ f; U% q3 M4 A5 u, n6 @( }; bwww.huuoo.comThrow通知只在JointPoint抛出异常时执行，实现Throw通知的类需要实现接口ThrowsAdvice，示例代码如下：
  1. public class LogThrowAdvice implements ThrowsAdvice
  2. {
  3.     public void afterThrowing (RemoteException ex) throws Throwable
  4.     {
  5.         System.out.println(" 审核数据抛出异常，请检查..." + ex);
  6.     }
  7. }
复制代码
5.5.5  Introduction通知
0 ?: {/ H. ~. j- VIntroduction通知只在JointPoint调用完毕后执行，实现Introduction通知的类需要实现接口IntroductionAdvisor和接口IntroductionInterceptor。
/ U5 r  t- Y" h! d! ~7 m  t  H  v1 }前面所讲的知识点，更多的是理论，下面的章节将会讲述更多的实例，来帮助读者更好地理解上面的理论知识。忽悠社区1 I- O/ e( i; o* ~; w4 `7 ~. @

1 M' l# i7 d: U# owww.huuoo.com5.6  Spring的Advisor
2 P: Q9 B) Z& P' gwww.huuoo.com前面讲过，Advisor是Pointcut和Advice的配置器，它是将Advice注入程序中Pointcut位置的代码。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。$ s" Q2 J. A: |9 Q: w- }2 j! Z
org.springframework.aop.support.DefaultPointcutAdvisor是最通用的Advisor类。在Spring中，主要通过XML的方式来配置Pointcut和Advice
/ K0 m( K1 e4 T1 F6 K忽悠社区& s3 j& z3 o# z+ V1 I6 n. ]2 A
5.7  用ProxyFactoryBean创建AOP代理
) Q, w8 q; m9 H5 |" U2 c$ ^( v. Zwww.huuoo.com使用Spring提供的类org.springframework.aop.framework.ProxyFactoryBean是创建AOP的最基本的方式。忽悠,忽悠社区,忽悠论坛.' E* C, [% Y5 ~( j$ d$ W
忽悠社区3 }& v9 q; N3 g& [1 V
5.7.1  使用ProxyFactoryBean代理目标类的所有方法2 [9 N+ Z. G* q4 p
在Spring中，ProxyFactoryBean是在XML中进行配置的，它的示例代码如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <bean id="log" class="com.gc.action.LogAround"/>
  6. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  7. <!--设定代理类-->
  8. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  9.         <!--这里代理的是接口-->
  10.         <property name="proxyInterfaces">
  11.             <value>com.gc.impl.TimeBookInterface</value>
  12.         </property>
  13.                <!--是ProxyFactoryBean要代理的目标类-->
  14.         <property name="target">
  15.             <ref bean="timeBook"/>
  16.         </property>
  17.                <!--程序中的Advice-->
  18.         <property name="interceptorNames">
  19.             <list>
  20.                 <value>log</value>
  21.             </list>
  22.         </property>
  23.     </bean>
  24. </beans>
复制代码
代码说明：忽悠,忽悠社区,忽悠论坛.: C# ^7 V# l; N/ u8 m4 Z3 H7 k
  ●    id为log的Bean，是程序中的Advice。
6 ]2 d2 D) r, j8 T( G2 g忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。  ●    id为timeBook的Bean，是ProxyFactoryBean要代理的目标类。www.huuoo.com& Z! I% o2 J* @( e
  ●    id为logProxy的Bean，就是ProxyFactoryBean。忽悠社区) A2 g( w# }: c! b
  ●    ProxyFactoryBean的proxyInterfaces属性，指明要代理的接口。
% ~% z" X5 `7 D; A  ●    ProxyFactoryBean的target属性，指明要代理的目标类，这个目标类实现了上面proxyInterfaces属性指定的接口。! ~* ?5 x% g. O
  ●    ProxyFactoryBean的interceptorNames属性，指明要在代理的目标类中插入的Adivce。忽悠,忽悠社区,忽悠论坛.; |. B0 j. N# z! h* p$ l
  ●    ProxyFactoryBean还有一个proxyTargetClass属性，如果这个属性被设定为“true”，说明ProxyFactoryBean要代理的不是接口类，而是要使用CGLIB方式来进行代理，后面会详细讲解使用CGLIB方式来进行代理。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。) i, L1 G7 X4 x4 |4 i! D

5 O: ?' ^9 s- d8 b2 V/ m1 R2 rwww.huuoo.com%注意：ProxyFactoryBean的proxyInterfaces属性只支持使用字符串的方式进行注入，不支持使用Bean的依赖方式进行注入。
6 X" X- V: N0 a忽悠社区www.huuoo.com5 F  B; h/ X; B0 y" s7 }
5.7.2  使用ProxyFactoryBean代理目标类的指定方法
( L  @; G& [* b+ a( L; o' l忽悠,忽悠社区,忽悠论坛.
2 u1 V9 T% c' y. r$ J忽悠,忽悠社区,忽悠论坛.在上面的示例中，Advice会代理目标类的所有方法。忽悠社区. K# ?% {% G& ~2 f4 e
如果要代理目标类的指定方法，则需要使用Spring提供的
. P4 p* ]* A' G- n# H# uwww.huuoo.comorg.springframework.aop.support.RegexpMethodPointcutAdvisor类。
3 \/ j% ?! n  q代理目标类的指定方法的示例代码如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <bean id="log" class="com.gc.action.LogAround"/>
  6. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  7. <!--代理目标类的指定方法-->
  8. <bean id="logAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  9.         <property name="advice">
  10.             <ref bean="log"/>
  11.         </property>
  12.                <!--指定要代理的方法-->
  13.         <property name="patterns">
  14.             <value>.*doAuditing.* </value>
  15.         </property>
  16.     </bean>
  17. <!--设定代理类-->
  18. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  19.         <property name="proxyInterfaces">
  20.             <value>com.gc.impl.TimeBookInterface</value>
  21.         </property>
  22.         <property name="target">
  23.             <ref bean="timeBook"/>
  24.         </property>
  25.         <property name="interceptorNames">
  26.             <list>
  27.                 <value>logAdvisor</value>
  28.             </list>
  29.         </property>
  30.     </bean>
  31. </beans>
复制代码
代码说明：www.huuoo.com$ r! d5 g) n7 i& k  B0 G* e/ H
  ●       在id为logAdvisor的Bean中设定Advice和要指定的方法。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。* _/ ], U! P+ r$ g& l& Q; T7 v! e
  ●       把id为logProxy的Bean的interceptorNames属性值改为logAdvisor。
& x* H7 q! j$ y  ●       logAdvisor的advice属性指定Advice。www.huuoo.com) P7 Y* C, G1 k
  ●       logAdvisor的patterns属性指定要代理的方法。“.doAuditing”表示只有doAuditing()方法才使用指定的Advice。0 T. ?7 r3 y2 K& Q; r( w! g
忽悠,忽悠社区,忽悠论坛.  M, O  K) y, z# i* V: _
patterns属性值使用的是正则表达式，关于正则表达式的使用，下节将会进行讲解。
0 C" n  L7 f/ ?! D, l  p+ _忽悠社区%注意：因为要使用正则表达式，所以要把spring-framework-2.0-m1\lib\oro目录下的www.huuoo.com9 h6 x2 Y) D$ s
jakarta-oro-2.0.8.jar加入到ClassPath下，加入方法可参考第2章。忽悠,忽悠社区,忽悠论坛.. g( i# y, A- e2 ^* q$ H+ d+ \+ m

. [: H; x, K& A' e$ T5.7.3  正则表达式简介www.huuoo.com. ^- \/ y! Q  b1 d9 ~4 [& Y
正则表达式最早是由数学家Stephen 忽悠,忽悠社区,忽悠论坛./ Q" c9 t& c% c; I8 n: _, P) W/ R
Kleene于1956年在对自然语言的递增研究成果的基础上提出来的。正则表达式并非一门专用语言，但它可用于在一个文件中查找字符。下面把几个常用的进行一下讲解：
0 z! u& g( t  O5 w忽悠社区
) I; C: |. d& H' o( k* [+ [
（1）“.”，可以用来匹配任何一个字符。比如：正则表达式为“g.f”，它就会匹配“gaf”、“g1f”、“g*f”和“g #f”等。
5 q& c8 i# V) l4 m5 K) F0 [www.huuoo.com（2）“[]”，只有[]里指定的字符才能匹配。比如：正则表达式为“g[abc]f”，它就只能匹配“gaf”、“gbf”和“gcf”，而不会匹配“g1f”、“g*f”和“g#f”等。  a2 `  E2 \2 ^* _3 D2 p( c
（3）“*”，表示匹配次数，可以任意次，用来确定紧靠该符号左边的符号出现的次数。比如：正则表达式为“g.*f”，它能匹配“gaf”、“gaaf”、“gf”和“g*f”等。
9 u8 Z% r; f; H) p: v（4）“?”，可以匹配0或1次，用来确定紧靠该符号左边的符号出现的次数。比如：正则表达式为“g.?f”，它能匹配“gaf”“g*f”等。
. x6 O: p2 |* ]% mwww.huuoo.com（5）“\”，是正则表达式的连接符。比如：正则表达式为“g.\-f”，它能匹配“g-f”、“ga-f”和“g*-f”等。' @- D+ k$ h2 P7 o
www.huuoo.com% p1 b( q" R- P$ v- \
上面的示例中，只对TimeBook类的doAuditing()方法有效，如果要对TimeBook类中所有以do开头的方法有效，可以这样设定“.*do.*”，示例代码如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <bean id="log" class="com.gc.action.LogAround"/>
  6. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  7. <!--代理目标类的指定方法-->
  8. <bean id="logAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  9.         <property name="advice">
  10.             <ref bean="log"/>
  11.         </property>
  12.           /*对所有以do开头的方法有效*/
  13.         <property name="patterns">
  14.             <value>.*do.* </value>
  15.         </property>
  16.     </bean>
  17. <!--设定代理类-->
  18. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  19.         <property name="proxyInterfaces">
  20.             <value>com.gc.impl.TimeBookInterface</value>
  21.         </property>
  22.         <property name="target">
  23.             <ref bean="timeBook"/>
  24.         </property>
  25.                <!--指定要代理的类-->
  26.         <property name="interceptorNames">
  27.             <list>
  28.                 <value>logAdvisor</value>
  29.             </list>
  30.         </property>
  31.     </bean>
  32. </beans>
复制代码
上述代码对TimeBook类中所有以do开头的方法都有效。如果要对TimeBook类中所有方法有效，可以这样设定“.*com\.gc\.impl\.TimeBookInterface.*”，示例代码如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <bean id="log" class="com.gc.action.LogAround"/>
  6. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  7. <!--代理目标类的指定方法-->
  8. <bean id="logAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  9.         <property name="advice">
  10.             <ref bean="log"/>
  11.         </property>
  12.            /*注意包路径的定义*/
  13.         <property name="patterns">
  14.             <value> .*com\.gc\.impl\.TimeBookInterface.*</value>
  15.         </property>
  16.     </bean>
  17. <!--设定代理类-->
  18. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  19.         <property name="proxyInterfaces">
  20.             <value>com.gc.impl.TimeBookInterface</value>
  21.         </property>
  22.         <property name="target">
  23.             <ref bean="timeBook"/>
  24.         </property>
  25.                <!--指定要代理的类-->
  26.         <property name="interceptorNames">
  27.             <list>
  28.                 <value>logAdvisor</value>
  29.             </list>
  30.         </property>
  31.     </bean>
  32. </beans>
复制代码
上述代码对TimeBook类中所有的方法都有效。
& U7 y% Y7 B# y8 [忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。%注意：包的路径要用“\”连接符来表示“.”不是正则表达式的“.”。www.huuoo.com4 Q( Q% g3 C/ r" @
www.huuoo.com3 o8 s* s0 h% |
5.8  把输出日志的实例改成用Spring的AOP来实现www.huuoo.com$ J- _; t- Y4 {7 I( K

* r+ ]  w$ s" ]! }% q5 u在前面输出日志信息的实例中，没有用到Spring的任何组件，只是使用了Java的动态代理机制，但是却实实在在地体现了AOP的思想，如果使用Spring提供的AOP功能，应该怎样来实现前面那个实例呢？下面笔者就主要讲解如何把前面的那个实例改成通过Spring提供的AOP来实现。忽悠,忽悠社区,忽悠论坛.5 u% Q4 t) T; ?5 r3 {, w
7 w' n+ k2 Z! M; q; t7 t: l
5.8.1  采用Interception Around通知的形式实现2 u( G" o" T/ l) j% |
Interception Around通知会在JointPoint的前后执行，实现Interception Around通知的类需要实现接口MethodInterceptor。其实现思路是：首先实现接口MethodInterceptor，在invoke()方法里编写负责输出日志信息的代码，具体的业务逻辑还使用前面的接口TimeBookInterface和它的实现类TimeBook，然后在Spring的配置文档中定义Pointcut，最后编写测试程序，执行测试程序，查看输出结果。具体步骤如下：忽悠,忽悠社区,忽悠论坛.; D6 S0 b& U1 `+ t' z

' F/ J/ H2 |8 w  U+ e6 W4 Z（1）编写负责输出日志信息的类LogAround，该类实现了接口MethodInterceptor，重写了invoke()方法。LogAround.java的示例代码如下：
  1. //******* LogAround.java**************
  2. package com.gc.action;
  3. import org.aopalliance.intercept.MethodInvocation;
  4. import org.aopalliance.intercept.MethodInterceptor;
  5. import org.apache.log4j.Level;
  6. import org.apache.log4j.Logger;
  7. // Interception Around通知会在JointPoint的前后执行
  8. public class LogAround implements MethodInterceptor
  9. {
  10.          private Logger logger = Logger.getLogger(this.getClass().getName());
  11.          //负责输出日志信息的代码
  12.          public Object invoke(MethodInvocation mi) throws Throwable
  13.              {
  14.                    logger.log(Level.INFO, mi.getArguments()[0] + " 开始审核数据....");

  16.         try {
  17.                    Object result = mi.proceed();
  18.                     //返回值即是被调用的方法的返回值
  19.                    return result;
  20.         }
  21.         finally
  22.         {
  23.                             logger.log(Level.INFO, mi.getArguments()[0] + " 审核数据结束....");
  24.         }        
  25.    }
  26. }
复制代码
代码说明：www.huuoo.com' j- C7 l* V$ i/ x
  ●       参数MethodInvocation，通过它可以获得方法的名称、程序传入的参数Object[]等。( l+ M# }% R) q! x3 t/ D9 \
  ●       proceed()方法，通过它即可执行被调用的方法。
1 o+ e! p4 \  G" J3 `5 Y  ●       return result，返回值即是被调用的方法的返回值。www.huuoo.com0 n  O  s0 h1 r: [( @" ?" }
, v4 R# w1 M; I, n/ W3 M# W. [! a
（2）使用com.gc.impl包中的接口TimeBookInterface。TimeBookInterface.java的示例代码如下：
  1. //******* TimeBookInterface.java**************
  2. package com.gc.impl;
  3. import org.apache.log4j.Level;
  4. public interface TimeBookInterface
  5. {
  6.          //负责具体的业务逻辑
  7.          public void doAuditing(String name);
  8. }
复制代码
（3）使用com.gc.action包中的类TimeBook，doAuditing()方法中编写具体的考勤审核代码。TimeBook.java的示例代码如下：
  1. //******* TimeBook.java**************
  2. package com.gc.action;
  3. import com.gc.impl.TimeBookInterface;
  4. public class TimeBook implements TimeBookInterface
  5. {
  6.       public void doAuditing(String name)
  7.           {
  8.               //审核数据的相关程序
  9.                ……   
  10.           }
  11. }
复制代码
（4）定义Spring的配置文档config.xml。config.xml的示例代码如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <!--使用依赖注入完成变量值设定-->
  6.   <bean id="HelloWorld" class="com.gc.action.HelloWorld" depends-on="date">
  7.       <property name="msg">
  8.           <value>HelloWorld</value>
  9.       </property>
  10. <!--使用Bean进行参考-->
  11. <property name="date">
  12. <ref bean="date"/>
  13. </property>
  14. </bean>
  15. <bean id="date" class="java.util.Date"/>
  16. <!--以下是使用Spring AOP实现日志输出的Bean-->
  17. <bean id="log" class="com.gc.action.LogAround"/>
  18. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  19. <!--使用Spring提供的ProxyFactoryBean来实现代理-->
  20. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  21.         <property name="proxyInterfaces">
  22.             <value>com.gc.impl.TimeBookInterface</value>
  23.         </property>
  24.         <property name="target">
  25.             <ref bean="timeBook"/>
  26.         </property>
  27.                <!--指定要代理的类-->
  28.         <property name="interceptorNames">
  29.             <list>
  30.                 <value>log</value>
  31.             </list>
  32.         </property>
  33.     </bean>
  34. </beans>
复制代码
代码说明：
4 v# L6 |( S- f' }% J" u  ●       id为log的Bean，负责输出日志信息。
. n# S2 D5 `) r4 O! W( z7 wwww.huuoo.com  ●       id为timeBook的Bean，负责具体的业务逻辑考勤审核。
, Z) ?1 o0 A; D( z& E忽悠,忽悠社区,忽悠论坛.  ●       id为logProxy的Bean，使用Spring提供的ProxyFactoryBean来实现代理，在该Bean里要定义相关的属性，包括要代理的接口、目标类以及要使用的Interceptor。
- U8 V  R6 Y3 v6 h, r4 ]www.huuoo.com
( m- w9 t+ L% b% j' kwww.huuoo.com（5）修改测试代码TestHelloWorld，使用Spring提供的代理类ProxyFactoryBean实现日志的输出。TestHelloWorld.java的示例代码如下：
  1. //******* TestHelloWorld.java**************
  2. package com.gc.test;
  3. import com.gc.action.TimeBook;
  4. import com.gc.action.TimeBookProxy;
  5. import com.gc.impl.TimeBookInterface;
  6. public class TestHelloWorld
  7. {
  8.          public static void main(String[ ] args)
  9.             {
  10.                 //通过ApplicationContext获取XML
  11.                 ApplicationContext actx=new FileSystemXmlApplicationContext("config.xml");  
  12.                 TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("logProxy");
  13.                 timeBookProxy.doAuditing("张三");
  14.             }
  15. }
复制代码
（6）运行测试程序，可以得到通过LogAround类输出日志信息，如图5.4所示。忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。' l4 M' q* g, U% V

图5.4  通过LogAround类输出日志信息

上面这个例子即实现了Interception Around通知，最终的效果和前面使用Java代理的效果一样，但是功能却更加强大。假如有一个新的关账程序要实现日志输出，则可以建立新的接口和其实现类，然后只要在配置文件中注册一下就可以使新的实现类也输出日志信息了。

www.huuoo.com3 l- j) ], a; w$ K1 p, V

（7）在com.gc.impl包中建立新的接口FinanceInterface。FinanceInterface.java的示例代码如下：

  1. //******* FinanceInterface.java**************
  2. package com.gc.impl;
  3. import org.apache.log4j.Level;
  4. //定义为接口主要是为了实现代理
  5. public interface FinanceInterface
  6. {
  7.          public void doCheck(String name);
  8. }
复制代码

（8）在com.gc.action包中新建类Finance，doCheck()方法中编写具体的财务关账代码。Finance.java的示例代码如下：

  1. //******* Finance.java**************
  2. package com.gc.action;
  3. import com.gc.impl. FinanceInterface;
  4. public class Financeimplements FinanceInterface
  5. {
  6.      public void doCheck (String name)
  7.         {
  8.             //关账的相关程序
  9.             ……   
  10.         }
  11. }
复制代码

（9）定义Spring的配置文档config.xml。config.xml的示例代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5.   <!--使用依赖注入完成变量值设定-->
  6.   <bean id="HelloWorld" class="com.gc.action.HelloWorld" depends-on="date">
  7.       <property name="msg">
  8.           <value>HelloWorld</value>
  9.       </property>
  10. <property name="date">
  11. <ref bean="date"/>
  12. </property>
  13. </bean>
  14. <bean id="date" class="java.util.Date"/>
  15. <!--以下是使用Spring AOP实现日志输出的Bean-->
  16. <bean id="log" class="com.gc.action.LogAround"/>
  17. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  18. <!--以下是考勤审核-->
  19. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  20.         <property name="proxyInterfaces">
  21.             <value>com.gc.impl.TimeBookInterface</value>
  22.         </property>
  23.         <property name="target">
  24.             <ref bean="timeBook"/>
  25.         </property>
  26.                <!--指定要代理的类-->
  27.         <property name="interceptorNames">
  28.             <list>
  29.                 <value>log</value>
  30.             </list>
  31.         </property>
  32.     </bean>
  33. <!--以下是财务关账-->
  34. <bean id="finance" class="com.gc.action.Finance"/>
  35. <bean id="logProxy1" class="org.springframework.aop.framework.ProxyFactoryBean">
  36.         <property name="proxyInterfaces">
  37.             <value>com.gc.impl.FinanceInterface</value>
  38.         </property>
  39.         <property name="target">
  40.             <ref bean="finance"/>
  41.         </property>
  42. <!--指定要代理的类-->
  43.         <property name="interceptorNames">
  44.             <list>
  45.                 <value>log</value>
  46.             </list>
  47.         </property>
  48.     </bean>
  49. </beans>
复制代码

  ●       id为finance的Bean，负责具体的业务逻辑财务关账。忽悠,忽悠社区,忽悠论坛.  v! a! [) O5 f* X, J/ Q& p0 b
  ●       id为logProxy1的Bean，使用Spring提供的ProxyFactoryBean来实现代理，在该Bean里要定义相关的属性，包括要代理的接口、目标类以及要使用的Interceptor。

忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。0 Z! w. v! L+ V. A/ K

（10）修改测试代码TestHelloWorld，使用Spring提供的代理类ProxyFactoryBean实现日志的输出。TestHelloWorld.java的示例代码如下：

  1. //******* TestHelloWorld.java**************
  2. package com.gc.test;
  3. import com.gc.action.TimeBook;
  4. import com.gc.action.TimeBookProxy;
  5. import com.gc.impl.TimeBookInterface;
  6. import com.gc.impl.FinanceInterface;
  7. public class TestHelloWorld
  8. {
  9.          public static void main(String[ ] args)
  10.             {
  11.                  //通过ApplicationContext获取XML
  12.                  ApplicationContext actx=new FileSystemXmlApplicationContext("config.xml");      
  13.                  FinanceInterface financeProxy = (FinanceInterface)actx.getBean("logProxy1");
  14.                  financeProxy.doCheck("李四");
  15.     }
  16. }
复制代码

（11）运行测试程序，可以得到通过LogAround类输出日志信息，如图5.5所示。

图5.5  通过LogAround类输出日志信息


5 o+ a& ~- A2 m: j$ T; b忽悠,忽悠社区,忽悠论坛.

5.8.2  采用Before通知的形式实现忽悠社区是综合性社区网站,将最新、最快、最专业的资讯、新闻,图片,视频奉献给所有爱好者。5 e1 R* k, ~6 h
Before通知只在JointPoint的前面执行，实现Before通知的类需要实现接口MethodBeforeAdvice。实现思路是：首先实现接口MethodBeforeAdvice，在before()方法里编写负责输出日志信息的代码，具体的业务逻辑还使用前面的接口TimeBookInterface和它的实现类TimeBook，然后在Spring的配置文档中定义Pointcut，最后测试程序不用改变，执行测试程序，查看输出结果。具体步骤如下：

（1）编写负责输出日志信息的类LogBefore，该类实现了接口MethodBeforeAdvice，重写了before()方法。LogBefore.java的示例代码如下：

  1. //******* LogBefore.java**************
  2. package com.gc.action;
  3. import java.lang.reflect.Method;
  4. import org.apache.log4j.Level;
  5. import org.apache.log4j.Logger;
  6. import org.springframework.aop.MethodBeforeAdvice;
  7. //实现Before通知的类需要实现接口MethodBeforeAdvice
  8. public class LogBefore implements MethodBeforeAdvice
  9. {
  10.          private Logger logger = Logger.getLogger(this.getClass().getName());
  11.          // Before通知只在JointPoint的前面执行
  12.          public void before(Method method, Object[ ] args, Object target) throws Throwable
  13.             {
  14.                    logger.log(Level.INFO, args[0] + " 开始审核数据....");
  15.             }
  16. }
复制代码

（2）使用com.gc.impl包中的接口TimeBookInterface。TimeBookInterface.java的示例代码如下：

  1. //******* TimeBookInterface.java**************
  2. package com.gc.impl;
  3. import org.apache.log4j.Level;
  4. public interface TimeBookInterface
  5. {
  6.          public void doAuditing(String name);
  7. }
复制代码

（3）使用com.gc.action包中的类TimeBook，doAuditing()方法中编写具体的考勤审核代码。TimeBook.java的示例代码如下：

  1. //******* TimeBook.java**************
  2. package com.gc.action;
  3. import com.gc.impl.TimeBookInterface;
  4. public class TimeBook implements TimeBookInterface
  5. {
  6.       public void doAuditing(String name)
  7.           {
  8.                   //审核数据的相关程序
  9.                   ……   
  10.           }
  11. }
复制代码

（4）定义Spring的配置文档config.xml。config.xml的示例代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.springframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5.    <!--使用依赖注入完成变量值设定-->
  6.   <bean id="HelloWorld" class="com.gc.action.HelloWorld" depends-on="date">
  7.       <property name="msg">
  8.           <value>HelloWorld</value>
  9.       </property>
  10. <property name="date">
  11. <ref bean="date"/>
  12. </property>
  13. </bean>
  14. <bean id="date" class="java.util.Date"/>
  15. <!--以下是使用Spring AOP实现日志输出的Bean-->
  16. <bean id="log" class="com.gc.action.LogAop"/>
  17. <!--负责具体的业务逻辑考勤审核-->
  18. <bean id="timeBook" class="com.gc.action.TimeBook"/>
  19. <bean id="logProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  20.         <property name="proxyInterfaces">
  21.             <value>com.gc.impl.TimeBookInterface</value>
  22.         </property>
  23.         <property name="target">
  24.             <ref bean="timeBook"/>
  25.         </property>
  26.                 <!--指定要代理的类-->
  27.         <property name="interceptorNames">
  28.             <list>
  29.                 <value>log</value>
  30.             </list>
  31.         </property>
  32.     </bean>
  33. <!--以下是实现Before通知-->
  34. <bean id="logBefore" class="com.gc.action.LogBefore"/>
  35.   <bean id="logBeforeAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  36.         <property name="advice">
  37.             <ref bean="logBefore"/>
  38.         </property>
  39.         <!--代理指定类中的doAuditing 方法-->
  40.         <property name="patterns">
  41.             <value>.*doAuditing.* </value>
  42.         </property>
  43.     </bean>
  44.   <bean id="logProxy2" class="org.springframework.aop.framework.ProxyFactoryBean">
  45.         <property name="proxyInterfaces">
  46.             <value>com.gc.impl.TimeBookInterface</value>
  47.         </property>
  48.         <property name="target">
  49.             <ref bean="timeBook"/>
  50.         </property>
  51. <!--指定要代理的类-->
  52.         <property name="interceptorNames">
  53.             <list>
  54.                 <value>logBeforeAdvisor</value>
  55.             </list>
  56.         </property>
  57.   </bean>
  58. </beans>
复制代码

代码说明：
6 X: B- _% V2 R, \0 _4 R  ●       id为timeBook的Bean，负责具体的业务逻辑考勤审核。忽悠社区5 b3 b4 o6 n$ A: m) ~$ b
  ●       id为logProxy2的Bean，使用Spring提供的ProxyFactoryBean来实现代理，在该Bean里要定义相关的属性，包括要代理的接口、目标类以及要使用的Interceptor。
- W/ e' P" @: ]9 B+ U5 n忽悠,忽悠社区,忽悠论坛.  ●       id为logBeforeAdvisor的Bean，使用类RegexpMethodPointcutAdvisor来实现对切入点的配置
/ `, V( z: m3 }4 R, R忽悠,忽悠社区,忽悠论坛.  ●       属性名为patterns的值，指明只对doAuditing()方法有效。

（5）修改测试代码TestHelloWorld，使用Spring提供的代理类ProxyFactoryBean实现日志的输出。TestHelloWorld.java的示例代码如下：

  1. //******* TestHelloWorld.java**************
  2. package com.gc.test;
  3. import com.gc.action.TimeBook;
  4. import com.gc.action.TimeBookProxy;
  5. import com.gc.impl.TimeBookInterface;
  6. public class TestHelloWorld
  7. {
  8.          public static void main(String[ ] args)
  9.             {
  10.                    //通过ApplicationContext来获取XML
  11.                   ApplicationContext actx=new FileSystemXmlApplicationContext("config.xml");      
  12.                   TimeBookInterface timeBookProxy = (TimeBookInterface)actx.getBean("logProxy2");
  13.                   timeBookProxy.doAuditing("张三");
  14.             }
  15. }
复制代码

（6）运行测试程序，可以得到通过LogBefore类输出日志信息，如图5.6所示。

图5.6  通过LogBefore类输出日志信息

上面这个例子即实现了Before通知。

www.huuoo.com" a8 J$ T1 u: }) y: x5 p  L
5.8.3  采用After Returning通知的形式实现
; Q6 d7 c8 K. Y8 W1 @  E7 Ewww.huuoo.comAfter Returning通知只在JointPoint的后面执行，实现After Returning通知的类需要实现接口AfterReturningAdvice。

其实现思路是：首先实现接口AfterReturningAdvice，在afterReturning()方法里编写负责输出日志信息的代码，具体的业务逻辑还使用前面的接口TimeBookInterface和它的实现类TimeBook，然后在Spring的配置文档中定义Pointcut，最后测试程序不用改变，执行测试程序，查看输出结果。具体步骤如下：; s, O# w/ G7 H  C  u9 D
（1）编写负责输出日志信息的类LogAfter，该类实现了接口AfterReturningAdvice，重写了afterReturning()方法。LogAfter.java的示例代码如下：
回复 引用

TOP

游客 60.32.0.x
3#
游客 发表于 2007-7-25 16:46
::
回复 引用

TOP

游客 60.32.0.x
4#
游客 发表于 2007-7-25 16:47
写的这么好.  怎么不写完呢?
回复 引用

TOP

12
返回列表
高级回复 | 发新话题
B Color Image Link Quote Code Smilies
换一个