spring aop 笔记

最新推荐文章于 2024-07-17 14:39:25 发布
最新推荐文章于 2024-07-17 14:39:25 发布
阅读量74 收藏
点赞数
分类专栏： zh笔记 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48082177/article/details/120274316
版权

文章目录

AOP

  • 什么是aop 面向切面编程 (面向方面编程)
  • 利用aop以对业务逻辑的各个部分进行隔离 从而使得业务逻辑各个部分之间耦合度降低 提高程序的可重用性 同时提高了开发的效率

aop 想添加功能 但是不修改源代码 在主干功能里添加新功能

aop ( 底层原理 )

AOP 的底层 使用 动态代理

  1. 有两种情况的动态代理
    1. 有接口的情况 使用 JDK动态代理
    2. 没有接口的情况 使用CGLIB动态代理

aop jdk动态代理

  1. 使用jdk 动态代理,使用Proxy类中的方法 创建代理对象

    public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException
    1. 方法中含有三个参数
      1. 第一个 类加载器
      2. 第二个 增强方法所在的类 这个类实现的接口 支持多个接口
      3. 第三个 实现这个接口 InvocationHandler 创建代理对象

  2. jdk 动态代理代码

    1. 创建接口 定义方法

      package com.zh.demo1;

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

    2. 创建接口的实现类 实现方法

      package com.zh.demo1;

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

    3. 使用Proxy类创建接口代理对象

      1. 创建一个类 创建main方法
      2. 实现Proxy中newProxyInstance 方法 方法含有三个参数 上边写了 第一个参数是类的加载器 为JDKProxy.class.getClassLoader() 第二个参数为增强方法所在的类 举例为userdao 第三个参数一个接口用来创建代理对象 两种方法 1 匿名内部类 直接new 2 创建一个新的类实现此接口 我采用的为此方法
      package com.zh.demo1;

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

public class JDKProxy {
    private Object object;
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces={UserDao.class};
        UserDaoImpl userDao=new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add=dao.add(1,2);
        System.out.println(add);
    }
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
    //1 把创建的是 谁的代理对象 把谁传递过来
    //通过有参构造进行传递
    private Object object;
    public UserDaoProxy(Object object){
        this.object=object;
    }
    //增强的逻辑
    @Override
    //第一个参数 代理对象 第二个值 表示当前的方法  第三个 表示方法的参数
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        //method.getName()执行的方法名字
        System.out.println("方法之前执行"+method.getName()+":传递的参数====="+ Arrays.toString(args));

        //被增强的方法
        //下面表示执行当前方法
        Object a=method.invoke(object,args);
        //方法之后
        System.out.println("方法之后执行      "+object);
        return a;
    }
}

    ​

aop 术语

  1. 连接点 类里的哪些方法可以被增强 这些方法被称为连接点
  2. 切入点 实际被真正增强的方法 被称为切入点
  3. 通知(增强)
    1. 实际增强的逻辑的部分称为通知
    2. 通知有多种类型
      1. 前置通知 @before
      2. 后置通知 @afterReturning
      3. 环绕通知 @around
      4. 异常通知 @afterThrowing
      5. 最终通知 @after
  4. 切面 是动作 把通知应用到切入点的过程

aop操作 (准备)

  1. spring 框架一般都是基于aspectJ实现aop 操作
    1. 什么是AspectJ AspectJ不是spring组成部分 是独立aop框架 一般吧AspectJ和spring框架一起使用 进行aop操作
  2. 基于AspectJ实现aop操作
    1. 基于xml配置文件实现
    2. 基于注解方式实现
  3. 在项目工程中引入aop相关依赖
  4. 切入点表达式
    1. 作用: 知道对哪个类里面的方法进行增强
    2. 语法结构 :execution([权限修饰符] [返回类型] [方法名称] ([参数列表]))
    3. 举例1 execution(* con.zh.demo1.Book.add(…)) *表示所有的修饰符
    4. 举例2 对类里的所有方法进行增强 execution(* com.zh.demo.Book.*(…))
    5. 举例3 对包中的所有类 类里的所有方法进行增强execution(* com.zh.* . *(…))

aop操作(基于AspectJ注解方式)

  1. 创建一个类 在类中定义方法,实现对类的方法增强

  2. 创建一个增强类,编写增强的逻辑

    1. 在增强类中创建方法 让不同的方法代表不同的通知类型

  3. 进行通知的配置

    1. 在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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    开启注解的扫描-->
    <context:component-scan base-package="com.zh"></context:component-scan>

    2. 使用注解创建user和userproxy两个对象

      //被增强的类
