Spring的AOP自动代理（含AspectJ的AOP开发）

最新推荐文章于 2020-04-26 15:47:48 发布
原创 最新推荐文章于 2020-04-26 15:47:48 发布 · 2.6k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨Spring AOP与AspectJ的自动代理机制，通过BeanNameAutoProxyCreator、DefaultAdvisorAutoProxyCreator与AnnotationAwareAspectJAutoProxyCreator的比较，详细阐述了基于后处理BeanPostProcessor的自动代理过程。同时，文章介绍了如何利用AspectJ进行基于注解的AOP开发，包括AspectJ通知类型、切点表达式定义、基于注解的配置与测试案例，以及如何通过XML或注解方式定义切面、通知及配置。
部署运行你感兴趣的模型镜像

1. 自动代理:

 上面这两种代理的方式不好,需要为每一个类配置一个独立的ProxyFactoryBean.(如果需要代理的类特别的多,每个类都需要创建一个代理的类.)

 根据切面Advisor的定义的信息,看到哪些类的哪些方法需要增强.(为这些需要增强的类生成代理.

 自动代理:基于后处理BeanPostProcessor完成代理.

 代理机制不同

     基于ProxyFactoryBean代理:先有被代理对象,将被代理对象传递给代理对象,为其生成代理.

        自动代理:基于BeanPostProcessor代理.在生成类的过程中产生一个代理对象,返回的就是代理对象本身.

  

   

    BeanNameAutoProxyCreator     根据Bean名称创建代理
   

   

    DefaultAdvisorAutoProxyCreator   根据Advisor本身包含信息创建代理
   

   

    AnnotationAwareAspectJAutoProxyCreator 基于Bean中的AspectJ 注解进行自动代理

      == > BeanNameAutoProxyCreator: 

  

   

    <!-- 后处理Bean配置:不需要配置id -->
   

   

    <!-- 自动代理 -->
   

   

    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
   

   

        <!-- 配置Bean的名称 -->
   

   

        <property name="beanNames" value="*Dao"/>
   

   

        <property name="interceptorNames" value="beforeAdvice"/>
   

   

    </bean>
  == >DefaultAdvisorAutoProxyCreator : 

  

   

    <!-- 定义切面(带有切点切面) -->
   

   

    <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
   

   

        <property name="pattern" value="cn\.itcast\.spring3\.demo4\.CustomerDao\.add.*"/>
   

   

        <property name="advice" ref="aroundAdvice"/>
   

   

    </bean>
   

   

    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

区分:

代理机制不同:

  

   

    基于ProxyFactoryBean代理:先有被代理对象,将被代理对象传递给代理对象,为其生成代理.
   

   

    自动代理:基于BeanPostProcessor代理.在生成类的过程中产生一个代理对象,返回的就是代理对象本身.
   

  
2. 基于AspectJ的AOP的开发
:
2.1 什么是AspectJ

AspectJ概述

Spring为了简化AOP的开发,引入AspectJ技术.

 AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

 Spring2.0以后新增了对AspectJ切点表达式支持

AspectJ的通知类型;

   

    

     @Before 前置通知，相当于BeforeAdvice
    

    

     @AfterReturning 后置通知，相当于AfterReturningAdvice
    

    

     @Around 环绕通知，相当于MethodInterceptor
    

    

     @AfterThrowing抛出通知，相当于ThrowAdvice
    

    

     @After 最终final通知，不管是否异常，该通知都会执行
    

    

     @DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

AspectJ的切点的表达式定义:

配置哪些类的哪些方法需要使用增强:

* 类似于正则的方法切点切面.

语法：

   

    

      execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
    

    

      例如:
    

    

      execution(* *(..));
    

    

      execution(* cn.itcast.spring3.demo1.UserDao.*(..))
    

    

      execution(* cn.itcast.spring3.demo1.*(..))
    

    

      execution(* cn.itcast.spring3.demo1..*(..))
    

    

      execution(* cn.itcast.dao.UserDAO+.*(..))

2.2基于注解AspectJ

步骤一:引入AspectJ的相应jar包:

aspectJ的开发需要依赖aop的环境.

   

    

     引入aspectJ的jar包:com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
    

    

     引入spring整合aspectJ的jar包:spring-aspects-3.2.0.RELEASE.jar

步骤二:引入配置文件:

Log4j和spring的配置文件

步骤三:创建包和类:

   

    

     cn.green.demo5
    

    

     UserDao
    

    

     UserDaoImpl

步骤四:定义切面:

切面:就是切点和通知组合.

 在哪些类的哪些方法上使用增强.

 

定义切面:

   

    

      @Aspect

定义增强:

   

    

     @Before 前置通知，相当于BeforeAdvice
    

    

     @AfterReturning 后置通知，相当于AfterReturningAdvice
    

    

     @Around 环绕通知，相当于MethodInterceptor
    

    

     @AfterThrowing抛出通知，相当于ThrowAdvice
    

    

     @After 最终final通知，不管是否异常，该通知都会执行
    

    

     @DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

代码:

   

    

     package cn.green.demo5;
    

    

      
    

    

     import org.aspectj.lang.annotation.Aspect;
    

    

     import org.aspectj.lang.annotation.Before;
    

    

      
    

    

     @Aspect
    

    

     public class MyAspectAnno {
    

    

      
    

    

     	@Before(value="execution(* cn.green.demo5.UserDao.add(..))")
    

    

     	public void before(){
    

    

     		System.out.println("这是before增强.....");
    

    

     	}
    

    

     }

步骤五:配置:

引入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"
    

    

            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">
    

   

   

        
        
      
    <!-- 基于AspectJ的自动代理.使用AnnotationAwareAspectJAutoProxyCreator  -->
    

   

   

    

     	<aop:aspectj-autoproxy />
    

    

     	<bean id="userDao" class="cn.green.demo5.UserDaoImpl"></bean>
    

    

     	<bean id="myAspectionAnno" class="cn.green.demo5.MyAspectAnno"></bean>	
    

    

     	
    

    

     </beans>


测试样例：
   

    

     package cn.green.demo5;
    

    

      
    

    

     import javax.annotation.Resource;
    

    

      
    

    

     import org.junit.Test;
    

    

     import org.junit.runner.RunWith;
    

    

     import org.springframework.test.context.ContextConfiguration;
    

    

     import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    

    

      
    

    

     @RunWith(SpringJUnit4ClassRunner.class)
    

    

     @ContextConfiguration("classpath:applicationContext3.xml")
    

    

     public class TestCase{
    

    

     	
    

    

     	@Resource(name="userDao")
    

    

     	private UserDao userDao;
    

    

     	
    

    

     	@Test
    

    

     	public void demo(){
    

    

     		userDao.delete();
    

    

     		userDao.update();
    

    

     		userDao.add();
    

    

     		userDao.find();
    

    

     	}
    

    

     }
结果：
   

    

     delete run....
    

    

     update run....
    

    

     这是before增强.....
    

    

     add run....
    

    

     find run....

2.2.1 AspectJ的通知的类型:

   

    

     @Before:前置通知:在目标方法之前执行.(不能拦截目标方法.)
    

    

     * JoinPoint:连接点
    

    

      
    

    

     @AfterReturing:后置通知:在目标方法执行之后执行.
    

    

     * JoinPoint:连接点
    

    

     * Object:返回值
    

    

     // 后置增强:
    

    

     @AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.delete(..))",returning="result")
    

    

     public void afterReturing(JoinPoint joinPoint,Object result){
    

    

         System.out.println("后置增强=============="+result);
    

    

     }
    

    

      
    

    

     @Around:环绕通知:
    

    

     // 环绕通知:(阻止目标对象的方法执行)
    

    

     @Around(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
    

    

     public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
    

    

         System.out.println("环绕前增强=============");
    

    

         Object obj = joinPoint.proceed();
    

    

         System.out.println("环绕后增强=============");
    

    

         return obj;
    

    

     }
    

    

      
    

    

     @AfterThrowing:抛出异常通知:
    

    

     // 抛出异常通知:
    

    

     @AfterThrowing(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))",throwing="e")
    

    

     public void afterThrowing(Throwable e){
    

    

         System.out.println("异常通知========="+e.getMessage());
    

    

     }
    

    

      
    

    

     @After:最终通知.类似finally代码块.
    

    

     // 最终通知:
    

    

     @After(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
    

    

     public void after(){
    

    

         System.out.println("最终通知===========");
    

    

     }

2.2.2AspectJ的切点的定义:

   

    

     // 定义一个切点:
    

    

     @Pointcut(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
    

    

     private void mypointcut(){}

面试题:

   

    

     Advisor 和 Aspect区别?
    

    

     Advisor:是Spring传统AOP开发中提供一个切面概念.一般情况下都一个切入点和一个通知组合.
    

    

     Aspect:是真正意义上的切面,可以有多个切入点和多个通知组合.

2.3    基于XML的AspectJ骤一:引入AspectJ的相应jar包:

aspectJ的开发需要依赖aop的环境.

   

    

     引入aspectJ的jar包:com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
    

    

     引入spring整合aspectJ的jar包:spring-aspects-3.2.0.RELEASE.jar

步骤二:引入配置文件:

Log4j和spring的配置文件

步骤三:创建包和类:

   

    

     cn.spring3.demo2
    

    

     OrderDao

步骤四:编写切面类:

   

    

     public class MyAspectXml {
    

    

      
    

    

     public void before(){
    

    

         System.out.println("前置增强============");
    

    

     }
    

    

     }

步骤五:修改配置文件:

   

    

     <bean id="orderDao" class="cn.spring3.demo2.OrderDao"></bean>
    

    

     <bean id="myAspect" class="cn.spring3.demo2.MyAspectXml"></bean>
    

    

     <!-- aop的配置 -->
    

    

     <aop:config>
    

    

         <!-- 定义切点 -->
    

    

         <aop:pointcut expression="execution(* cn.spring3.demo2.OrderDao.add(..))" id="mypointcut"/>
    

    

         <!-- 定义切面 -->
    

    

         <aop:aspect ref="myAspect">
    

    

             <aop:before method="before" pointcut-ref="mypointcut"/>
    

    

         </aop:aspect>
    

    

     </aop:config>

步骤六:编写测试:
其他类型的通知配置;

   

    

     <!-- aop的配置 -->
    

    

     <aop:config>
    

    

         <!-- 定义切点 -->
    

    

         <aop:pointcut expression="execution(* cn.spring3.demo2.OrderDao.add(..))" id="mypointcut1"/>
    

    

         <aop:pointcut expression="execution(* cn.spring3.demo2.OrderDao.delete(..))" id="mypointcut2"/>
    

    

         <!-- 定义切面 -->
    

    

         <aop:aspect ref="myAspect">
    

    

     <!--             <aop:before method="before" pointcut-ref="mypointcut1"/> -->
    

    

     <!--             <aop:around method="around" pointcut-ref="mypointcut1"/> -->
    

    

             <aop:after method="after" pointcut-ref="mypointcut1"/>
    

    

             <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut1" throwing="e"/>
    

    

             <aop:after-returning method="afterReturing" pointcut-ref="mypointcut2" returning="result"/>
    

    

         </aop:aspect>
    

    

     </aop:config>

























您可能感兴趣的与本文相关的镜像

Llama Factory

Llama Factory

模型微调
LLama-Factory

LLaMA Factory 是一个简单易用且高效的大型语言模型（Large Language Model）训练与微调平台。通过 LLaMA Factory，可以在无需编写任何代码的前提下，在本地完成上百种预训练模型的微调

@Aspectj 自动代理原理
墨鱼第二大脑
08-10 267
@EnableAspectJAutoProxy org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator extendsAbstractAdvisorAutoProxyCreator extendsAbstr...
【Spring笔记07】Spring中AOP的动态代理介绍
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 优快云 记录学习心得和笔记内容。
05-30 998
这篇文章，主要介绍一下动态代理模式，以及Spring框架中AOP采用的两种动态代理技术，分别是：JDK动态代理、CGLIB的动态代理。 目录 一、两种代理模式介绍 1.1、代理模式 1.2、静态代理 （1）创建抽象角色接口 （2）创建目标角色类 （3）创建代理角色类 （4）测试程序 1.3、动态代理 二、两种动态代理 2.1、JDK动态代理 （1）创建抽象角色接口 （2）创建具体角色类 （3）自定义InvocationHandler实现类 （4）创建代理工厂方法 （5）测.
AOP 动态代理（Proxy invocationHandler）
04-22
AOP 动态代理（Proxy invocationHandler），Spring的动态代理的介绍
spring自动代理
baidu_36074048的博客
08-20 469
spring默认提供的几种auto-proxy：    BeanNameAutoProxyCreator   :  可以配置需要被进行auto-proxy的bean names列表，它控制的是需要代理的bean列表InfrastructureAdvisorAutoProxyCreator  DefaultAdvisorAutoProxyCreator :  将对应匹配的advisor，
springaop自动代理
jianghuihong2012的专栏
09-29 802
一、背景 spring的aop就是切面编程，切面编程的意思，就是横向对方法进行拦截，加入统一的自定义处理逻辑。比如，统计所有方法的执行次数、统计所有方法的执行时间、在打印所有方法的返回值等等。 切面编程用到的就是jdk的代理，也就是设计模式中的代理模式。代理模式即对目标对象创建一个代理对象，代理对象持有目标对象的引用，因此调用代理对象，就完全可以实现对目标对象的调用，而代理对象是我们自己创建的，
Spring--AOP自动代理
人生理想，活的尽兴
05-26 691
Spring AOP的自动创建代理可分为三种： BeanNameAutoProxyCreator 根据Bean名称创建代理 DefaultAdvisorAutoProxyCreator 根据Advisor本身包含信息创建代理 AnnotationAwareAspectJAutoProxyCreator基于Bean中的AspectJ注解进行自动代理 1、BeanNameAutoPro...
AOP的自动代理
weixin_30414635的博客
10-16 225
Spring的aop机制提供两类方式实现类代理。一种是单个代理，一种是自动代理。 单个代理通过ProxyFactoryBean来实现（就如上面的配置）。 自动代理：自动代理能够让切面定义来决定那个bean需要代理，不需要我们为特定的bean明确的创建代理从而提供一个更完整的aop实现 通过BeanNameAutoProxyCreator或者 DefaultAdvisorAutoProxyCre...
Spring Aop自动创建代理
ai_xiangjuan的博客
04-21 271
1.介绍 在Bean生命周期过长中调用BeanPostProcessor,将对象进行包装，生成代理对象。 2.举例 public class LogMethodInterceptor implements MethodInterceptor { @Override public Object invoke(MethodInvocation invocation...
Spring（九）Spring中的两种自动代理
weixin_34319374的博客
03-12 203
这里说的自动代理说的是自动代理bean对象，就是说在xml中不用再配置代理工厂，就可以自动代理 下面来说第一种 第一种自动代理：默认自动代理生成器（DefaultAdvisorAutoProxyCreator） 第一步：定义接口，在接口中声明几个方法 package demo17; /** * Created by mycom on 2018/3/8. */ publi...
Aop自动代理配置
毛聿修的博客
04-26 2621
Aop自动代理配置 一个ProxyFactoryBean工厂只能配置一个Target类，如果你想增强多个类的话，那么需要配置多个工厂。当需要配置一两个还可以，如果需要加强的类多了的话，那么需要的工厂就很麻烦，明明加强的方法一样，但是还要写多个Proxy工厂来配置，显的很low。那么这里就出现了自动代理配置，只需要建一个工厂就能对多个类实现加强。 ...
Spring AOP 自动创建代理
实践是最好的方法
08-29 1038
目录   1、概述 2、实现类介绍 3、BeanNameAutoProxyCreator的使用 4、DefaultAdvisorAutoProxyCreator 1、概述 在学习切面的时候，都是通过ProxyFactoryBean创建织入切面的代理，每个需要被代理Bean都需要使用一个ProxyFactoryBean进行配置，很是麻烦。Spring为我们提供了自动代理机制，Sprin...
Spring的自动代理
qq_36074043的博客
08-03 540
spring默认提供的几种auto-proxy：    BeanNameAutoProxyCreator   :  可以配置需要被进行auto-proxy的bean names列表，它控制的是需要代理的bean列表InfrastructureAdvisorAutoProxyCreator  DefaultAdvisorAutoProxyCreator :  将对应匹配的advisor，
SpringAOP自动代理
Wang________的博客
02-28 185
SpringAOP 注解自动代理 接口类 com.qust.aop import java.util.List; public interface IUserService { /** * 获取所有的用户对象列表 * @return */ List<Object> ge...
Spring-AOP 自动创建代理
热门推荐
小工匠
08-21 2万+
导读 概述 实现类介绍 BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator AnnotationAwareAspectJAutoProxyCreator AOP总结导读Spring-AOP 自动创建代理Spring-AOP 自动创建代理之BeanNameAutoProxyCreatorSpring-AOP 自动创建代理之DefaultAdv
使用Spring AOP 自动代理配置声明式事务
我的世界我的梦
06-04 1894
我们可以使用下面两种方式消除proxyFactoryBean的繁重配置1.继承parent bean2.使用aop 自动代理spring中的事务都是基于AOP的，我们同样可以使用自动代理消除TransactionProxyFactoryBean的重负实例首先，我们要做任何自动通知一样，需要声明一个bean,成为DefaultAdvisorAutoProxyCreator 
AOP基于XML的自动代理，基于Annotation的设置配置后，自动代理
qq_39632912的博客
05-03 420
AOP基于XML时，配置好后，AOP自动进行，如图一。AOP基于Annotation时，要在xml文件中手写一行配置，对配置好的aspect进行代理，没有配置的aspect，不进行代理，如图二。。。END...
通过SpringAOP+注解实现自动代理
jaune162的专栏，最新动态请关注：https://jaune162.blog
03-11 7474
最近在做一个数据对接项目，通过Hessian与其他企业对接数据。但是公司电脑不能上网只能通过代理上网。如果每个方法都写代理的代码太繁琐，而且项目发布到服务器上的时候服务器是可以上网的。即便通过配置文件配置各个类是否使用代理，但是当发布的时候修改配置文件的内容也会比较多。所以就想到了通过注解+AOP的方式实现自动调用代理。
Spring实战教程 | 第十一篇：SrpringAOP之Spring中的自动代理
w
02-05 808
自动代理的好处：自动检查IoC容器的目标对象，并对这些目标对象产生代理对象，也就是我们不用为每个Action建立相应的代理bean 下面的例子是所有类都以do开头的方法，在被调用时，都要进行日志的输出 实现思路： ① 在接口TimeBookInterface中添加方法doAuditing（）和doCheck（），实现类TimeBook实现该接口 ② 使用Before、After通知 ...
Spring AOP的自动代理
yzgyjyw
09-23 374
一般情况下的代理针对每一个对象的只能增强都需要新建一个bean标签，当有很多类的时候就显得比较繁琐，这时Spring为我们提供了自动代理 情况1：BeanNameAutoProxyCreator    根据Bean的名称来创建代理 配置：修改一般情况下的代理类ProxyFactoryBean为BeanNameAutoProxyCreator <bean class="org.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值