【Spring】手动实现简易AOP和IOC

已于 2023-05-10 13:28:13 修改
阅读量483 收藏 1
点赞数
分类专栏： space 文章标签： spring java 后端
于 2023-02-17 15:06:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43209531/article/details/129086468
版权

前言

XML：通过Dom4j对XML进行解析和验证。
IOC：通过获取要创建对象的Class类型、构造函数后，通过反射来实现。
AOP：通过使用JDK动态代理和Cglib动态代理实现。

一、解析XML

1.1、解析bean标签

/**
  * 解析bean标签
  * @param xmlBean bean标签
  */
 private void parseBeanDefinitionXML(Element xmlBean){
     String beanId = xmlBean.attributeValue("id");
     if (beanDefinitionMap.containsKey(beanId)) {
         return;
     }
     String beanClass = xmlBean.attributeValue("class");
     BeanDefinition beanDefinition = new BeanDefinition();
     beanDefinition.setId(beanId);
     beanDefinition.setClassName(beanClass);
     List<Element> xmlConstructor = xmlBean.elements();
     //  无参bean,则解析完成
     if (UsualUtil.isNull(xmlConstructor)) {
         beanDefinitionMap.put(beanId, beanDefinition);
         return;
     }
     List<BeanDefinition.ConstructArg> constructArgs = new ArrayList<>();
     //  解析参数
     for (Element xmlConstructArg : xmlConstructor) {
         //  目前仅解析constructor-arg
         if ("constructor-arg".equals(xmlConstructArg.getName())) {
             String typeClass = xmlConstructArg.attributeValue("type");
             String value = xmlConstructArg.attributeValue("value");
             String refName = xmlConstructArg.attributeValue("ref");
             BeanDefinition.ConstructArg constructArg = new BeanDefinition.ConstructArg();
             constructArg.setType(typeClass);
             constructArg.setValue(value);
             constructArg.setRef(refName);
             //  非引用其他bean
             if (UsualUtil.isNull(refName)) {
                 if (typeClass.endsWith("List")) {
                     Element xmlCollection = xmlConstructArg.elements().get(0);
                     String valueTypeClass = xmlCollection.attributeValue("value-type");
                     constructArg.setItemType(valueTypeClass);
                     List<String> itemValue = new ArrayList<>();
                     for (Element xmlItem : xmlCollection.elements()) {
                         itemValue.add(xmlItem.getStringValue());
                     }
                     constructArg.setItemValue(itemValue);
                 }
             }
             constructArgs.add(constructArg);
         }
     }
     beanDefinition.setConstructArgs(constructArgs);
     beanDefinitionMap.put(beanId, beanDefinition);
 }

1.2、解析aspect标签

/**
  * 解析aspect标签
  * @param xmlAspect aspect标签
  * @param useCglib 是否使用cglib
  */
 private void parseAspectXML(Element xmlAspect, boolean useCglib) {
//    <aop:config>
//        <aop:aspect ref="aspect">
//            <aop:before method="run" pointcut="execution(public void org.tree.aspect.AspectProcessor.before())"/>
//            <aop:after method="run" pointcut="execution(public void org.tree.aspect.AspectProcessor.after())"/>
//        </aop:aspect>
//    </aop:config>
     String refName = xmlAspect.attributeValue("ref");
     if (aspectDefinitionMap.containsKey(refName)) {
         return;
     }
     AspectDefinition aspectDefinition = new AspectDefinition();
     aspectDefinition.setUseCglib(useCglib);
     aspectDefinition.setRef(refName);
     List<AspectDefinition.Advice> advices = new ArrayList<>();
     for (Element xmlAdvice : xmlAspect.elements()) {
         AspectDefinition.Advice advice = new AspectDefinition.Advice();
         advice.setType(xmlAdvice.getName());
         //  execution(public void org.tree.aspect.AspectProcessor.before())
         String pointcutStr = xmlAdvice.attributeValue("pointcut");
         pointcutStr = pointcutStr.replace("execution", "");
         pointcutStr = pointcutStr.substring(0, pointcutStr.length() - 1);
         //  public void org.tree.aspect.AspectProcessor.before()
         String[] strings = pointcutStr.split(" ");
         advice.setMethod(xmlAdvice.attributeValue("method"));
         advice.setProxyMethod(strings[2].substring(strings[2].lastIndexOf('.') + 1, strings[2].length() - 2));
         advice.setProxyClass(strings[2].substring(0, strings[2].lastIndexOf('.')));
         advices.add(advice);
     }
     aspectDefinition.setAdvices(advices);
     aspectDefinitionMap.put(refName, aspectDefinition);
 }

