【Spring专题】手写简易Spring容器过程分析

前置知识

《【Spring专题】Spring底层核心原理解析》

思路整理

我们在上一节《【Spring专题】Spring底层核心原理解析》课里面有简单分析过一个Spring容器的一般流程，所以，本节课我们这里尝试写一下简易的Spring容器。

手写源码示例

一、手写前的准备

1.1 注解

既然是需要手写Spring容器，那我们肯定需要自定义一个MyApplicationContext类，以及自定义注解@ComponentScan，@Component，@Autowired和@Scope代码如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {
    String value() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ComponentScan {
    String value() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Scope {
    String value() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Autowired {
}

其中@Scope是为了验证多例Bean跟单例Bean的。当然，需要准备的接口不止于此，后面我会随着方法的完善，逐渐引出其余需要的接口或者注解。

1.2 测试Bean

另外就是测试用的Bean，代码如下：

/**
 * @author zhangshen
 * @tag 【手写】
 * @Date 2023/8/7 19:57
 * @slogan 编码即学习
 **/
@Component("userService")
public class MyUserService implements InitializingBean, BeanPostProcessor {

    private int afterPropertiesSet = 0;
    private int postProcessBeforeInitialization = 0;
    private int postProcessAfterInitialization = 0;
    private static int count = 0;

    public void showYourFace() {
        System.out.println("手写的spring。。。。。 test一下");
        System.out.println("初始化是第几步，答案是：" + afterPropertiesSet);
        System.out.println("初始化前是第几步，答案是：" + postProcessBeforeInitialization);
        System.out.println("初始化后是第几步，答案是：" + postProcessAfterInitialization);
    }


    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("这里是初始化，是在aware回调之后");
        count++;
        afterPropertiesSet = count;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("这里是初始化前");
        count++;
        postProcessBeforeInitialization = count;
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("这里是初始化后");
        count++;
        postProcessAfterInitialization = count;
        return bean;
    }
}

1.3 调用实例

调用实例：

/**
 * 手写Spring容器测试
 *
 * @author zhangshen
 * @tag 【手写】
 * @Date 2023/8/7 19:55
 * @slogan 编码即学习
 **/
public class MyApplicationContextTest {

    public static void main(String[] args) {
        MyApplicationContext context = new MyApplicationContext(MyAppConfig.class);
        MyUserService userService = (MyUserService) context.getBean("userService");
        userService.showYourFace();
    }
}

二、构造方法（构建基本流程）

在上节课中，我们说过，在容器启动的构造方法里面，大致的流程可以分为三步：
在这里插入图片描述
所以，我们代码起手式，是新建一个MyApplicationContext类，然后一个默认的无参构造方法，代码如下：

public class MyApplicationContext {
    public MyApplicationContext(Class clazz) {
        
        // 步骤一：扫描
        scan(clazz);
        
        // 步骤二：IOC
        ioc();

        // 步骤三：AOP
        aop();
    }
}

但事实上，我们前面说过，虽然看似大过程是3步，不过AOP是需要发生在IOC内部的（Bean放入单例池之前），所以，后面，我们会把这个AOP的过程写在IOC里面，如下：

public class MyApplicationContext {
    public MyApplicationContext(Class clazz) {
        
        // 步骤一：扫描
        scan(clazz);
        
        // 步骤二：IOC
        ioc();
    }

    private void doIOC() {

        // 步骤三：AOP
        aop();
    }
}

三、实现scan()方法

先上扫描的简易流程图：
在这里插入图片描述
接下来，我们只需要在doScan()方法里面实现这些步骤就好了。

    /**
     * 扫描方法
     *
     * @param clazz 配置类
     */
    private void scan(Class clazz) {

        // 步骤一：获取扫描路径
        String basePackage = doGetScanPackage(clazz);
        if (StrUtil.isEmpty(basePackage)) {
            return;
        }

        // 步骤二、三：从电脑磁盘中加载文件，并且扫描
        doLoadClassFromDiskAndScan(basePackage, clazz);
    }

3.1 doGetScanPackage()：获取扫描路径

    /**
     * 获取包扫描路径
     *
     * @param clazz 配置类
     * @return 扫描路径
     */
    private String doGetScanPackage(Class clazz) {
        if (clazz.isAnnotationPresent(ComponentScan.class)) {
            ComponentScan componentScanAnnotation = (ComponentScan) clazz.getAnnotation(ComponentScan.class);
            return componentScanAnnotation.value();
        }

        return null;
    }

3.2 doLoadClassFromDiskAndScan()：从电脑磁盘中加载文件，并且扫描

    /**
     * 从磁盘中加载class，并且扫描
     *
     * @param basePackage 扫描路径
     */
    private void doLoadClassFromDiskAndScan(String basePackage) {

        // 将Java包名转换为电脑路径名
        basePackage = basePackage.replace(".", "/");

        // 加载
        ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(basePackage);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            for (File listFile : file.listFiles()) {

				// 获取全限定名
                String fullyQualifiedClassName = transferToFullyQualifiedClassName(listFile);

                try {
                    Class<?> beanClass = classLoader.loadClass(fullyQualifiedClassName);
                    if (!beanClass.isAnnotationPresent(Component.class)) {
                        continue;
                    }

                    // 记录Bean信息
                    doRecordBeanInfo(beanClass);

                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }

方法解读：

  1. 在上一步，我们已经获取到了扫描路径，但是扫描路径是我们Java包名，现在需要从磁盘重读取的话，定然是需要转换成电脑磁盘重的路径的。
  2. 大家可能对classLoader这一块比较难理解，这是属于JVM那一块的。不过这么说，我们自己写的业务代码，除非特别指定，不然都是使用的同一个类加载器
  3. 这里还有2个关键方法调用，一个是transferToFullyQualifiedClassName()，是将文件名转换为类加载器能识别的类全限定名；另一个是doRecordBeanInfo()方法，记录Bean定义信息的。代码会在后面

3.3 transferToFullyQualifiedClassName() ：获取全限定名

    /**
     * 将电脑磁盘上的文件，转换为AppClassLoader能识别的类全限定名（包 + 类名）
     *
     * <p>
     * 由于JVM的类加载器有三种，默认加载用户自定义class文件的，其实是ApplicationClassLoader
     * 该类加载器所能识别的，其实是包名
     * </p>
     *
     * @param listFile 电脑磁盘上的文件
     */
    private String transferToFullyQualifiedClassName(File listFile) {
        String absolutePath = listFile.getAbsolutePath();
        absolutePath = absolutePath.substring(absolutePath.indexOf("org"), absolutePath.indexOf(".class"));
        absolutePath = absolutePath.replace("\\", ".");
        return absolutePath;
    }

*3.4 doRecordBeanInfo() ：记录Bean信息

    /**
     * 过滤，并且记录Bean信息
     */
    private void doRecordBeanInfo(Class<?> beanClass) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        // 获取bean的名字
        String beanName = doGetBeanName(beanClass);

		// 记录BeanPostProcessor
        if (BeanPostProcessor.class.isAssignableFrom(beanClass)) {
            BeanPostProcessor instance = (BeanPostProcessor) beanClass.getConstructor().newInstance();
            beanPostProcessorList.add(instance);
        }

        BeanDefinition beanDefinition = new BeanDefinition();
        beanDefinition.setType(beanClass);
        if (beanClass.isAnnotationPresent(Scope.class)) {
            Scope scopeAnnotation = beanClass.getAnnotation(Scope.class);
            String value = scopeAnnotation.value();
            beanDefinition.setScope(value);
        }

        // 记录BeanDefinition
        beanDefinitionMap.put(beanName, beanDefinition);
    }

这里，引入了一个新的类BeanDefinition类，源码如下：

/**
 * 手写Bean定义
 *
 * @author zhanghuitong
 * @tag 【手写】 【Bean定义】 【图纸】
 * @Date 2023/8/8 10:54
 * @slogan 编码即学习
 **/
@Getter
@Setter
public class BeanDefinition {

    private static final String SINGLETON = "singleton";

    /**
     * Bean类型
     */
    private Class type;

    /**
     * 作用域
     * 是原型，还是单例
     */
    private String scope = SINGLETON;
}

也许大家会很奇怪，为什么需要引入这么一个东西呢？我都已经扫描好了，我直接根据类信息生成不就行了吗？如果你也有这个想法，那么我反问你一个问题：如果我后面想修改怎么办？还别说，真的有可能修改！Spring提供了那么多拓展机制，其中就有对类信息修改的拓展点（至于具体应用场景，我还没彻底学清楚，我后面学到了我会回来更新的）。但是为了方便大家理解这个玩意的存在，我举个通俗的例子，如下：

BeanDefinition的存在更像是一份家具定制的图纸，Bean是具体的某个家具。而Spring里面，在后面我们会学到的ApplicationContext，则是生产家具的厂家。这样类比的话，你应该能想明白，为什么需要BeanDefinition了吧。
总结一句话：ApplicationContext厂家根据BeanDefinition图纸生成具体的某个家具Bean。（PS：ApplicationContext 包含 BeanFactory，都是Bean工厂）

四、实现ioc()方法

先看看ioc简易流程图：
在这里插入图片描述
（PS：下面的手写源码，没有实现【推断构造方法】的逻辑）

    /**
     * 进行IOC过程
     */
    private void ioc() {

        // 循环遍历beanDefinitionMap
        Set<Map.Entry<String, BeanDefinition>> entries = beanDefinitionMap.entrySet();
        for (Map.Entry<String, BeanDefinition> entry : entries) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();
            if (beanDefinition.getScope().equals(BeanDefinition.SINGLETON)) {

                // 创建Bean
                Object bean = createBean(beanName, beanDefinition);

                // AOP
                aop();
                
                singletonPool.put(beanName, bean);
            }
        }
    }

方法解读：

  1. 在这里，就是遍历我们上一步获得的beanDefinitionMap图纸Map。
  2. 接着就开始根据图纸生成Bean了（createBean()方法）
  3. 接着看看是否需要AOP了（在放入单例池之前）
  4. 最后就是放入单例池里面了

*4.1 createBean() ：创建Bean

    /**
     * 创建bean
     *
     * @param beanName       bean名称
     * @param beanDefinition 对应的bean定义
     */
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        Class clazz = beanDefinition.getType();
        Object instance = null;
        try {

            // 实例化。本应该实现推断构造方法，但是这里从简使用默认的
            instance = clazz.getConstructor().newInstance();

            // 依赖注入
            doDependecyInjection(clazz, instance);

            // 各种Aware回调
            doAwareCallBack(beanName, instance);

            // 初始化前
            instance = doInitBefore(beanName, instance);

            // 初始化
            doInit(instance);

            // 初始化后
            instance = doInitAfter(beanName, instance);

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 返回
        return instance;
    }

方法解读：
虽然上面的代码是简单的实现，但也稍微能窥见一点IOC的生命周期了，大家需要好好记住。

实例化 -> 依赖注入 -> 各种Aware回调 -> 初始化前 -> 初始化 -> 初始化后

因为是简单实现，所以上面这个流程不全，应该是缺了点其他拓展点的实现的。但是局部上的顺序是没啥问题，而且这不是我吹的，而是在Spirng接口上注释的。

4.2 doDependecyInjection() ：依赖注入

    /**
     * 依赖注入
     *
     * @param clazz    需要被注入的对象的类信息
     * @param instance 需要被注入的对象
     */
    private void doDependecyInjection(Class clazz, Object instance) throws IllegalAccessException {
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.isAnnotationPresent(Autowired.class)) {
                declaredField.setAccessible(true);
                declaredField.set(instance, getBean(declaredField.getName()));
            }
        }
    }

