• Spring框架第五篇之Spring与AOP


    一、AOP概述

    AOP(Aspect Orient Programming),面向切面编程,是面向对象编程OOP的一种补充。面向对象编程是从静态角度考虑程序的结构,而面向切面编程是从动态角度考虑程序运行过程。

    AOP底层就是采用动态代理模式实现的,采用了两种代理:JDK的动态代理与CGLIB的动态代理。

    面向切面编程,就是将交叉业务逻辑封装成切面,利用AOP容器的功能将切面织入到主业务逻辑中。所谓交叉业务逻辑是指,通用的、与主业务逻辑无关的代码。如安全检查、事务、日志等。

    若不是用AOP,则会出现代码纠缠,即交叉业务逻辑与主业务逻辑混合在一起,这样会使主业务逻辑变的混杂不清。

    二、通知Advice

    1、通知详解

    (1)前置通知MethodBeforeAdvice

    定义前置通知,需要实现MethodBeforeAdvice接口。该接口中有一个方法before(),会在目标方法执行之前执行。

    前置通知的特点:

    1、在目标方法执行之前执行。

    2、不改变目标方法的执行流程,前置通知代码不能阻止目标方法执行。

    3、不改变目标方法执行的结果。

     举例:

    创建IService接口:

    package com.ietree.spring.basic.aop.beforeadvice;
    
    public interface IService {
    
        void doFirst();
    
        void doSecond();
    
    }

    创建接口的实现类:

    package com.ietree.spring.basic.aop.beforeadvice;
    
    public class SomeServiceImpl implements IService {
    
        @Override
        public void doFirst() {
            System.out.println("执行doFirst()方法");
        }
    
        @Override
        public void doSecond() {
            System.out.println("执行doFirst()方法");
        }
    
    }

    创建前置通知类MyMethodBeforeAdvice,该类必须实现MethodBeforeAdvice接口:

    package com.ietree.spring.basic.aop.beforeadvice;
    
    import java.lang.reflect.Method;
    
    import org.springframework.aop.MethodBeforeAdvice;
    
    /**
     * 前置通知
     * 
     * @author Root
     */
    public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
    
        // 当前方法在目标方法执行之前执行
        // method:目标方法
        // args:目标方法参数列表
        // target:目标对象
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            // 对于目标方法的增强代码就写在这里
            System.out.println("执行前置通知...");
        }
    
    }

    配置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">
        
        <!-- 1、注册目标对象 -->
        <bean id="someService" class="com.ietree.spring.basic.aop.beforeadvice.SomeServiceImpl"/>
        
        <!-- 2、注册切面:通知 -->
        <bean id="myAdvice" class="com.ietree.spring.basic.aop.beforeadvice.MyMethodBeforeAdvice"/>
        
        <!-- 3、生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定目标对象 -->
            <!-- <property name="targetName" value="someService"/> -->
            <property name="target" ref="someService"/>
            <!-- 指定切面 -->
            <property name="interceptorNames" value="myAdvice"/>
        </bean>
        
    </beans>

    测试:

    package com.ietree.spring.basic.aop.beforeadvice;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
    
        @Test
        public void test() {
            
            String resource = "com/ietree/spring/basic/aop/beforeadvice/applicationContext.xml";
            
            ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
        
            IService service = (IService)ac.getBean("serviceProxy");
            
            service.doFirst();
            System.out.println("==============");
            service.doSecond();
        }
    
    }

    输出:

    执行前置通知...
    执行doFirst()方法
    ==============
    执行前置通知...
    执行doFirst()方法

    注意:执行之前需要导入spring-aop-4.3.9.RELEASE.jar包

    (2)后置通知AfterReturningAdvice

    定义前置通知,需要实现AfterReturningAdvice接口。该接口中有一个方法afterReturning(),会在目标方法执行之后执行。

    后置通知的特点:

    1、在目标方法执行之后执行。

    2、不改变目标方法的执行流程,后置通知代码不能阻止目标方法执行。

    3、不改变目标方法执行的结果。

    大致流程和前置通知差不多,这里就简单列举一下不同之处:

    创建后置通知类并实现AfterReturningAdvice接口,重写afterReturning()方法:

    package com.ietree.spring.basic.aop.afterreturningadvice;
    
    import java.lang.reflect.Method;
    
    import org.springframework.aop.AfterReturningAdvice;
    
    /**
     * 后置通知:可以获取到目标方法的返回结果,但是无法改变目标方法的结果
     * 
     * @author Root
     */
    public class MyAfterReturningAdvice implements AfterReturningAdvice {
    
        // 在目标方法执行之后执行
        // returnValue:目标方法的返回值
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("执行后置通知方法 returnValue = " + returnValue);
        }
    
    }

    配置文件:

    <?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">
        
        <!-- 1、注册目标对象 -->
        <bean id="someService" class="com.ietree.spring.basic.aop.afterreturningadvice.SomeServiceImpl"/>
        
        <!-- 2、注册切面:通知 -->
        <bean id="myAdvice" class="com.ietree.spring.basic.aop.afterreturningadvice.MyAfterReturningAdvice"/>
        
        <!-- 3、生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定目标对象 -->
            <property name="target" ref="someService"/>
            <!-- 指定切面 -->
            <property name="interceptorNames" value="myAdvice"/>
        </bean>
        
    </beans>

    注意:后置通知可以获取到目标方法的返回结果,但是无法改变目标方法执行的返回结果。

    (3)环绕通知MethodInterceptor

     定义环绕通知,需要实现MethodInterceptor接口。环绕通知,也叫方法拦截器,可以在目标方法调用之前及之后做处理,可以改变目标方法的返回值,也可以改变程序执行流程。

    创建环绕通知类MyMethodInterceptor,实现MethodInterceptor接口:

    package com.ietree.spring.basic.aop.methodinterceptor;
    
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    // 环绕通知:可以修改目标方法的返回结果
    public class MyMethodInterceptor implements MethodInterceptor {
    
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            
            System.out.println("执行环绕通知:目标方法执行之前");
            // 执行目标方法
            Object result = invocation.proceed();
            
            System.out.println("执行环绕通知:目标方法执行之后");
            if(null != result)
            {
                result = ((String)result).toUpperCase();
            }
            return result;
        }
    
    }

    配置文件:

    <?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">
        
        <!-- 1、注册目标对象 -->
        <bean id="someService" class="com.ietree.spring.basic.aop.methodinterceptor.SomeServiceImpl"/>
        
        <!-- 2、注册切面:通知 -->
        <bean id="myAdvice" class="com.ietree.spring.basic.aop.methodinterceptor.MyMethodInterceptor"/>
        
        <!-- 3、生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定目标对象 -->
            <!-- <property name="targetName" value="someService"/> -->
            <property name="target" ref="someService"/>
            <!-- 指定切面 -->
            <property name="interceptorNames" value="myAdvice"/>
        </bean>
        
    </beans>

    测试:

    package com.ietree.spring.basic.aop.methodinterceptor;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
    
        @Test
        public void test() {
            
            String resource = "com/ietree/spring/basic/aop/methodinterceptor/applicationContext.xml";
            
            ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
        
            IService service = (IService)ac.getBean("serviceProxy");
            
            service.doFirst();
            System.out.println("==============");
            
            String result = service.doSecond();
            System.out.println(result);
        }
    
    }

    输出:

    执行环绕通知:目标方法执行之前
    执行doFirst()方法
    执行环绕通知:目标方法执行之后
    ==============
    执行环绕通知:目标方法执行之前
    执行doSecond()方法
    执行环绕通知:目标方法执行之后
    ABCDE

    注意:环绕通知不仅可以获取到方法的返回结果,而且还可以修改方法的返回结果。

    (4)异常通知ThrowsAdvice

    异常分两种:
    1)运行时异常,不进行处理,也可以通过编译。若一个类继承自RunTimeException,则该异常就是运行时异常
     2)编译时异常,受查异常,Checked Exception。不进行处理,则无法通过编译。若一个类继承自Exception,则该异常就是受查异常。

    创建接口IService:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    public interface IService {
        // 用户登录
        boolean login(String username, String password) throws UserException;
    }

    创建接口实现类SomeServiceImpl:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    public class SomeServiceImpl implements IService {
    
        @Override
        public boolean login(String username, String password) throws UserException {
            if (!"jack".equals(username)) {
                throw new UsernameException("用户名错误!");
            }
            if (!"123".equals(password)) {
                throw new PasswordException("密码错误!");
            }
    //        double i = 3 / 0;
            return true;
        }
    
    }

    创建三个自定义异常:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    /**
     * 自定义异常
     * 异常分两种:
     * 1)运行时异常,不进行处理,也可以通过编译。若一个类继承自RunTimeException,则该异常就是运行时异常
     * 2)编译时异常,受查异常,Checked Exception。不进行处理,则无法通过编译。若一个类继承自Exception,则该异常就是受查异常。
     * 
     * @author Root
     */
    public class UserException extends Exception {
    
        public UserException() {
            super();
        }
    
        public UserException(String message) {
            super(message);
        }
    
    }

    用户名异常:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    public class UsernameException extends UserException {
    
        public UsernameException() {
            super();
        }
    
        public UsernameException(String message) {
            super(message);
        }
    
    }

    密码异常:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    public class PasswordException extends UserException {
    
        public PasswordException() {
            super();
        }
    
        public PasswordException(String message) {
            super(message);
        }
    
    }

    定义异常通知:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    import org.springframework.aop.ThrowsAdvice;
    
    /**
     * 异常通知 当目标方法抛出与指定类型的异常具有is-a关系的异常时,执行当前方法afterThrowing()
     * 
     * @author Root
     */
    public class MyThrowsAdvice implements ThrowsAdvice {
    
        // 当目标方法抛出UsernameException异常时,执行当前方法
        public void afterThrowing(UsernameException ex) {
            System.out.println("发生用户名异常 ex = " + ex.getMessage());
        }
    
        // 当目标方法抛出UsernameException异常时,执行当前方法
        public void afterThrowing(PasswordException ex) {
            System.out.println("发生密码异常 ex = " + ex.getMessage());
        }
    
        // 当目标方法抛出UsernameException异常时,执行当前方法
        public void afterThrowing(Exception ex) {
            System.out.println("发生其它异常 ex = " + ex.getMessage());
        }
    }

    配置文件:

    <?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">
        
        <!-- 1、注册目标对象 -->
        <bean id="someService" class="com.ietree.spring.basic.aop.throwsadvice.SomeServiceImpl"/>
        
        <!-- 2、注册切面:通知 -->
        <bean id="myAdvice" class="com.ietree.spring.basic.aop.throwsadvice.MyThrowsAdvice"/>
        
        <!-- 3、生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定目标对象 -->
            <!-- <property name="targetName" value="someService"/> -->
            <property name="target" ref="someService"/>
            <!-- 指定切面 -->
            <property name="interceptorNames" value="myAdvice"/>
        </bean>
        
    </beans>

    测试:

    package com.ietree.spring.basic.aop.throwsadvice;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
    
        @Test
        public void test() throws UserException {
            
            String resource = "com/ietree/spring/basic/aop/throwsadvice/applicationContext.xml";
            
            ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
        
            IService service = (IService)ac.getBean("serviceProxy");
            
            service.login("jack", "123");
        }
    
    }

     (5)同时使用多个通知的配置方法

    <?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">
        
        <!-- 1、注册目标对象 -->
        <bean id="someService" class="com.ietree.spring.basic.aop.multipleadvice.SomeServiceImpl"/>
        
        <!-- 2、注册切面:通知 -->
        <!-- 前置通知 -->
        <bean id="beforeAdvice" class="com.ietree.spring.basic.aop.multipleadvice.MyMethodBeforeAdvice"/>
        <!-- 后置通知 -->
        <bean id="afterAdvice" class="com.ietree.spring.basic.aop.multipleadvice.MyAfterReturningAdvice"/>
        
        <!-- 3、生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定目标对象 -->
            <property name="target" ref="someService"/>
            <!-- 指定切面 -->
            <!-- 方式一 -->
            <property name="interceptorNames" value="beforeAdvice,afterAdvice"/>
            <!-- 方式二 -->
            <!-- <property name="interceptorNames">
                <array>
                    <value>beforeAdvice</value>
                    <value>afterAdvice</value>
                </array>
            </property> -->
        </bean>
        
    </beans>

    三、顾问Advisor

     通知(Advice)是Spring提供的一种切面(Aspect)。但其功能过于简单:只能将切面织入到目标类的所有方法中,无法完成将切面织入到指定目标方法中。

    顾问(Advisor)是Spring提供的另一种切面。它可以完成更为复杂的切面织入功能。PointcutAdvisor是顾问的一种,可以指定具体的切入点。顾问将通知进行了包装,会根据不同的通知类型,在不同的时间点,将切面织入到不同的切入点。

    PointcutAdvisor接口有两个较为常用的实现类:

    NameMatchMethodPointcutAdvisor:名称匹配方法切入点顾问

    RegexpMethodPointcutAdvisor:正则表达式匹配方法切入点顾问

    1、名称匹配方法切入点顾问NameMatchMethodPointcutAdvisor

     NameMatchMethodPointcutAdvisor,即名称匹配方法切入点顾问。容器可根据配置文件中指定的方法名来设置切入点。

    <?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">
        
        <!-- 1、注册目标对象 -->
        <bean id="someService" class="com.ietree.spring.basic.aop.advisor.namematchmethodpointcutadvisor.SomeServiceImpl"/>
        
        <!-- 2、注册切面:通知 -->
        <bean id="myAdvice" class="com.ietree.spring.basic.aop.advisor.namematchmethodpointcutadvisor.MyMethodBeforeAdvice"/>
        
        <!-- 3、注册顾问:顾问 -->
        <bean id="myAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
            <!-- 指定切面 -->
            <property name="advice" ref="myAdvice"/>
            <!-- 指定切入点 -->
            <!-- <property name="mappedName" value="doFirst"/> -->
            <!-- <property name="mappedNames" value="doFirst,doSecond"/> -->
            <property name="mappedNames" value="*ir*"/>
        </bean>
        
        <!-- 4、生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 指定目标对象 -->
            <property name="target" ref="someService"/>
            <!-- 指定顾问-->
            <property name="interceptorNames" value="myAdvisor"/>
        </bean>
        
    </beans>

    2、正则表达式匹配方法切入点顾问RegexpMethodPointcutAdvisor

     RegexpMethodPointcutAdvisor,即正则表达式方法顾问。容器可根据正则表达式来设置切入点。注意,与正则表达式进行匹配的对象是接口中的方法名,而非目标类(接口实现类)的方法名。

    <?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、注册目标类-->
        <bean id="someServiceImpl" class="com.ietree.spring.aop.advisor.SomeServiceImpl"></bean>
        <!-- 2、注册通知 -->
        <bean id="myAdvice" class="com.ietree.spring.aop.advisor.MyMethodBeforeAdvice"></bean>
    
        <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            <property name="advice" ref="myAdvice"></property>
            <!-- 这里的正则表达式匹配的对象是全限定性方法名 -->
            <!-- 方式一 -->
            <!--<property name="pattern" value=".*doFirst"/>-->
            <!-- 方式二 -->
            <!--<property name="patterns" value=".*doFirst,.*doSecond"/>-->
            <!-- 方式三 -->
            <!--<property name="pattern" value=".*doFirst|.*doSecond"/>-->
        </bean>
    
        <!-- 生成代理对象 -->
        <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="target" ref="someServiceImpl"/>
            <property name="interceptorNames" value="myAdvisor"/>
        </bean>
    
    </beans>
               

    测试:

    package com.ietree.spring.aop.advisor;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Created by Root on 2017/7/3.
     */
    public class Test {
    
        @org.junit.Test
        public void test01(){
    
            String resource = "com/ietree/spring/aop/advisor/applicationContext.xml";
            ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
    
            ISomeService service = (ISomeService)ac.getBean("serviceProxy");
            service.doFirst();
            System.out.println("==========================");
            service.doSecond();
            System.out.println("==========================");
            service.doThird();
    
        }
    
    }

    四、自动代理生成器

     1、默认advisor自动代理生成器

    <?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-2.5.xsd">
               
        <!--1、注册目标类-->
        <bean id="someServiceImpl" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
        <bean id="someServiceImpl2" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
        <!-- 2、注册通知 -->
        <bean id="myAdvice" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.MyMethodBeforeAdvice"></bean>
    
        <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            <property name="advice" ref="myAdvice"></property>
            <!-- 这里的正则表达式匹配的对象是全限定性方法名 -->
            <property name="pattern" value=".*doFirst"/>
        </bean>
    
        <!-- 注册默认自动代理生成器 -->
        <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
    
    </beans> 
               

    测试:

    package com.ietree.spring.aop.defaultadvisorautoproxycreator;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Created by Root on 2017/7/3.
     */
    public class Test {
    
        @org.junit.Test
        public void test01(){
    
            String resource = "com/ietree/spring/aop/defaultadvisorautoproxycreator/applicationContext.xml";
            ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
    
            ISomeService service = (ISomeService)ac.getBean("someServiceImpl");
            service.doFirst();
            System.out.println("==========================");
            service.doSecond();
            System.out.println("==========================");
            service.doThird();
    
            System.out.println("----------------------------------");
    
            ISomeService service2 = (ISomeService)ac.getBean("someServiceImpl2");
            service2.doFirst();
            System.out.println("==========================");
            service2.doSecond();
            System.out.println("==========================");
            service2.doThird();
        }
    
    }

    注意:使用DefaultAdvisorAutoProxyCreator自动代理生成器会有以下几个问题:

    1)不能选择目标对象。

    2)不能选择切面类型,切面只能是advisor。

    3)不能选择advisor,所有的advisor都将被作为切面织入到目标方法中。

    需要解决这几个问题,需要使用Bean名称自动代理生成器实现。

    2、Bean名称自动代理生成器

    <?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-2.5.xsd">
               
        <!--1、注册目标类-->
        <bean id="someService" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
        <bean id="someService2" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
        <!-- 2、注册通知 -->
        <bean id="myAdvice" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.MyMethodBeforeAdvice"></bean>
        <!-- 3、注册顾问 -->
        <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            <property name="advice" ref="myAdvice"></property>
            <!-- 这里的正则表达式匹配的对象是全限定性方法名 -->
            <property name="pattern" value=".*doFirst"/>
        </bean>
    
        <!-- 注册默认自动代理生成器 -->
        <!--<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>-->
    
        <!-- 注册Bean名称自动代理生成器 -->
        <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
            <property name="beanNames" value="someService"/>
            <property name="interceptorNames" value="myAdvisor"/>
        </bean>
    
    </beans>
               

    五、AspectJ对AOP的实现

    1、AspectJ基本概念 

    AspectJ切入表达式原型:

    execution(
          [modifiers-pattern] 访问权限类型
          ret-type-pattern 返回值类型
          [declaring-type-pattern] 全限定性类名
          name-pattern(param-pattern)方法名(参数名)
          [throws-pattern] 抛出异常类型
     )

    其中,带有[ ]的部分是可以省略的,红色的部分是不能省略的部分。

    还可以使用以下符号:

    符号 意义
    * 0至多个任意字符
    ..

    用在方法参数中,表示任意多个参数。

    用在包名后,表示当前包及其子包路径。

    +

    用在类名后,表示当前类及其子类。

    用在接口后,表示当前接口及其实现类。

    2、基于注解方式的实现

    首先创建切面类 MyAspectJ:

    package com.ietree.spring.aop.aspectj.annotation;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.util.StringUtils;
    
    import java.util.Locale;
    
    /**
     * 切面类
     * <p>
     * Created by Root on 2017/7/5.
     */
    @Aspect // 表示当前类为切面类
    public class MyAspectJ {
    
        // 设置前置通知
        @Before("execution(* *..ISomeService.doFirst(..))")
        public void before() {
            System.out.println("执行前置通知方法...");
        }
    
        @Before("execution(* *..ISomeService.doFirst(..))")
        public void before(JoinPoint jp) {
            System.out.println("执行前置通知方法,jp = " + jp);
        }
    
        // 设置后置通知
        @AfterReturning("execution(* *..ISomeService.doSecond(..))")
        public void afterReturning() {
            System.out.println("执行后置通知方法...");
        }
    
        @AfterReturning(value = "execution(* *..ISomeService.doSecond(..))", returning = "result")
        public void afterReturning(Object result) {
            System.out.println("执行后置通知方法, result = " + result);
        }
    
        // 设置环绕通知
        @Around("execution(* *..ISomeService.doSecond(..))")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("执行环绕通知方法之前...");
            // 执行目标方法
            Object result = pjp.proceed();
            System.out.println("执行环绕通知方法之后...");
            if (!StringUtils.isEmpty(result)) {
                result = ((String) result).toUpperCase(Locale.US);
            }
            return result;
        }
    
        // 设置异常通知
        @AfterThrowing("execution(* *..ISomeService.doThird(..))")
        public void afterThrowing() {
            System.out.println("执行异常通知方法...");
        }
    
        // 设置异常通知
        @AfterThrowing(value = "execution(* *..ISomeService.doThird(..))", throwing = "ex")
        public void afterThrowing(Exception ex) {
            System.out.println("执行异常通知方法,ex = " + ex.getMessage());
        }
    
        // 设置最终通知
        //@After("doThirdPointCut()")
        @After("execution(* *..ISomeService.doThird(..))")
        public void After() {
            System.out.println("执行最终通知方法");
        }
    
        // 定义一个切入点,叫做doThirdPointCut(),可以用来替换掉同样的切入点表达式,例如替换后的最终通知
        @Pointcut("execution(* *..ISomeService.doThird(..))")
        public void doThirdPointCut() {
        }
    }

    配置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.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <!-- 注册目标类 -->
        <bean id="myService" class="com.ietree.spring.aop.aspectj.annotation.SomeServiceImpl"/>
    
        <!-- 注册切面类 -->
        <bean id="myAspectJ" class="com.ietree.spring.aop.aspectj.annotation.MyAspectJ"/>
    
        <!-- 使用aspectj的自动代理 -->
        <aop:aspectj-autoproxy/>
    </beans>

    3、基于XML方式的实现

    首先创建切面类 MyAspectJ:

    package com.ietree.spring.aop.aspectj.xml;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.util.StringUtils;
    
    import java.util.Locale;
    
    /**
     * 切面类
     * <p>
     * Created by Root on 2017/7/5.
     */
    public class MyAspectJ {
    
        // 设置前置通知
        public void before() {
            System.out.println("执行前置通知方法...");
        }
    
        public void before(JoinPoint jp) {
            System.out.println("执行前置通知方法,jp = " + jp);
        }
    
        // 设置后置通知
        public void afterReturning() {
            System.out.println("执行后置通知方法...");
        }
    
        public void afterReturning(Object result) {
            System.out.println("执行后置通知方法, result = " + result);
        }
    
        // 设置环绕通知
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("执行环绕通知方法之前...");
            // 执行目标方法
            Object result = pjp.proceed();
            System.out.println("执行环绕通知方法之后...");
            if (!StringUtils.isEmpty(result)) {
                result = ((String) result).toUpperCase(Locale.US);
            }
            return result;
        }
    
        // 设置异常通知
        public void afterThrowing() {
            System.out.println("执行异常通知方法...");
        }
    
        // 设置异常通知
        public void afterThrowing(Exception ex) {
            System.out.println("执行异常通知方法,ex = " + ex.getMessage());
        }
    
        // 设置最终通知
        public void after() {
            System.out.println("执行最终通知方法");
        }
    
    
    }

    配置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.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <!-- 注册目标类 -->
        <bean id="myService" class="com.ietree.spring.aop.aspectj.xml.SomeServiceImpl"/>
    
        <!-- 注册切面类 -->
        <bean id="myAspectJ" class="com.ietree.spring.aop.aspectj.xml.MyAspectJ"/>
    
        <aop:config>
            <aop:pointcut id="doFirstPointcut" expression="execution(* *..ISomeService.doFirst(..))"/>
            <aop:pointcut id="doSecondPointcut" expression="execution(* *..ISomeService.doSecond(..))"/>
            <aop:pointcut id="doThirdPointcut" expression="execution(* *..ISomeService.doThird(..))"/>
            <aop:aspect ref="myAspectJ">
                <!-- 前置通知 -->
                <aop:before method="before" pointcut-ref="doFirstPointcut"/>
                <aop:before method="before(org.aspectj.lang.JoinPoint)" pointcut-ref="doFirstPointcut"/>
    
                <!-- 后置通知 -->
                <aop:after-returning method="afterReturning" pointcut-ref="doSecondPointcut"/>
                <aop:after-returning method="afterReturning(java.lang.Object)" pointcut-ref="doSecondPointcut" returning="result"/>
    
                <!-- 环绕通知 -->
                <aop:around method="around" pointcut-ref="doSecondPointcut"/>
    
                <!-- 异常通知 -->
                <aop:after-throwing method="afterThrowing(java.lang.Exception)" pointcut-ref="doThirdPointcut" throwing="ex"/>
    
                <!-- 最终通知 -->
                <aop:after method="after" pointcut-ref="doThirdPointcut"/>
            </aop:aspect>
    
        </aop:config>
    </beans>

    程序输出:

    执行前置通知方法...
    执行前置通知方法,jp = execution(void com.ietree.spring.aop.aspectj.xml.ISomeService.doFirst())
    执行doFirst()方法
    -----------------
    执行环绕通知方法之前...
    执行doSecond()方法
    执行环绕通知方法之后...
    执行后置通知方法, result = ABCDE
    执行后置通知方法...
    -----------------
    执行最终通知方法
    执行异常通知方法,ex = / by zero
    
    java.lang.ArithmeticException: / by zero
  • 相关阅读:
    路由
    客户端如何调用
    第一个简单的DEMO
    Web API初印象
    项目开发中经常使用的缓存
    EF的Model First
    如何计算代码的运行性能
    使用Obsolete特性来标记方法过时或弃用
    nodeJs实现文件上传,下载,删除
    node 部署教程二
  • 原文地址:https://www.cnblogs.com/Dylansuns/p/7100989.html
Copyright © 2020-2023  润新知