二、加载Bean

加载Bean时，本文实现的是通过构造函数注入参数，所以无法解决循环依赖的问题。
浅说下发现构造函数循环依赖的原理：当要加载一个bean时，记录下当前bean的加载状态为“正在创建中”，准备好构造函数所需要的参数，如果参数是未加载的，则取加载其参数，当加载的参数发现自己正处于“正在创建中”的状态时，则此刻这两个bean之间发生循环依赖了。

2.1、getBean

/**
  * 通过bean实例名字获取实例
  * @param id bean实例名字
  * @return bean实例
  */
 public Object getBean(String id) throws Exception {
     if (beanFactory.containsKey(id)) {
         return beanFactory.get(id);
     }
     if (!beanDefinitionMap.containsKey(id)) {
         return null;
     }
     BeanDefinition beanDefinition = beanDefinitionMap.get(id);
     List<BeanDefinition.ConstructArg> constructArgs = beanDefinition.getConstructArgs();
     if (UsualUtil.isNull(constructArgs)) {
         //  创建bean前操作
         if (beanPostProcessor != null) {
             beanPostProcessor.preInitBean(objectFactory.get(id), id);
         }
         Object beanObj = Class.forName(beanDefinition.getClassName()).getConstructor().newInstance();
         //  如果该bean被aop引用
         beanObj = doEnhanceBean(beanDefinition, beanObj);
         //  创建bean后操作
         if (beanPostProcessor != null) {
             beanPostProcessor.postInitBean(beanObj, id);
         }
         beanFactory.put(id, beanObj);
         return beanObj;
     }
     return doCreateBean(beanDefinition);
 }

2.2、doCreateBean

/**
  * 创建bean
  * @param beanDefinition bean标签
  * @return bean实例
  * @throws Exception 空
  */
 private Object doCreateBean(BeanDefinition beanDefinition) throws Exception{
     //  标记该bean正在创建实例中
     objectFactory.put(beanDefinition.getId(), Class.forName(beanDefinition.getClassName()).getConstructor().newInstance());
     List<BeanDefinition.ConstructArg> constructArgs = beanDefinition.getConstructArgs();
     Class<?>[] paramTypes = new Class[constructArgs.size()];
     Object[] paramValues= new Object[constructArgs.size()];
     int paramIndex = 0;
     for (BeanDefinition.ConstructArg constructArg : constructArgs) {
         //  构造函数参数为引用
         if (!UsualUtil.isNull(constructArg.getRef())) {
             //  该引用bean已经创建实例
             if (beanFactory.containsKey(constructArg.getRef())) {
                 Object refBeanObj = beanFactory.get(constructArg.getRef());
                 paramTypes[paramIndex] = refBeanObj.getClass();
                 paramValues[paramIndex] = refBeanObj;
                 paramIndex++;
             //  该引用bean正在创建实例中，循环引用
             } else if (objectFactory.containsKey(constructArg.getRef())) {
                 throw new Exception("Both id '" + beanDefinition.getId() + "' and '" + constructArg.getRef() + "' are circular reference");
             //  该引用bean未创建实例
             } else {
                 Object refBeanObj = doCreateBean(beanDefinitionMap.get(constructArg.getRef()));
                 paramTypes[paramIndex] = refBeanObj.getClass();
                 paramValues[paramIndex] = refBeanObj;
                 paramIndex++;
             }
             continue;
         }
         paramTypes[paramIndex] = Class.forName(constructArg.getType());
         //  构造函数参数为非引用类型, 且是非集合类型
         if (!(constructArg.getType().endsWith("List"))) {
             paramValues[paramIndex++] = Class.forName(constructArg.getType()).getConstructor(String.class).newInstance(constructArg.getValue());
             continue;
         }
         List<Object> objParamList = new ArrayList<>();
         for (String itemValue : constructArg.getItemValue()) {
             objParamList.add(Class.forName(constructArg.getItemType()).getConstructor(String.class).newInstance(itemValue));
         }
         paramValues[paramIndex++] = objParamList;
     }
     //  创建bean前操作
     if (beanPostProcessor != null) {
         beanPostProcessor.preInitBean(objectFactory.get(beanDefinition.getId()), beanDefinition.getId());
     }
     Object beanObj = Class.forName(beanDefinition.getClassName()).getConstructor(paramTypes).newInstance(paramValues);
     //  如果该bean被aop引用
     beanObj = doEnhanceBean(beanDefinition, beanObj);
     //  创建bean后操作
     if (beanPostProcessor != null) {
         beanPostProcessor.postInitBean(beanObj, beanDefinition.getId());
     }
     beanFactory.put(beanDefinition.getId(), beanObj);
     //  标记该bean没有正在创建
     objectFactory.remove(beanDefinition.getId());
     return beanObj;
 }

