程序员社区

【深入Spring】Spring使用AOP的几种方式

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>
【深入Spring】Spring使用AOP的几种方式插图
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子包下所有类(接口)中的所有方法为切入点

【深入Spring】Spring使用AOP的几种方式插图1
untitled.png

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

【深入Spring】Spring使用AOP的几种方式插图2
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>
赞(0) 打赏
未经允许不得转载:IDEA激活码 » 【深入Spring】Spring使用AOP的几种方式

相关推荐

  • 暂无文章

一个分享Java & Python知识的社区