spring的AOP

最新推荐文章于 2023-06-10 19:11:45 发布
最新推荐文章于 2023-06-10 19:11:45 发布
阅读量114 收藏
点赞数
分类专栏： java 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45432976/article/details/114451834
版权

文章目录

AOP

1.1AOP的作用及优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少代码重复，提高开发效率，并且便于维护

1.2AOP的底层实现

实际上，AOP的底层是通过Spring提供的动态代理技术实现的，在运行期间，Spring通过动态代理技术动态生成代理对象，代理对象方法执行时进行功能增强的介入，在去调用目标对象方法，从而完成功能的增强

1.3动态代理技术

常用的动态代理技术

  • JDK:基于接口的动态代理技术
    1.定义一个接口及实现类(实现了相同的接口)
package com.blb.com.jdk;

public interface Tar {
   public void say();
}


package com.blb.com.jdk;

public class TarImpl implements Tar {
   @Override
   public void say() {
       System.out.println("hollow word");
   }
}

2.增强方法

package com.blb.com.jdk;

public class Add {
   public void before(){
       System.out.println("代理前置增强");
   }
   public void afer()
   {
       System.out.println("代理后置增强");
   }
}

3.实现代理

package com.blb.com.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Text {
   public static void main(String[] args) {
       final Tar tar=new TarImpl();//目标对象
       final Add add=new Add();//增强对象

       //返回值为动态生成的代理对象
       Tar  o = (Tar) Proxy.newProxyInstance(
               tar.getClass().getClassLoader(),//目标对象的类加载器
               tar.getClass().getInterfaces(),//目标对象相同的接口字节码对象数组
               new InvocationHandler() {
                   //调用代理对象的任何方法，实质上都是执行invoke方法
                   @Override
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                       add.before();//前置增强
                       method.invoke(tar, args);//目标方法
                       add.afer();//后置增强
                       return null;
                   }
               }
       );
            o.say();
   }
}
  • cglib:基于父类发动态代理技术（继承关系）

1.原实现类

package com.blb.com.cglib;

public class Tar {

   public void say() {
       System.out.println("hollow word");
   }
}

2.增强类

package com.blb.com.cglib;

public class Add {
    public void before(){
        System.out.println("代理前置增强");
    }
    public void afer()
    {
        System.out.println("代理后置增强");
    }
}

3.实现代理

package com.blb.com.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Text {
    public static void main(final String[] args) {
        final Tar tar=new Tar();
        final Add add=new Add();//增强对象
        //1.创建增强器
        Enhancer enhancer =new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(Tar.class);
        //3.设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                add.before();//执行前置
               Object  invoke = method.invoke(tar, args);//执行目标
                add.afer();//执行后置
                return invoke;
            }
        });
        Tar o =(Tar) enhancer.create();//创建代理对象
          o.say();

    }
}

1.4AOP相关概念

Spring的AOP实现底层就是对上面的动态代理的代码实现的封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

AOP的常用术语

Target（目标对象）：代理的目标对象
Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类
Joinpoint（连接点）：所谓的连接点是指哪些被拦截到的点。在Spring中，这些点指的是方法，因为spring只支持方法类型的连接点
Pointcut（切入点）：所谓的切入点是指我们要对哪些Jointpoint进行拦截的定义
Advice（通知/增强）：所谓通知是指拦截到Jointpoint之后所要做的事情就是通知
Aspect（切面）：是切入点和通知的结合
Weaving（织入）：是指吧增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，二AspectJ采用编译器织入和类装载期织入

1.5springAOP开发明确的事项

1.5.1需要编写的内容

  • 编写核心业务代码（目标类的目标方法）
  • 编写切面类，切面类中有通知（增强功能方法）
  • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

1.5.2AOP技术实现的内容

Spring框架监控切入点方法的执行，一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将=通知的对应功能织入，完成完整的代码逻辑运行

1.5.3AOP底层使用哪种代理方式

在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理方式

1.6知识要点

  1. aop:面向切面编程
  2. aop底层实现：基于jdk动态代理和基于cglib的动态代理
  3. aop是重点概念：
       Pointcut(切入点)：被增强的方法
       Advice(通知/增强)：封装增强业务逻辑的方法
       Aspect(切面)：切点+通知
       Weaving(织入)：将切点与通知结合的过程
  4. 开发明确事项：
       谁是切点（切点表达式配置）
       谁是通知（切面类中的增强方法）
       将切点和通知进行织入配置

2.基于xml的AOP的开发

2.1快速入门

  1. 导入AOP相关坐标
    <dependency>
     <groupId>org.aspectj</groupId>
     <artifactId>aspectjweaver</artifactId>
     <version>1.9.4</version>
   </dependency>
  1. 创建目标接口和目标类（内部有切点）
  2. 创建切面类（内部有增强方法）
  3. 将目标类和切面的创建权交给spring
