SpringAOP

SpringAOP详解+快速入门 本文介绍了 Spring AOP 的实现原理,并通过实例解析详细阐述了其实现过程。在使用 Spring AOP时,我们需要定义切面类,并为需要实现AOP的方法添加注解。 Spring 会自动将切面逻辑插入到这些方法中,从而实现AOP的功能。 阅读详情

Spring存在意义:

    Java是一个面向对象(OOP)的语言,但它有一些弊端,比如当我们需要为多个不具有继承关系的对象引入一个公共行为,例如日志,权限验证,事务等功能时,只能在在每个对象里引用公共行为,这样做不便于维护,而且有大量重复代码。AOP的出现弥补了OOP的这点不足。

1.代理模式:

      代理模式:为其他对象提供一种代理以控制对这个对象的访问。即A要做一件事,在没有代理的时候需要自己动手,当有了代理B以后就可以让B去替他完成;

2.静态代理:

   

public interface IUserDAO {
    public void run();
}
public class UserDAO implements IUserDAO {
    @Override
    public void run() {
        System.out.println("事务运行");
    }
}
public class Proxy implements IUserDAO {
    private IUserDAO target=new UserDAO();
    @Override
    public void run() {
        System.out.println("事务运行前");
        target.run();
        System.out.println("事务运行后");
    }
}
public class Test {
    public static void main(String[] args) {
        IUserDAO proxy=new Proxy();
        proxy.run();
    }
}

静态代理虽然保证了业务类只需关注逻辑本身,代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理。再者,如果增加一个方法,除了实现类需要实现这个方法外,所有的代理类也要实现此方法。增加了代码的维护成本,为了减少成本就需要使用动态代理。

3.动态代理:

动态代理模式:动态代理类的源码是在程序运行期间通过JVM反射等机制动态生成,代理类和委托类的关系是运行时才确定的。

public interface IUserDAO {
    public void save();
    public void find();
}
class RealUser implements IUserDAO{

    @Override
    public void save() {
        System.out.println("模拟:保存用户");
    }

    @Override
    public void find() {
        System.out.println("查询");
    }
}
class ProxyFactory{
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }
    public Object getProxyInstance(){
        Object proxy=Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//目标对象使用的类加载
                target.getClass().getInterfaces(),//目标对象实现的接口
                //执行代理对象方法是触发,
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //执行方法名
                        String name=method.getName();
                        //返回值
                        Object result=null;
                        if("find".equals(name)){
                            result=method.invoke(target,args);
                        }else {
                            System.out.println("开始事务");
                            result=method.invoke(target,args);
                            System.out.println("事务提交");
                        }return result;

                    }
                }
        );return proxy;
    }
}
class Client{
    public static void main(String[] args) {
        IUserDAO target=new RealUser();
        System.out.println("目标对象:"+target.getClass());
        IUserDAO proxy=(IUserDAO) new ProxyFactory(target).getProxyInstance();
        System.out.println("代理对象:"+proxy.getClass());
        proxy.save();
    }
}

 

JDK代理:目标类要有实现的接口;

CGLIB代理:目标类没有实现接口,其是以动态生成目标类的子类来实现的,目标类不能被final修饰(不能继承);


4.SpringAOP原理:

SpringAOP基本理论:

  • 面向切面编程:

       DI有助于对象之间的解耦;

       AOP实现横切关注点与其所影响的对象之间的解耦;(散布与应用中多处的功能为横切关注点)

  • 通知(Advice):

      定义了切面是什么以及何处使用,即做什么和什么时候做;

  • 连接点(JoinPoint):

      spring允许使用通知的地方,基本每个方法的前,后(两者都有也行),或抛出异常时都可以是连接点,spring只支持方法连接点;

  • 切入点(PointCut):

     在连接点的基础上,来定义切入点,一个类里,有许多方法,就有许多个连接点,但是你并不想在所有方法附近都使用通知(使用叫织入),你只想让其中的几个,在调用这几个方法之前,之后或者抛出异常时干点什么,那么就用切点来定义这几个方法,让切点来筛选连接点,选中那几个你想要的方法;