@Component
public class User {
    public void add(){
        System.out.println("add.............");
    }
}
//增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before.........");

    }
}

    3. 在增强的类上添加一个注解 @aspect

      //增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before.........");

    }
}

    4. 在spring配置文件中 开启生成代理对象`

      <!--    开启aspectJ生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

    5. 配置不同类型的通知

      1. 在我们增强类的里边 在作为通知方法上面 添加通知类型注解 使用切入点表达式配置

        //前置通知
//before 注解表示作为前置通知
@Before(value = "execution(* com.zh.demo2.User.add())")
public void before(){
    System.out.println("before.........");
}

        //环绕通知 在add之间 和之后都执行
@Around(value = "execution(* com.zh.demo2.User.add())")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕之前");
    //执行被增强的方法
    proceedingJoinPoint.proceed();
    System.out.println("环绕之后");
}

        before 前置通知 afterthrowing 异常通知 产生异常 才会执行after 最终通知 有异常也执行

    6. 对公共切入点抽取

      //相同切入点抽取
@Pointcut(value = "execution(* com.zh.demo2.User.add())")
public void pointdemo(){

}

//前置通知
//before 注解表示作为前置通知
@Before(value ="pointdemo()")
public void before(){
    System.out.println("before.........");

}

    7. 有多个增强类对同一个方法进行增强 设置增强类的优先级

      1. 在增强类上面添加一个注解 @Order(数字类型值) 数字类型值越小 优先级越高

        //增强的类
@Component
@Aspect//生成代理对象
@Order(3)
public class UserProxy {}

========================================================
@Component
@Aspect
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.zh.demo2.User.add())")
    public void before(){
        System.out.println("person  before.........");

    }
}

aop操作(AspectJ配置文件方式)

  1. 创建两个类 增强类和被增强类 创建方法

  2. 在spring配置文件中创建两个类对象

    	创建对象
    <bean id="book" class="com.zh.demo3.Book"></bean>
    <bean id="bookProxy" class="com.zh.demo3.BookProxy"/>

  3. 在spring配置文件中配置切入点

    <!--    配置aop增强 -->
    <aop:config>
<!--        切入点-->
        <aop:pointcut id="zh" expression="execution(* com.zh.demo3.Book.buy())"/>
<!--        配置切面   表示把增强的方法应用到切入点的过程-->
        <aop:aspect ref="bookProxy">
<!--            配置 增强作用在具体的方法上   method 增强的方法   pointcut-ref作用在哪个切入点-->
            <aop:before method="before" pointcut-ref="zh"/>
        </aop:aspect>
    </aop:config>

完全注解(简单了解)

创建一个配置类 不需要创建xml配置文件

package com.zh.demo3;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan(basePackages = {"com.zh.demo3"})//替代配置文件中 开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//替代配置文件中 开启aspect生成代理对象
public class ConfigAop {
}
54daboluo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP学习笔记
01-27
,文章属于基础级文章，适合入门级的小伙伴，它的概念，应用场景，实现原理及Spring的AOP的开发。全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
Spring Aop 学习笔记
03-25
Spring Aop 学习笔记
spring aop笔记
蔡文彬的博客
11-21 133
    JDK动态代理     Cglib代理   传统aop   基于aspectJ      
Spring AOP 学习笔记
锦瑟年华,逐梦之人
08-06 1829
注：该篇文章会与我的个人博客同步更新。欢迎移步https://cqh-i.github.io/体验更好的阅读效果。 什么是AOP   全称面向切面编程(Aspect Oriented Programming), 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
Spring AOP笔记
Hulk_Corleone的博客
04-14 114
对于有返回值的method，如果要加@Around注解，要记得Advice的返回值不能为void
spring AOP 笔记
信言的笔记
04-23 534
AOP的目的就是要把共通的切面（Aspect）抽出来，允许不同的对象复用。比如打日志，记录方法执行时间等。 于是一个Aspect的实例（advisor），需要表达清楚两点： 1.pointCut，即准入条件。类名和方法名符合什么样的要求，才可以触发切面执行。如方法签名具有annotation @Monitor。 2.advice，即触发的动作。一般会在如下几种时机触发：方法执行before、
spring AOP简写笔记
qq_43709204的博客
11-24 186
spring AOP简写笔记 什么是AOP？ aop就是一个完整的程序，分为dao层，mapper层，service层等等，我们可以用aop来对某一层进行切面来实现对这个功能不动其原代码的情况下增强功能。 AOP的特点 降低模块与模块之间的耦合度，提⾼业务代码的聚合度。（⾼内聚低耦合） 提⾼了代码的复⽤性。 提⾼系统的扩展性。（⾼版本兼容低版本） 可以在不影响原有的功能基础上添加新的功能 AOP的底层实现 动态代理（JDK + CGLIB） 基本概念 Joinpoint（连接点）：被拦截的每一个方法
Spring Aop学习笔记
weixin_42082191的博客
05-03 513
在学习AOP之前我们先提出几个问题？ AOP是什么？ AOP优点是什么？ AOP组成结构？ AOP实现原理？ AOP是什么 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以通过预编译方式和运行其动态代理实现在不修改源代码的情况下给程序动态统一添加某种特定功能的一种技术。在springAop表现中就是对某一类型的方法进行拦截处理。 AOP优点是什么？ 使用面向对象编程（OOP）有一些弊端，当需要为多个不具有继承关系的对象引入同一个公共行为时，例如日志
Spring AOP学习笔记（一）
zcawesome的博客
12-06 415
AOP使用代理机制   AOP可以在不修改源码的情况下对代码进行增强 AOP使用动态代理有阆中实现方式当我们实现了接口的时候Spring会使用JDK动态代理     没有实现接口就会自动切换到  Cglib（类似于Javassit）动态代理    cglib  是生成子类对象来实现的动态代理 JDK动态代理：《查》 动态代理的实现 public class MyJDKPr...
Spring-Aop笔记
qq_44392492的博客
05-24 136
Spring-Aop笔记aop使用总流程1、导入依赖2、编写业务类3、编写切面类3、将类放入spring容器 aop使用总流程 导入aop依赖 spring-aspects 编写业务类 编写切面类 将切面类和业务类都加入spring容器（告诉spring哪个是切面类） 开启aop功能 1、导入依赖 这里只说明了spring的依赖和aop依赖，其他相关依赖自行导入 <dependency> <groupId>org.springframework</g
spring-AOP笔记（理论知识）
weixin_46363627的博客
07-14 212
一些AOP的笔记，靠我记得的写，不够的可以评论补充，一起学习的快乐是属于大家的(｡◕ˇ∀ˇ◕)(^_−)☆AOP的术语如：切点表达语法：通知类型->通知的配置语法： 七、基于注解AOP开发 1.步骤 创建目标接口和目标类（内部有切点） 创建切面类（内部有增强方法） 将目标类和切面类的对象创建权交给spring 在切面类中使用注解配置织入关系 在配置文件中开启组件扫描和AOP的自动代理 //组件扫描跟Xml一致+aop自动代理（aop：aspectj-autoproxy） 最后测试 2.注解通知类型
Spring AOP小笔记
huangliuyu00的博客
04-17 106
Spring AOP小笔记 AOP概念 通知(Advice)、连接点(Join point)、切点(Poincut)、切面(Aspect)、引入(Introduction)、织入(Weaving) 通知 定义了切面是什么以及何时使用。(何时) 连接点 是有可能操作的地方。 切点 定义了真正操作的连接点。操作的区域 切面 定义要做什么。 引入 允许我们向现有的类添加新方法或属性。 织入 把切面应用到目标对象并创建代理对象的过程。也就是说，观察计划了这么久，要动手了。 ...
Spring AOP源码笔记
03-11
【Spring AOP源码笔记】 Spring AOP是Spring框架的核心组件之一，它实现了面向切面编程（Aspect-Oriented Programming，简称AOP），允许开发者定义“切面”，这些切面可以封装横切关注点，如日志记录、事务管理等。...
spring aop 学习笔记
05-27
本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面（Aspect）**：切面是关注点的模块化，包含业务逻辑之外的横切关注点，如日志、事务管理。 - **连接点（Join Point...
springAOP笔记
10-27
springAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOP
SpringBoot整合SSE，实现后端主动推送DEMO
最新发布
zjy660358的专栏
07-17 249
说起服务端主动推送，大家第一个想到的一定是WEBSOCKET。作为软件工程师，不能无脑使用一种技术，要结合实际情况，择优选取。SSE（Server-Sent Events）相比于WEBSOCKET1、轻量化、兼容性 基于传统的HTTP协议，所以浏览器兼容性比较好2、 只支持单向通讯。（服务器->客户端）
大白话之SpringMVC中的ModelAndView
qq_36634055的博客
07-12 279
就像是你吃东西的地方，它决定了数据（Model）将以什么样的形式展现给用户。这可能是一个HTML页面，一个JSON响应，或者甚至是一张图片。是一个非常关键的类，它用于封装控制器(Controller)方法执行后的两个重要输出：模型数据(Model)和视图(View)。就像是服务员把厨房做好的食物送到指定的位置，这样顾客就可以享用美食了。在Web开发中，这就是如何将数据展示给用户的整个过程。就像是你要的食物，是你希望展示给用户的数据。比如，你可能想要在网页上显示一个用户的名字和他们的订单详情，这些都是。
springboot start.aliyun.com java8
JavaUpgrade
07-15 123
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Spring Security 授权
persistence_PSH的博客
07-14 868
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
spring Aop笔记,和源码讲解
06-09
好的，关于Spring AOP的笔记和源码讲解，我可以给你简单介绍一下。 Spring AOP是Spring框架中的一个重要模块，提供了基于代理的AOP实现。AOP（Aspect Oriented Programming）面向切面编程，是一种编程思想，它通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值