自研Spring容器，带你解析ioc内部原理

最新推荐文章于 2024-10-18 11:53:17 发布
最新推荐文章于 2024-10-18 11:53:17 发布
阅读量257 收藏 4
点赞数 2
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43567055/article/details/116534417
版权

spring设计架构

image-20210507104401379"

Test：测试模块

Core container ：核心模块

Beans ：将对象设置成Beans，Core核心工具类，Context上下文将Beans和Core组装运行环境，SpEL表达式语言

Aop ：将java中动态代理为基础一系列横线切面

Data：操作数据库

Web：web组件开发支持

Jsp实现原理

image-20210507104431631

日志

image-20210507104543925

Url

image-20210507104625929

反射

image-20210507104634579

三种获取Class方法

https://www.cnblogs.com/wwjj4811/p/12539804.html

注解

image-20210507104336449

自研框架-前传

image-20210507104314083

自研框架-ioc

注解怎么创建？

image-20210507104303164

ioc容器怎么拿到对象名？
package org.simpleframework.utils;

import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;
@Slf4j
public class ClassUtil {

    public static Set<Class<?>> exractPackClass(String packgeName){

        获取当前线程的类加载器
        ClassLoader classLoder = getClassLoder();

        //通过类加载器获取到加载的资源
        URL url = classLoder.getResource(packgeName.replace(".", "/"));
        if (url == null) {
            log.warn("获取不到url"+packgeName);
            return null;
        }
        //依据不同资源类型，采用不用方式获取
        Set<Class<?>> classSet = null;

        //过滤出文件类型的资源
        if(url.getProtocol().equalsIgnoreCase("file")){//对比不区分大小写
           classSet = new HashSet<Class<?>>();
            File packageDiectory = new File(url.getPath());
            extractClassFile(classSet,packageDiectory,packgeName);
        }

        return classSet;


    }

    /***
     * 递归获取目标package里面所有class文件
     * @param classSet
     * @param packageDiectory
     * @param packgeName
     */
    private static void extractClassFile(Set<Class<?>> classSet, File packageDiectory, String packgeName) {
        //递归终止点，当递归到文件的时候就退出
        if (!packageDiectory.isDirectory()){
            return;
        }

        File[] files = packageDiectory.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                //ava中的isDirectory()是检查一个对象是否是文件夹。返回值是boolean类型的。如果是则返回true，否则返回false
                if (file.isDirectory()){
                    return true;
                }else {
                    //获取文件绝对值路劲
                    String absolutePath = file.getAbsolutePath();
                    if (absolutePath.endsWith(".class")){
                        
                        //获取到绝对值路径后将通过反射加入
                        addToClassSet(absolutePath);
                    }
                    
                }
                return false;
            }

            //将Class文件的绝对值路径。获取生成class对象，并放入classSet中
            private void addToClassSet(String absolutePath) {
                //从class文件绝对值路径中提取包类名
                absolutePath = absolutePath.replace(File.separator, ".");
                String className = absolutePath.substring(absolutePath.indexOf(packgeName));
                className = className.substring(0,className.lastIndexOf("."));
                //通过反射将对象名拿出来
                Class<?> aClass = loadClass(className);
                classSet.add(aClass);
            }
        });

        if (files != null){
            for (File f: files) {
                extractClassFile(classSet, f, packgeName);
            }
        }
    }

    public static ClassLoader getClassLoder(){
        //获取当前线程的类加载器
        return Thread.currentThread().getContextClassLoader();

    }

    public static Class<?> loadClass(String className){
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    //获取class类实例
    public static <T> T newInstance(Class<?> clazz,boolean accessible) {
        try {
            Constructor declaredConstructor = clazz.getDeclaredConstructor();
            declaredConstructor.setAccessible(accessible);
            return (T) declaredConstructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }

    }

}

image-20210507104242518

根据实际路径获取class文件名存入set集合

容器单例输出安全吗？

image-20210508170005287

开始创建容器吧！！

package org.simpleframework.core;

import com.sun.corba.se.impl.io.ValueUtility;
import com.sun.deploy.util.StringUtils;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.simpleframework.core.annotation.Compoment;
import org.simpleframework.core.annotation.Controller;
import org.simpleframework.core.annotation.Repository;
import org.simpleframework.core.annotation.Service;
import org.simpleframework.utils.ClassUtil;

