Spring[2]-AOP原理（动态代理和cglib）

最新推荐文章于 2024-09-18 09:16:06 发布
最新推荐文章于 2024-09-18 09:16:06 发布
阅读量148 收藏
点赞数
分类专栏： Spring框架 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42642159/article/details/103220580
版权

一、AOP概述

1)在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
2)AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
3)利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
4)AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
5)经典应用：事务管理、性能监视、安全检查、缓存 、日志等【画图】
6)Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
7)AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

二、AOP的实现

2.1 动态代理

a.aop底层将采用代理机制进行实现。
b.接口 + 实现类 ：spring采用 jdk 的动态代理Proxy。
c.实现类：spring 采用 cglib字节码增强。

2.2 术语

1.target：目标类，需要被代理的类。例如：UserService
2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
3.PointCut 切入点：已经被增强的连接点。例如：addUser()
4.advice 通知/增强，增强代码。例如：after、before
5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
6.proxy 代理类
7. Aspect(切面): 是切入点pointcut和通知advice的结合
一个线是一个特殊的面。
一个切入点和一个通知，组成成一个特殊的面。
在这里插入图片描述
1.4 手动代理
1.4.1 JDK动态代理

package com.sinosun.springbootdemo.core.spring.aop.dynamicproxy;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * 动态代理源码:接口 + 实现类
 */
@Configuration
@ComponentScan(value = {"com.sinosun.springbootdemo.core.spring.aop.dynamicproxy"})
public class Config16 {
    /**
     * 1.target：目标类，需要被代理的类。例如：UserService
     * 2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
     * 3.PointCut 切入点：已经被增强的连接点。例如：addUser()
     * 4.advice 通知/增强，增强代码。例如：after、before
     * 5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
     * 6.proxy 代理类
     * 7. Aspect(切面): 是切入点pointcut和通知advice的结合
     * 	一个线是一个特殊的面。
     * 	一个切入点和一个通知，组成成一个特殊的面。
     */
}


package com.sinosun.springbootdemo.core.spring.aop.dynamicproxy;

public interface IUserService {
    void addUser();

    void deleteUser();

    void updateUser();

    String selectUserName(int id);


}

package com.sinosun.springbootdemo.core.spring.aop.dynamicproxy;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;

/**
 * 切面类
 * 增加代码与切入点的结合
 */
@Component
public class MyAspect {
    public void before() {
        System.out.println("切面类...开启事务");
    }

    public void after() {
        System.out.println("切面类...提交事务");
    }
}


package com.sinosun.springbootdemo.core.spring.aop.dynamicproxy;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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


@Component
public class UserServiceFactory {
    @Autowired
    private UserServiceImpl userService;
    @Autowired
    private MyAspect aspect;

    public IUserService createUserImpl() {
        // 1.创建目标对象target
        IUserService iUserService = userService;
        // 2.声明切面类对象
        MyAspect myAspect = aspect;
        // 3.把切面类的两个方法应用到目标类
        //3.1 创建JDK代理
        /*newProxyInstance(
                ClassLoader loader,//类加载器
                Class<?>[] interfaces,// 接口，接口的方法会被拦截
                InvocationHandler h//) // 处理方法*/
        IUserService proxyUserService = (IUserService) Proxy.newProxyInstance(UserServiceFactory.class.getClassLoader(),
                iUserService.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //开启事务
                        myAspect.before();
                        // 业务方法的返回值
                        iUserService.addUser();
                        iUserService.selectUserName(2);
                        Object result = method.invoke(iUserService, args);
                        System.out.println("拦截返回值:" + result);
                        //关闭事务
                        myAspect.after();
                        return result;
                    }
                });
        return proxyUserService;
    }
}


package com.sinosun.springbootdemo.core.spring.aop.dynamicproxy;

import org.springframework.stereotype.Component;

@Component
public class UserServiceImpl implements IUserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }

    @Override
    public void updateUser() {
        System.out.println("修改用户");
    }

    @Override
    public String selectUserName(int id) {
        System.out.println("查询用户");
        return "zhansan";
    }
}


    @Test
    public void test4() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Config16.class);
        System.out.println("容器加载完成");
        String[] name = app.getBeanDefinitionNames();
        for (String s : name) {
            System.out.println("容器器中的beanId--->:" + s);
        }
        UserServiceFactory userServiceFactory = app.getBean(UserServiceFactory.class);
        IUserService iUserService = userServiceFactory.createUserImpl();
        iUserService.selectUserName(1);
    }

