Spring AOP使用

心已赠人 2022-05-18 00:49 207阅读 0赞

**Spring按照增强处理在目标方法的位置，分为5类：**

1：前置处理。org.springframework.aop.MethodBeforeAdvice。在目标方法执行前进行增强处理。

2：后置处理。org.springframework.aop.AfterReturningAdvice。在目标方法执行后进行增强处理。

3：环绕处理。org.aopalliance.intercept.MethodInterceptor。在目标方法执行的前后都进行处理。

4：异常抛出处理。org.springframework.aop.ThrowsAdvice。在方法抛出异常后进行处理。

5：引介处理。org.springframework.aop.IntroductionInterceptor。在目标类中添加新的方法和属性。这个暂时不考虑。

**SPring的AOP切面类型：**

1：Advisor：一般切面。就是对目标类所有的方法进行拦截。

2：PointcutAdvisor：有切入点的切面。都指定方法进行拦截。

**案例：1：一般切面案列：**

首先引入包。处理Spring必须的5个包外，要引入aop有关的包：aop联盟的包和spring的aop包。

<dependency>
          <groupId>aopalliance</groupId>
          <artifactId>aopalliance</artifactId>
          <version>1.0</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>

下面建一个接口：StudentDao

package com.imooc.aop.demo3;
    
    public interface StudentDao {
    
        public void find();
    
        public void save();
    
        public void update();
    
        public void delete();
    }

实现类：StudentDaoImpl

package com.imooc.aop.demo3;
    
    public class StudentDaoImpl implements StudentDao {
    
        public void find() {
            System.out.println("学生查询");
        }
    
        public void save() {
            System.out.println("学生保存");
    
        }
    
        public void update() {
            System.out.println("学生修改");
    
        }
    
        public void delete() {
            System.out.println("学生删除");
    
        }
    }

在配置文件中进行配置：

现在需要对方法进行增强。进行方法前置增强。

创建一个类MyBeforeAdvice，继承前置增强接口：MethodBeforeAdvice

package com.imooc.aop.demo3;
    
    import org.springframework.aop.MethodBeforeAdvice;
    
    import java.lang.reflect.Method;
    
    public class MyBeforeAdvice implements MethodBeforeAdvice {
    
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("前置增强===================");
        }
    }

在配置文件中配置该类：

还要配置ProxyFactoryBean类，用来产生代理：

<bean id="studentDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        
        <property name="target" ref="studentDao"></property>
        
        <property name="proxyInterfaces" value="com.imooc.aop.demo3.StudentDao"></property>
        
        <property name="interceptorNames" value="myBeforeAdvice"></property>
    </bean>

这就配置好了。下面进行测试：

package com.imooc.aop.demo3;
    
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class SpringDemo3 {
    
        @Test
        public void demo1(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            StudentDao proxy = (StudentDao)applicationContext.getBean("studentDaoProxy");
            proxy.update();
            proxy.save();
            proxy.delete();
            proxy.find();
        }
    }

这就实现了对每个方法实现了前置增强。

**案例2：带有切入点的切面。**

这种方式在开发中较为常用。与前面的区别是，在配置文件中要增加对切入点的配置。

常用的PointcutAdvisor实现类有两个：

DefaultPointcutAdvisor：是最常见的切面类型，可以通过任意Pointcut和Advice组合来定义切面。

JdkRegexpMethodPointcut：构造正则表达式的切入点。

这两个掌握一个就行。下面用到的是正则表达式。

首先是一个类：customerDao

package com.imooc.aop.demo4;
    
    public class CustomerDao {
    
        public void find(){
            System.out.println("查询客户");
        }
    
        public void save(){
            System.out.println("保存客户");
        }
    
        public void update(){
            System.out.println("修改客户");
        }
    
        public void delete(){
            System.out.println("删除客户");
        }
    
    }

在配置文件中配置：

下面定义一个增强处理类：MyAroundAdvice

package com.imooc.aop.demo4;
    
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    //实现了MethodInterceptor，也就是环绕增强
    public class MyAroundAdvice implements MethodInterceptor {
    
        public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    
            System.out.println("环绕前增强=====================");
    
            //执行原目标方法（也可以不掉用次方法，那就不执行原方法）
            Object obj = methodInvocation.proceed();
    
            System.out.println("环绕后增强=====================");
    
            return obj;
        }
    }

在配置文件中配置：

由于要指定切入点。需要进行一下配置：

<bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        
        <property name="pattern" value=".*"></property>
        
        <property name="advice" ref="myAroundAdvice"></property>
    </bean>

当然，还要配置生成代理类的Bean

这就配置好了配置文件。完整的为：applicationContext2.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    
        
        <bean id="customerDao" class="com.imooc.aop.demo4.CustomerDao"></bean>
    
        
        <bean id="myAroundAdvice" class="com.imooc.aop.demo4.MyAroundAdvice"></bean>
    
        
        <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            
            <property name="pattern" value=".*save"></property>
            <property name="advice" ref="myAroundAdvice"></property>
        </bean>
    
        
        <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="target" ref="customerDao"></property>
            <property name="proxyTargetClass" value="true"></property>
            <property name="interceptorNames" value="myAdvisor"></property>
        </bean>
    </beans>

这就配置好了。下面测试一下：

package com.imooc.aop.demo4;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class SpringDemo4 {
    
        @Test
        public void demo(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
            CustomerDao proxy = (CustomerDao)applicationContext.getBean("customerDaoProxy");
            proxy.delete();
            proxy.find();
            proxy.save();
            proxy.update();
        }
    }

从结果可以看到，在save方法中进行了环绕增强。我们可以修改正则表达式来改变切入点。

需要提到的是：当使用RegexpMethodPointcutAdvisor时，匹配的方法应该是：全限定类名.方法名。所以pattern处用的是：.\*save。