Spring动态代理与AOP实现

已于 2022-10-04 18:42:26 修改
阅读量1.5k 收藏 9
点赞数 6
分类专栏： JavaEE实验 文章标签： spring java intellij-idea
于 2022-10-03 00:26:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72151428/article/details/127147896
版权

Spring动态代理与AOP实现


实验要求：
理解动态代理原理，掌握AOP编程的方法。

实验内容：
实验1：利用CGLIB实现动态代理，编写类MyAdvice,在该类中提供log()方法，控制台输出“正在进行日志编写”,被代理类UserDao ，在该类中提供add（）方法，控制台输出“正在添加数据库记录”，编写代理类MyProxy,当访问代理类的add方法时，先访问log方法，再访问add方法，实现日志记录。
实验2：利用声明式（xml）和注解式两种方式分别实现Aspect 的AOP。利用实验1中的MyAdvice 类（作为切面），在校园卡充值程序中当访问Biz层的充值方法时（切点），织入log（）方法，完成日志记录。Log方法要求记录访问时间、访问者的IP地址、访问方法的名称到数据库中。(LogDao)
实验3：根据自己的理解，解释Spring的AOP。

实验分析：

  • 实验1主要利用CGLIB实现动态代理，可以编写四个简单类进行实现。分别是切面类MyAdvice、被代理类UserDao、代理类MyProxy和测试类Test1。
  • 实验2需要利用声明式（xml）和注解式两种方式分别实现Aspect的AOP，并且需要用到之前的学生卡充值，可以参考利用Spring框架为自己的校园卡充值。此实验还需要连接数据库，可以采用Spring的数据库连接，也可以使用Java简易的JDBC，本次实验作者采用的就是JDBC连接，需要在数据库中建立两个表，分别为记录和充值功能。

实验操作所用工具（软件）：
IntelliJ IDEA 2021.2.1

实验2需要建立三层结构，分别是：Dao层、Biz层、Aop层。

以此建立三层结构。即在工程文件下的src文件夹的main中的Java建立三个包（package）。在resource下编写配置文件。
在工程文件下的src文件夹的test中的Java建立test类。

代码实现：

实验1

MyAdvice类：

package com.cqust.aop;
//切面类：存在多个通知Advice（增强的方法）
public class MyAdvice {
    public void log(){
        System.out.println("正在进行日志编写");
    }
}

UserDao类：

package com.cqust.aop;
//目标类
public class UserDao {
    public void addUser(){
        System.out.println("正在添加数据库记录");
    }
}

MyProxy类：

package com.cqust.aop;

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 MyProxy implements MethodInterceptor {
    //代理方法
    public Object createProxy(Object target){
        //创建一个动态类对象
        Enhancer enhancer = new Enhancer();
        //确定需要增强的类，设置其父类
        enhancer.setSuperclass(target.getClass());
        //添加回调函数
        enhancer.setCallback(this);
        //返回创建的代理类
        return enhancer.create();
    }
    /**
     * proxy CGlib根据指定父类生成的代理对象
     * method 拦截的方法
     * args 拦截方法的参数数组
     * methodProxy 方法的代理对象，用于执行父类的方法
     */
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
       //创建切面类对象
        MyAdvice myAdvice = new MyAdvice();
        //前增强
        myAdvice.log();
        //目标方法执行
        Object obj = methodProxy.invokeSuper(proxy,args);
        //后执行
        myAdvice.log();
        return obj;
    }
}

Test1（测试类）：

import com.cqust.aop.MyProxy;
import com.cqust.aop.UserDao;

public class Test1 {
    public static void main(String[] args){
        MyProxy myProxy = new MyProxy();
        UserDao userDao = new UserDao();
        UserDao userDao1 = (UserDao) myProxy.createProxy(userDao);
        userDao1.addUser();

    }
}

实验2

CardDao类：

package com.cqust.dao;

public interface CardDao {
    public int save();
}

CardDaoImpl类：

package com.cqust.dao;

import org.springframework.stereotype.Repository;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

@Repository
public class CardDaoImpl implements CardDao {
    @Override
    public int save() {
        int count = 0;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection connection= DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "1");
            Statement statement= connection.createStatement();
            String sql="insert into reCharge(cardId,money) values ('Hades','888.88')";
            count = statement.executeUpdate(sql);
            statement.close();
            connection.close();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return count;
    }
}

LogDao类：

package com.cqust.dao;

public interface LogDao {
    public int addLog(String name);
}

LogDaoImpl类：

package com.cqust.dao;

import org.springframework.stereotype.Repository;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.Statement;
import java.text.SimpleDateFormat;

@Repository
public class LogDaoImpl implements LogDao {