2.2 cglib 增强字节码

没有接口，只有实现类。
采用字节码增强框架 cglib，在运行时 创建目标类的子类，从而对目标类进行增强。

package com.sinosun.springbootdemo.core.spring.aop.cglibproxy;

import org.springframework.stereotype.Component;

/**
 * 切面类
 * 增加代码与切入点的结合
 */
@Component
public class MyAspect {
    public void before() {
        System.out.println("CGLIB切面类...开启事务");
    }

    public void after() {
        System.out.println("CGLIB切面类...提交事务");
    }
}


package com.sinosun.springbootdemo.core.spring.aop.cglibproxy;

import org.springframework.stereotype.Component;

@Component
public class StudengService {
    public void add(String name) {
        System.out.println("add student:" + name);
    }

    public void delete(int uuid) {
        System.out.println("delete student" + uuid);
    }

    public void update() {
        System.out.println("update student");
    }
}

package com.sinosun.springbootdemo.core.spring.aop.cglibproxy;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
public class StudentServiceFactory {
    @Autowired
    StudengService service;
    @Autowired
    MyAspect aspect;


    public StudengService createStudentServiceImpl() {
        // 1.创建目标对象target
        final StudengService studengService = service;
        // 2.声明切面类对象
        MyAspect myAspect = aspect;
        // 3.增加对象
        Enhancer enhancer = new Enhancer();
        // 4.设置父类
        enhancer.setSuperclass(studengService.getClass());
        // 设置回调【拦截作用】
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                /*
                采用字节码增强框架 cglib，在运行时 创建目标类的子类，从而对目标类进行增强。
                obj:该对象是studengService的子类
                class service.business.cglibproxy.StudengService$$EnhancerByCGLIB$$cb8ff36e
                class org.springframework.cglib.proxy.MethodProxy
                 拦截*/
                // 开启事务
                myAspect.before();
                System.out.println("拦截");
                //执行目标类的方法
                //Object result = method.invoke(studengService, objects);
                /**
                 * 和studengService对象解耦
                 * 执行代理类的方法（目标类和代理类是父子关系）
                 */
                Object result = methodProxy.invokeSuper(obj, objects);
                myAspect.after();
                return result;
            }
        });
        StudengService cglibStudengService = (StudengService) enhancer.create();
        return cglibStudengService;
    }
}


package com.sinosun.springbootdemo.core.spring.aop.cglibproxy;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * CGLIB:实现类
 */
@Configuration
@ComponentScan(value = {"com.sinosun.springbootdemo.core.spring.aop.cglibproxy"})
public class Config17 {
}


    @Test
    public void test5() {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Config17.class);
        System.out.println("容器加载完成");
        String[] name = app.getBeanDefinitionNames();
        for (String s : name) {
            System.out.println("容器器中的beanId--->:" + s);
        }
        StudentServiceFactory studentServiceFactory = app.getBean(StudentServiceFactory.class);
        StudengService studengService = studentServiceFactory.createStudentServiceImpl();
        studengService.add("zhangsan");
    }