4.3 doAwareCallBack() ：各种Aware回调

    /**
     * 实现各种Aware的回调处理
     *
     * @param beanName bean名称
     * @param instance bean对象
     */
    private void doAwareCallBack(String beanName, Object instance) {
        if (instance instanceof BeanNameAware) {
            ((BeanNameAware) instance).setBeanName(beanName);
        }
    }

方法解读：
在这里，引入了一个新的接口BeanNameAware，它实现自Aware接口。其实除了这个我们用来展示的BeanNameAware还有很多其他的XxxAware，主要的目的是在实例化之后，让我们获得感知一些Spring组件等等能力。下面是BeanNameAware接口的代码示例（其中注释源于Spring源码）：

/**
 * 手写Spring的BeanNameAware接口
 *
 * @author zhangshen
 * @tag 【手写】
 * @Date 2023/8/8 19:04
 * @slogan 编码即学习
 **/
public interface BeanNameAware {

    /**
     * 在创建该bean的bean工厂中设置该bean的名称。
     * 在填充普通bean属性之后，但在初始化回调(如InitializingBean.afterPropertiesSet())或自定义初始化方法之前调用。
     * 参数:
     * 名称-工厂中bean的名称。请注意，这个名称是工厂中使用的实际bean名称，它可能与最初指定的名称不同:特别是对于内部bean名称，实际bean名称可能通过附加“#…”后缀来使其唯一。如果需要，使用BeanFactoryUtils.originalBeanName(String)方法提取原始bean名称(不带后缀)。
     */
    void setBeanName(String name);
}