三、增强Bean

3.1、doEnhanceBean

/**
  * 创建增强bean
  * @param beanDefinition bean标签
  * @param beanObj bean对象
  * @return 增强bean
  * @throws Exception 空
  */
 private Object doEnhanceBean(BeanDefinition beanDefinition, Object beanObj) throws Exception {
     if (aspectDefinitionMap.containsKey(beanDefinition.getId())) {
         AspectDefinition aspectDefinition = aspectDefinitionMap.get(beanDefinition.getId());
         for (AspectDefinition.Advice advice : aspectDefinition.getAdvices()) {
             //  增强beanObj
             beanObj = doCreateProxy(beanObj, advice.getMethod(), advice.getProxyClass(), advice.getProxyMethod()
                     , "before".equals(advice.getType()), aspectDefinition.isUseCglib());
         }
     }
     return beanObj;
 }

3.2、doCreateProxy

/**
  * 创建代理对象
  * @param beanObj bean实例
  * @param joinPointMethod 要代理的bean方法
  * @param strProxyClass 代理类
  * @param strProxyMethod 代理类的方法
  * @param isBefore 通知类型
  * @param useCglib 是否使用cglib
  * @return 代理对象
  * @throws Exception 空
  */
 private Object doCreateProxy(Object beanObj, String joinPointMethod, String strProxyClass, String strProxyMethod
         , boolean isBefore, boolean useCglib) throws Exception {
     Class<?> clazz = Class.forName(strProxyClass);
     Object proxyObject = clazz.getConstructor().newInstance();
     Method proxyMethod = clazz.getMethod(strProxyMethod);
     //  如果使用cglib动态代理
     if (useCglib) {
         Enhancer enhancer = new Enhancer();
         enhancer.setSuperclass(beanObj.getClass());
         /*
          * 设置被代理类执行方法时的逻辑
          * o 被代理类生成的对象实例(子类)
          * method 被代理类的方法
          * args 方法的参数
          * methodProxy 被代理类的方法的代理方法
          */
         enhancer.setCallback((MethodInterceptor) (o, method, args, methodProxy) -> {
             //  当方法是我们要代理的方法时
             if (method.getName().equals(joinPointMethod)) {
                 if (isBefore) {
                     proxyMethod.invoke(proxyObject);
                 }
                 //  调用父类的方法
                 methodProxy.invokeSuper(o, args); // 使用beanObj会报错，因为参数需要的是生成的子类
                 if (!isBefore) {
                     proxyMethod.invoke(proxyObject);
                 }
             } else { // 如果不写，则是全放空（由于生成的是子类，其他方法全空，不调用父类的【被代理类】）
                 methodProxy.invokeSuper(o, args); // 调用父类的方法
             }
             return o;
         });
         return enhancer.create();
     }
     /*
      * clazz 加载被代理类的加载器
      * interfaces 被代理类实现的所有接口
      * 增强方法
      *  o 被代理类的对象实例
      *  method 被代理类实现的所有接口的方法，且要执行
      *  args 方法需要的参数
      */
     // 代理一个类，该类通过loader加载，且实现interfaces接口
     return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), beanObj.getClass().getInterfaces(), (o, method, args) -> {
         //  当方法为我们要代理的方法时，执行特定增强
         if (method.getName().equals(joinPointMethod)) {
             if (isBefore) {
                 proxyMethod.invoke(proxyObject);
             }
             //  调用被代理类实际的方法
             method.invoke(beanObj, args); // 这里写beanObj不报错是因为它是AspectInterface的子类, 但不能写o,会死循环（调用了代理的自己，又再次调用）
             if (!isBefore) {
                 proxyMethod.invoke(proxyObject);
             }
         } else {
             method.invoke(beanObj, args);
         }
         //  返回值就是代理类执行代理方法的返回值
         return o;
     });