import java.awt.*;
import java.lang.annotation.Annotation;
import java.util.*;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @description:
 * @author: zhangyihan
 * @createDate: 2021-04-29 14:50
 * @version: 1.0
 */
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanContainer {


    //检查容器是否被加载过
    private boolean load = false;


    /**
     *获取bean实例
     *
     * @return
     */

    public static BeanContainer getInstance(){
        return ContainerHolder.HOLDER.instance;
    }


    //设置单例方法，将对象存入HOLDER
    //使用枚举可以防止反射的入侵
    private enum ContainerHolder{

        HOLDER;
        private BeanContainer instance;

        ContainerHolder(){

            instance =new BeanContainer();
        }

    }
    /**
     *  存放所有被注解配置过的目标对象Map
     */
    private final Map<Class<?>,Object> beanMap= new ConcurrentHashMap();


    /**
     * 加载bean的注解列表
     *
     * @return
     */
    private static final List<Class<? extends Annotation>> BEAN_ANNOTATION=
            Arrays.asList(Compoment.class, Controller.class, Service.class, Repository.class);


    //判断是否被加载
    public boolean islocad(){
        return load;
    }
    /***
     *
     * 扫描所有的类名
     *
     */
   public synchronized void localBeans(String packName){

       if (islocad()){
           log.warn("bean容器已经被加载过了");
           return;
       }

       //获取当前线程的包名将class文件类名通过反射获取出来
       Set<Class<?>> classSet = ClassUtil.exractPackClass(packName);

       if (classSet == null || classSet.isEmpty()){
           log.warn("找不到包类名"+packName);

           return;
       }

       //将获取到的类名遍历出来
       for (Class aClass:classSet){

           //将标有注解的类循环遍历出来
          for (Class<? extends Annotation> beanClass : BEAN_ANNOTATION)
          {
              //判断是否加了那四个注解
              if (aClass.isAnnotationPresent(beanClass)){

                  //加了的话将类名本身作为减，实例作为值传入map之中
                  beanMap.put(aClass,ClassUtil.newInstance(aClass,true));
              }

          }


       }

       load = true ;

   }


    /***
     * 添加一个class对象及其实例
     *
     */

     public Object addBean(Class<?> clazz,Object bean){

         //map会返回传入值的对象
         Object o = beanMap.put(clazz, bean);
         return o;
     }

    /***
     * 删除一个容器管理对象
     *
     */
     public Object removeBean(Class<?> clazz){
         //根据名字删除，有值会返回删除值的类型，没就是null
         return beanMap.remove(clazz);
     }


    /***
     * 获取一个容器管理对象
     *
     */
    public Object getBean(Class<?> clazz){
        return beanMap.get(clazz);
    }



    /***
     * 获取容器管理所有对象
     *
     */
    public Set<Class<?>> getClasses(){
        //根据名字删除，有值会返回删除值的类型，没就是null
        return beanMap.keySet();
    }


    /***
     * 获取容器bean集合
     *
     */
    public Set<Object> getBeansValues(){
        //根据名字删除，有值会返回删除值的类型，没就是null
        return new HashSet<>(beanMap.values());
    }

    /***
     * 根据注解筛选出bean的class集合
     *
     */
    public Set<Class<?>> getClassByAnnotation(Class<? extends Annotation> annotation){
        //获取beanMap的所有class对象
        Set<Class<?>> keySet = getClasses();
        if (keySet == null || "".equals(keySet)){
           log.warn("nothing in beanMap");
           return null;
        }
        //通过注解筛选出class对象，并添加到set里
        Set<Class<?>> classSet = new HashSet<>();
        for(Class<?> clazz :keySet){
            if (clazz.isAnnotationPresent(annotation)){
                classSet.add(clazz);
            }
        }
        //统一返回值
        return classSet.size() > 0? classSet:null;
    }


    /***
     * 通过接口或者父类获取实现类或者子类的class集合，不包含本身
     *
     */
    public Set<Class<?>> getClassBySuper(Class<?> interfaceORClass){
        //获取beanMap容器的所有class对象
        Set<Class<?>> keySet = getClasses();
        if (keySet == null || "".equals(keySet)){
            log.warn("nothing in beanMap");
            return null;
        }
        //通过注解筛选出class对象是否传入接口的子类，并添加到set里
        Set<Class<?>> classSet = new HashSet<>();
        for(Class<?> clazz :keySet){
            //是否是传入接口的子类
            if (interfaceORClass.isAssignableFrom(clazz) && !clazz.equals(interfaceORClass)){
                classSet.add(clazz);
            }
        }
        //统一返回值
        return classSet.size() > 0? classSet:null;
    }



}

