美文网首页
Spring使用AOP的几种方式

Spring使用AOP的几种方式

作者: 叫我不矜持 | 来源:发表于2019-02-14 21:29 被阅读3次
    1.经典的基于代理的AOP

    [1]前置通知

    public class BeforeAdvice implements MethodBeforeAdvice{
    
        @Override
        public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
            System.out.println("前置通知");
            /*
             * arg0 切点的方法
             * arg1 切点的方法形参
             * arg3 切点所在的对象
            */
        }
        
    }
    
    

    [2]后置通知

    public class AfterAdvice implements AfterReturningAdvice{
    
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("后置通知");
        }
    
    }
    

    [3]环绕通知

    public class AroundAdvice implements MethodInterceptor{
    
        @Override
        public Object invoke(MethodInvocation arg0) throws Throwable {
            System.out.println("环绕通知前");
            Object proceed = arg0.proceed();
            System.out.println("环绕通知后");
            return proceed;
        }
    
    }
    

    [4]异常通知

    public class ExceptionAdvice implements ThrowsAdvice{
        public void afterThrowing(Exception ex){
            System.err.println(ex.getMessage());
            System.out.println("异常通知");
        }
    }
    

    [5]application.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"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
        <!-- 注册代理目标类 -->
        <bean id="someServiceImpl" class="com.bjsxt.service.SomeServiceImpl"></bean>
        
        <!-- 注册前置通知 -->
        <bean id="beforeAdvice" class="com.bjsxt.advice.BeforeAdvice"></bean>
        
        <!-- 注册后置通知 -->
        <bean id="afterAdvice" class="com.bjsxt.advice.AfterAdvice"></bean>
        
        <!-- 注册环绕通知 -->
        <bean id="aroundAdvice" class="com.bjsxt.advice.AroundAdvice"></bean>
        
        <!-- 注入异常通知 -->
        <bean id="exceptionAdvice" class="com.bjsxt.advice.ExceptionAdvice"></bean>
        
        <!-- 注册代理工厂Bean --> 
        <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
            <!-- 配置目标类-->
            <property name="targetName" value="someServiceImpl"></property>
            
            <!-- 配置拦截时执行的通知 -->
            <property name="interceptorNames">
                <!-- 字符串数组 -->
                <!-- 方式一   在property标签中的value属性中用,分隔注入  例如:(value="beforeAdvice,afterAdvice")-->
                <!-- 方式二 (数组注入)-->
                <array>
                    <value>beforeAdvice</value>
                    <value>afterAdvice</value>
                    <value>aroundAdvice</value>
                    <value>exceptionAdvice</value>
                </array>
            </property>
            
            <!-- 配置目标类的接口 -->
            <property name="interfaces">
                <list>
                    <!-- (字节码对象数组)注意:字节码对象可以直接在value属性中表示 -->
                    <value>com.bjsxt.service.SomeService</value>
                </list>
            </property>
        </bean>
       
    </beans>
    
    QQ截图20190214203643.png
    2.通过AspectJ提供的注解实现AOP

    AspectJ对AOP的实现
    对于AOP这种编程思想,很多框架都进行了实现。Spring就是其中之一,可以完成面向切面编程。然而,AspectJ也实现了AOP的功能,且其实现方式更为简捷,使用更为方便,而且还支持注解式开发。所以,Spring又将AspectJ的对于AOP的实现也引入到了自己的框架中。
    在Spring中使用AOP开发时,一般使用AspectJ的实现方式。

    AspectJ中常用的通知有五种类型:

               前置通知 
               后置通知 
               环绕通知 
               异常通知 
               最终通知:无论程序执行是否正常,该通知都会执行。类似于try..catch中finally代码块。 
    

    AspectJ的切入点表达式 (execution)
    举例:
    execution(public * (..))
    指定切入点为:任意公共方法。
    execution(
    set (..))
    指定切入点为:任何一个以"set"开始的方法。
    execution(
    com.xyz.service..(..))
    指定切入点为:定义在service包里的任意类的任意方法。
    execution(* com.xyz.service...(..))
    指定切入点为:定义在service包或者子包里的任意类的任意方法。".."出现在类名中时,后面必须跟"",表示包、子包下的所有类。
    execution(
    .service..(..))
    指定只有一级包下的serivce子包下所有类(接口)中的所有方法为切入点
    execution(
    ..service..*(..))
    指定所有包下的serivce子包下所有类(接口)中的所有方法为切入点

    untitled.png

    切入点表达式要匹配的对象就是目标方法的方法名。所以,execution表达式中明显就是方法的签名。注意,表达式中加[ ]的部分表示可省略部分,各部分间用空格分开。在其中可以使用以下符号

    untitled2.png

    代码示例

    @Component("myAspect")
    @Aspect  //表明当前类是一个切面 
    public class MyAspect {
        @Before(value="execution(* *..service.*.*(..))")
        public void before(JoinPoint joinPoint) throws Throwable {
            System.out.println("前置通知"+jp);
                    //通过JoinPoint 获取切点方法的参数列表集合
                   Object[] args = joinPoint.getArgs();
                    //获取切点所在的目标对象
                    Object target = joinPoint.getTarget();
                    //获取切点的方法的对象
                Signature signature = joinPoint.getSignature();
            MethodSignature ms = (MethodSignature)signature;
            Method method = ms.getMethod();
        }
        @Around(value="execution(* *..service.*.*(..))")
        public Object around(ProceedingJoinPoint arg0) throws Throwable {
            System.out.println("环绕通知前");
            Object proceed = arg0.proceed();
            
            if(proceed!=null){
                System.out.println(proceed.toString().toUpperCase());
            }
            System.out.println("环绕通知后");
            return proceed;
        }
        
        @AfterReturning(value="execution(* *..service.*.*(..))",returning="result")
        public void afterReturning(Object result) throws Throwable {
            System.out.println("后置通知");
            System.out.println("后置通知获取返回值:"+result);
        }
        
        @AfterThrowing(value="execution(* *..service.*.*(..))" ,throwing="ex")
        public void afterThrowing(Exception ex){
            System.out.println("异常通知"+ex.getMessage());
        }
        
        //使用@After(value="pointcut()"),表示继承了方法pointcut()的切入表达式:execution(* *..service.*.*(..))。
        @After(value="pointcut()")
        public void after(){
            System.out.println("最终通知");
        }
        @Pointcut("execution(* *..service.*.*(..))")
        public void pointcut(){
            
        }
        
    }
    

    application.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">
    
        
       
        <context:component-scan base-package="com.terence.aop.aspectj"/>
        <!-- 配置切面自动代理 -->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
        
       
    </beans>
    
    3.AspectJ通过XML方式实现AOP
            <!-- 注册目标类 --> 
           <bean id="someServiceImpl" class="com.bjsxt.service.impl.SomeServiceImpl"></bean> 
           <!-- 注册切面--> 
           <bean id="myAspect" class="com.bjsxt.aspects.MyAspect"></bean> 
            
           <!-- aop配置 --> 
           <aop:config> 
                   <!-- 指定切入点 --> 
                   <aop:pointcut expression="execution(* *..service.*.doSome(..))" id="doSomePC"/> 
                   <aop:pointcut expression="execution(* *..service.*.doOther(..))" id="doOtherPC"/> 
                   <!-- 指定切面 --> 
                   <aop:aspect ref="myAspect"> 
                           <!-- 指定切面当中的前置通知方法 --> 
                         
                           <aop:before method="before" pointcut-ref="doSomePC"/> 
                           <aop:before method="before(org.aspectj.lang.JoinPoint)" pointcut-ref="doSomePC"/> 
                             
                           <!-- 指定切面当中的后置通知方法 --> 
                           <aop:after-returning method="afterReturning(java.lang.Object)" pointcut-ref="doOtherPC" returning="result"/> 
    
                           <!-- 指定切面当中的环绕通知方法 --> 
                           <aop:around method="around" pointcut-ref="doOtherPC"/> 
    
                           <!-- 指定切面当中的异常通知方法 --> 
                           <aop:after-throwing method="afterThrowing(java.lang.Exception)" pointcut-ref="doSomePC" throwing="ex"/> 
    
                           <!-- 指定切面当中的最终通知方法 --> 
                           <aop:after method="after" pointcut-ref="doSomePC"/> 
                   </aop:aspect> 
           </aop:config> 
    
    
    4.基于Scheme-base的AOP
    <?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"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
        <!-- 注册user实体类 -->
        <bean id="user" class="com.bjsxt.pojo.User"></bean>
        
        <!-- 注册前置通知 -->
        <bean id="before" class="com.bjsxt.advice.BeforeAdvice"></bean>
        
        <!-- 注册后置通知 -->
        <bean id="after" class="com.bjsxt.advice.AfterAdvice"></bean>
        
        <!-- 注册环绕通知 -->
        <bean id="run" class="com.bjsxt.advice.RunAdvice"></bean>
        
        <!-- 注册异常通知 -->
        <bean id="exception" class="com.bjsxt.advice.ExceptionAdvice"></bean>
        <!-- 配置aop -->
        <aop:config>
            <!-- 选择切点 -->
            <!-- 指定方法的切点 -->
            <aop:pointcut expression="execution(* com.bjsxt.pojo.User.b(String))" id="point"/>
            <!-- ..代表有参数和无参数都行 -->
            <aop:pointcut expression="execution(* com.bjsxt.pojo.User.b(..))" id="point2"/>
            <!-- *代表通配符 (User类的所有方法都是切点) -->
            <aop:pointcut expression="execution(* com.bjsxt.pojo.User.*(..))" id="point3"/>
            <!-- pojo报下的所有方法都是切点 -->
            <aop:pointcut expression="execution(* com.bjsxt.pojo.*.*(..))" id="point4"/>
            <!-- 定义切面 -->
            <aop:advisor advice-ref="before" pointcut-ref="point"/>
            <aop:advisor advice-ref="after" pointcut-ref="point"/>
            <aop:advisor advice-ref="run" pointcut-ref="point"/>
            <aop:advisor advice-ref="exception" pointcut-ref="point"/>
        </aop:config>
    </beans>
    

    相关文章

      网友评论

          本文标题:Spring使用AOP的几种方式

          本文链接:https://www.haomeiwen.com/subject/ciuyeqtx.html