之前的aop是通过手动创建代理类来进行通知的，但是在日常开发中，我们并不愿意在代码中硬编码这些代理类，我们更愿意使用DI和IOC来管理aop代理类。Spring为我们提供了以下方式来使用aop框架

ProxyFactoryBean类是FactoryBean的一个实现类，它允许指定一个bean作为目标，并且为该bean提供一组通知和顾问（这些通知和顾问最终会被合并到一个AOP代理中）它和我们之前的ProxyFactory都是Advised的实现。

以下是一个简单的例子：一个学生和一个老师，老师会告诉学生应该做什么。

  1. public class Student {
  3.     public void talk() {
  4.         System.out.println("I am a boy");
  5.     }
  7.     public void walk() {
  8.         System.out.println("I am walking");
  9.     }
  11.     public void sleep() {
  12.         System.out.println("I want to sleep");
  13.     }
  14. }

老师类

  1. public class Teacher {
  3.     private Student student;
  5.     public void tellStudent(){
  6.         student.sleep();
  7.         student.talk();
  8.     }
  10.     public Student getStudent() {
  11.         return student;
  12.     }
  14.     public void setStudent(Student student) {
  15.         this.student = student;
  16.     }
  17. }
  1. package cn.lyn4ever.aop;
  3. import org.aspectj.lang.JoinPoint;
  5. public class AuditAdvice implements MethodBeforeAdvice {
  6.     @Override
  7.     public void before(Method method, Object[] objects, @Nullable Object o) throws Throwable {
  8.         System.out.println("这个方法被通知了" + method.getName());
  9.     }
  10. }
  • 然后就使用spring的IOC来管理这个通知类,在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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/util
  8.        https://www.springframework.org/schema/util/spring-util.xsd">
  10.     <!--注入student-->
  11.     <bean name="student" class="cn.lyn4ever.aop.aopconfig.Student">
  12.     </bean>
  14.     <!--注入teacher-->
  15.     <bean name="teacher" class="cn.lyn4ever.aop.aopconfig.Teacher">
  16.         <!--注意,这个student的属性要是上边的代理类,而不是能student-->
  17.         <!--<property name="student" ref="student"/>-->
  18.         <property name="student" ref="proxyOne"/>
  19.     </bean>
  21.     <!--注入我们创建的通知类-->
  22.     <bean id="advice" class="cn.lyn4ever.aop.aopconfig.AuditAdvice"></bean>
  24.     <!--创建代理类，使用前边写的通知进行通知，这样会使这个类上的所有方法都被通知-->
  25.     <bean name="proxyOne" class="org.springframework.aop.framework.ProxyFactoryBean" p:target-ref="student"
  26.           p:interceptorNames-ref="interceptorNames">
  27.         <!--因为interceptorNames的属性是一个可变参数,也就是一个list-->
  28.     </bean>
  30.     <!--在上边引入了util的名称空间,简化了书写-->
  31.     <util:list id="interceptorNames">
  32.         <value>advice</value>
  33.     </util:list>
  34. </beans>
  • 测试类
  1.  public static void main(String[] args) {
  2.         GenericXmlApplicationContext context = new GenericXmlApplicationContext();
  3.         context.load("application1.xml");
  4.         context.refresh();
  6.         Teacher teacher = (Teacher) context.getBean("teacherOne");
  7.         teacher.tellStudent();
  9.     }

  • 运行结果没有问题
    SpringAop在web应用中的使用

  • 以上是通过直接创建通知的方式，接下来我们试一个创建一个切入点（因为以上是对类中所有方法都进行通知，这时我们使用切入点只对其中部分方法进行通知）,在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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/util
  8.        https://www.springframework.org/schema/util/spring-util.xsd">
  10.     <!--注入student-->
  11.     <bean name="student" class="cn.lyn4ever.aop.aopconfig.Student">
  12.     </bean>
  14.     <!--注入teacher-->
  15.     <bean name="teacherOne" class="cn.lyn4ever.aop.aopconfig.Teacher">
  16.         <!--注意,这个student的属性要是上边的代理类,而不是能student-->
  17.         <!--<property name="student" ref="student"/>-->
  18.         <property name="student" ref="proxyOne"/>
  19.     </bean>
  21.     <!--注入我们创建的通知类-->
  22.     <bean id="advice" class="cn.lyn4ever.aop.aopconfig.AuditAdvice"></bean>
  24.     <!--创建代理类，使用前边写的通知进行通知，这样会使这个类上的所有方法都被通知-->
  25.     <bean name="proxyOne" class="org.springframework.aop.framework.ProxyFactoryBean" p:target-ref="student"
  26.           p:interceptorNames-ref="interceptorNames">
  27.         <!--因为interceptorNames的属性是一个可变参数,也就是一个list-->
  28.     </bean>
  30.     <!--在上边引入了util的名称空间,简化了书写-->
  31.     <util:list id="interceptorNames">
  32.         <value>advice</value>
  33.     </util:list>
  36.     <!--以下是使用切入点的方式来进行通知,上边的代码和上一个配置文件一样,没有修改-->
  37.     <!--sutdent基本bean,我们继续使用-->
  39.     <bean name="teacherTwo" p:student-ref="proxyTwo" class="cn.lyn4ever.aop.aopconfig.Teacher"/>
  41.     <bean id="proxyTwo" class="org.springframework.aop.framework.ProxyFactoryBean"
  42.           p:target-ref="student" p:interceptorNames-ref="interceptorAdvisorNames">
  43.     </bean>
  45.     <util:list id="interceptorAdvisorNames">
  46.         <value>advisor</value>
  47.     </util:list>
  49.     <!--配置切入点bean-->
  50.     <bean id="advisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"
  51.           p:advice-ref="advice">
  52.         <property name="pointcut">
  53.             <!--这个切入点我们用了一个匿名bean来写aspectJ的表达式,当然也可以用其他的类型切入点,这个在上边链接中能看到-->
  54.             <bean class="org.springframework.aop.aspectj.AspectJExpressionPointcut"
  55.                   p:expression="execution(* talk*(..))"/>
  56.         </property>
  58.     </bean>
  60. </beans>