    @Override
    public int addLog(String name) {
        int count=0;
        try {
//date
            SimpleDateFormat formatter= new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss z");
            Date date = new Date(System.currentTimeMillis());
//ip4
            InetAddress ip4 = Inet4Address.getLocalHost();

            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection connection= DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "1");
            Statement statement= connection.createStatement();
            String sql="insert into addressing(date,ip_address,method_name) values ('"+date+"','"+ip4.getHostAddress()+"','"+name+"')";
            count = statement.executeUpdate(sql);
            statement.close();
            connection.close();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return count;
    }
}

CardBiz类：

package com.cqust.biz;


public interface CardBiz {
    public boolean reCharge();
}

CradBizImpl类：

package com.cqust.biz;

import com.cqust.dao.CardDao;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class CardBizImpl implements CardBiz {
    @Resource(name = "cardDaoImpl")
    private CardDao cardDao;

    @Override
    public boolean reCharge() {
        if(cardDao.save()>0){
            System.out.println("充值成功");
            return true;
        }
        System.out.println("充值失败");
        return false;
    }
}

Test2（测试类）:

import com.cqust.biz.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        CardBiz cardBiz = (CardBiz) context.getBean("cardBizImpl");
        cardBiz.reCharge();
    }
}

XML方式：
MyAdvice类：

package com.cqust.aop;

import com.cqust.dao.LogDaoImpl;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

//切面类：存在多个通知Advice（增强的方法）
@Component
public class MyAdvice {
    public void pointCut(){}
    @Resource(name="logDaoImpl")
    private LogDaoImpl logDaoImpl;
    
    public void log(){
        System.out.println("正在记录操作信息...");
        logDaoImpl.addLog("reCharge");
    }
}

applicationContext.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 https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="userDao" class="com.cqust.dao.CardDaoImpl"/>
    <bean id="logDao" class="com.cqust.dao.LogDaoImpl"/>
    <bean id="cardBiz" class="com.cqust.biz.CardBizImpl"/>
    <bean id="myAdvice" class="com.cqust.aop.MyAdvice"/>
	<!--使用context命名空间，在配置文件中开启相应的注解处理器-->
	<context:component-scan base-package="com.cqust"/>
     <!--配置Spring AOP-->
    <aop:config>
        <!--指定切入点-->
        <aop:pointcut id="pointCut" expression="execution(*
            com.cqust.aop.MyAdvice.*(..))"/>
        <!--指定切面-->
        <aop:aspect ref = "myAdvice">
            <!--指定记录通知-->
            <aop:before method="log" pointcut-ref="pointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

注解方式：
MyAdvice类：

package com.cqust.aop;

import com.cqust.dao.LogDaoImpl;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

//切面类：存在多个通知Advice（增强的方法）
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.cqust.biz.CardBizImpl.reCharge(..))")
    public void pointCut(){}
    @Resource(name="logDaoImpl")
    private LogDaoImpl logDaoImpl;

    @Before("pointCut()")
    public void log(){
        System.out.println("正在记录操作信息...");
        logDaoImpl.addLog("reCharge");
    }
}

applicationContext.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 https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.cqust"/>
    <aop:aspectj-autoproxy/>
</beans>

实验3

  Spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。

  现在可以自己想一想，怎么搞出来这个伪装类，才不会被调用者发现（通过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。

 1.实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事物等）。

  这就好比，一个人让你办件事，每次这个时候，你弟弟就会先出来，当然他分不出来了，以为是你，你这个弟弟虽然办不了这事，但是他知道你能办，所以就答应下来了，并且收了点礼物（写日志），收完礼物了，给把事给人家办了啊，所以你弟弟又找你这个哥哥来了，最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了，你只是专心把这件事情做好。

  顺着这个思路想，要是本身这个类就没实现一个接口呢，你怎么伪装我，我就压根没有机会让你搞出这个双胞胎的弟弟，那么就用第2种代理方式，创建一个目标类的子类，生个儿子，让儿子伪装我。

 　2.生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，我继承的吗？当然查不出来了，子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）。

  这次的对比就是，儿子先从爸爸那把本事都学会了，所有人都找儿子办事情，但是儿子每次办和爸爸同样的事之前，都要收点小礼物（写日志），然后才去办真正的事。当然爸爸是不知道儿子这么干的了。这里就有件事情要说，某些本事是爸爸独有的(final的)，儿子学不了，学不了就办不了这件事，办不了这个事情，自然就不能收人家礼了。

  前一种兄弟模式（JDK动态代理），spring会使用JDK的java.lang.reflect.Proxy类，它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。

  后一种父子模式（CGLib动态代理），spring使用CGLIB库生成目标类的一个子类，在创建这个子类的时候，spring织入通知，并且把对这个子类的调用委托到目标类。

  相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。

