手写Spring源码，了解bean的重要生命周期

小白努力学java

已于 2022-10-20 11:09:29 修改

阅读量220

点赞数 1

分类专栏： Spring 文章标签： spring

于 2022-10-18 21:14:55 首次发布

本文链接：https://blog.csdn.net/qq_42743858/article/details/127396435

版权

Spring AnnotationConfigApplicationContext bean生命周期组件扫描依赖注入

关键词由CSDN通过智能技术生成

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Spring系列文章目录

第一章手写Spring

前言

本篇文章是围绕AnnotationConfigApplicationContext加载的spring当中bean的生命周期过程，所有注解，类都可以在Spring当中找到对应的类。

一、代码主体结构

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、spring代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lotus</groupId>
  <artifactId>handle-write-spring</artifactId>
  <version>1.0-SNAPSHOT</version>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>8</source>
          <target>8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <name>Maven</name>
  <inceptionYear>2001</inceptionYear>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

</project>

Autowired

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

}

Component

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {

    String value() default "";

}

ComponentScan

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ComponentScan {

    String value() default "";
}

Scope

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Scope {

    String value() default "";
}

BeanNameAware

public interface BeanNameAware {

    void setBeanName(String name);
}

BeanPostProcessor

public interface BeanPostProcessor {

    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

InitializingBean

public interface InitializingBean {

    void afterPropertiesSet();
}

AppConfig

/**
 * 声明扫描
 **/
@ComponentScan("com.lotus.demo")
public class AppConfig {

}

BeanDefinition

public class BeanDefinition {

    private Class<?> type;

    private String scope;

    public Class<?> getType() {
        return type;
    }

    public void setType(Class<?> type) {
        this.type = type;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }
}

AnnotationConfigApplicationContext

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.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 模拟spring 注解启动上下文
 **/
public class AnnotationConfigApplicationContext {

    private Class<?> appConfig;

    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
    private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

    public AnnotationConfigApplicationContext(Class<?> appConfig) {
        this.appConfig = appConfig;

        scanConfig(appConfig);

        // 将扫描到的BeanDefinition判断属性是否放入到单例
        for (Map.Entry<String, BeanDefinition> definitionEntry : beanDefinitionMap.entrySet()) {
            String beanName = definitionEntry.getKey();
            BeanDefinition definition = definitionEntry.getValue();
            if (definition.getScope().equals("singleton")) {
                singletonObjects.put(beanName, createBean(beanName, definition));
            }
        }
    }

    /**
     * 扫描配置的包路径
     **/
    private void scanConfig(Class<?> appConfig) {
        if (appConfig.isAnnotationPresent(ComponentScan.class)) {
            ComponentScan componentScan = appConfig.getAnnotation(ComponentScan.class);
            String componentScanVal = componentScan.value();
            System.out.println("spring  获取ComponentScan定义扫描路径: " + componentScanVal);

            ClassLoader classLoader = AnnotationConfigApplicationContext.class.getClassLoader();
            componentScanVal = componentScanVal.replace(".", "/");
            URL resource = classLoader.getResource(componentScanVal);

            File file = new File(resource.getFile());
            loadFile(classLoader, file);
        }
    }

    /**
     * 加载文件
     **/
    private void loadFile(ClassLoader classLoader, File file) {
        if (file.isDirectory()) {
            for (File listFile : file.listFiles()) {
                // 如果为文件夹则递归
                if (listFile.isDirectory()) {
                    loadFile(classLoader, listFile);
                }
                String absolutePath = listFile.getAbsolutePath();
                if (absolutePath.lastIndexOf(".class") == -1) {
                    continue;
                }
                absolutePath = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class")).replace("\\", ".");

                try {
                    Class<?> loadClass = classLoader.loadClass(absolutePath);
                    // 查看类上是否有注解 标明这是一个bean
                    if (loadClass.isAnnotationPresent(Component.class)) {
                        // 对于通过实现BeanPostProcessor的bean单独放到一个list当中保存
                        if (BeanPostProcessor.class.isAssignableFrom(loadClass)) {
                            BeanPostProcessor instance = (BeanPostProcessor) loadClass.getConstructor().newInstance();
                            beanPostProcessorList.add(instance);
                        }

                        Component component = loadClass.getAnnotation(Component.class);
                        String beanName = component.value();
                        // 获取bean的名称 如果赋值则取赋值的名称，否则取类名第一个单词小写的名称
                        beanName = beanName == null || "".equals(beanName) ? Introspector.decapitalize(loadClass.getSimpleName()) : beanName;
                        // 构造beanDefinition后续加载bean
                        BeanDefinition beanDefinition = new BeanDefinition();
                        beanDefinition.setType(loadClass);
                        if (loadClass.isAnnotationPresent(Scope.class)) {
                            Scope scope = loadClass.getAnnotation(Scope.class);
                            String scopeVal = scope.value();
                            beanDefinition.setScope(scopeVal);
                        } else {
                            beanDefinition.setScope("singleton");
                        }
                        beanDefinitionMap.put(beanName, beanDefinition);
                    }

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

    /**
     * 从 beanDefinitionMap 获取单例bean 或者 原型bean
     **/
    public Object getBean(String beanName) {
        if (!beanDefinitionMap.containsKey(beanName)) {
            throw new NullPointerException();
        }
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        String scope = beanDefinition.getScope();
        Object singletonBean = null;
        if ("singleton".equals(scope)) {
            singletonBean = singletonObjects.get(beanName);
            singletonObjects.put(beanName, singletonBean);
        } else {
            singletonBean = createBean(beanName, beanDefinition);
        }
        return singletonBean;
    }

    /**
     * 通过beanDefinition创建bean实例，同时加载bean的生命周期
     **/
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        Object instance = null;
        Class<?> clazz = beanDefinition.getType();
        try {
            instance = clazz.getConstructor().newInstance();

            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    field.set(instance, getBean(beanName));
                }
            }

            if (instance instanceof BeanNameAware) {
                ((BeanNameAware) instance).setBeanName(beanName);
            }

            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
            }

            if (instance instanceof InitializingBean) {
                ((InitializingBean) instance).afterPropertiesSet();
            }

            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
            }

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

三、测试代码

UserService

public interface UserService {

    void test();
}

OrderService

import com.lotus.spring.BeanNameAware;
import com.lotus.spring.BeanPostProcessor;
import com.lotus.spring.Component;
import com.lotus.spring.InitializingBean;

@Component
public class OrderService implements BeanNameAware, BeanPostProcessor, InitializingBean {

    private String beanName;

    @Override
    public void setBeanName(String name) {
        System.out.println("spring-->初始化前优先设置bean名称" + name);
        this.beanName = name;
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("spring-->初始化bean，此时bean的名称：" + beanName);
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("spring-->初始化bean之前，做的事" + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("spring-->初始化bean之后，做的事" + beanName);
        return bean;
    }
}

UserServiceImpl

@Component
public class UserServiceImpl implements UserService {

    public void test() {
        System.out.println("==============");
    }
}

四、测试类

DemoTest

import com.lotus.demo.service.impl.UserServiceImpl;
import com.lotus.spring.AnnotationConfigApplicationContext;
import com.lotus.spring.AppConfig;

public class DemoTest {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

        UserServiceImpl userServiceImpl = (UserServiceImpl) applicationContext.getBean("userServiceImpl");
        userServiceImpl.test();
    }
}