old~boy
关注
专栏目录
Spring AOP实现原理详解之Cglib代理实现
JavaMonsterr的博客
07-06 1128
我们在前文中已经介绍了SpringAOP的切面实现和创建动态代理的过程，那么动态代理是如何工作的呢？本文主要介绍Cglib动态代理的案例和SpringAOP实现的原理。要了解动态代理是如何工作的，首先需要了解什么是代理？代理模式(Proxy pattern): 为另一个对象提供一个替身或占位符以控制对这个对象的访问举个简单的例子：我(client)如果要买(doOperation)房，可以找中介(proxy)买房，中介直接和卖方(target)买房。中介和卖方都实现买卖(doOperation)的操作。中介
使用CGLIB实现AOP功能与AOP概念解释
李阿昀的博客
10-19 5260
使用CGLIB实现AOP功能在Java里面，我们要产生某个对象的代理对象，这个对象必须要有一个特点，即这个对象必须实现一个接口，动态代理技术只能基于接口进行代理。有时候我们在做开发的时候，这个对象就没有实现接口，有人可能会说，它既然没有接口，那我就给它定义一个接口，这是不行的，因为有时候我们拿到一个对象，而这个对象是服务器产生给我们的，是服务器提供给我们的，又不是我们自己写的，动不动就给它定义一个接
AOP学习之一 -- CGLIB使用介绍
凉水的博客
07-16 736
AOP学习之一 – CGLIB使用介绍 前言 spring-aop是基于cglib实现的（spring本身基于cglib做了一些修改，但是使用方法类似），所以在学习aop的过程中，看到最后，是绕不过cglib的，如果不熟悉cglib的使用，可能会比较难理解其中的一些逻辑实现，本文就简单介绍下cglib的使用。 CGLIB CGLIB简单来讲，就是围绕Callback接口而来，更具体的是MethodInterceptor接口，代理类的每个函数都会调用该接口的intercept函数，然后由intercept负责
Spring AOP的两种动态代理方式的原理和实现（JDK和CGLIB）
weixin_51542566的博客
04-25 9620
代理机制 Spring 的AOP 部分使用使用JDK动态代理，部分使用CGLIB来为目标对象创建代理。如果被代理的目标对象实现了至少一个接口，则会使用JDK动态代理；如果目标对象没有实现任何接口，则会创建CGLIB动态代理。CGLIB是第三方包，从Spring4.3开始就无需再次导入包了。 注意 客户端直接调用与目标类相对应的代理类的功能，为了保证代理类与目标类具有相同功能，代理类与目标类必须实现相同的接口 代理是实现AOP的核心和关键技术。只要是AOP，就一定会涉及代理技术 . 代理技术的分类 按照是否
AOP实现原理（二）CGLIB动态代理
我是你妹她哥的博客
04-21 3419
上一篇博客中给大家介绍了AOP中的JDK动态代理。附上地址： https://blog.csdn.net/bicheng4769/article/details/80028158 回顾一下上一篇的内容，JDK动态代理必须要求目标类实现接口才能使用。那么在AOP的使用中，我们貌似没有这个限制，所以这里AOP还有一种动态代理的机制：CGLIB动态代理。 什么是CGLIB CGLIB(Co...
Java Spring-AOP动态代理-JDK和CGlib实现
涂涂写写的笔记
11-18 1424
代理增强的方法和Bean本身的方法当作一个切面，是对面向对象编程OOP的升华。OOP是纵向对一个事物的抽象，一个对象包括静态的属性信息，包括动态的方法信息等。而AOP是横向的对不同事物的抽象，属性与属性、方法与方法、对象与对象都可以组成一个切面，而用这种思维去设计编程的方式叫做。思想，我们会new一个筷子对象，new一个手机对象，然后先调用 chopsticks.pickUp() ，再调用 phone.user()。编码是为了解决生活中的问题，譬如现在我想用筷子吃饭的时候看手机，那么首先会有两个对象。
【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理
m0_65277261的博客
05-27 1742
Spring AOP 的实现原理是基于动态代理和字节码操作的。而动态代理是基于反射机制的。 在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。
spring-aop原理讲解 JDK动态代理和CGLIB动态代理
bingguang1993的博客
04-21 544
Spring的两大特性是IOC和AOP IOC负责将对象动态的注入到容器，从而达到一种需要谁就注入谁，什么时候需要就什么时候注入的效果。理解spring的ioc也很重要。 但是今天主要来和大家讲讲aop。 AOP 广泛应用于处理一些具有横切性质的系统级服务，AOP 的出现是对 OOP 的良好补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。 AOP实现的关键在于A...
关于Spring AOP，除了动态代理、CGLIB，你还知道什么？
12-20
- Spring AOP主要通过动态代理来实现，包括JDK动态代理和CGLIB。对于接口实现类，Spring使用JDK动态代理；对于没有接口的类，使用CGLIB生成子类来实现切面。 - **Pointcut**在Spring中通过`org.springframework....
Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现.doc
07-08
Spring AOP提供了两种代理方式：JDK动态代理和Cglib代理。 Cglib代理是Spring AOP在无法使用JDK动态代理（例如代理的目标对象没有实现接口）时的另一种选择。Cglib是一个强大的、高性能的代码生成库，它基于ASM库来...
Spring-AOP-JDK动态代理
05-12
在Java编程领域，Spring框架是应用最广泛的轻量级开源框架之一，它提供了一系列强大的功能，包括依赖注入、面向切面编程（AOP）...在实际项目中，熟练掌握Spring AOP和JDK动态代理，能够有效地提升开发效率和软件质量。
spring-cglib-repack-3.2.0.jar和spring-objenesis-repack-2.1.jar
03-15
总的来说，`spring-cglib-repack-3.2.0.jar`和`spring-objenesis-repack-2.1.jar`是Spring框架正常运行的关键组成部分，它们分别负责动态子类生成和无参构造函数对象的快速实例化，对于理解和优化Spring应用的性能有...
Spring Session
最新发布
2401_84881237的博客
09-18 402
它把 servlet 容器实现的 httpSession 替换为 spring-session ，Session 信息存储在 Redis 或其它数据库中统一管理，解决了 session 共享的问题。Spring Session 是 Spring 家族中的一个子项目，Spring Session 提供了用于管理用户会话信息的 API 和实现。在 Web 项目开发中，Session 会话管理是一个很重要的部分，用于存储与记录用户的状态或相关的数据。
SpringBoot结合Mybatis-plus项目直接执行sql语句
qq_50801874的博客
09-15 294
在平常的SpringBoot项目中，只有极少的情况需要直接执行sql语句，不需要传参。这里通过Mybatis-plus实习效果。impl层将sql语句作为参数直接调用dao层接口，这里需要注意，在dao层新增一个接口，通过@Select注解执行sql语句。，不然会报错，所以在调用之前最好判断一下sql语句是否为空。
java项目之基于springboot的贸易行业crm系统（源码+文档）
sinat_26552841的博客
09-13 529
基于springboot的贸易行业crm系统的主要使用者分为： 管理员功能有个人中心，部门管理，员工管理，产品分类管理，产品信息管理，客户信息管理，市场活动管理，销售订单管理，配送订单管理。员工可以操作自己的个人中心，客户信息，产品信息，销售订单，配送订单，售后回访等。
构建基于SpringBoot的在线学习平台
2402_85762143的博客
09-14 904
首页、课程信息、个人中心、后台管理、购物车等功能，这给管理者的工作带来了巨大的挑战，面对大量的信息，传统的管理系统，都是通过笔记的方式进行详细信息的统计，后来出现电脑，通过电脑输入软件将纸质的信息统计到电脑上，这种方式比较传统，而且想要统计数据信息比较麻烦，还受时间和空间的影响，所以为此开发了在线视频教育平台；可以在多种平台上运用的，兼容性比较强，适应市面上大多数操作系统，不会出现乱码的现像，其扩展性和维护性都更好，具有分析问题和解决问题的能力，是面向过程的程序设计方便我们编写的代码更强壮。
基于SpringBoot的校园二手商品交易平台的设计与实现
2401_87134477的博客
09-14 1437
就以校园二手交易平台的用户及数据来分析，本系统还是有很大的发展前景和潜力的，在以后的发展中可以不仅局限于本校，可以与本市的其他高校联合建立更完善完整地平台体系，这样商品的种类以及用户量都会增多，更加便于学生之间的物品交换以及资源的再利用率。党的十九大报告要求继续深化生态建设，将我国建设成节约型社会，而节约型社会呼唤节约型校园，建设节约型校园是落实科学发展观、建设和谐校园的客观要求，而校园二手物品交易网站的建设便是推进实现校园闲置物品循环利用，促进和谐校园建设的重要环节。大力推行节约型的校园建设。
基于SpringBoot项目实现Docker容器化部署
不惑
09-18 1122
将Spring Boot项目部署到Docker容器中的涉及几个主要步骤： Docker容器化部署Spring Boot项目的原理涉及将应用程序及其依赖项打包到一个Docker镜像中，然后在容器内运行该镜像。这使得应用程序在不同环境中更加可移植和隔离，同时也方便了部署和扩展。使用Docker可以大大简化应用程序的部署流程，并提供了更好的资源管理和隔离，以及更高的可伸缩性。
springboot3.X版本集成mybatis遇到的问题
SmileAssassn的博客
09-15 497
最根本的原因是搜出来的配置是参照springboot2.X版本，当我们使用springboot3.x版本之后，需要配置使用3.0.3及以上的mybatis才行，否则的话就会出现无法注入mapper的bean的问题。参照我如下的maven配置即可完美解决该问题，使用3.0.3版本的mybatis就可以完美适配springboot3.X版本。当我参照如下搜索的内容去集成mybatis的时候，会出现各种各样的报错。由于我本地springboot为3.x版本，如下图所示，最新版本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值