"execution(* com.answer.springAOP2.IUserDAO.save())"
  • 切面(Aspect):

     即通知和切入点的结合,通知是做什么和什么时候做,切入点是在哪做;

  • 引入(Introduction):

      允许我们向现有的类添加新方法属性,就是把切面(也就是新方法属性:通知定义的)用到目标类中;

  • 织入(Weaving):

       把切面应用到目标对象来创建新的代理对象的过程。有3种方式,spring采用的是运行时。

  关键就是:切点定义了哪些连接点会得到通知;

  1. 编译期:切面在目标类编译时被织入,需要特殊的编译器;
  2. 类加载期:切面在目标类加载到JVM时织入,需要特殊的类加载器(ClassLoader),它可以在目标类被引入应用之前加强该目标类的字节码;
  3. 运行期:切面在运行的某个时刻被织入,AOP为目标类动态创建代理对象;

A.SpringAOP是动态代理模式;

B.创建容器对象的时候,根据切入点表达式拦截的类,生成代理对象;

C.如果目标对象有实现接口,使用jdk代理。如果目标对象没有实现接口,则使用Cglib代理。然后从容器获取代理后的对象,在运行期植入"切面"类的方法;


SpringAOP(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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="cglib" class="com.answer.springAOP1.Cglib"></bean>
    <bean id="jdk" class="com.answer.springAOP1.Jdk"></bean>
    <bean id="transcantionaop" class="com.answer.springAOP1.TranscationAOP"></bean>
    <aop:config>
        <!-- 切入点表达式定义-->
        <aop:pointcut id="transcationPointcut" expression="execution(* com.answer.springAOP1.*.*(..))"></aop:pointcut>
        <aop:aspect ref="transcantionaop">
            <aop:before method="beforeTransaction" pointcut-ref="transcationPointcut"></aop:before>
            <aop:after method="afterTranscation" pointcut-ref="transcationPointcut"></aop:after>
            <aop:after-returning method="afterReturn" pointcut-ref="transcationPointcut" returning="result"></aop:after-returning>
            <aop:around method="round" pointcut-ref="transcationPointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>
public interface IUserDAO {
    public String save();
}
class Cglib{
    public String save(){
        System.out.println("Cglib代理");
        return "不需要接口实现";
    }
}
class Jdk implements IUserDAO{

    @Override
    public String save() {
        System.out.println("JDK代理");
        return "需要一个接口实现";
    }
}
class TranscationAOP{
    public void beforeTransaction(){
        System.out.println("前置增强");
    }
    public void afterTranscation(){
        System.out.println("后置增强");
    }
    public void afterReturn(Object result){

        System.out.println("后置返回增强"+result);
    }
    public void afterThrow(){
        System.out.println("后置异常增强");
    }
    public Object round(ProceedingJoinPoint pjp) throws Throwable {
        Object result=null;
        System.out.println("环绕前:");
        result=pjp.proceed();
        System.out.println("环绕后:");
        return result;
    }
}
class Test{
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("aop1.xml");
        IUserDAO userDAO=(IUserDAO) applicationContext.getBean("jdk");
        //System.out.println(userDAO.getClass());
        userDAO.save();
        Cglib cglib=(Cglib) applicationContext.getBean("cglib");
        cglib.save();
    }
}


SpringAOP(注解):

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

    <context:component-scan base-package="com.answer.springAOP2">
        <context:include-filter type="annotation"	expression="org.aspectj.lang.annotation.Aspect"/>
    </context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
public interface IUserDAO {
    public String save();
    public void mine();
}

@Component("jdk")
public class Jdk implements IUserDAO {
    @Override
    public String save() {
        System.out.println("JDK动态代理");
        return "需要接口";
    }

    @Override
    public void mine() {
        System.out.println("我不需要切面");
    }
}

