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

news2024/10/5 14:22:51

前置知识

《【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.coloradmin.cn/o/849250.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FirmAE 模拟固件

FirmAE 模拟固件

一、介绍 FirmAE目标是创造一个可以供用户动态调试分析的环境&#xff0c;而不是复现和硬件一模一样的环境,&#xff0c;其卖点是大规模(Large-Scale)。 论文开头就直指“友商”Firmadyne&#xff0c;提出其模拟成功率低等问题&#xff0c; 其将原本Firmadyne的成功率16.28%提高…
阅读更多...
Navicat 导出excel表数据结构

Navicat 导出excel表数据结构

效果展示&#xff1a; 实现过程&#xff1a; 1 打开Navicat 执行以下SQL&#xff0c;注意&#xff1a;将以下SQL中的数据库名称和表名称替换。 SELECT COLUMN_NAME 列名, COLUMN_TYPE 数据类型, DATA_TYPE 字段类型, CHARACTER_MAXIMUM_LENGTH 长度, IS_NULLABLE 是否为空, C…
阅读更多...
代码随想录算法学习心得 50 | 739.每日温度、496.下一个更大元素I...

代码随想录算法学习心得 50 | 739.每日温度、496.下一个更大元素I...

一、每日温度 链接&#xff1a;力扣 描述如下&#xff1a;给定一个整数数组 temperatures &#xff0c;表示每天的温度&#xff0c;返回一个数组 answer &#xff0c;其中 answer[i] 是指对于第 i 天&#xff0c;下一个更高温度出现在几天后。如果气温在这之后都不会升高&…
阅读更多...
pytest自动化测试框架之标记用例(指定执行、跳过用例、预期失败)

pytest自动化测试框架之标记用例(指定执行、跳过用例、预期失败)

pytest中提供的mark模块&#xff0c;可以实现很多功能&#xff0c;如&#xff1a; 标记用例&#xff0c;即打标签skip、skipif标记跳过&#xff0c;skip跳过当前用例&#xff0c;skipif符合情况则跳过当前用例xfail标记为预期失败 标记用例 有时候我们可能并不需要执行项目中…
阅读更多...
HTTP协议——应用层

HTTP协议——应用层

HTTP协议 只要保证, 一端发送时构造的数据, 在另一端能够正确的进行解析, 就是ok的. 这种约定, 就是 应用层协议 HTTP简介 HTTP&#xff08;Hyper Text Transfer Protocol&#xff09;协议又叫做超文本传输协议&#xff0c;是一个简单的请求-响应协议&#xff0c;HTTP通常运行…
阅读更多...
Spring-1-深入理解Spring XML中的依赖注入(DI)：简化Java应用程序开发

Spring-1-深入理解Spring XML中的依赖注入(DI)：简化Java应用程序开发

学习目标 前两篇文章我们介绍了什么是Spring,以及Spring的一些核心概念&#xff0c;并且快速快发一个Spring项目&#xff0c;以及详细讲解IOC&#xff0c;今天详细介绍一些DI(依赖注入) 能够配置setter方式注入属性值 能够配置构造方式注入属性值 能够理解什么是自动装配 一、…
阅读更多...
lwip不同的socket分别作为监听和客户端连接

lwip不同的socket分别作为监听和客户端连接

在LWIP中&#xff0c;一个网络设备&#xff08;如以太网卡&#xff09;可以创建多个socket&#xff0c;用于处理不同的网络连接。一般&#xff0c;你可以创建一个socket用于监听&#xff08;listen&#xff09;连接&#xff0c;另一个socket用于主动发起&#xff08;connect&am…
阅读更多...
本地化部署自建类ChatGPT服务远程访问

本地化部署自建类ChatGPT服务远程访问

本地化部署自建类ChatGPT服务远程访问 文章目录 本地化部署自建类ChatGPT服务远程访问前言系统环境1. 安装Text generation web UI2.安装依赖3. 安装语言模型4. 启动5. 安装cpolar 内网穿透6. 创建公网地址7. 公网访问8. 固定公网地址 &#x1f340;小结&#x1f340; 前言 Te…
阅读更多...
【ARM64 常见汇编指令学习 15 -- ARM 标志位的学习】

【ARM64 常见汇编指令学习 15 -- ARM 标志位的学习】

文章目录 ARM 标志位介绍Zero Condition flag(零标志位)零标志位判断实例 上篇文章&#xff1a;ARM64 常见汇编指令学习 14 – ARM 汇编 .balign,.balignw,.balign 伪指令学习 下篇文章&#xff1a;ARM64 常见汇编指令学习 16 – ARM64 SMC 指令 ARM 标志位介绍 在ARM架构中&am…
阅读更多...
医学图像处理

医学图像处理

医学图像处理 opencv批量分片高像素图像病理图像数据增强提升样本多样性基于 imgaug、skimage 实现色彩增强 降低样本多样性基于 DCGAN、TransposeConv 完成染色标准化 精细化提取特征自动生成数据标注 分类场景下的医学图像分析分割场景下的医学图像分析检测场景下的医学图像分…
阅读更多...
揭秘Word高级技巧：事半功倍的文字处理策略