SpringAop在web应用中的使用

  • 上图中的那个aspectj表达式写错了，在代码中有正确的
    title

在xml中引入如下的名称空间，为了不被影响，我册了其他多余的名称空间。然后很普通地注入我们之前那三个bean

  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.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/aop
  8.        http://www.springframework.org/schema/aop/spring-aop.xsd
  9.   ">
  11.     <!--通过普通的方式来注入三个bean-->
  12.     <!--注入student-->
  13.     <bean name="student" class="cn.lyn4ever.aop.aopconfig.Student"/>
  14.     <!--注入teacher-->
  15.     <bean name="teacherOne" class="cn.lyn4ever.aop.aopconfig.Teacher">
  16.         <property name="student" ref="student"/>
  17.     </bean>
  18.     <!--注入我们创建的通知类-->
  19.     <bean id="advice" class="cn.lyn4ever.aop.proxyfactory.BeforeAdvice"/>
  22.     <aop:config>
  23.         <aop:pointcut id="talkExecution" expression="execution(* talk*(..))"/>
  24.         <aop:aspect ref="advice">
  25.             <!--这个方法就是我们在自定义通知类中之写的方法-->
  26.             <aop:before method="beforeSaySomething" pointcut-ref="talkExecution"/>
  27.             <!--当然,还可以配置其他通知类型-->
  28.         </aop:aspect>
  29.     </aop:config>
  33. </beans>

在这个配置中，我们还可以配置其他类型的通知，但是这个method属性一定要写我们自定义的那个通知类中的方法

SpringAop在web应用中的使用

  • 在aop:pointcut中写expression时还支持如下语法：
  1. <aop:pointcut id="talkExecution" expression="execution(* talk*(..)) and args(String) and bean(stu*)"/>
  2. <!--
  3. 中间的这个and表示和，也可以用or来表示或
  4. args(String) 意思是参数类型是string,也可是自定义的类，这个后边有例子
  5. bean(stu*) 意思是bean的id是以stu开头的，常用的就是用bean(*Service*)来表示服务层的bean
  6. -->