4.4 doInitBefore() ：初始化前

    /**
     * 实施初始化之前
     *
     * @param beanName bean名称
     * @param instance bean对象
     */
    private Object doInitBefore(String beanName, Object instance) {
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
            instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
        }
        return instance;
    }

方法解读：

  1. 初始化前这是属于SpringIOC提供的一个拓展点，需要一个非常非常非常重要的接口，BeanPostProcessor ，它的定义如下：（其中注释源于Spring源码）
/**
 * 手写Spring的ABeanPostProcessor接口
 *
 * @author zhangshen
 * @tag 【手写】
 * @Date 2023/8/8 19:04
 * @slogan 编码即学习
 **/
public interface BeanPostProcessor {

    /**
     * 在任何bean初始化回调(如InitializingBean的afterPropertiesSet或自定义初始化方法)之前，将此BeanPostProcessor应用于给定的新bean实例。这个bean已经被属性值填充了。返回的bean实例可能是原始bean实例的包装器。
     * 默认实现按原样返回给定的bean。
     * 参数:
     * Bean——新的Bean实例
     * beanName—bean的名称
     * 返回:
     * 要使用的bean实例，无论是原始的还是包装的;如果为空，则不会调用后续的BeanPostProcessors
     * 抛出:
     * BeansException -在错误的情况下
     */
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    /**
     * 在任何bean初始化回调(如InitializingBean的afterPropertiesSet或自定义init-method)之后，将此BeanPostProcessor应用于给定的新bean实例。这个bean已经被属性值填充了。返回的bean实例可能是原始bean实例的包装器。
     * 对于FactoryBean，将为FactoryBean实例和由FactoryBean创建的对象调用这个回调(从Spring 2.0开始)。后处理器可以通过相应的FactoryBean instanceof检查来决定是应用于FactoryBean还是已创建的对象，或者两者都应用。
     * 这个回调也将在由InstantiationAwareBeanPostProcessor触发的短路之后被调用。postProcessBeforeInstantiation方法，与所有其他BeanPostProcessor回调相反。
     * 默认实现按原样返回给定的bean。
     * 参数:
     * Bean——新的Bean实例
     * beanName—bean的名称
     * 返回:
     * 要使用的bean实例，无论是原始的还是包装的;如果为空，则不会调用后续的BeanPostProcessors
     * 抛出:
     * BeansException -在错误的情况下
     * 参见:
     * org.springframework.beans.factory.InitializingBean。afterPropertiesSet, org.springframework.beans.factory.FactoryBean
     * 以上翻译结果来自有道神经网络翻译（YNMT）· 通用场景
     */
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

从上面的注释希望大家在后面真的阅读源码的时候能知道，BeanPostProcessor这个拓展点就是作用在初始化前后的

4.5 doInit() ：初始化