揭秘Word高级技巧：事半功倍的文字处理策略

Microsoft Word是一款广泛使用的文字处理软件&#xff0c;几乎每个人都有使用过它的经历。但是&#xff0c;你是否知道Word中隐藏着许多高级技巧和功能&#xff0c;可以帮助你事半功倍地处理文字&#xff1f;在本文中&#xff0c;我们将揭秘一些Word的高级技巧&#xff0c;让你…
阅读更多...
[] Adobe XD免费版功能一览,设计师们速来免费使用!

[] Adobe XD免费版功能一览,设计师们速来免费使用!

Adobe XD 作为一款流行的原型设计工具&#xff0c;免费使用对许多设计师来说是非常重要的。但现在 Adobe XD 的免费版体验已经不是那么舒适了。别担心&#xff0c;本文将为你推荐真正免费好用的 Adobe XD 替代工具。 Adobe XD 是免费的吗&#xff1f; Adobe XD 在早期确实是完…
阅读更多...
Licheepi Nano屏幕驱动并输出打印信息

Licheepi Nano屏幕驱动并输出打印信息

Licheepi Nano买回来好长时间&#xff0c;没咋玩&#xff0c;最近看了一个利用F1C100S自制迷你电脑的博客&#xff0c;里面主要参考的就是Licheepi Nano。我打算先在Licheepi Nano上完成屏幕操作、Debian文件系统和USB键盘等内容&#xff0c;这里介绍怎样利用Licheepi Nano外接…
阅读更多...
Java进阶（1）——JVM的内存分配 反射Class类的类对象 创建对象的几种方式 类加载（何时进入内存JVM） 注解 反射+注解的案例

Java进阶（1）——JVM的内存分配 反射Class类的类对象 创建对象的几种方式 类加载（何时进入内存JVM） 注解 反射+注解的案例

目录 引出java内存分配java内存分布概略图堆方法区常量池 创建对象内存分配 反射class文件的底层类加载顺序1.检查2.开辟静态资源空间3.常量池4.其他...5.创建一个唯一的类的对象获取Class对象的几种方式 创建对象几种方式new 看到new : new Book()反射 Class.forName(“包名.类…
阅读更多...
断路器回路电阻试验

断路器回路电阻试验

试验目的 断路器回路电阻主要取决于断路器动、 静触头的接触电阻, 其大小直接影响正常 运行时的发热情况及切断短路电流的性能, 是反应安装检修质量的重要数据。 试验设备 回路电阻测试仪 厂家&#xff1a; 湖北众拓高试代销 试验接线 对于单断口的断路器, 通过断口两端的接线…
阅读更多...
8年测试经验，接口测试总结，测试进阶之路一篇打通...

8年测试经验，接口测试总结，测试进阶之路一篇打通...

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 1、什么是接口测试…
阅读更多...
开源数据库Mysql_DBA运维实战 （部署服务篇）

开源数据库Mysql_DBA运维实战 （部署服务篇）

前言❀ 1.数据库能做什么 2.数据库的由来 数据库的系统结构❀ 1.数据库系统DBS 2.SQL语言(结构化查询语言) 3.数据访问技术 部署Mysql❀ 1.通过rpm安装部署Mysql 2.通过源码包安装部署Mysql 前言❀ 1.数据库能做什么 a.不论是淘宝&#xff0c;吃鸡&#xff0c;爱奇艺…
阅读更多...
k8sday02

k8sday02

第四章 实战入门 本章节将介绍如何在kubernetes集群中部署一个nginx服务&#xff0c;并且能够对其进行访问。 Namespace ​ Namespace是kubernetes系统中的一种非常重要资源&#xff0c;它的主要作用是用来实现多套环境的资源隔离或者多租户的资源隔离。 ​ 默认情况下&…
阅读更多...
机器学习实战1-kNN最近邻算法

机器学习实战1-kNN最近邻算法

文章目录 机器学习基础机器学习的关键术语 k-近邻算法&#xff08;KNN&#xff09;准备&#xff1a;使用python导入数据实施kNN分类算法示例&#xff1a;使用kNN改进约会网站的配对效果准备数据&#xff1a;从文本文件中解析数据分析数据准备数据&#xff1a;归一化数值测试算法…
阅读更多...
淘宝API接口为开发者提供了与淘宝平台进行数据交互和操作的便捷途径

淘宝API接口为开发者提供了与淘宝平台进行数据交互和操作的便捷途径

淘宝API接口是指淘宝开放平台提供的一套接口&#xff0c;用于与淘宝网进行数据交互和操作。通过使用淘宝API接口&#xff0c;第三方开发者可以实现商品搜索、店铺信息获取、订单管理、商家服务等功能&#xff0c;从而实现与淘宝平台的对接和数据共享。 淘宝API接口的使用可以帮…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023