虽然是通过注解的方式来声明注解类，但是还是需要在xml中配置一点点内容（通过注解的方式也可以配置，但是在springboot中要使用的话有更方便的方式）

  • 为了方便，就只写了一个HighStudent，而且直接调用它的方法，不依赖于外部的teacher实例来调用
  1. package cn.lyn4ever.aop.aspectj;
  3. import cn.lyn4ever.aop.aopconfig.Teacher;
  4. import org.springframework.stereotype.Component;
  6. /**
  7.  * 声明这是一个SpringBean,由Spring来管理它
  8.  */
  9. @Component
  10. public class HighStudent {
  12.     public void talk() {
  13.         System.out.println("I am a boy");
  14.     }
  16.     public void walk() {
  17.         System.out.println("I am walking");
  18.     }
  20.     /**
  21.      * 这个方法添加一个teacher来做为参数,为了配置后边切入点中的args()
  22.      * @param teacher
  23.      */
  24.     public void sleep(Teacher teacher) {
  25.         System.out.println("I want to sleep");
  26.     }
  27. }
  • 创建切面类
  1. package cn.lyn4ever.aop.aspectj;
  3. import cn.lyn4ever.aop.aopconfig.Teacher;
  4. import org.aspectj.lang.JoinPoint;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Before;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. import org.springframework.stereotype.Component;
  12. /**
  13.  * 声明切面类,也就是包括切点和通知
  14.  */
  15. @Component //声明交由spring管理
  16. @Aspect //表示这是一个切面类
  17. public class AnnotatedAdvice {
  19.     /*
  20.     创建切入点,当然也可以是多个
  21.      */
  22.     @Pointcut("execution(* talk*(..))")
  23.     public void talkExecution(){}
  25.     @Pointcut("bean(high*)")//这里为什么是high,因为我们这回测试bean是highStudent
  26.     public void beanPoint(){}
  28.     @Pointcut("args(value)")
  29.     public void argsPoint(Teacher value){}
  31.     /*
  32.     创建通知,当然也可以是多个
  33.     这个注解的参数就是上边的切入点方法名,注意有的还带参数
  34.     这个通知方法的参数和之前一样,榀加JoinPoint,也可不加
  35.      */
  36.     @Before("talkExecution()")
  37.     public void doSomethingBefore(JoinPoint joinPoint){
  38.         System.out.println("before: Do Something"+joinPoint.getSignature().getName()+"()");
  39.     }
  41.     /**
  42.      * 环绕通知请加上ProceedingJoinPoint参数 ,它是joinPoint的子类
  43.      * 因为你要放行方法的话,必须要加这个
  44.      * @param joinPoint
  45.      * @param teacher
  46.      */
  47.     @Around("argsPoint(teacher) && beanPoint()")
  48.     public Object doSomethindAround(ProceedingJoinPoint joinPoint, Teacher teacher) throws Throwable {
  49.         System.out.println("Around: Before Do Something"+joinPoint.getSignature().getName()+"()");
  50.         Object proceed = joinPoint.proceed();
  51.         System.out.println("Around: After Do Something"+joinPoint.getSignature().getName()+"()");
  53.         return proceed;
  54.     }
  56. }
  • 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:context="http://www.springframework.org/schema/context"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.        http://www.springframework.org/schema/beans/spring-beans.xsd
  8.        http://www.springframework.org/schema/aop
  9.        http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  11.     <!--通知Spring扫描@Aspect注解-->
  12.     <aop:aspectj-autoproxy/>
  14.     <!--配置扫描包,扫描@Component-->
  15.     <context:component-scan base-package="cn.lyn4ever.aop.aspectj"/>
  17. </beans>
  • 使用Java注解配置的方式配置扫描注解
  2. @Configuration //声明这是一个配置类
  3. @ComponentScan("cn.lyn4ever.aop.aspectj")
  4. @EnableAspectJAutoProxy(proxyTargetClass = true)//相当于xml中的<aop:aspectj-autoproxy/>
  5. public class BeanConfig {
  6. }
  • 测试方法
  1. package cn.lyn4ever.aop.aspectj;
  3. import cn.lyn4ever.aop.aopconfig.Teacher;
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  5. import org.springframework.context.support.GenericApplicationContext;
  6. import org.springframework.context.support.GenericXmlApplicationContext;
  8. public class AspectMain {
  9.     public static void main(String[] args) {
  10. //        xmlConfig();
  11.         javaConfig();
  13.     }
  15.     private static void javaConfig() {
  16.         GenericApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
  17.         HighStudent student = (HighStudent) context.getBean("highStudent");
  18.         student.sleep(new Teacher());//应该被环绕通知
  19.         System.out.println();
  21.         student.talk();//前置通知
  22.         System.out.println();
  24.         student.walk();//不会被通知
  25.         System.out.println();
  26.     }
  28.     private static void xmlConfig(){
  29.         GenericXmlApplicationContext context = new GenericXmlApplicationContext();
  30.         context.load("application_aspect.xml");
  31.         context.refresh();
  33.         HighStudent student = (HighStudent) context.getBean("highStudent");
  34.         student.sleep(new Teacher());//应该被环绕通知
  35.         System.out.println();
  37.         student.talk();//前置通知
  38.         System.out.println();
  40.         student.walk();//不会被通知
  41.         System.out.println();
  42.     }
  43. }

SpringAOP在web应用中的使用

项目代码地址,如果觉得还不错的话,给个star吧

版权声明：本文为Lyn4ever原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Lyn4ever/p/12057672.html