第八章 aop xml配置实现

最新推荐文章于 2021-11-09 17:03:00 发布

最新推荐文章于 2021-11-09 17:03:00 发布 · 110 阅读

文章标签：

#XML #AOP #配置管理 #Spring

spring 专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了如何通过XML配置实现Spring的AOP机制，包括服务层接口、实现类、切面类的定义，以及如何配置切入点和通知类型。通过实例展示了前置通知、后置通知、异常通知和最终通知的实现，并对切入点表达式进行了深入研究。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

通过XML配置来实现Spring的AOP

首先还是提供一个服务层的接口与实现类:
接口:
public interface UserService {
public void create() throws Exception;
public void update() throws Exception;
public void delete() throws Exception;
}
实现类:
public class UserServiceImpl implements UserService {
@Override
public void create() throws Exception {
System.out.println("create方法调用");
}
@Override
public void delete() throws Exception {
System.out.println("delete方法调用");
}
@Override
public void update() throws Exception {
System.out.println("update方法调用");
}
}

接着,提供一个切面类,这个时候我们可以看到切面类只是一个普通的Java类
public class MyAspect {
public void beforeAdvice() {
System.out.println("前置通知");
}
public void afterAdvice() {
System.out.println("后置通知");
}
public void throwAdvice() {
System.out.println("异常通知");
}
public void finallyAdvice() {
System.out.println("最终通知");
}
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("环绕通知:进入方法");
Object retVal = pjp.proceed();
System.out.println("环绕通知:退出方法");
return retVal;
}
}

接着,我们开始XML的配置,
首先,将服务层,和切面类纳入Spring的管理范围,这里我们使用XML配置的方式(记住,切面类一定要纳入Spring的管理范围)
<?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:context="http://www.springframework.org/schema/context"
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/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<bean id="userService" class="com.wdpc.aop.service.impl.UserServiceImpl" />
<bean id="myAspect" class="com.wdpc.aop.aspect.MyAspect" />
<aop:config>
<aop:aspect id="myAop" ref="myAspect">
<aop:pointcut id="mycut" expression="execution(* com.wdpc.aop..*.*(..))" />
<aop:before pointcut-ref="mycut" method="beforeAdvice" />
<aop:after-returning pointcut-ref="mycut" method="afterAdvice" />
<aop:after-throwing pointcut-ref="mycut" method="throwAdvice" />
<aop:after pointcut-ref="mycut" method="finallyAdvice" />
<aop:around pointcut-ref="mycut" method="aroundAdvice" />
</aop:aspect>
</aop:config>
</beans>
配置文件解释:
定义切面类: <bean id="myAspect" class="com.wdpc.aop.aspect.MyAspect" />
定义一个切面: <aop:aspect id="myAop" ref="myAspect">, 指定切面的实现类: ref="myAspect"
定义一个切入点:
<aop:pointcut id="mycut" expression="execution(* com.wdpc.aop..*.*(..))" />
前置通知:
<aop:before pointcut-ref="mycut" method="beforeAdvice" />, 引用切入点: pointcut-ref="mycut"

Test类:
public class Test {
public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService)ctx.getBean("userService");
try {
userService.create();
} catch (Exception e) {

}
}
}
可以改动UserServiceImpl类让create方法抛出一个异常,再看看执行的效果
@Override
public void create() throws Exception {
System.out.println("create方法调用");
throw new Exception();
}

切入点的简单研究:
 拦截返回类型为String类型的方法
在接口中添加一个方法,并在实现类中实现:
接口:
public String getUser() throws Exception;
实现类:
@Override
public String getUser() throws Exception {
System.out.println("getUser方法调用");
return "getUser";
}
修改切入点表达式:
<aop:pointcut id="mycut" expression="execution(java.lang.String com.wdpc.aop..*.*(..))" />
Test:
userService.getUser(); //被拦截
userService.create(); //不拦截

 拦截参数列表第一个为int类型的方法
在接口中添加一个方法,并在实现类中实现::
接口:
public String getUser() throws Exception;
public String getUser(int id) throws Exception;
public String getUser(int id, String name) throws Exception;

实现类:
@Override
public String getUser() throws Exception {
System.out.println("不带参的getUser方法调用");
return "getUser";
}

@Override
public String getUser(int id) throws Exception {
System.out.println("带参的getUser方法调用");
return "getUser";
}