实现容器的依赖注入

image-20210507163534042
1.定义相关注解

image-20210507165800377

2.创建注入类-DependencyInjector

package org.simpleframework.inject;

import lombok.extern.slf4j.Slf4j;
import org.simpleframework.core.BeanContainer;
import org.simpleframework.inject.annotation.Autowired;
import org.simpleframework.utils.ClassUtil;

import java.lang.reflect.Field;
import java.util.Set;

@Slf4j
public class DependencyInjector {

    //获取容器
    private BeanContainer beanContainer;

    public DependencyInjector() {
        beanContainer = BeanContainer.getInstance();
    }


    /**
     * 执行ioc依赖注入
     *
     */

    public void doIoc(){



        if ((beanContainer.getClasses() == null || "".equals(beanContainer.getClasses()))){
            log.warn("empty classet");
            return;
        }
        //1.遍历Bean容器中所有的Class对象
        for (Class<?> clazz :beanContainer.getClasses()){
            //2.遍历Class对象的所有成员变量
            // getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
            Field[] fields = clazz.getDeclaredFields();
            if (fields == null || "".equals(fields)){
                continue;
            }
            for (Field field :fields){

                //3.找出被Autowired标记的成员变量
                if (field.isAnnotationPresent(Autowired.class)){
                    
                    Autowired autowired = field.getAnnotation(Autowired.class);
                    String value = autowired.value();

                    //4.获取成员变量的类型
                    Class<?> aClass = field.getType();
                    //5.获取成员变量的类型在容器里面对饮的实例
                    Object fieldvalue = getFieldInstance(aClass,value);
                    if (fieldvalue == null){
                        throw new RuntimeException("运行autowired异常");
                    }else {

                        //6.通过反射将对应的成员变量实例注入到成员变量所在类的实例里
                        Object targetbean = beanContainer.getBean(clazz);
                        ClassUtil.setField(field,targetbean,fieldvalue,true);



                    }
                }
            }


        }

    }


    /**
     *获取成员变量获取的实例
     * @param aClass
     * @return
     */
    private Object getFieldInstance(Class<?> aClass,String value) {
        Object bean =beanContainer.getBean(aClass);
        //判断变量是否为空，为空是类，不为空是接口
        if (bean != null){
            //类直接返回
            return bean;
        }else {
            //接口获取实现类
           Class<?> impl = getImpl(aClass,value);
           if (impl != null){
               return beanContainer.getBean(impl);
           }else {
               return null;
           }

        }
    }

    /**
     * 获取接口实现类
     * @param bean
     * @return
     */
    private Class<?> getImpl(Class<?> bean,String value) {
         //调用实现接口子类
        Set<Class<?>> classBySuper = beanContainer.getClassBySuper(bean);
        //是否有这个实现子类
        if (!(classBySuper == null || "".equals(classBySuper))){
            //是否设置默认值输出实现类
        if ((classBySuper == null || "".equals(value))){
              //只有一个实现类
            if (classBySuper.size() == 1){
                //迭代输出
                return classBySuper.iterator().next();
            }else {
                //多个实现类，抛出异常让用户自己选择加out注解
                throw new RuntimeException("多个实现类"+bean.getName());
            }

        }else {
            for (Class<?> aClass : classBySuper){
               if (value.equals(aClass.getSimpleName())){

                   return aClass;
               }

            }
        }
        }
      return null;
    }



}

工具类创建属性

    /***
     * 设置类属性值
     * @param field 成员变量
     * @param target 类实例
     * @param value 成员变量的值
     * @param accessible 是否允许有私自属性
     */
    public static void setField(Field field, Object target, Object value, Boolean accessible)
    {
        field.setAccessible(accessible);
        try {
            //给target实例里面的field成员变量设置value的值
            field.set(target,value);
        }catch (IllegalAccessException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }

    }

}

使用

image-20210508164753665 image-20210508164719752

当有两类时就会报出有多个实现类的错误，需要指定实现

image-20210508165547968

beanPostProcessors使用

