SpringAOP基础学习笔记

最新推荐文章于 2023-11-15 16:40:25 发布
最新推荐文章于 2023-11-15 16:40:25 发布
阅读量164 收藏
点赞数
分类专栏： Spring 文章标签： 代理模式 java spring 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55715292/article/details/124568327
版权

引子：在实际给别人做业务时，对业务的的要求是一直存在变化的

  • 代码混乱：越来越多的非业务需求（日志和验证等）加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。
  • 代码分散：以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。

可以使用代理的方式解决上述问题：
代理设计模式原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
两种代理方式：

  • 静态代理：
    优点：通过静态代理，我们达到了功能增强的目的，而且没有侵入原代码，这是静态代理的一个优点。
    缺点：虽然静态代理实现简单，且不侵入原代码，但是，当场景稍微复杂一些的时候，静态代理的缺点也会暴露出来。
    1、 当需要代理多个类的时候，由于代理对象要实现与目标对象一致的接口，有两种方式：
    （1）只维护一个代理类，由这个代理类实现多个接口，但是这样就导致代理类过于庞大
    （2）新建多个代理类，每个目标对象对应一个代理类，但是这样会产生过多的代理类
    2、当接口需要增加、删除、修改方法的时候，目标对象与代理类都要同时修改，不易维护。

  • 动态代理：根据接口或目标对象，计算出代理类的字节码，然后再加载到JVM中使用。

目录

动态代理分两种：

1.通过实现接口的方式 ->JDK动态代理

案例：对计算器进行动态代理
在这里插入图片描述
JiSuanQi：

package 计算器;

public interface JiSuanQi {
    public int add(int a,int b);
    public int jian(int a,int b);
    public int cheng(int a,int b);
    public int chu(int a,int b);
}

JiSuanQiImpl：

package 计算器;

public class JiSuanQiImpl implements JiSuanQi {
    public int add(int a, int b) {
        return a+b;
    }

    public int jian(int a, int b) {
        return a-b;
    }

    public int cheng(int a, int b) {
        return a*b;
    }

    public int chu(int a, int b) {
        return a/b;
    }
}

JiSuanQiProxy：

package 计算器;

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

public class JiSuanQiProxy {
    //被代理的对象
    Object target;
    public JiSuanQiProxy(Object target){
        this.target=target;
    }
    //通过方法返回一个代理对象
    public Object getObject() {
        //获取被代理的对象的类加载器
        ClassLoader loader = target.getClass().getClassLoader();
        //JDK动态代理可以代理多个接口
        Class[] interfaces={JiSuanQi.class};
        //在匿名内部类中，可以对方法进行标注等处理，比如写日志
        InvocationHandler h=new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName()+"被执行之前");
                Object o=method.invoke(target,args);
                System.out.println(method.getName()+"被执行之后");
                return o;
            }
        };
        Object o = Proxy.newProxyInstance(loader, interfaces, h);
        return o;
    }
}

在这里插入图片描述

2.通过继承类的方式 -> CGLIB动态代理

在这里插入图片描述
PersonService：

package aop.cglib;

public class PersonService {

    public PersonService(){}
    public void setPerson(){

    }
    public void getPerson(){

    }
}

CglibProxyIntercepter：

package aop.cglib;

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

import java.lang.reflect.Method;

public class CglibProxyIntercepter implements MethodInterceptor {
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//        Object o是代理对象
        System.out.println("方法执行前");
//        method.invoke(o,objects);
//        Object object = methodProxy.invokeSuper(o, objects);
        System.out.println("方法执行后");

        return null;
    }
}

在这里插入图片描述

应用AOP技术：

AOP（面向切面(aspect)编程）是对传统OOP（面向对象编程）的补充。

AOP的好处：

1、每个事务逻辑位于同一位置，不分散，便于维护和升级
2、业务模块更简洁，只包含核心业务代码

在计算器案例中应用AOP技术：

在web.xml中导入所需jar包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.9.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/aspectj/aspectjrt -->
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.5.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.13</version>
        </dependency>

在这里插入图片描述
JiSuanQi：

package aop;
public interface JiSuanQi {
    public int add(int a, int b);
    public int mul(int a, int b);
    public int cheng(int a, int b);
    public int chu(int a, int b);
}

JiSuanQiImpl：

package aop;
import org.springframework.stereotype.Service;
//将类放在IOC容器中
@Service
public class JiSuanQiImpl implements JiSuanQi {

    public int add(int a, int b) {
        int result=a+b;
        return result;
    }

    public int mul(int a, int b) {
        int result=a-b;
        return result;
    }

    public int cheng(int a, int b) {
        int result=a*b;
        return result;
    }

    public int chu(int a, int b) {
        int result=a/b;
        return result;
    }
}

AspectjTest：

package aop;

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

