Spring aop-阿里云开发者社区

1.Spring aop的背景

Spring AOP（面向切面编程）是Spring框架中的一个重要特性，用于实现横切关注点的模块化和重用。

背景：

在传统的面向对象编程中，应用程序的功能被分散在各个类和方法中。当应用程序需要实现特定的横向关注点（如日志记录、性能监测、事务管理等）时，这些关注点的代码会散布在各个类和方法中，导致代码的冗余和重复。

Spring AOP的背景是解决这样的问题。它借助于反射和动态代理等技术，将关注点的代码从被关注的对象中解藕，实现关注点的模块化和重用。通过AOP，我们可以在不修改原始代码的情况下，将关注点的代码动态地织入到应用程序的不同位置。

Spring AOP的实现原理是基于动态代理。Spring通过代理模式创建了一个代理对象，该代理对象包含了横切逻辑。当应用程序调用代理对象的方法时，代理对象会在调用前、调用后或抛出异常时，执行指定的横切逻辑。

使用Spring AOP，可以将横切关注点与核心业务逻辑分离，提高代码的可维护性和重用性。同时，它还可以降低代码的耦合性，使系统更易于测试和扩展。

总结：

Spring AOP是Spring框架中的一个重要特性，用于实现横切关注点的模块化和重用。它的背景是为了解决传统面向对象编程中的代码冗余和重复的问题。通过AOP，我们可以将关注点的代码动态地织入到应用程序的不同位置，使代码更具可维护性和重用性。

2.Spring aop的用途：

Spring AOP的主要用途是实现横切关注点的模块化和重用。它可以应用于各种方面，包括但不限于以下几个方面：

日志记录：通过AOP，可以在方法的调用前后记录日志，用于跟踪应用程序的执行过程，帮助调试和问题排查。

安全性控制：通过AOP，可以在方法的调用前进行权限验证，确保只有具有足够权限的用户可以访问敏感操作。

事务管理：通过AOP，可以在方法的调用前后处理事务，实现数据库操作的原子性和一致性。

性能监测：通过AOP，可以在方法的调用前后计算方法的执行时间，用于性能分析和优化。

异常处理：通过AOP，可以在方法执行过程中捕获并处理异常，实现统一的异常处理逻辑。

缓存管理：通过AOP，可以在方法的调用前后处理缓存操作，提高应用程序的性能。

日志审计：通过AOP，可以在方法的调用前后进行日志审计，用于记录敏感操作和数据变更。

并发控制：通过AOP，可以在方法的调用前后进行并发控制，确保对共享资源的安全访问。

Spring AOP提供了一种简洁和灵活的方式来实现这些横切关注点，在不修改原始代码的情况下，将关注点的代码动态地织入到应用程序中。这样，可以有效地提高代码的可维护性、重用性和可测试性，降低代码的耦合性，使代码更易于理解和扩展。

3.Spring aop的特点：

Spring AOP有以下几个特点：

非侵入性：使用Spring AOP并不需要修改原始代码，而是通过代理来实现横切关注点的织入。这意味着开发人员可以专注于核心业务逻辑而不需要考虑横切关注点的实现细节。

模块化和重用性：Spring AOP将关注点的代码从被关注的对象中解耦，使其成为可独立的模块。这样，可以将关注点的代码在不同的应用程序中重用，提高代码的模块化和重用性。

动态性：Spring AOP的横切关注点是在运行时动态织入的，而不是在编译时静态织入的。这意味着可以在运行时动态地决定是否织入横切关注点，以及如何织入。

支持多种织入方式：Spring AOP支持多种织入方式，包括基于接口的代理、基于类的代理和基于注解的代理。这样，开发人员可以选择最适合自己的织入方式。

可扩展性：Spring AOP提供了扩展点，开发人员可以通过编写自定义的切面、通知和切点来扩展和定制AOP的功能。这使得Spring AOP具有很高的灵活性和可扩展性。

高性能：Spring AOP使用了动态代理技术，性能较高。对于基于接口的代理，Spring使用JDK动态代理；对于基于类的代理，Spring使用CGLIB代理。根据应用程序的需求，可以选择适合的代理方式来获得更好的性能。