    /**
     * 实施初始化方法
     *
     * @param instance bean对象
     */
    private void doInit(Object instance) throws Exception {
        if (instance instanceof InitializingBean) {
            ((InitializingBean) instance).afterPropertiesSet();
        }
    }

方法解读：

  1. 初始化方法，在这里又是需要一个新的接口，InitializingBean，在工作使用频率挺高的。当然也可以通过自定义初始化方法，不一定就是这个。接口代码如下：（其中注释源于Spring源码）
/**
 * 手写Spring的ABeanPostProcessor接口
 *
 * @author zhangshen
 * @tag 【手写】
 * @Date 2023/8/8 19:04
 * @slogan 编码即学习
 **/
public interface InitializingBean {

    /**
     * 在设置了所有bean属性并满足BeanFactoryAware、ApplicationContextAware等要求后，由包含bean的BeanFactory调用。
     * 此方法允许bean实例在设置了所有bean属性后对其总体配置和最终初始化执行验证。
     * 抛出:
     * 异常-在配置错误的情况下(例如设置基本属性失败)，或者由于任何其他原因导致初始化失败
     */
    void afterPropertiesSet() throws Exception;
}

4.6 doInitAfter() ：初始化后

    /**
     * 实施初始化之后
     *
     * @param beanName bean名称
     * @param instance bean对象
     */
    private Object doInitAfter(String beanName, Object instance) {
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
            instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
        }
        return instance;
    }

方法解读：

  1. 初始化后，跟初始化前一样，是属于SpringIOC提供的一个拓展点。并且使用的也是BeanPostProcessor接口

五、实现aop()方法

这个就不实现了，大家知道有这个东西就好