//将切面放在IOC容器中
@Component
//声明这是一个切面类
@Aspect
public class AspectjTest {

    //添加Before注解，在目标方法执行之前执行此方法
    @Before(value = "execution(public int aop.JiSuanQiImpl.add(int,int))")
    public  void before(){
        System.out.println("目标方法执行之前");
    }
    //添加After注解，在目标方法执行之后执行此方法
    @After(value = "execution(public int aop.JiSuanQiImpl.add(int,int))")
    public  void after(){
        System.out.println("目标方法执行之后");
    }


}

aop.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: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="aop"></context:component-scan>
    <bean id="jiSuanQi" class="aop.JiSuanQiImpl"/>
    <!--启用spring 支持 aop注解-->
    <aop:aspectj-autoproxy/>
</beans>

在这里插入图片描述

AOP更多使用的技巧

优化@Before

对于此类注解

@Before(value = “execution(public int aop.JiSuanQiImpl.add(int,int))”)

当我们的目标方法不止一个时，我们可以使用通配符，方法类型和方法名用*来代替，传参类型用…来代替

@Before(value = “execution(* aop.JiSuanQiImpl.*(…))”)

要是在每个方法上面都要添加这个注解很麻烦，可以使用抽取切入点表达式的方法来简化代码

package aop;

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

//将切面放在IOC容器中
@Component
//声明这是一个切面类
@Aspect
public class AspectjTest {

    //抽取切入点表达式
    @Pointcut(value = "execution(* aop.JiSuanQiImpl.*(..))")
    public void cut(){}

    //添加Before注解，在目标方法执行之前执行此方法
    @Before(value = "cut()")
    public  void before(JoinPoint point){
        System.out.println(point.getSignature().getName()+"目标方法执行之前");
    }
    //添加After注解，在目标方法执行之后执行此方法
    @After(value = "cut()")
    public  void after(JoinPoint point){
        System.out.println(point.getSignature().getName()+"目标方法执行之后");
    }


}

在这里插入图片描述

返回通知和异常通知的注解

    @AfterReturning(value = "cut()",returning = "object")
    public void returnResult(JoinPoint joinPoint,Object object){
        System.out.println(joinPoint.getSignature().getName()+"返回结果后执行  返回值"+object);
    }
    @AfterThrowing(value = "cut()",throwing = "e")
    public void returnException(Exception e){
        System.out.println("异常通知："+e);
    }

环绕通知：

环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。
对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是JoinPoint的子接口，允许控制何时执行，是否执行连接点。
在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。
注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用joinPoint.proceed();的返回值，否则会出现空指针异常。

设置切面优先级

@Order(1)

可以不在类上加注解，可以将类放在IOC容器中，在IOC容器中对类进行标注操作

    <bean id="aspectjTest2" class="aop.AspectjTest2"/>
    <aop:config>
        <aop:aspect ref="aspectjTest2">
            <aop:pointcut id="add" expression="execution(public int aop.JiSuanQiImpl.add(int,int))"/>
            <aop:before method="before" pointcut-ref="add"/>
            <aop:after method="after" pointcut-ref="add"/> 
        </aop:aspect>
    </aop:config>