4.Spring aop的专业术语：

这几个词需要牢记以后会频繁出现：

切面（Aspect）：切面是横切关注点的模块化，它包含了在程序中需要被跨越的点，比如日志记录、事务管理等。

连接点（Join Point）：连接点是在应用程序执行过程中可以插入切面的一个点，比如方法调用、异常抛出等。

通知（Advice）：通知定义了在连接点上执行的动作，包括前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）等。

切点（Pointcut）：切点是一个表达式，用来匹配连接点的准则。它定义了哪些连接点会被切面的通知所影响。

引入（Introduction）：引入允许向现有的类添加新的方法或属性。

目标对象（Target Object）：目标对象是被一个或多个切面所通知的对象。

AOP代理（AOP Proxy）：AOP代理是由AOP框架动态生成的对象，用于将切面织入到目标对象中。

5.Spring aop的前置通知：

前置通知可以用来执行以下操作：

记录日志：在目标方法执行之前记录日志，包括方法名称、参数值等信息，用于跟踪应用程序的执行过程。

权限验证：在目标方法执行之前进行权限验证，确保只有具有足够权限的用户可以访问敏感操作。

输入校验：在目标方法执行之前对输入参数进行校验，确保输入的合法性和有效性。

缓存操作：在目标方法执行之前进行缓存操作，检查缓存中是否存在所需的数据，避免重复的计算或查询。

实例演示：

先创建一个接口：IBookBiz

package com.zking.aop.biz;
public interface IBookBiz {
  // 购书
  public boolean buy(String userName, String bookName, Double price);
  // 发表书评
  public void comment(String userName, String comments);
}

在建一个接口实现类：BookBizImpl

package com.zking.aop.biz.impl;
import com.zking.aop.biz.IBookBiz;
import com.zking.aop.biz.exception.PriceException;
public class BookBizImpl implements IBookBiz {
  public BookBizImpl() {
    super();
  }
  public boolean buy(String userName, String bookName, Double price) {
    // 通过控制台的输出方式模拟购书
    if (null == price || price <= 0) {
      throw new PriceException("book price exception");
    }
    System.out.println(userName + " buy " + bookName + ", spend " + price);
    return true;
  }
  public void comment(String userName, String comments) {
     //通过控制台的输出方式魔力发表书评
    System.out.println(userName + " say:" + comments);
  }
}

再建一个异常类：PriceException

package com.zking.aop.biz.exception;
/**
 * 异常类
 */
public class PriceException extends RuntimeException {
  public PriceException() {
    super();
  }
  public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    super(message, cause, enableSuppression, writableStackTrace);
  }
  public PriceException(String message, Throwable cause) {
    super(message, cause);
  }
  public PriceException(String message) {
    super(message);
  }
  public PriceException(Throwable cause) {
    super(cause);
  }
}

配置Spring-context.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--ioc的javaBean-->
<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->
<bean class="com.zking.ioc.web.UserAction" id="userAction">
    <property name="userService" ref="userService"></property>
    <constructor-arg name="uname" value="雨哦西" ></constructor-arg>
    <constructor-arg name="age" value="18" ></constructor-arg>
    <constructor-arg name="hobby"  >
        <list>
            <value>大大的</value>
            <value>花菇凉</value>
        </list>
    </constructor-arg>
</bean>
<bean class="com.zking.ioc.web.GoodsAction" id="goodsAction">
    <property name="userService" ref="userServiceImpl1"></property>
    <property name="gname" value="小狗"></property>
    <property name="age" value="2"></property>
    <property name="peoples">
        <list>
            <value>小红</value>
            <value>漂亮</value>
            <value>别个说的</value>
        </list>
    </property>
</bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl" id="userService" ></bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl1" id="userServiceImpl1"></bean>
    <!--讲解aop相关的JavaBean-->
    <!--目标对象-->
    <bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <!--代理-->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
       <!--配置目标对象-->
        <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.aop.biz.IBookBiz</value>
            </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
            </list>
        </property>
    </bean>
</beans>

再建一个前置通知类：MyMethodBeforeAdvice