四、类图在这里插入图片描述

_Mr.Tree
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springioc和spring aop
09-05
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
Spring 核心 IOC跟 AOP的自我实现
01-20
文章目录Spring1、Core Container（核心容器）2、Data Access3、Web4、AOP5、TestSpring 版本与 Java 版本的对应关系IoC1、XML 解析：2、根据第 1 步获取的信息，动态创建对象spring-ioc.xml文件如下User类Spring ...
手动实现一个迷你版的AOP（实战增强版）
Java知音
05-08 180
在正式进行aop模块的介绍之前，我们需要先弄懂一些基本的术语概念。在软件业，AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和...
SpringAop 源码解析 (二) - 代理对象的创建以及执行过程
小毕超博客
04-09 736
方法，主要做了对切面方法的扫描和匹配过程，并且这里拿到的结果就是所有匹配的切面方法包装类集合，本篇文章继续上篇文章的脚步，分析下后面代理对象的创建过程和执行过程。上面文章分析到这个位置，下面继续，如果存在匹配的切面方法，则先进行标记，反之不存在也进行标记，下次再进来该。的话，则会对当前代理对象进行缓存，目的是在同一个类中自我方法调用的情况下，如果被调用的方法带有。，其实是触发所有的切面增强方法，最后再触发目标方法，看到。最后一个时，就是代表所有的切面方法都触发完了，这里的。
SpringAOP原理：手写动态代理实现
最新发布
weixin_44440311的博客
08-20 274
SpringAOP原理：手写动态代理实现
Spring基于注解配置AOP
Purpletaro的专栏
06-04 317
Spring 项目使用 AOP 功能需要定义三个部分：切面、切点和通知。在 Spring 管理的 Bean 类上使用@Aspect注解就可以定义一个切面。@Aspect@Component在切面类的方法使用@Pointcut注解来定义切点，然后在通知注解中使用方法签名来指定切点。切点表达式用来匹配切入的目标类和方法。目标类只能是 Spring 容器管理的类，切面只能切入 Bean 中的方法。@Aspect@Component切点表达式也可以在定义通知的时候指定，而不需要使用@Pointcut。
手动AOP的实现的几种方式
赵英超的博客
04-18 1023
静态AOP在编译期，切面直接以字节 码的形式编译到目标字节 码文件中。AspectJ属于静态AOP，是在编译时进行增强，会在编译的时候将AOP逻辑织入到代码中，需要专有的编译器和织入器。优点：被织入的类性能不受影响。缺点：不够灵活动态AOPJDK动态代理在运行期，目标类加载后，为接口动态生成代理类，将切面植入到代理类中。Java从1.3引入动态代理。实现原理是为被代理的业务接口生成代理类，将AOP...
SpringBoot Aop的初始化流程原理
不吃肥肉的傲寒
12-02 306
查看AnnotationAwareAspectJAutoProxyCreator继承关系 其父类实现。所有的一切都是从spring的启动流程refresh方法中开始。执行refresh方法中的bean预初始化方法。方法最终执行创建代理方法 实例化bean对象。在doCreateBean的方法中进行实例化。
Spring IOC和Spring AOP_spring aop_springIOC
09-24
spring基础Spring IOC和Spring AOP的原理及使用
SpringIOC和AOP原理设计模式
01-27
在接触Spring的过程中，听到最多的无非两个名词，一个是控制反转一个是依赖注入。实际这是一个意思，控制反转代表原来由程序本身去控制对象之间的依赖关系的这种格局被反转了，通过第三方容器（IOC）去完成控制这些...
Spring核心IoC和AOP的理解
08-31
本文主要介绍了Spring核心IoC和AOP的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
仿照 Spring 实现简单的 IOC 和 AOP - 上篇
weixin_33851429的博客
08-19 253
1. 背景 我在大四实习的时候开始接触 J2EE 方面的开发工作，也是在同时期接触并学习 Spring 框架，到现在也有快有两年的时间了。不过之前没有仿写过 Spring IOC 和 AOP，只是宏观上对 Spring IOC 和 AOP 原理有一定的认识。所以为了更进一步理解 Spring IOC 和 AOP 原理。在工作之余，参考了一...
手写简易AOP，彻底悟懂AOP
qq_63815371的博客
11-10 567
AOP 意为：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能功能的统一维护。其实 AOP 也是 OOP 的延续，在 Spring 框架中是一个非常重要的内容，使用 AOP 可以对业务逻辑的各个部分进行隔离，从而使各模块间的业务逻辑耦合度降低，提高代码的可复用性，同时也能提高开发效率。
自己动手实现aop
qq_16725749的博客
05-28 291
用动态代理实现aop，$proxy0是代理类，A13是demo演示 $proxy0类代码： package com.example.springdemo.A013; import com.example.springdemo.A013.A13.*; import java.lang.reflect.Method; public class $proxy0 implements A13.Foo{ private InvocationHandler h; public $proxy0
spring之手动实现AOP编程
nwpu_geeker的博客
01-22 1396
前言首先来看如何手动实现简单AOP编程的例子，对于掌握spring的核心AOP编程有很大的帮助。AOP编程简单说一下概念，AOP是面向切面编程。利用AOP可以实现“业务代码”与“关注点代码”分离。业务代码就是平时程序员最关注的核心业务代码，而关注点代码是程序员不怎么关心的，或者可以通过框架来帮我们实现在运行时期动态的植入到我们的核心业务代码中去，也就是说程序员开发中可以不用花大量精力关注这些，只要会
7.7 Spring AOP底层实现，以及两种动态代理的实现（建议自己手动实现两种代理方式）；
服务端开发进阶之路
05-12 500
转载：https://www.cnblogs.com/hublogs/p/12035415.html AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。 AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（例如性能监视、事务管理、安全检查、缓存、日志记录等） 切面：需要代理一些方法和增强代码 AOP的应用场景 场景一：记录日志 场景二：监控方法运行时间 （监控性能） 场景三： 权限控制 场景四： 缓存优化 （第一次调用查询
AOP切面的实现
gonglei181818的博客
07-25 877
AOP切面的实现 AOP的全称是Aspect Orient Programming，即面向切面编程。是对OOP（Object Orient Programming）的一种补充，战门用于处理一些具有横切性质的服务。常常用于日志输出、安全控制等。 最近遇到增加操作日志记录功能问题，网上推荐使用切面技术实现，可以在不修改其它模块代码的前提下实现各个模块日志记录。 实现方法： 第一步：添加切面注解@Asp...
六、Spring AOP -- （二）手动实现Aop
weixin_45602227的博客
07-29 394
一、AOP 1.1 AOP的引入 public class UserDao implements IUserDao{ @Override public void save() { //关注点代码 System.out.println("----> 获取连接，开启事务"); //核心业务代码 System.out.println("DB 保存"); //关注点代码 System.out.println("----> 事务提交/关闭"); } }
Java 手写 Spring框架 IOC 和 AOP----手写Spring IoC和AOP
殷志鹏的博客
01-23 1658
本文将首先通过手写Spring，了解Spring基本思想，然后介绍Spring的一些高级用法，随后深度剖析其源码，让读者有更深入的了解====本文源码基于5.1.12版本讲解
spring的aop和ioc实现原理
06-28
Spring的AOP和IOC实现原理： AOP（面向切面编程）是Spring框架的一个重要特性，它通过在运行时动态地将代码切入到类的方法中，实现了对业务逻辑的解耦和横向切割。Spring的AOP实现原理是基于动态代理和字节码生成...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值