Mr.Sun1127
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习笔记——AOP
qq_47102228的博客
04-11 692
Spring AOP，AspectJ
SpringAOP学习笔记
01-27
,文章属于基础级文章，适合入门级的小伙伴，它的概念，应用场景，实现原理及Spring的AOP的开发。全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
spring-AOP简介和实现方式（包含动态代理）
我不想学习但是必须学习
09-14 214
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP （面向对象程序设计）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用
Spring AOP 整理笔记
weixin_34290096的博客
03-16 212
一、AOP概念 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码. Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器...
SpringAOP笔记
zz60708320的博客
10-21 165
AOP： 面向切面编程，通过预编译方式和运行期动态代理实现的统一维护的一种技术，主要用于日志记录，性能统计，安全控制，事物处理，异常处理等。 AOP实现方式（两种）： ·预编译—AspectJ ·运行期动态代理（JDK动态代理、CGLib动态代理）—SpringAOP、JbossAOP AOP相关概念 名称 说明 切面（Aspect） 一个关注点的模块化，这个关注点可能会横切多个对...
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
spring项目开发学习笔记
04-08
Spring是一个轻量级的DI/IoC和AOP容器框架。存在的目的是用于构建轻量级的J2EE应用。 轻量级：应用大小和应用开支，包括应用方式 依赖注入DI/IoC控制反转：提供松耦合的一种实现技术 AOP面向切面编程：(可以在不...
Spring IOC和AOP代码与笔记整理
12-07
3. **Spring容器**：有BeanFactory和ApplicationContext两种，BeanFactory是最基础的容器，而ApplicationContext提供了更多的企业级服务，如国际化、事件传播、资源加载等。 **二、Spring的AOP（面向切面编程）** ...
Spring+SpringMVC基础学习笔记（b站课程学习笔记）
03-24
Spring框架的学习通常从理解其核心概念如IoC和AOP开始，然后深入到各个模块的应用，如数据访问（JdbcTemplate、Hibernate、MyBatis等）、Web开发（SpringMVC）和事务管理。在实际项目中，Spring常常与其他技术结合，...
Spring AOP 学习笔记
锦瑟年华,逐梦之人
08-06 1828
注：该篇文章会与我的个人博客同步更新。欢迎移步https://cqh-i.github.io/体验更好的阅读效果。 什么是AOP   全称面向切面编程(Aspect Oriented Programming), 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
SpringAOP笔记整理
qq_38762479的博客
05-14 408
我们都知道，想使用SpringAop需要做一些xml配置，其中很大一部分是基于标签的，这些标签并不是Spring原生，而是自定义注解。Spring中如果声明了自定义注解，那么就一定会在程序中的某个地方注册了对应的解析器。我们的分析也是由此开始。 我们全局搜索后发现了AopNamespaceHandler类，点进去看下： public class AopName...
spring AOP学习笔记
ZgaoYi的博客
05-05 343
文章目录1，AOP简介1.1 什么是AOP?1.2 AOP作用1.3 AOP核心概念2，AOP入门案例2.1 需求分析2.2 思路分析2.3 环境准备2.4 AOP实现步骤步骤1:添加依赖步骤2:定义接口与实现类步骤3:定义通知类和通知步骤4:定义切入点步骤5:制作切面步骤6:将通知类配给容器并标识其为切面类步骤7:开启注解格式AOP功能步骤8:运行程序知识点1：@EnableAspectJAutoProxy知识点2：@Aspect知识点3：@Pointcut知识点4：@Before3，AOP工作流程3.1
Spring学习笔记----AOP编程
太匆匆
07-14 3467
先用代码讲一下什么是传统的AOP(面向切面编程)编程 需求：实现一个简单的计算器，在每一步的运算前添加日志。最传统的方式如下： Calculator.java package cn.limbo.spring.aop.calculator; /** * Created by Limbo on 16/7/14. */ public interface Calculator { in
Spring AOP -- 简介
weixin_42389904的博客
03-05 209
一、AOP简介 1、AOP概念 AOP（Aspect Oreriented Programming）面向切面编程 OOP（Object Oreriented Programming）面向对象编程 面向切面编程：基于OOP新的编程思想，指在程序运行期间，将某段代码动态切入到指定方法的指定位置进行运行的编程方式 2、场景 计算器在计算的时候进行日志记录 2.1、创建一个AOP工程 2.2、实验 2.2.1、创建一个Calculator接口 创建加减乘除四个运算方法 package com.fxp; publ
spring AOP相关知识（笔记）
最新发布
qq_67832732的博客
11-15 137
Spring AOP（Aspect Oriented Programming） 是Spring 框架的重要组成部分，面向切面编程是以另一个角度来考虑程序结构，通过分析程序结构的关注点来完善面向对象编程（OOP）。：通过Spring提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。二、是采用静态植入的方式，引入特定的语法创建”切面“，从而使编译器可以在编译期间织入有关”切面“的代码。
spring 学习笔记（AOP）
李意成的博客
07-30 1599
一、spring 的aop思想分析如下图: 二、aop 解释 1.1 Spring中的aop Spring能够为容器中管理的对象生成动态代理对象 以前我们要使用动态代理，我们需要自己调用下面的方法生成对象Proxy.newProxyInstance(xx,xx,xx) 生成代理对象，现在Spring能够帮我们生成代理对象。 1.2 Spring实现aop原理 动态代理（优先） ...
Spring AOP 切入点表达式说明
Geoffrey's blog
07-15 254
execution: 匹配方法的执行(常用) execution(表达式) 表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数)) 写法说明： 全匹配方式： public void org.hodge.service.impl.CustomerServiceImpl.saveCustomer() ...
SpringAOP个人心得笔记
LiuY521的博客
04-26 712
本篇博客是在学习Spring时所写博客,仅供参考(加自己心得想法) 学习流程 Spring第一天：Spring的概述、SpringIOC入门（XML）、Spring的Bean管理、Spring属性注入 Spring第二天：Spring的IOC的注解方式、Spring的AOP开发（XML） Spring第三天：Spring的AOP的注解开发、Spring的声明式事务、JdbcTempl...
拿捏面试官-Spring AOP IOC源码笔记
01-30
本文是关于Spring AOP IOC源码的笔记，通过对Spring的入门和IOC的介绍，深入分析了Spring的核心模块以及Bean对象的创建细节和对象依赖注入。文章通过解释Spring的侵入式和松耦合概念，引出了Spring的核心模块IOC的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值