<?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="target" class="comm.blb.Aop.TargetImpl"></bean>
   <!-- 切面对象-->
   <bean id="myAspect" class="comm.blb.Aop.MyAspect"></bean>
   <!-- 配置织入：告诉是sping框架 哪些方法（切点）需要进行增强（前置、后置）-->
   <aop:config>
       <!--声明切面 -->
       <aop:aspect ref="myAspect">
           <!--切面：切点+通知 -->
           <aop:before method="before" pointcut="execution(public void comm.blb.Aop.TargetImpl.say())"/>
           <aop:after method="af" pointcut="execution(public void comm.blb.Aop.TargetImpl.say())"></aop:after>
       </aop:aspect>
   </aop:config>
</beans>
  1. 在applicationContext.xml中配置织入关系
  2. 测试代码

2.2xml配置AOP详解

    1切点表达式的写法
表达式语法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))
  1. 访问修饰符可以省略
  2. 返回值类型、 包名.类名.方法名可以使用星号*代表任意
  3. 包名与类名一个点.代表当前包下的类，两个点…表示当前包及其子包下的类
  4. 参数列表可以使用两个点…表示任意个数，任意类型的参数列表
    2通知类型
    通知的配置语法：
<aop:通知类型 method="切面类中的方法名" pointcut="切点表达式"/><?aop:通知类型>
名称标签说明
前置通知before用于配置前置通知，指定增强方法在切入点之前执行
后置通知after-returning用于配置后置通知，指定增强方法在切入点之后执行
环绕通知around用于配置环绕通知，指定增强方法在切入点之前和之后执行
异常抛出通知throwing用于配置异常抛出通知，指定增强方法在出现异常时执行
最终通知after用于配置最终通知，无论增强方式 是否有异常都会通知

   3切点表达式抽取
当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcut属性来引用抽取后的切点表达式

    <aop:config>
        <!--声明切面 -->
        <aop:aspect ref="myAspect">
            <!--切面：切点+通知 -->
            <aop:pointcut id="point" expression="execution(public void comm.blb.Aop.TargetImpl.say())"/>
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="af" pointcut-ref="point"></aop:after>
        </aop:aspect>
    </aop:config>

3.基于注解的AOP开发

3.1快速入门

基于注解的Aop开发步骤

  1. 创建目标接口和目标类（内部有切点）
  2. 创建切面类（内部有增强方法）
  3. 将目标类和切面的创建权交给spring
  4. 在切面类中使用注解配置织入关系
  5. 在配置文件中开启组件扫描和AOP的自动代理
  6. 测试
    目标类
package com.blb.anno;

import comm.blb.Aop.Target;
import org.springframework.stereotype.Component;

@Component("target")
public class TargetImpl implements Target {
   public void say() {
       System.out.println("Target...");
   }
}

接口

package com.blb.anno;

public interface Target {
    public void say();
}

切面