package com.zking.aop.advice;
import java.lang.reflect.Method;
import java.util.Arrays;
import org.springframework.aop.MethodBeforeAdvice;
/**
 * 买书、评论前加系统日志
 * @author Administrator
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
  @Override
  public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
//    在这里，可以获取到目标类的全路径及方法及方法参数，然后就可以将他们写到日志表里去
    String target = arg2.getClass().getName();
    String methodName = arg0.getName();
    String args = Arrays.toString(arg1);
    System.out.println("【前置通知：系统日志】："+target+"."+methodName+"("+args+")被调用了");
  }
}

再写一个demo类：demo1

package com.zking.aop.demo;
import com.zking.aop.biz.IBookBiz;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author bing人
 * @site
 * @company xy集团
 * @create 2023-08-17 15:57
 */
public class Demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
       // IBookBiz bookBiz = (IBookBiz) context.getBean("bookBiz");
        IBookBiz bookBiz = (IBookBiz) context.getBean("bookProxy");
        System.out.println(bookBiz);
        bookBiz.buy("花菇凉", "小日子", 9.9d);
        bookBiz.comment("花菇凉" ,"太爽了");
    }
}

输出结果：

6.Spring aop的后置通知：

后置通知（After Advice）是Spring AOP中的一种通知类型，它在目标方法执行之后执行。后置通知可以捕获目标方法的返回值，但无法修改方法的执行结果。

在Spring AOP中，后置通知有两种类型：

后置返回通知（AfterReturning Advice）：在目标方法成功执行并返回结果后执行。可以通过@AfterReturning注解或XML配置来定义后置返回通知。

后置异常通知（AfterThrowing Advice）：在目标方法抛出异常后执行。可以通过@AfterThrowing注解或XML配置来定义后置异常通知。

这些后置通知可以用于记录日志、处理异常、收集统计信息等操作。通过使用Spring AOP的后置通知，可以将这些横切关注点与业务逻辑分离，提高代码的可维护性和重用性。

实例演示：

先建立一个后置通知类：MyAfterReturningAdvice

