spring AOP 之 xml 配置实现（附 Java 代码实例）
来源：互联网 发布：网络推广的工作 编辑：程序博客网 时间：2024/06/04 18:16
不过，这个就和学习spring的控制反转（IOC）和依赖注入（DI）一样，刚刚开始的时候，都是从简单的xml配置学起、然后再进一步简化：最开始也是在xml文件里面配置很多的bean，每个model都得配置一个bean标签，直到后来的只要一句话
<context:component-scan base-package="com.lxk.hello" />；
就可以搞定spring的依赖注入，也就是使用注解相关的配置了。
这个AOP配置也是这么个道理。所以先从这个麻烦但是基础的配置模式看起。好理解这个aop。
这个aop测试所使用到的jar包有以下：
aspectjrt.jar
aspectjweaver.jar
cglib-nodep-2.1_3.jar
spring.jar
某度云盘如下：
链接：http://pan.baidu.com/s/1nuUrV3z 密码：zppw
下面是测试代码。
共同接口：
package com.lxk.spring.aop;import java.util.List;/** * 目标对象和代理对象都实现的接口 */public interface PersonDao { void deletePerson(); List<Person> getPerson() throws Exception; void savePerson(); void updatePerson();}目标对象实现目标接口：
package com.lxk.spring.aop;import com.google.common.collect.Lists;import java.util.List;/** * 目标对象:实现目标接口 */public class PersonDaoImpl implements PersonDao { @Override public void deletePerson() { System.out.println("delete perosn"); } @Override public List<Person> getPerson() throws Exception { List<Person> personList = Lists.newArrayList(); Person person1 = new Person(); person1.setPid(1L); person1.setPname("person1"); System.out.println("get person"); personList.add(person1); Person person2 = new Person(); person2.setPid(2L); person2.setPname("person2"); personList.add(person2); return personList; } @Override public void savePerson() { System.out.println("delete perosn"); } @Override public void updatePerson() { System.out.println("delete perosn"); }}切面和切面里面的通知
package com.lxk.spring.aop;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.ProceedingJoinPoint;import java.util.ArrayList;import java.util.List;/** * 切面(spring aop 就不需要拦截器啦) * (模拟hibernate里面保存数据要打开事物，然后各种增删改之后，再提交事物。) */public class Transaction { public void beginTransaction() {//前置通知 //打开事物 System.out.println("begin Transaction"); } /** * @param joinPoint 通过joinPoint可以得到目标类和目标方法的一些信息 * @param val 目标方法的返回值 * 和<aop:after-returning returning="val"/>中returning的值保质一致 */ public void commit(JoinPoint joinPoint, Object val) {//后置通知 String methodName = joinPoint.getSignature().getName(); System.out.println(methodName); System.out.println(joinPoint.getTarget().getClass().getName()); //提交事物 System.out.println("commit"); List<Person> personList = (ArrayList<Person>) val; for (Person person : personList) { System.out.println(person.getPname()); } } public void finalMethod() { System.out.println("最终通知"); } public void aroundMethod(ProceedingJoinPoint joinPoint) {//环绕通知 try { System.out.println("around method"); joinPoint.proceed();//调用目标类的目标方法 } catch (Throwable e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * 异常通知 */ public void throwingMethod(Throwable except) { System.out.println(except.getMessage()); }}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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <!-- 1、目标类 2、切面3、进行aop的配置(目标接口没有：因为引入到容器是为了实例化对象，接口是不能实现对象的。)(也没有拦截器的引入，有的只是aop的配置，如上的3、) --> <!-- 目标类 --> <bean id="personDao" class="com.lxk.spring.aop.PersonDaoImpl"/> <!-- 切面的声明 --> <bean id="transaction" class="com.lxk.spring.aop.Transaction"/> <!-- aop配置 --> <aop:config> <!-- 配置aop的切入点 id 是切入点的标识 expression 为切入点的表达式 execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern） throws-pattern?） modifiers-pattern 修饰符 可选 public private protected ret-type-pattern 返回类型 必选 * 代表任意类型 declaring-type-pattern 方法的声明类型 name-patterm 方法名称类型 set* 以set开头的所有的方法名称 update* 以update开头的所有的方法名称 param-pattern 参数匹配 (..) 任意多个参数，每个参数任意多个类型 (*,String) 两个参数 第一个是任意类型，第二个是String (String,*,Integer) 三个参数，第一个是String类型，第二个是任意类型，第三个是Integer类型 throws-pattern 异常的匹配模式 例子： execution(* cn.itcast.spring.aop.xml.AService.*(..)); cn.itcast.spring.aop.xml.AService下的所有的方法 execution(public * cn.itcast.oa..*.*(..)) 返回值为任意类型，修饰符为public，在cn.itcast.oa包及子包下的所有的类的所有的方法 exectuion(* cn.itcast.oa..*.update*(*,String)) 返回值是任意类型，在cn.itcast.oa包及子包下所有的以update开头的参数为两个，第一个为任意类型 第二个为String类型的所有类的所有的方法 --> <aop:pointcut expression="execution(* com.lxk.spring.aop.PersonDaoImpl.*(..))" id="perform"/> <!-- 配置切面(切面里面配置通知)—— ref 指向声明切面的类 --> <aop:aspect ref="transaction"> <!-- 前置通知pointcut-ref 引用一个切入点 --> <aop:before method="beginTransaction" pointcut-ref="perform"/> <!-- 后置通知 * returning 目标方法的返回值 * 如果目标方法中有可能存在异常，异常确实发生了，这个时候，后置通知将不再执行 --> <!--<aop:after-returning method="commit" pointcut-ref="perform" returning="val"/>--> <!-- 最终通知 * 不能得到目标方法的返回值 * 无论目标方法是否有异常，最终通知都将执行 * 资源的关闭、连接的释放写在最终通知里 --> <!--<aop:after pointcut-ref="perform" method="finalMethod"/>--> <!-- 环绕通知 * ProceedingJoinPoint的proceed方法就是目标对象的目标方法 * 环绕通知可以控制目标对象目标方法执行 --> <!-- <aop:around method="aroundMethod" pointcut-ref="perform"/> --> <!-- 异常通知 在异常通知中获取目标方法抛出的异常 --> <!--<aop:after-throwing method="throwingMethod" pointcut-ref="perform" throwing="except"/>--> </aop:aspect> </aop:config></beans>
main方法测试类
package com.lxk.spring.aop;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;/** * 原理： * 当启动spring容器的时候， * * 会把纳入spring容器的bean实例化 * * spring容器会解析配置文件中的 * <aop:config>,从而解析aop:config下的切入点表达式 * * 解析出来以后就会在spring容器的bean中查找 * 是否有类符合切入点表达式，如果符合，则为这个对象创建代理对象 * * 客户端根据bean的id寻找一个bean,如果该bean有代理对象，则返回代理对象，如果没有代理对象则 * 返回bean的对象 * @author Administrator * */public class AOPXMLTest {@Testpublic void test() throws Exception{ApplicationContext context = new ClassPathXmlApplicationContext("com/lxk/spring/aop/applicationContext.xml");PersonDao personDao = (PersonDao)context.getBean("personDao");personDao.getPerson();}}person的model：
package com.lxk.spring.aop;/** * model */public class Person { private Long pid; private String pname; public Long getPid() { return pid; } public void setPid(Long pid) { this.pid = pid; } public String getPname() { return pname; } public void setPname(String pname) { this.pname = pname; }}上述代码模仿的是hibernate在操作数据库的时候，每当要增删改的时候，就要开启事物，然后增删改完之后，又得提交事物，每个增删改方法都得有这2个动作。然后就做这个优化。
具体如图：
然后各种注意事项都基本写在代码里面了。有不足的改天再补上。
实际开发用的不是这么个配置姿势，实际开发配置页和spring注解实现一样，也就一两行的配置，下次再说吧。
Spring AOP 中的 execution切入点指示符。执行表达式格式和实际代码对照，以及参数的理解。
execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern） throws-pattern?）
?，问号表示可选项。可填可不填。declaring-type是方法全名，只到类，不含方法名，具体就是类路径。看上面的图的对应关系可知。
关于切入点表达式，应该选中谁？
应该把目标类的目标方法给选中。
<aop:pointcut expression="execution(* com.lxk.spring.aop.PersonDaoImpl.*(..))" id="perform"/>
返回类型是任意类型，在com.lxk.spring.aop.PersonDaoImpl这个类下面的所有方法，方法的参数任意。然后这个切入点在spring容器中的名字也就是id是 id="perform"
在xml配置文件中，除前置通知外，其他的几个通知都给注释了。
下面讨论，这些个通知，一共5个。
前置通知：（<aop:before>）
method对应的是切面里面的通知--也就是切面里面的方法啦。参数就是切面里面的方法名，写错就找不到了。
pointcut-ref="perform"，是引用上面定义的切入点。
后置通知：（<aop:after-returning>）
method对应的是切面里面的通知--也就是切面里面的方法啦。参数就是切面里面的方法名，写错就找不到了。
pointcut-ref="perform"，是引用上面定义的切入点。
returning="val" 目标方法的返回值
这个目标方法对应的是 List<Person> getPerson() ，这方法的最终效果是获得查询结果。在最终测试文件里面要调用系统生成的代理对象：personDao.getPerson();
如果目标方法中有可能存在异常，异常确实发生了，这个时候，后置通知将不再执行
比如在getPerson()方法加入如下code ： int a = 100 / 0;
他就异常了，这个后置通知就不会执行了,与最终通知的区别：后置通知可能会不执行，但是最终通知会始终执行。
最终通知：（<aop:after>）
pointcut-ref="perform"，是引用上面定义的切入点。
method对应的是切面里面的通知--也就是切面里面的方法啦。参数就是切面里面的方法名，写错就找不到了。
不能得到目标方法的返回值
无论目标方法是否有异常，最终通知都将执行
资源的关闭、连接的释放写在最终通知里
环绕通知:（<aop:around>）
pointcut-ref="perform"，是引用上面定义的切入点。
method对应的是切面里面的通知--也就是切面里面的方法啦。参数就是切面里面的方法名，写错就找不到了。
有了环绕通知，那么前置后置通知，就可以暂时先注释掉。
ProceedingJoinPoint的proceed方法就是目标对象的目标方法
环绕通知可以控制目标对象目标方法执行.
前置通知和后置通知，则不能控制目标对象的目标方法的执行
异常通知:（<aop:after-throwing>）
在异常通知中获取目标方法抛出的异常
pointcut-ref="perform"，是引用上面定义的切入点。
method对应的是切面里面的通知--也就是切面里面的方法啦。参数就是切面里面的方法名，写错就找不到了。
throwing="except" 的参数和切面的异常通知抛的异常要一致。
最后关于xml配置spring aop 的注意事项：
1.如果切入点表达式的类写得不正确，则直接报错，找不到该类
2.如果切入点表达式的方法写错了，则客户端直接返回该bean的对象
3.spring的aop的原理可以采用两种形式产生代理对象
* 如果目标类实现接口，则spring会采用jdk动态代理
* 如果目标类没有实现接口，则采用cglib动态代理
4.针对一个目标类，切面可以有很多个
关于上面的第三点，可以如下测试：
PersonDaoImpl这个类不实现PersonDao接口，那么在主测试文件中，把 context.getBean("personDao")的返回值类型，改为目标对象类型。那么程序还是可以正常运行。
由前面的jdk动态代理和cglib动态代理的区别。可以确定，当 不实现接口的时候，使用的就是cglib来实现动态代理的。
做软件，做程序员，这个结果咱就不要猜，最有效的就是测试，自己整一下。就造了。
下面是我放的debug测试的截图，注意这个变量的名字，就可以说明这个就是cglib实现的动态代理。
关于上面的第四点，可以如下测试：
在xml配置文件里面再添加个id=logger的bean标签，将其纳入spring容器管理，当然对应实现个Java类代码
然后还在主测试文件调用，就可以。具体的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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <bean id="personDao" class="com.lxk.spring.aop.xml.PersonDaoImpl"/> <bean id="transaction" class="com.lxk.spring.aop.xml.Transaction"/> <bean id="logger" class="com.lxk.spring.aop.xml.Logger"/> <aop:config> <aop:pointcut id="perform" expression="execution(* com.lxk.spring.aop.xml.PersonDaoImpl.*(..))"/> <aop:aspect ref="transaction"> <aop:before method="beginTransaction" pointcut-ref="perform"/> </aop:aspect> <aop:aspect ref="logger"> <aop:before method="logging" pointcut-ref="perform"/> </aop:aspect> </aop:config></beans>
- spring AOP 之 xml 配置实现（附 Java 代码实例）
- spring AOP 之 注解 配置实现（附 Java 代码实例）
- spring AOP 之 注解 配置实现（附 Java 代码实例）
- Spring Aop实例之xml配置
- spring04 Spring Aop实例之xml配置
- Spring Aop实例之xml配置
- Spring Aop实例之xml配置
- Spring Aop实例之xml配置
- Spring Aop实例之xml配置
- Spring Aop实例之xml配置
- Spring Aop实例之xml配置
- Spring之AOP（非XML配置）
- Spring AOP XML配置实现
- Spring AOP之XML配置
- 实例说明Spring实现AOP的2种方式（注解和XML配置）
- Spring AOP+AspectJ在XML配置实例
- spring aop xml实例
- spring.AOP（XML实现）
- android中dp、dip、sp、px和屏幕密…
- 软件测试相关概念
- 应用无法发送重新扫描sdcard的广播
- 加载大图片到内存
- 初识Linux之常用命令一
- spring AOP 之 xml 配置实现（附 Java 代码实例）
- Xcode8 代码自动对齐快捷键
- 初识Linux之vi编辑器的使用
- 记录red hat linux&nbsp…
- 初识Linux之常用命令二
- linux的运行级别设置
- 掌上党校
- 勿忘音乐播放器
- hdoj 3499 Flight(最短路)