程序运行结果：
实验1：
在这里插入图片描述

实验2：
在这里插入图片描述
在这里插入图片描述

实验总结：

  1. Spring是一个轻型容器，Spring整个系列的最最核心的概念当属IoC、AOP。可见AOP是Spring框架中的核心之一，在应用中具有非常重要的作用，也是Spring其他组件的基础。
  2. AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
  3. AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率，OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。
  4. AOP的源码中用到了两种动态代理来实现拦截切入功能：
    jdk动态代理：
    1)jdk动态代理是由java内部的反射机制来实现的，jdk动态代理的应用前提是目标类基于统一的接口。如果没有该前提，jdk动态代理不能应用。由此可以看出jdk动态代理有一定的局限性。
    2)JDK动态代理机制是委托机制，不需要以来第三方的库，只要要JDK环境就可以进行代理，动态实现接口类，在动态生成的实现类里面委托为hanlder去调用原始实现类方法。CGLib
    必须依赖于CGLib的类库，使用的是继承机制，是被代理类和代理类继承的关系，所以代理类是可以赋值给被代理类的，如果被代理类有接口，那么代理类也可以赋值给接口。
    cglib动态代理： cglib动态代理底层则是借助asm来实现的，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。CGLib必须依赖于CGLib的类库，使用的是继承机制，是被代理类和代理类继承的关系，所以代理类是可以赋值给被代理类的，如果被代理类有接口，那么代理类也可以赋值给接口。

对于Spring AOP这一概念，我相信每一个学习Spring的人都会有自己的理解。这种概念上的理解没有绝对的标准答案，仁者见仁智者见智。如果有理解不到位或者理解错的地方，欢迎广大猿友指正！
　　
谢谢浏览！