package com.zking.aop.advice;
import java.lang.reflect.Method;
import java.util.Arrays;
import org.springframework.aop.AfterReturningAdvice;
/**
 * 买书返利
 * @author Administrator
 *
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
  @Override
  public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
    String target = arg3.getClass().getName();
    String methodName = arg1.getName();
    String args = Arrays.toString(arg2);
    System.out.println("【后置通知：买书返利】："+target+"."+methodName+"("+args+")被调用了，"+"该方法被调用后的返回值为："+arg0);
  }
}

再配置Spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--ioc的javaBean-->
<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->
<bean class="com.zking.ioc.web.UserAction" id="userAction">
    <property name="userService" ref="userService"></property>
    <constructor-arg name="uname" value="雨哦西" ></constructor-arg>
    <constructor-arg name="age" value="18" ></constructor-arg>
    <constructor-arg name="hobby"  >
        <list>
            <value>大大的</value>
            <value>花菇凉</value>
        </list>
    </constructor-arg>
</bean>
<bean class="com.zking.ioc.web.GoodsAction" id="goodsAction">
    <property name="userService" ref="userServiceImpl1"></property>
    <property name="gname" value="小狗"></property>
    <property name="age" value="2"></property>
    <property name="peoples">
        <list>
            <value>小红</value>
            <value>漂亮</value>
            <value>别个说的</value>
        </list>
    </property>
</bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl" id="userService" ></bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl1" id="userServiceImpl1"></bean>
    <!--讲解aop相关的JavaBean-->
    <!--目标对象-->
    <bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
    <!--代理-->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
       <!--配置目标对象-->
        <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.aop.biz.IBookBiz</value>
            </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>myAfterReturningAdvice</value>
            </list>
        </property>
    </bean>
</beans>

输出结果：

7.Spring aop的环绕通知：

环绕通知（Around Advice）是Spring AOP中的一种通知类型，它可以在目标方法执行之前和之后都执行自定义的逻辑。环绕通知可以完全控制目标方法的执行，包括是否执行目标方法以及修改目标方法的返回值。

在Spring AOP中，使用环绕通知需要使用@Around注解或XML配置来定义。环绕通知方法需要一个ProceedingJoinPoint参数，通过调用proceed()方法来执行目标方法，并可以在执行前后进行自定义处理。

环绕通知具有以下特点：

可以决定是否执行目标方法。

可以在目标方法执行前后进行一些自定义操作。

可以修改目标方法的返回值。

使用环绕通知可以实现更细粒度的控制和处理，比如记录方法的执行时间、实现缓存、进行安全检查等。但需要注意，在使用环绕通知时，需要手动调用proceed()方法来执行目标方法，否则目标方法将不会被执行。

实例演示：

先建立一个环绕通知类：MyMethodInterceptor

package com.zking.aop.advice;
import java.util.Arrays;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
 * 环绕通知
 *  包含了前置和后置通知
 * 
 * @author Administrator
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
  @Override
  public Object invoke(MethodInvocation arg0) throws Throwable {
    String target = arg0.getThis().getClass().getName();
    String methodName = arg0.getMethod().getName();
    String args = Arrays.toString(arg0.getArguments());
    System.out.println("【环绕通知调用前：】："+target+"."+methodName+"("+args+")被调用了");
//    arg0.proceed()就是目标对象的方法
    Object proceed = arg0.proceed();
    System.out.println("【环绕通知调用后：】：该方法被调用后的返回值为："+proceed);
    return proceed;
  }
}

配置Spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--ioc的javaBean-->
<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->
<bean class="com.zking.ioc.web.UserAction" id="userAction">
    <property name="userService" ref="userService"></property>
    <constructor-arg name="uname" value="雨哦西" ></constructor-arg>
    <constructor-arg name="age" value="18" ></constructor-arg>
    <constructor-arg name="hobby"  >
        <list>
            <value>大大的</value>
            <value>花菇凉</value>
        </list>
    </constructor-arg>
</bean>
<bean class="com.zking.ioc.web.GoodsAction" id="goodsAction">
    <property name="userService" ref="userServiceImpl1"></property>
    <property name="gname" value="小狗"></property>
    <property name="age" value="2"></property>
    <property name="peoples">
        <list>
            <value>小红</value>
            <value>漂亮</value>
            <value>别个说的</value>
        </list>
    </property>
</bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl" id="userService" ></bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl1" id="userServiceImpl1"></bean>
    <!--讲解aop相关的JavaBean-->
    <!--目标对象-->
    <bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
    <bean class="com.zking.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>
    <!--代理-->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
       <!--配置目标对象-->
        <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.aop.biz.IBookBiz</value>
            </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>myAfterReturningAdvice</value>
                <value>myMethodInterceptor</value>
            </list>
        </property>
    </bean>
</beans>

输出结果：

8.Spring aop的异常通知：

异常通知（AfterThrowing Advice）是Spring AOP中的一种通知类型，它在目标方法抛出异常后执行。异常通知可以捕获目标方法抛出的异常，并进行相应的处理。

在Spring AOP中，异常通知有两种类型：

局部异常通知（局部异常处理）：只针对特定的异常类型进行处理。可以使用@AfterThrowing注解或XML配置来定义局部异常通知。

全局异常通知（全局异常处理）：针对所有抛出的异常进行处理。可以使用@AfterThrowing注解或XML配置来定义全局异常通知。

异常通知可以用于记录日志、恢复错误状态、发送警报等。通过使用Spring AOP的异常通知，可以将异常处理与业务逻辑分离，提高代码的可维护性和可重用性。

实例演示：

先建立一个异常通知类：MyThrowsAdvice

package com.zking.aop.advice;
import org.springframework.aop.ThrowsAdvice;
import com.zking.aop.biz.exception.PriceException;
/**
 * 出现异常执行系统提示，然后进行处理。价格异常为例
 * @author Administrator
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
  public void afterThrowing(PriceException ex) {
    System.out.println("【异常通知】：当价格发生异常，那么执行此处代码块！！！");
  }
}

配置Spring-context.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--ioc的javaBean-->
<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->
<bean class="com.zking.ioc.web.UserAction" id="userAction">
    <property name="userService" ref="userService"></property>
    <constructor-arg name="uname" value="雨哦西" ></constructor-arg>
    <constructor-arg name="age" value="18" ></constructor-arg>
    <constructor-arg name="hobby"  >
        <list>
            <value>大大的</value>
            <value>花菇凉</value>
        </list>
    </constructor-arg>
</bean>
<bean class="com.zking.ioc.web.GoodsAction" id="goodsAction">
    <property name="userService" ref="userServiceImpl1"></property>
    <property name="gname" value="小狗"></property>
    <property name="age" value="2"></property>
    <property name="peoples">
        <list>
            <value>小红</value>
            <value>漂亮</value>
            <value>别个说的</value>
        </list>
    </property>
</bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl" id="userService" ></bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl1" id="userServiceImpl1"></bean>
    <!--讲解aop相关的JavaBean-->
    <!--目标对象-->
    <bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
    <bean class="com.zking.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>
   <bean class="com.zking.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
    <!--代理-->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
       <!--配置目标对象-->
        <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.aop.biz.IBookBiz</value>
            </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>myAfterReturningAdvice</value>
                <value>myMethodInterceptor</value>
                <value>myThrowsAdvice</value>
            </list>
        </property>
    </bean>
</beans>

输出结果：

9.Spring aop的过滤通知

实例演示：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--ioc的javaBean-->
<!--    在spring配置文件spring-context.xml中配置，那么该类javabean就交给spring容器管理 -->
<bean class="com.zking.ioc.web.UserAction" id="userAction">
    <property name="userService" ref="userService"></property>
    <constructor-arg name="uname" value="雨哦西" ></constructor-arg>
    <constructor-arg name="age" value="18" ></constructor-arg>
    <constructor-arg name="hobby"  >
        <list>
            <value>大大的</value>
            <value>花菇凉</value>
        </list>
    </constructor-arg>
</bean>
<bean class="com.zking.ioc.web.GoodsAction" id="goodsAction">
    <property name="userService" ref="userServiceImpl1"></property>
    <property name="gname" value="小狗"></property>
    <property name="age" value="2"></property>
    <property name="peoples">
        <list>
            <value>小红</value>
            <value>漂亮</value>
            <value>别个说的</value>
        </list>
    </property>
</bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl" id="userService" ></bean>
<bean class="com.zking.ioc.service.Impl.UserServiceImpl1" id="userServiceImpl1"></bean>
    <!--讲解aop相关的JavaBean-->
    <!--目标对象-->
    <bean class="com.zking.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
    <bean class="com.zking.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>
   <bean class="com.zking.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myAfterReturningAdvicePlus">
    <property name="advice" ref="myAfterReturningAdvice"></property>
        <property name="pattern" value=".*buy"></property></bean>
    <!--代理-->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
       <!--配置目标对象-->
        <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口-->
        <property name="proxyInterfaces">
            <list>
                <value>com.zking.aop.biz.IBookBiz</value>
            </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>myAfterReturningAdvice</value>
                <value>myMethodInterceptor</value>
                <value>myThrowsAdvice</value>
                <value>myAfterReturningAdvicePlus</value>
            </list>
        </property>
    </bean>
</beans>

输出结果：

Spring aop

1.Spring aop的背景

2.Spring aop的用途：

3.Spring aop的特点：

4.Spring aop的专业术语：

5.Spring aop的前置通知：

实例演示：

6.Spring aop的后置通知：

实例演示：

7.Spring aop的环绕通知：

实例演示：

8.Spring aop的异常通知：

实例演示：

9.Spring aop的过滤通知

实例演示：

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Spring aop

1.Spring aop的背景

2.Spring aop的用途：

3.Spring aop的特点：

4.Spring aop的专业术语：

5.Spring aop的前置通知：

实例演示：

6.Spring aop的后置通知：

实例演示：

7.Spring aop的环绕通知：

实例演示：

8.Spring aop的异常通知：

实例演示：

9.Spring aop的过滤通知

实例演示：

热门文章

最新文章

相关课程

相关电子书

相关实验场景