@Override
public String getUser(int id, String name) throws Exception {
System.out.println("带丙个参数的getUser方法调用");
return "getUser";
}
可以看到方法重载了

修改切入点表达式:
<aop:pointcut id="mycut"
expression="execution(java.lang.String com.wdpc.aop..*.*(int,..))" />
注意这里: java.lang.Integer,.. 格式为:类型逗号两点

Test:
userService.getUser();
System.out.println("--------------");
userService.getUser(2);
System.out.println("--------------");
userService.getUser(2,"zhd");

 拦截返回类型为非void 类型的方法
修改切入点表达式,注意非空的写法 :!void
<aop:pointcut id="mycut"
expression="execution(!void com.wdpc.aop..*.*(..))" />
Test:
userService.create();
System.out.println("--------------");
userService.update();
System.out.println("--------------");
userService.delete();
System.out.println("--------------");
userService.getUser();
System.out.println("--------------");
userService.getUser(2);
System.out.println("--------------");
userService.getUser(2,"zhd");

 基于XML配置的
在切面中获取给方法传递的参数
这个时候就不能直接使用切入点的方式来编写了.
修改接口和实现类:
接口:
public void create(String name) throws Exception;
实现类:
@Override
public void create(String name) throws Exception {
System.out.println("create方法调用");
}
切面类:
public void beforeAdvice(String name) {
System.out.println("前置通知,获取的参数:" + name);
}
XML中的配置:
<aop:before pointcut="execution(* com.wdpc.aop..*.*(..)) and args(name)" method="beforeAdvice" arg-names="name" />
注意这里的写法:
pointcut="execution(* com.wdpc.aop..*.*(..)) and args(name)"
用的是pointcut,而不是pointcut-ref, 并且是and,而不是 &&
Test:
userService.create("zhd");

在切面中获取方法的返回值(注意,只能在后置通知中获取返回值)
修改接口,实现类, 切面类
接口:
public String create(String name) throws Exception;
实现类:
@Override
public String create(String name) throws Exception {
System.out.println("create方法调用");
return "这里是create的返回值:" + name;
}
切面类:
public void beforeAdvice(String name) {
System.out.println("前置通知,获取的参数:" + name);
}
public void afterAdvice(String result) {
System.out.println("后置通知,接收的返回值:" + result);
}
XML配置:
<aop:before pointcut="execution(* com.wdpc.aop..*.*(..)) and args(name)" method="beforeAdvice" arg-names="name" />
<aop:after-returning pointcut="execution(* com.wdpc.aop..*.*(..))" returning="result" method="afterAdvice" />

在切面中得到异常对象(只能在异常通知中获取)
修改实现类,让create 方法抛出一个异常
public String create(String name) throws Exception {
System.out.println("create方法调用");
throw new Exception("手动抛出的异常");
//return "这里是create的返回值:" + name;
}
return "这里是create的返回值:" + name; 这一句因为不可达,所以需要注释掉
修改切面类中的异常通知方法:
public void throwAdvice(Exception e) {
System.out.println("异常通知" + e);
}
XML配置:
<aop:after-throwing pointcut="execution(* com.wdpc.aop..*.*(..))" throwing="e" method="throwAdvice" />

Test:
public class Test {
public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService)ctx.getBean("userService");
try {
userService.create("zhd");
} catch (Exception e) {
}
}
}

前置通知接收参数时不能直接使用切入点的引用,
后置通知接收返回值是可以使用切入点的引用
异常通知接收异常对象是可以使用切入点的引用
<aop:config>
<aop:aspect id="mycut" ref="myAspect">
<aop:pointcut id="myPointcut" expression="execution(* com.wdpc.aop..*.*(..))" />
[color=red]<aop:before pointcut-ref="myPointcut and args(name)" method="beforeAdvice" arg-names="name"/>[/color]
<aop:after-returning pointcut-ref="myPointcut" returning="result" method="afterAdvice" />
<aop:after-throwing pointcut-ref="myPointcut" throwing="e" method="throwAdvice" />
<aop:after pointcut-ref="myPointcut" method="finallyAdvice"/>
<aop:around pointcut-ref="myPointcut" method="aroundAdvice"/>
</aop:aspect>
</aop:config>
红色部分为错误的语法.