基础较差的cs菜鸟
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CGLIB动态代理应用-java使用记录操作日志
kissing7的专栏
07-05 1209
1.调用动态代理记录操作。 public class CommandPublishSearchAction extends Action{     public ActionForward execute(ActionMapping mapping, ActionForm form,             HttpServletRequest request, HttpServletR
cglib动态代理
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
Spring学习（7）—— AOP（使用注解方式通过AspectJ实现AOP）
Archer__13的博客
04-18 1610
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得各部分之间的耦合度降低。 Spring框架一般都是基于AspectJ实现AOP操作。 1. AOP中的术语 （1）连接点：类中可以被增强的方法； （2）切入点：类中实际被增强的方法； （3）通知（增强）：给类中某个方法编写的实际增强的逻辑部分；通知有多种类型：①前置通知、②后置通知、③环绕通知、④异常通知、⑤最终通知 （4）切面：把通知应用到切入点的过程 2. 切入点表达式 切入点表达式的作用：指明对哪个类里的哪个方法进行增强 语法...
Java动态代理——cglib动态代理解析
zhaoquanwei2018的博客
01-06 853
名词解释 静态代理：编译期就已确定代理对象。即编码出代理类。 动态代理：运行时动态生成代理对象。可对被代理类做出统一的处理，如日志打印，统计调用次数等。 cglib动态代理：cglib工具包实现的动态代理生成方式，通过字节码来实现动态代理，不需要被代理类必须实现接口。 1. 举例 使用cglib代理需要引入两个包，maven的话包引入如下 ...
基于jdk的动态代理实现方式详解
ningmeng666_c的博客
03-25 108
Proxy和InvocationHandler的一个关系？ 1.Proxy并不是代理类，作用是用来去创建代理类，这个Proxy仅仅是创建代理类并返回代理类的实例对象，并不做实际性的工作（就是调用真实对象身上的方法，例如租房rent） 2.做实质性的工作是由InvocationHandler来去做的 编写动态代理类的步骤： 1.去自定义一个类，这个类实现InvocationHandler接口，并重写invoke方法 2.编写抽象角色/公共接口/Subject接口 3.编写真实对象/RealSubject/房东
关于Spring中AOP的使用以及对数据库的连接操作
qq_59776041的博客
03-31 2084
AOP AOP概念 什么是AOP 面向切面编程 利用AOP可以对业务逻辑的各个方面进行隔离，从而使业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率 通俗描述：不通过改源代码的方式，在主干功能里面添加新的功能 AOP的底层原理 AOP的底层使用动态代理 两种动态代理 有接口，使用JDK动态代理 创建接口实现类代理对象，增强类的方法 没有接口，使用CGLIB动态代理
Spring框架+SpringAOP动态代理
最新发布
03-22
SpringAOP动态代理 Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于...
springAOP配置动态代理实现
03-28
动态代理则是Spring AOP实现的核心技术之一，它允许我们在运行时创建具有额外行为的对象。下面将详细阐述Spring AOP的配置以及动态代理的实现。 一、Spring AOP基础知识 1. **什么是AOP**：AOP是一种编程范式，...
spring之AOP（动态代理）
09-06
在Spring中，AOP主要通过两种动态代理技术实现：JDK动态代理和CGLIB动态代理。 首先，让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现，它适用于目标对象实现了至少一个接口的情况。在运行时，JDK...
Spring CGLlB动态代理实现过程解析
08-25
"Spring CGLlB动态代理实现过程解析" Spring CGLIB动态代理是Spring框架中的一种动态代理机制，它通过CGLIB（Code Generation Library）生成代理类来实现动态代理。CGLIB是一个高性能的开源代码生成包，能够在运行...
动态代理模式(Cglib实现)
Gaaidou的博客
07-14 567
使用过SpringAOP的人都知道, AOP的底层实现原理是使用了动态代理模式来实现面向切面编程。而SpringAOP使用的动态代理方式有JDK的动态代理，另一个则是Cglib的动态代理。本文先不讲AOP，主要讲Cglib的动态代理实现过程。 Cglib底层实现是使用了ASM操作字节码生成代理对象，由于这种技术十分底层，因此本文不打算研究，而且这些知识对于应用开发来说投入产出比不高，因此对于Cglib，个人主张只需要知道其大概实现过程，在日常开发中一旦遇到和Cglib相关的问题，可以能比较快速的解决方案。
spring-aop前身--【aspectj】面向切面编程 强制使用cglib进行动态代理
weixin_42275175的博客
08-01 625
看本篇文章之前，必须要了解动态代理的相关知识， 如果不了解，请点击：https://blog.csdn.net/weixin_42275175/article/details/98044391 aspectj是一个Aop组织提供的面向切面编程框架。 使用方法：a:用户自己开发自己的业务类和业务方法 b:用户自己开发自己的增强逻辑，增强逻辑可以卸载一个普通的Advice类中 c:配置一个配置文件，告...
cglib动态代理实现（使用代理类的父类作为目标对象）
jaesonchen
03-28 1586
import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; //直接使用代理类的父类作为目标业务对象。 public class Bu...
AOP的实现原理 —— 静态代理 和 动态代理（ Spring AOP）
热门推荐
猎人在吃肉
03-08 1万+
这里的AOP指的是面向切面编程思想，而不是Spring AOP 。 AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。 AOP实现主要分为 静态代理 和 动态代理 。 - 静态代理 主要是 `AspectJ` - 动态代理 主要是 `Spring AOP`
CGLib动态代理
DotWait的博客
09-12 568
CGLib动态代理 一、简介 CGLib（Code Generation Library）是一个高性能的字节码生成库，可以在运行期扩展Java类和接口。 实现原理：利用ASM（直接操作字节码的框架）加载被代理类的class文件，修改字节码生成继承自被代理类的子类（代理类），代理类通过重写被代理类方法实现代理。 限制： 无法代理被final修饰的类或方法 二、实现CGLib动态代理的Demo 1.被代理类 public class PrintService { public void print(
细说Spring——AOP详解（动态代理实现AOP）
啦啦啦的博客
06-05 9830
前言 嗯，我应该是有一段实现没有写过博客了，在写完了细说Spring——AOP详解（AOP概览）之后，我发现我不知道该怎么写AOP这一部分，所以就把写博客这件事给放下了，但是这件事情又不想就这么放弃，所以今天我仔细思考了一下，决定还是要克服困难，我仔细的想了一下怎么讲解AOP实现这一部分，然后我决定由浅入深的讲解动态代理，然后用动态代理实现一个简单的AOP，感觉这样能够让人对AOP的原理有一个比...
SpringAop动态代理的两种实现方式
qq_28754027的博客
08-18 5732
Spring的面向切面编程也是基于动态代理来实现的 静态代理:也就是自己手动创建的代理对象 动态代理:也就是在程序运行中通过配置参生的 那么Spring的AOP也就是面向切面编程，就是基于动态代理来实现的，通过代理原始类增加额外功能，我们可以将额外功能一次定义然后配合切点达到多次使用的效果，比如 做日志啊 事物啊 时间啊等等…提高了复用性 开发效率. 那么在Spirng当中动态代理有两种 第一种也就是JDK自带的动态代理 1.JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用In
Spring AOP动态代理的实现方式
小驴
06-06 1万+
"JDK"动态代理和"CGLIB"动态代理 JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类 CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，注意，CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那...
java Spring代理模式AOP-IOC结合
10-01
"深入理解Java Spring中的代理模式与AOP、IOC的结合应用" 在软件开发中，代理模式是一种常用的设计模式，它允许我们为一个对象创建一个代理，以控制对原对象的访问。Spring框架中，代理模式与AOP（面向切面编程）和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值