package com.blb.anno;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component("myAspect")
@Aspect//当前
public class MyAspect {
     @Before("execution(public void com.blb.anno.TargetImpl.say())")
    public void before(){
        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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.blb"></context:component-scan>
    <!-- aop自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

测试类

package com.blb.text;

import comm.blb.Aop.Target;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applica.xml")
public class annoText {
    @Autowired
    private Target target;
    @Test
    public void text1(){
        target.say();
    }
}
smilecb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring AOP
CloudLai的博客
05-25 270
1.前置知识讲解： a)什么是动态代理：相对于静态代理 b)Jdk动态代理： i.新建接口Task如下： public interface Task { public void doSomeThing(); } ii.新建类Person实现Task接口，并覆盖抽象方法doSomething如下： public class Person implements Task{ publi...
6.AOP的后置通知AfterAdvice
weixin_44137201的博客
09-06 475
自己写的AfterAdvice实现AfterReturningAdvice类,重写里面的方法afterReturning() 与前置通知相比，大概的类不变，只需要改变AfterAdvice以及xml 切面类MyLogger.java //切面类 public class MyLogger { public void log(String msg){ System.out.println("log:"+msg); } } 实体类Account.java //银行账户 public class
Spring AOP，Before Advices、After Advice、Around Advice、Throw Advice的解析与使用。
hjw0505521的博客
03-17 877
AOP是一个横向的关系：如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将空心圆柱体剖开，以获得其内部的消息。而剖开的切面又能将剖开的切面复原，不留痕迹。 AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离”。 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象（比如事务管理）； 在Spring ...
Spring AOP编程官方文档解读之增强
m0_37607945的博客
09-12 211
系列文章目录 第一章 : Spring AOP编程官方文档解读之切点 文章目录系列文章目录前言Advice的定义方式对命名切入点的简单运用就地声明的切入点表达式Advice的几种类型Before 方法执行前增强After returning advice：正常返回增强After throwing advice ：异常返回增强After advice : 正常和异常返回都增强 通常用于释放资源Around advice 功能最齐全总结 前言 什么是增强 ？英文名为Advice。所谓的增强就是功能的增加，通
Spring的动态代理
weixin_70320260的博客
03-28 2951
当代理对象调用接口方法时，实际执行的是代理类中的对应方法。动态代理是Java语言中的一个重要特性，它允许我们在运行时动态地创建代理对象，而无需在编译时就确定代理对象的类型。在动态代理中，代理对象与目标对象实现了相同的接口，因此代理对象可以完全替代目标对象，执行与目标对象相同的操作。基于接口的动态代理是指代理类和目标对象实现了相同的接口，代理类在实现接口方法时，通过反射机制调用目标对象的对应方法。动态代理是Java语言中一种非常重要的技术，它允许我们在运行时动态地创建代理对象，从而实现对目标对象的代理操作。
Spring中的动态代理
Lyzxii
10-30 7314
1.Spring AOP 就是要对目标进行代理对象的创建， Spring AOP是基于动态代理的，有动态代理机制： JDK动态代理和CGLIB动态代理 动态代理：在虚拟机内部，运行的时候，动态生成代理类(运行时生成，runtime生成) ，并不是真正存在的类， 一般格式： Proxy$$ （Proxy$$Customer） 静态代理：实际存在代理类 （例如：struts2 Action...
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring aop
03-28
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式的企业级服务，如事务管理、日志记录等。AOP的核心概念是切面（Aspect）和通知（Advice...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring aop.docx
最新发布
12-14
**Spring AOP 入门** 在深入探讨Spring AOP之前，我们先理解AOP（面向切面编程）的概念。AOP是一种编程范式，旨在减少代码的重复性，提高代码的可维护性和可读性。它通过将关注点（如日志记录、事务管理、安全性等...
spring 动态代理
weixin_44214857的博客
06-10 2147
感觉不错 三连支持 一起进步！动态代理。
Spring——动态代理
ly000666的博客
05-22 8019
动态代理(理解)：基于反射机制。 掌握程度： 1.什么是动态代理？ ​ 使用jdk的反射机制，创建对象的能力，创建的是代理类的对象。而不用你创建类文件。不用谢java文件。 ​ 动态：在程序执行时，调用JDK提供的方法才能创建代理类的对象。 ​ jdk动态代理，必须有接口，目标类必须实现接口，没有接口时，需要使用cylib动态代理。 2.知道动态代理能做什么？ ​ 可以在不改变原来目标方法功能的前提下，可以在代理中增强自己的功能代码。 ​ 程序开发中的意思。 ​ 比如：你所在的项目中，有一个功能是其他人
Spring动态代理
zzs1126的博客
03-31 401
一、什么是代理？代理是一种设计模式，提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。可以不修改目标对象，对目标对象功能进行拓展。在我们学习Spring的时候就会发现，AOP（面向切面编程）的底层就是代理。代理的实现可以分为静态代理和动态代理。动态代理又根据实现的方式分为：基于JDK接口的动态实现和基于Cglib类的动态实现为什么需要代理？代理的目的是为了使被代理类的功能更加纯粹，不用考虑其他的问题，其他的一些操作都可以在代理类中完成。
细说Spring——AOP详解和动态代理
m0_68758365的博客
03-28 881
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
Spring————动态代理、AOP
HUzxcvbnmasd的博客
04-03 491
有了动态代理的技术，那么就可以在不修改方法源码的情况下，增强被代理对象的方法的功能，在方法执行前后做任何你想做的事情。在软件业，AOP为Aspect Oriented Programming的缩写，意为: 面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。在生成代理对象的过程中，目标对象不变，代理对象中的方法是目标对象方法的增强方法。利用AOP可以对业务逻辑。
Spring中的AOP和动态代理
Purpletaro的专栏
06-04 303
AOP 提供一种通用的扩展机制，在业务操作前后提供一些切面的操作，这些操作通常是和业务无关的，例如：日志记录、性能统计、安全控制、事务处理、异常处理等。
SpringBoot+Vue项目快速入门
热门推荐
smilecb的博客
03-27 1万+
文章目录1. 项目技术选型2. 项目搭建2.1 环境搭建2.1.1 Node环境2.1.2 项目构建2.1.3 安装插件2.1.4 引入插件 1. 项目技术选型 Springboot+MyBatis-Plus+vue+element-ui+echarts 2. 项目搭建 2.1 环境搭建 2.1.1 Node环境 官方下载node 检查安装情况 node –v npm –v 安装cnpm npm install –g cnpm --registry=https://registry.npm.taobao.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值