beanPostProcessors是什么？

bean的后置处理器，bean初始化之前干点什么，之后又干点什么，在不影响代码的情况下创建类似于插件的功能，aop的实现原理也是如此。

image-20210524161132828

创建一个现实类

image-20210524155211532

创建一个list集合存放处理器

image-20210524155446336

判断这个类是否实现了beanPostProcessors接口

image-20210524160752543

将list里面的beanPostProcessors遍历出来一一实现

image-20210524161919900

运行测试，再多加一个类也是如此，不改变代码加功能

image-20210531121301931
Aop的代理逻辑也是在beanPostProcessors实现

如果对你有帮助，请点关注吧~第一时间获取后续更新内容…

丁师兄
关注
专栏目录
Spring容器架构
juziding的博客
03-14 326
Spring容器家族 BeanFactory：Spring容器的基石，顶级容器接口 在Spring官方文档中，称org.springframework.context.ApplicationContext这个接口就代表了Spring的容器，在解释ApplicationContext之前，必须要先介绍Spring容器的基石，BeanFactory接口。ApplicationContext就是继承了BeanFactory接口的一种高级容器接口。而BeanFactory是简单容器的代表，是Spring容.
Spring核心容器IOC原理实例解析
08-25
Spring核心容器IOC原理实例解析 Spring核心容器是IOC容器的核心组件，负责管理Bean对象及其相互依赖关系。在Spring框架中，IOC容器是通过BeanFactory接口来定义的，这个接口提供了许多方法来管理Bean对象，例如获取...
Spring IoC容器结构
a327369238的专栏
08-11 6409
Spring IoC容器 IoC容器主要作用就是创建并管理Bean对象以及Bean属性注入。如何创建Bean对象？是通过读取Bean配置文件生成相应对象。这些配置文件格式可能多种多样，xml、properties等格式，所以需要将其转换（ResourceLoader/Resolver）成统一资源对象（Resource），存储的位置也不一样，可能是ClassPath，可能是FileSystem
Spring容器结构
weixin_48751562的博客
06-27 279
我们可以输出工程的真正运行路径就可以知道了由于 该Spring是重量级的（数据量很大），一般我们都是只会创建一个使用debug的方式可以看到，ioc容器中有个组件叫beanFactory，xml文件还有对象实例的信息都是放在这个组件里面beanFactory中有个组件叫beanDefinitionMap，他本质上是一个ConcurrentHashMap，用于存放xml文件中的bean信息，我们在xml文件中配置的对象信息都可以在这里看到，然后,每个bean对象在这个ConcurrentHashMap中都是以
【自研框架一】自研框架IoC容器及单例模式
qq_43430343的博客
01-18 696
自研框架IoC容器的使用 框架具备的最基本功能 ◆解析配置 ◆定位与注册对象， 定位就是标记（注解），定位到对象之后，需要将对象注册到容器中 ◆注入对象， 在用户需要时将对象精确的返回给用户 ◆提供通用的工具类， 方便用户和框架根据自身需求进行调用 IoC容器的实现 对象：泛指被标记的东西，通常指类。将类名以及类以键值对存入到容器当中。 存贮的并不是类实例本身，而是类得class对象，xml属性信息或者注解，将他们组成beanFactory存储在容器里。之后再决定是否在容器初始化的时候直接创建经过目
Spring5源码分析（一） IOC和Spring 核心容器体系结构
mokingone的专栏
05-17 9507
1.什么是 IOC/DI？   IOC(Inversion of Control)控制反转：所谓控制反转，就是把原先我们代码里面需要实现的对象创建、依赖的代码，反转给容器来帮忙实现。那么必然的我们需要创建一个容器，同时需要一种描述来让容器知道需要创建的对象与对象的关系。这个描述最具体表现就是我们可配置的文件。   DI(Dependency Injection)依赖注入：就是指对象是被动接受依...
Spring IOC深度解析：IOC容器的原理与高级特性详解
逆流的小鱼
05-26 2689
控制反转是一种设计原理，用于减少计算机代码之间的耦合度。在没有IOC的传统程序设计中，对象的创建以及它们之间的依赖关系通常是由开发者在代码内部显式地定义。而在使用IOC之后，这些工作被反转了：不再由对象自身控制依赖对象的创建和管理，而是交由外部容器来处理，对象只是声明它所需要的资源或依赖。// 传统方式创建对象及其依赖对象// 使用IOC容器后的对象声明方式// 依赖注入。
Spring Ioc原理及解析
小飞侠的博客
04-06 1218
Spring Ioc容器详解
Spring中的IOC详解
努力分享一些干货内容，纯干货，没有一点水
07-18 4100
单例Bean和多实例Bean的生命周期主要区别在于实例化和销毁的管理方式，单例Bean在容器启动时创建一个实例，并由容器负责管理其生命周期的完整过程。在Spring框架中，Bean是应用程序的核心组件，它们由Spring容器创建、组装和管理，以帮助开发者实现松耦合、可测试和可维护的代码。IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。Bean的自动装配是Spring框架提供的一种便捷的方式，用于自动解析和设置Bean之间的依赖关系，而无需显式配置每一个依赖关系的方式。
三、IOC容器原理
L_D_Y_K的博客
01-04 1330
三、IOC容器原理 1、概述 Sun ONE技术体系下的IOC容器有：轻量级的有Spring、Guice、Pico Container、Avalon、HiveMind；重量级的有EJB；不轻不重的有JBoss，Jdon等等。Spring框架作为Java开发中SSH(Struts、Spring、Hibernate)三剑客之一，大中小项目中都有使用，非常成熟，应用广泛，EJB在关键性的工业级项目中也被使用，比如某些电信业务。.Net技术体系下的IOC容器有：Spring.Net、Ca...
简单谈谈Spring Ioc原理解析
08-26
Spring容器在启动时解析配置文件，根据配置信息创建并初始化对象，然后在运行时根据对象的依赖关系，通过反射调用setter方法或构造器来注入依赖。例如，如果我们有一个`Animal`类需要依赖一个`Connection`对象，我们...
Spring创建IOC容器的方式解析
08-25
在Spring框架中，依赖注入（Dependency Injection，简称DI）是一种重要的设计模式，它通过控制反转（Inversion of Control，简称IOC）容器来实现。IOC容器是Spring的核心，它负责管理对象的生命周期和对象间的依赖...
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心...虽然这个简单的实现可能没有Spring框架那样全面和高效，但它可以帮助我们理解Spring IOC容器的工作原理，为进一步学习和研究Spring框架打下坚实的基础。
Spring IOC设计原理解析.docx
12-18
Spring IOC（Inversion of Control，控制反转）设计原理解析 一、什么是IOC/DI？ IOC，即控制反转，是软件设计模式中的一种，它将对象的创建和管理权交给了框架，而不是由对象自身负责。DI（Dependency Injection，...
在 Spring 中使用 @EhCache 注解作为缓存
龚小帅的博客
10-15 1377
Spring 有一个内置的 EhCache 缓存管理器。这适用于大多数缓存情况，但我发现定义自定义缓存管理器非常有用，因为它允许我使用相同的缓存管理器以编程方式或通过注释控制缓存。本文重点介绍 annotations，但让我们继续定义一个自定义缓存管理器，以便在需要时做好准备。如果您更喜欢坚持使用 默认缓存管理器 ，您可以跳过此步骤。我们将在 ：super();
【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter
wendao76的专栏
10-14 1372
首先，我们创建一个类，继承自@Override> clazz) {@Override// 假设MyObject的构造函数接受一个字符串@Override// 假设我们要将MyObject转换成字符串进行输出接下来，我们需要在Spring MVC的配置中注册我们的自定义转换器。如果你使用的是Java配置，可以像下面这样实现@Override// 如何自定义的转换器与默认转换器冲突，可以将自己的转换器放到默认转换器前面。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 910
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
车辆管理的SpringBoot技术革新
最新发布
2401_85760095的博客
10-18 836
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。B/S架构给使用管理系统的用户带来极大的便利。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。
快速构建SpringBoot项目
qq_38527427的博客
10-14 740
下文将简述如何快速构建一个SpringBoot项目，使用SpringData JPA实现持久层访问，集成lombok、swagger2及集成thymeleaf进行页面展示。
深度解析Spring IoC容器的内部结构
"对Spring IoC容器的结构进行深入分析，探讨其主要组件、接口和实现原理。" 在Spring框架中，IoC（Inversion of Control）容器是核心部分，负责管理对象的生命周期和依赖关系。Spring IoC容器通过反转控制权，使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值