@Component("cglib")
public class Cglib {
    public String save(){
        System.out.println("CGLIB动态代理");
        return "不需要接口";
    }
}
@Aspect
public class MyAspect {
    @Before("execution(* com.answer.springAOP2.IUserDAO.save())")
    public void beforeTransaction(){
        System.out.println("前置增强");
    }
    @After("execution(* com.answer.springAOP2.IUserDAO.save())")
    public void afterTranscation(){
        System.out.println("后置增强");
    }
    @AfterReturning(value = "execution(* com.answer.springAOP2.IUserDAO.save())",returning = "result")
    public void afterReturn(Object result){

        System.out.println("后置返回增强"+result);
    }
    @AfterThrowing("execution(* com.answer.springAOP2.IUserDAO.save())")
    public void afterThrow(){
        System.out.println("后置异常增强");
    }
    @Around("execution(* com.answer.springAOP2.IUserDAO.save())")
    public Object round(ProceedingJoinPoint pjp) throws Throwable {
        Object result=null;
        System.out.println("环绕前:");
        result=pjp.proceed();
        System.out.println("环绕后:");
        return result;
    }
}

 

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("aop2.xml");
        IUserDAO iUserDAO=(IUserDAO) applicationContext.getBean("jdk");
        iUserDAO.save();
        iUserDAO.mine();
        //Cglib cglib=(Cglib) applicationContext.getBean("cglib");
        //cglib.save();
    }
}

 


SpringAOP用处:

    1.Spring声明式事务管理配置。

    2.Controller层的参数校验。

    3.使用Spring AOP实现MySQL数据库读写分离案例分析

    4.在执行方法前,判断是否具有权限。

    5.对部分函数的调用进行日志记录。监控部分重要函数,若抛出指定的异常,可以以短信或邮件方式通知相关人员。

    6.信息过滤,页面转发等;

 

SpringAOP在项目中的简单应用 SpringAOP在项目中的简单应用   一、前言   项目背景 由于公司的机房到期,需要做应用迁移(包括数据库),割接到云平台。但是又不能进行一次性割接,需要分三个阶段:第一阶段割接2个地市,第二阶段再割接9个地市,第三阶段做全盘割接。在第一、第二阶段是要保证云平台与现网平台的应用能够正常并行运行。所以,要保证两边数据访问的正常,需要对某些功能进行改造。比如,某个子功能在并行阶段是不做... 阅读详情

相关推荐

SAP SM30数据维护实战:条件筛选与动态校验的实现技巧

本文详细介绍了SAP SM30数据维护的实战技巧,重点讲解如何通过条件筛选实现精准数据查取,以及利用表维护生成器事件实现动态数据检查与校验。文章提供了从基础视图创建到高级事件编程的完整流程,包括调用函数VIEW_MAINTENANCE_CALL传递筛选条件,以及在NEW_DATA和CHANGE_SAVE事件中编写业务规则校验逻辑,帮助开发者提升SM30的管控能力与数据质量。

q9w8e7r6t5的博客 522

SpringAOP学习--SpringAOP简介及原理

前文对AOP做了介绍,实际项目中,一般不会直接上手手动实现aop,而是使用一些高级封装的aop实现,如SpringAOP。 Spring是一个广泛应用的框架,SpringAOP则是Spring提供的一个标准易用的aop框架,依托Spring的IOC容器,提供了极强的AOP扩展增强能力,对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理,SpringAOP不是一种新的AOP实现,其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了

u012098021的博客 6万+

Mcgs 屏幕Modbus RTU通讯调试

昆仑通态屏幕作为Modbus Master 与 Modbus Slave通过RS485接口实现通信的调试记录

madao1234的博客 5578

SpringAOP是啥,怎么用?

SpringAOP是啥,怎么用? 一、面试问题:什么是SpringAOP? SpringAOP的全称是(Aspect Oriented Programming)中文翻译过来是面向切面编程,个人理解:主要意思是我们的传统架构至上而下,后期想要从中间切入写代码添加功能,比如日志、权限、事务等,这时候我们就需要写使用代理模式写,而springaop就是专门把这一块写代码的地方给抽象了出来称为切面,从而解决的代码混乱的问题,它的底层实现也是基于代理模式(动态代理)完成的。 二、SpringAOP的应用场景有

Object_de_Father的博客 19万+

用deepseek对GPU服务器进行压力测试

利用 DeepSeek 模型对 GPU 服务器进行压力测试,核心思路是通过,验证 GPU 服务器在计算、显存、网络等维度的承载能力,同时观察稳定性与性能瓶颈。

weixin_42795092的博客 1610