六、MyApplicationContext完整源码

package org.tuling.spring.handwriten;


import cn.hutool.core.util.StrUtil;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import java.beans.Introspector;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.*;

/**
 * 手写一个简易的Spring容器
 *
 * @author zhangshen
 * @tag 【Spring】 【手写】
 * @Date 2023/8/7 19:37
 * @slogan 编码即学习
 **/
public class MyApplicationContext {
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
    private Map<String, Object> singletonPool = new HashMap<>();
    private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

    public MyApplicationContext(Class clazz) {

        // 扫描
        scan(clazz);

        // IOC
        ioc();
    }

    /**
     * 进行IOC过程
     */
    private void ioc() {

        // 循环遍历beanDefinitionMap
        Set<Map.Entry<String, BeanDefinition>> entries = beanDefinitionMap.entrySet();
        for (Map.Entry<String, BeanDefinition> entry : entries) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();
            if (beanDefinition.getScope().equals(BeanDefinition.SINGLETON)) {

                // 创建Bean
                Object bean = createBean(beanName, beanDefinition);

                // AOP
                aop();

                singletonPool.put(beanName, bean);
            }
        }
    }

    /**
     * 创建bean
     *
     * @param beanName       bean名称
     * @param beanDefinition 对应的bean定义
     */
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        Class clazz = beanDefinition.getType();
        Object instance = null;
        try {

            // 实例化。本应该实现推断构造方法，但是这里从简使用默认的
            instance = clazz.getConstructor().newInstance();

            // 依赖注入
            doDependecyInjection(clazz, instance);

            // 各种Aware回调
            doAwareCallBack(beanName, instance);

            // 初始化前
            instance = doInitBefore(beanName, instance);

            // 初始化
            doInit(instance);

            // 初始化后
            instance = doInitAfter(beanName, instance);

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 返回
        return instance;
    }

    /**
     * 实施初始化之后
     *
     * @param beanName bean名称
     * @param instance bean对象
     */
    private Object doInitAfter(String beanName, Object instance) {
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
            instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
        }
        return instance;
    }

    /**
     * 实施初始化方法
     *
     * @param instance bean对象
     */
    private void doInit(Object instance) throws Exception {
        if (instance instanceof InitializingBean) {
            ((InitializingBean) instance).afterPropertiesSet();
        }
    }

    /**
     * 实施初始化之前
     *
     * @param beanName bean名称
     * @param instance bean对象
     */
    private Object doInitBefore(String beanName, Object instance) {
        for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
            instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
        }
        return instance;
    }

    /**
     * 实现各种Aware的回调处理
     *
     * @param beanName bean名称
     * @param instance bean对象
     */
    private void doAwareCallBack(String beanName, Object instance) {
        if (instance instanceof BeanNameAware) {
            ((BeanNameAware) instance).setBeanName(beanName);
        }
    }

    /**
     * 依赖注入
     *
     * @param clazz    需要被注入的对象的类信息
     * @param instance 需要被注入的对象
     */
    private void doDependecyInjection(Class clazz, Object instance) throws IllegalAccessException {
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (declaredField.isAnnotationPresent(Autowired.class)) {
                declaredField.setAccessible(true);
                declaredField.set(instance, getBean(declaredField.getName()));
            }
        }
    }


    /**
     * 进行AOP过程
     */
    private void aop() {

    }

    /**
     * 根据beanName获取Bean
     *
     * @param beanName bean名称
     * @return bean对象
     */
    public Object getBean(String beanName) {
        if (StrUtil.isEmpty(beanName)) {
            return null;
        }

        // 不存在beanDefinition，则肯定不是bean
        if (!beanDefinitionMap.containsKey(beanName)) {
            throw new NoSuchBeanDefinitionException("没有对应的bean定义");
        }

        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);

        // 创建对象
        if (beanDefinition.getScope().equals(BeanDefinition.SINGLETON)) {

            // 获取单例
            Object singletonBean = singletonPool.get(beanName);
            if (singletonBean == null) {
                singletonBean = createBean(beanName, beanDefinition);
                singletonPool.put(beanName, singletonBean);
            }
            return singletonBean;
        } else {

            // 获取多例
            Object prototype = createBean(beanName, beanDefinition);
            return prototype;
        }
    }

    /**
     * 扫描方法
     *
     * @param clazz 配置类
     */
    private void scan(Class clazz) {

        // 获取扫描路径
        String basePackage = doGetScanPackage(clazz);
        if (StrUtil.isEmpty(basePackage)) {
            return;
        }

        // 从电脑磁盘中加载文件，并且扫描
        doLoadClassFromDiskAndScan(basePackage);
    }

    /**
     * 从磁盘中加载class，并且扫描
     *
     * @param basePackage 扫描路径
     */
    private void doLoadClassFromDiskAndScan(String basePackage) {

        // 将Java包名转换为电脑路径名
        basePackage = basePackage.replace(".", "/");

        // 加载
        ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
        URL resource = classLoader.getResource(basePackage);
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            for (File listFile : file.listFiles()) {

                // 获取全限定名
                String fullyQualifiedClassName = transferToFullyQualifiedClassName(listFile);

                try {
                    Class<?> beanClass = classLoader.loadClass(fullyQualifiedClassName);
                    if (!beanClass.isAnnotationPresent(Component.class)) {
                        continue;
                    }

                    // 记录Bean信息
                    try {
                        doRecordBeanInfo(beanClass);
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }

                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 过滤，并且记录Bean信息
     */
    private void doRecordBeanInfo(Class<?> beanClass) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        // 获取bean的名字
        String beanName = doGetBeanName(beanClass);

        // 记录BeanPostProcessor
        if (BeanPostProcessor.class.isAssignableFrom(beanClass)) {
            BeanPostProcessor instance = (BeanPostProcessor) beanClass.getConstructor().newInstance();
            beanPostProcessorList.add(instance);
        }

        BeanDefinition beanDefinition = new BeanDefinition();
        beanDefinition.setType(beanClass);
        if (beanClass.isAnnotationPresent(Scope.class)) {
            Scope scopeAnnotation = beanClass.getAnnotation(Scope.class);
            String value = scopeAnnotation.value();
            beanDefinition.setScope(value);
        }

        // 记录BeanDefinition
        beanDefinitionMap.put(beanName, beanDefinition);
    }

    /**
     * 获取当前Bean的名字
     *
     * @param aClass 要加载的类
     * @return bean的名字
     */
    private String doGetBeanName(Class<?> aClass) {
        Component componentAnnotaion = aClass.getAnnotation(Component.class);
        String beanName = componentAnnotaion.value();
        if (StrUtil.isEmpty(beanName)) {
            beanName = Introspector.decapitalize(aClass.getSimpleName());
        }

        return beanName;
    }

    /**
     * 将电脑磁盘上的文件，转换为AppClassLoader能识别的类全限定名（包 + 类名）
     *
     * <p>
     * 由于JVM的类加载器有三种，默认加载用户自定义class文件的，其实是ApplicationClassLoader
     * 该类加载器所能识别的，其实是包名
     * </p>
     *
     * @param listFile 电脑磁盘上的文件
     */
    private String transferToFullyQualifiedClassName(File listFile) {
        String absolutePath = listFile.getAbsolutePath();
        absolutePath = absolutePath.substring(absolutePath.indexOf("org"), absolutePath.indexOf(".class"));
        absolutePath = absolutePath.replace("\\", ".");
        return absolutePath;
    }

    /**
     * 获取包扫描路径
     *
     * @param clazz 配置类
     * @return 扫描路径
     */
    private String doGetScanPackage(Class clazz) {
        if (clazz.isAnnotationPresent(ComponentScan.class)) {
            ComponentScan componentScanAnnotation = (ComponentScan) clazz.getAnnotation(ComponentScan.class);
            return componentScanAnnotation.value();
        }

        return null;
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/65840.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Sentinel整合Spring Cloud Gateway、Zuul详解

Sentinel整合Spring Cloud Gateway、Zuul详解

Sentinel 支持对 Spring Cloud Gateway、Zuul 等主流的 API Gateway 进行限流。 Sentinel 1.6.0 引入了 Sentinel API Gateway Adapter Common 模块&#xff0c;此模块中包含网关限流的规则和自定义 API 的实体和管理逻辑&#xff1a; GatewayFlowRule&#xff1a;网关限流规则…
阅读更多...
04-8_Qt 5.9 C++开发指南_QTableWidget的使用

04-8_Qt 5.9 C++开发指南_QTableWidget的使用

文章目录 1. QTableWidget概述2. 源码2.1 可视化UI设计2.2 程序框架2.3 qwintspindelegate.h2.4 qwintspindelegate.cpp2.5 mainwindow.h2.6 mainwindow.cpp 1. QTableWidget概述 QTableWidget是Qt中的表格组件类。在窗体上放置一个QTableWidget 组件后,可以在 PropertyEditor…
阅读更多...
ELK 企业级日志分析系统（二）

ELK 企业级日志分析系统（二）

目录 ELK Kiabana 部署&#xff08;在 Node1 节点上操作&#xff09; 1&#xff0e;安装 Kiabana 2&#xff0e;设置 Kibana 的主配置文件 3&#xff0e;启动 Kibana 服务 4&#xff0e;验证 Kibana 5&#xff0e;将 Apache 服务器的日志&#xff08;访问的、错误的&#x…
阅读更多...
明年，HarmonyOS不再兼容Android应用！

明年，HarmonyOS不再兼容Android应用！

2023年华为开发者大会&#xff0c;不知道各位老铁们是否观看了&#xff0c;一个震撼的消息就是&#xff0c;首次公开了HarmonyOS NEXT的概念&#xff0c;简而言之就是&#xff0c;这是一款专为开发者打造的预览版操作系统&#xff0c;旨在提供"纯正鸿蒙操作系统"的体…
阅读更多...
throw和throws的区别

throw和throws的区别

在Java中&#xff0c;throw和throws是两个关键字&#xff0c;用于异常处理。它们具有以下区别&#xff1a; 1. throw关键字&#xff1a; - throw关键字用于主动抛出异常。当程序执行到throw语句时&#xff0c;会创建一个异常对象并将其抛出。 - throw语句通常在方法内部…
阅读更多...
把大模型装进手机，分几步？

把大模型装进手机，分几步？

点击关注 文 | 姚 悦 编 | 王一粟 大模型“跑”进手机&#xff0c;AI的战火已经从“云端”烧至“移动终端”。 “进入AI时代&#xff0c;华为盘古大模型将会来助力鸿蒙生态。”8月4日&#xff0c;华为常务董事、终端BG CEO、智能汽车解决方案BU CEO 余承东介绍&#xff0c…
阅读更多...
Drools用户手册翻译——第四章 Drools规则引擎（十三）复杂事件处理（CEP）会话时钟，事件流和切入点

Drools用户手册翻译——第四章 Drools规则引擎（十三）复杂事件处理（CEP）会话时钟，事件流和切入点

甩锅声明&#xff1a;本人英语一般&#xff0c;翻译只是为了做个笔记&#xff0c;所以有翻译错误的地方&#xff0c;错就错了&#xff0c;如果你想给我纠正&#xff0c;就给我留言&#xff0c;我会改过来&#xff0c;如果懒得理我&#xff0c;就直接划过即可。 目录 会话时钟…
阅读更多...
【Paper Reading】DETR：End-to-End Object Detection with Transformers

【Paper Reading】DETR：End-to-End Object Detection with Transformers

背景 Transformer已经在NLP领域大展拳脚&#xff0c;逐步替代了LSTM/GRU等相关的Recurrent Neural Networks&#xff0c;相比于传统的RNN&#xff0c;Transformer主要具有以下几点优势 可解决长时序依赖问题&#xff0c;因为Transformer在计算attention的时候是在全局维度进行…
阅读更多...
《论文阅读》通过生成会话模型的迁移学习会话中的情感识别

《论文阅读》通过生成会话模型的迁移学习会话中的情感识别

《论文阅读》通过生成会话模型的迁移学习会话中的情感识别 前言简介模型结构Source TaskTarget Task损失函数前言 你是否也对于理解论文存在困惑？ 你是否也像我之前搜索论文解读，得到只是中文翻译的解读后感到失望？ 小白如何从零读懂论文？和我一起来探索吧！ 今天为大家…
阅读更多...
LangChain源码逐行解密之LLMs(二)

LangChain源码逐行解密之LLMs(二)

LangChain源码逐行解密之LLMs(二) 18.3 base.py源码逐行剖析 现在我们要聚焦于源代码中的大语言模型部分。如图18-3所示，LangChain提供了许多语言模型的选择。 Gavin大咖微信：NLP_Matrix_Space 图18- 3 LangChain的llms目录 如图18-4所示，整个LangChain的模块化设计非常出…
阅读更多...
JAVA集合框架 一:Collection（LIst，Set）和Iterator（迭代器）

JAVA集合框架 一:Collection（LIst，Set）和Iterator（迭代器）

目录 一、Java 集合框架体系 1.Collection接口&#xff1a;用于存储一个一个的数据&#xff0c;也称单列数据集合&#xff08;single&#xff09;。 2.Map接口&#xff1a;用于存储具有映射关系“key-value对”的集合&#xff08;couple&#xff09; 3.Iterator接口&#…
阅读更多...
ME41询价单创建BAPI

ME41询价单创建BAPI

关于ME41创建询价单系统并没有准备标准的BAPI&#xff0c;这一点在note:2115337中有说明。 但是通过查阅相关资料找到一个BAPI&#xff1a;BS01_MM_QUOTATION_CREATE&#xff0c;可以为ME41进行创建&#xff0c;但是如果不做一些增强&#xff0c;会有一些额外的错误&#xff0…
阅读更多...
Vue 整合 Element UI 、路由嵌套、参数传递、重定向、404和路由钩子（五）

Vue 整合 Element UI 、路由嵌套、参数传递、重定向、404和路由钩子（五）

一、整合 Element UI 1.1 工程初始化 使用管理员的模式进入 cmd 的命令行模式&#xff0c;创建一个名为 hello-vue 的工程&#xff0c;命令为&#xff1a; # 1、目录切换 cd F:\idea_home\vue# 2、项目的初始化&#xff0c;记得一路的 no vue init webpack hello-vue 1.2 安装…
阅读更多...
【代码】表格封装 + 高级查询 + 搜索 +分页器 （极简）

【代码】表格封装 + 高级查询 + 搜索 +分页器 （极简）

一、标题 查询条件按钮&#xff08;Header&#xff09; <!-- Header 标题搜索栏 --> <template><div><div class"header"><div class"h-left"><div class"title"><div class"desc-test">…
阅读更多...
Flutter系列文章-实战项目

Flutter系列文章-实战项目

在本篇文章中&#xff0c;我们将通过一个实际的 Flutter 应用来综合运用最近学到的知识&#xff0c;包括保存到数据库、进行 HTTP 请求等。我们将开发一个简单的天气应用&#xff0c;可以根据用户输入的城市名获取该城市的天气信息&#xff0c;并将用户查询的城市列表保存到本地…
阅读更多...
语音同声翻译软件到底谁更胜一筹呢

语音同声翻译软件到底谁更胜一筹呢

嘿&#xff01;你是否曾经遇到过需要在不同语言之间进行实时翻译的情况&#xff1f;别担心&#xff0c;现在有许多翻译软件可供选择&#xff0c;让你的沟通变得更加简便和愉快。无论你是旅行者、国际商务人士还是语言爱好者&#xff0c;这些软件都将成为你的得力助手&#xff0…
阅读更多...
领航优配：暑期旅游市场热度持续攀升，相关公司业绩有望持续释放

领航优配：暑期旅游市场热度持续攀升，相关公司业绩有望持续释放

到发稿&#xff0c;海看股份涨停&#xff0c;中广天择、探路者、众信旅行等涨幅居前。 8月8日&#xff0c;在线旅行板块震动上涨&#xff0c;到发稿&#xff0c;海看股份涨停&#xff0c;中广天择、探路者、众信旅行等涨幅居前。 今年以来&#xff0c;国内旅行商场逐渐恢复。文…
阅读更多...
arcgis--数据库构建网络数据集

arcgis--数据库构建网络数据集

1、打开arcmap软件&#xff0c;导入数据&#xff0c;如下&#xff1a; 该数据已经过处理&#xff0c;各交点处均被打断&#xff0c;并进行了拓扑检查。 2、在文件夹下新建文件数据库&#xff0c;名称为路网&#xff0c;在数据库下新建要素类&#xff0c;并导入道路shp文件&…
阅读更多...
网络编程的使用

网络编程的使用

文章目录 基础代码URL类进行传输编码解码 协议TCPUDPhttp PORT端口协议的实现TCPUDP 模拟服务器 基础代码 最后一个是&#xff1a;只要再timeout时间内连接上就是true URL类 导了一个common-iojar包&#xff0c;那个IOUtils就是那个里面的工具类 进行传输编码解码 协议 TC…
阅读更多...
应用在室外LED电子显示屏中的MiniLED背光

应用在室外LED电子显示屏中的MiniLED背光

LED电子显示屏是一种通过控制半导体发光二极管的显示方式&#xff0c;是由几万–几十万个半导体发光二极管像素点均匀排列组成。它利用不同的材料可以制造不同色彩的LED像素点&#xff0c;以显示文字、图形、图像、动画、行情、视频、录像信号等各种信息的显示屏幕。 LED显示屏…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站