从零到一:Ollama工具在RK3588上的深度优化实践

本文详细介绍了如何在RK3588开发板上深度优化Ollama工具,以高效运行DeepSeek模型。通过CPU与NPU负载平衡、模型量化、温度控制等策略,显著提升性能并降低功耗,适用于边缘计算场景。文章提供了具体的配置命令和优化方案,帮助开发者充分发挥RK3588的硬件潜力。

rgv23456789的博客 315

SpringAOP面向切面编程

介绍面向切面编程的思想(AOP),AOP的组成,SpringAOP的简单演示使用,SpringAOP基于动态代理的实现原理。

trong_ 的烂笔头 2545

第十六篇:Camx IFE 、OPE 各 port口功能定义

需要注意的是,类似 CSLTFEPortIdRawDump 是没有downscale功能的,所以如果遇到fov不正确的问题,可以排除下TFE这边的 output port是否被接到了 CSLTFEPortIdRawDump 上面来。我们知道Camx 的IFE 、OPE有不少的output port,各个port是有哪些功能的呢?老一点的框架平台,采用的TEF、OPE。

239

SpringAOP超详细教学

SpringAOP 前言 我的这篇AOP博客有大量的图片和例子教会怎么使用AOP 配置那里如果没有学习Maven的话也别急 就是使用maven下载了jar包而已了 你完全可以自己手动导入 如果你有一些代码比如说 事务 或者 日志等操作 需要大量嵌入你的代码前后的话 那么无疑AOP是最好用的 AOP运行流程 : 首先调用前置通知(你可以认为最一开始初始的东西)-&amp;gt;你的逻辑代码(这里先不说环...

TheSevenSky 8514

Python爬虫实战:微信小程序内容采集的全面指南

在移动互联网时代,微信小程序已成为企业和个人提供服务的重要渠道。小程序中包含了大量有价值的信息,但微信官方并未提供便捷的数据获取接口。本文将详细介绍如何使用Python爬虫技术采集微信小程序内容,包括最新技术方案、完整代码实现以及应对各种反爬机制的策略。小程序运行在微信封闭环境中,无法直接访问数据通信主要通过HTTPS加密传输内容动态加载,依赖JavaScript渲染微信有严格的反爬机制。

2201_76125261的博客 3122

YOLO26创新改进 | 全网独家创新篇、小目标检测专属 | AAAI 2025 | 引入HS-FPN中的HFP和SDP创新点,从频域增强小目标特征,淘汰FPN进行升级,助力YOLO26有效涨点

本文提出HS-FPN特征金字塔网络,通过高频感知模块(HFP)和空间依赖感知模块(SDP)优化YOLO26模型。HFP利用高通滤波器增强小目标的高频特征,SDP捕获相邻像素的空间依赖关系。在AI-TOD等小目标检测数据集上,HS-FPN相比传统FPN显著提升性能。文章详细介绍了HFP和SDP的模块结构、核心代码实现,以及如何在YOLO26中集成这两个模块的配置方法,提供了多个版本的yaml文件配置方案。实验结果表明该方法能有效改善微小目标检测效果。

Ai缝合怪、助力小伙伴高效发论文 208

springAOP

AOP是Aspect Oriented Programming(面向切面编程),切面是指某一特定问题,所以AOP也可以理解为面向特定方法编程。比如我们在用户登录时设置登录校验拦截器,就是对“登录校验”这一类问题的统一处理,所以拦截器是AOP的一种应用,而AOP是一种思想,拦截器就是AOP思想的一种实现。而Spring框架也实现了这种思想,提供了拦截器技术的相关接口。同样的,统一数据返回格式和统一异常处理,也是AOP思想的一种实现。

2202_75439262的博客 954

24届数字IC验证——SV+UVM基础知识汇总(一)

汇总整理在面试过程中常见的问题,如果都能回答下来,那么面试肯定不成问题的分别构建不同抽象级的transaction,来实现复杂的激励。(以前是单一层次的sequence,对激励复用、上层复用不塌友好)不同层级之间的sequence没有继承关系,相互之间进行转换低层次的sequence从高层次的sequencer中获取高层次的sequence,并将其转换为低层次的sequence,再通过低层次的sequencer发送出去如何连接:低层次的sequencer包含高层次sequencer的句柄。

qq_42135020的博客 3156

关于SpringAOP的详细介绍

关于springAOP的记录

IDEA_guo的博客 991

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

【springBoot】springAOP

如果其他类需要使用,需要把切点声明为public.使用时,类的全限定名称+切点名称 ==> 包+类名@Slf4j@Aspect@Component@After("com.example.aopdemo.aspect.AspectDemo.pt()")//前置通知log.info("执行AspectDemo1 doAfter……");

weixin_66409969的博客 1047

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

SpringAOP和AspectJ有什么关系 ?

✅作者简介:大家好,我是Leo,热爱Java后端开发者,一个想要与大家共同进步的男人😉😉✨特色专栏:🥭本文内容:SpringAOP和AspectJ有什么关系?📚个人知识库:,欢迎大家访问我们知道现在开发都是Spring,讲的最多的也是SpringAOP,在说springAOP前,先了解下AOP是什么?AOP是通过 “预编译方式” 和 “运行期间动态代理” 实现程序功能的统一维护的一种技术。

分享思想,留下痕迹。 1735

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

SpringAop(1)

一种规则Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对哪些⽅法来进⾏功能增强。也就是@Around后边的字符串,描述了在哪里进行切入。对哪些的方法进行功能增强。(告诉哪些能被连接成切面,哪些不能被连接成切面,哪些能被Aop认识到,就是寻找匹配项)。这是切面的设置以及切面的逻辑@Slf4j@Component@Aspect//作用的范围是TestController。

syx050403的博客 1190

基于注解的SpringAOP Redis缓存技术

这篇博文主要介绍如何使用SpringAOP + Redis +注解的方式实现缓存的开发。 一、术语说明 1、SpringAOP AOP(Aspect Oriented Programming),也就是面向方面编程的技术。AOP基于IOC基础,是对OOP的有益补充。SpringAOP的可配置式,使得代码几乎没有耦合侵入。 2、Redis Redis是一个开源的使用ANSI C语言编写、

chentian610的博客 5007

面试遇到SpringAOP不要慌

Aspect Oriented Programming(面向切面编程)是一种编程思想。所谓切面可以理解为特定的一些方法。所以AOP可以看成是面向特定的方法进行编程。比如上一篇文章提到的拦截器,就是AOP的体现。它针对特定的方法进行统一的管理,让代码模块化,易于维护。包括ExceptionAdvice、ResponseBodyAdvice(统一异常处理、统一数据返回格式)都运用了AOP的思想。定义一个注解:@Retention(RetentionPolicy.RUNTIME)//表示运行时,仍然存在。

HYY的博客 1214

springAOP落地实现

江湖阳哥曾经说过这么句话:使用技术在当前这个环境中无非就是这么几步:1、引入POM(maven)坐标2、改yml(配置文件也可以是properties等等)3、写配置类或者在启动类上加注解4、写代码就完事提示:以下是本篇文章正文内容,下面案例可供参考好了尽情的开发使用吧,其实这个是为了我写那个面试题的文章准备的哈哈哈哈。

sutingStart的博客 2128

SpringAOP详解

AOP(Aspect Oriented Programming)是思想(面向切面编程),对某一类事情的统一处理。Spring AOP是思想的具体实现框架。

小小太空人的博客 1033

一篇文章快速搞懂 AOP和SpringAOP

随着软件世界不断复杂化,传统的OOP(面向对象)建模思路已经不足以很好的处理好开发时所面临的种种挑战,AOP(Aspect Orient Programming)应运而生,它和OOP建模方式并不冲突,它是OOP编程的一种有效补充。 OOP面向名词领域建模,使用类作为单位来模块化目标系统,而AOP面向动词领域建模,其模块化单位则是`Aspect`:切面。常见于处理一些具有==横切性质==的系统级服务,例如: `日志管理、事务管理、安全检查缓存、对象池管理等`。

陈浩的博客 1740
上一篇: SpringIoC与DI
下一篇: Spring MVC
Dream答案
博客等级 码龄10年 161粉丝 113原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dream答案

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值