手写简易IOC容器

前言

本文是为了学习Spring IOC容器的执行过程而写，不能彻底表明Spring IOC容器，只是简单实现了容器的依赖注入和控制反转功能，没法用于生产，只能说对理解Spring容器可以起到必定的做用。

开始

建立项目

建立Gradle项目，并修改build.gradle

plugins {
    id 'java'
    id "io.franzbecker.gradle-lombok" version "3.1.0"
}

group 'io.github.gcdd1993'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
复制代码

建立BeanFactory

BeanFactory是IOC中用于存放bean实例以及获取bean的核心接口，它的核心方法是getBean以及getBean的重载方法，这里简单实现两个getBean的方法。

package io.github.gcdd1993.ioc.bean;

/** * bean factory interface * * @author gaochen * @date 2019/6/2 */
public interface BeanFactory {

    /** * 经过bean名称获取bean * * @param name bean名称 * @return bean */
    Object getBean(String name);

    /** * 经过bean类型获取bean * * @param tClass bean类型 * @param <T> 泛型T * @return bean */
    <T> T getBean(Class<T> tClass);

}
复制代码

建立ApplicationContext上下文

ApplicationContext，即咱们常说的应用上下文，实际就是Spring容器自己了。

咱们建立ApplicationContext类，并实现BeanFactory接口。

public class ApplicationContext implements BeanFactory {
}
复制代码

getBean方法

既然说是容器，那确定要有地方装咱们的bean实例吧，使用两个Map做为容器。

/** * 按照beanName分组 */
private final Map<String, Object> beanByNameMap = new ConcurrentHashMap<>(256);

/** * 按照beanClass分组 */
private final Map<Class<?>, Object> beanByClassMap = new ConcurrentHashMap<>(256);
复制代码

而后，咱们能够先完成咱们的getBean方法。

@Override
public Object getBean(String name) {
    return beanByNameMap.get(name);
}

@Override
public <T> T getBean(Class<T> tClass) {
    return tClass.cast(beanByClassMap.get(tClass));
}
复制代码

直接从Map中获取bean实例，是否是很简单？固然了，在真实的Spring容器中，是不会这么简单啦，不过咱们此次是要化繁为简，理解IOC容器。

构造器

Spring提供了@ComponentScan来扫描包下的Component，咱们为了简便，直接在构造器中指定要扫描的包。

private final Set<String> basePackages;
/** * 默认构造器，默认扫描当前所在包 */
public ApplicationContext() {
    this(new HashSet<>(Collections.singletonList(ApplicationContext.class.getPackage().getName())));
}

/** * 全参构造器 * @param basePackages 扫描的包名列表 */
public ApplicationContext(Set<String> basePackages) {
    this.basePackages = basePackages;
}
复制代码

refresh方法

refresh的过程基本按照如下流程来走

1. 扫描指定的包下全部带@Bean注解（Spring中是@Component注解）的类。

List<Class> beanClasses = PackageScanner.findClassesWithAnnotation(packageName, Bean.class);
System.out.println("scan classes with Bean annotation : " + beanClasses.toString());

for (Class beanClass : beanClasses) {
    try {
        createBean(beanClass);
    } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
        e.printStackTrace();
    }
}
复制代码

2. 遍历类，获取类的构造器以及全部字段。

Constructor constructor = beanClass.getDeclaredConstructor();
Object object = constructor.newInstance();
Field[] fields = beanClass.getDeclaredFields();
复制代码

3. 判断字段是依赖注入的仍是普通字段。

4. 若是是普通字段，经过字段类型初始化该字段，并尝试从@Value注解获取值塞给字段。

Value value = field.getAnnotation(Value.class);
if (value != null) {
    // 注入
    field.setAccessible(true);
    // 须要作一些类型转换，从String转为对应的类型
    field.set(object, value.value());
}
复制代码

5. 若是是依赖注入的字段，尝试从beanByClassMap中获取对应的实例，若是没有，就先要去实例化该字段对应的类型。

Autowired autowired = field.getAnnotation(Autowired.class);
if (autowired != null) {
    // 依赖注入
    String name = autowired.name();
    // 按照名称注入
    Object diObj;
    if (!name.isEmpty()) {
        diObj = beanByNameMap.get(name) == null ?
                createBean(name) :
                beanByNameMap.get(name);
    } else {
        // 按照类型注入
        Class<?> aClass = field.getType();
        diObj = beanByClassMap.get(aClass) == null ?
                createBean(aClass) :
                beanByClassMap.get(aClass);
    }
    // 注入
    field.setAccessible(true);
    field.set(object, diObj);
}
复制代码

测试咱们的IOC容器

建立Address

@Data
@Bean
public class Address {
    @Value("2222")
    private String longitude;

    @Value("1111")
    private String latitude;
}
复制代码

建立Person并注入Address

@Data
@Bean
public class Person {
    @Autowired
    private Address address;

    @Value("gaochen")
    private String name;

    @Value("27")
    private String age;
}
复制代码

建立测试类ApplicationContextTest

public class ApplicationContextTest {

    @Test
    public void refresh() {
        Set<String> basePackages = new HashSet<>(1);
        basePackages.add("io.github.gcdd1993.ioc");
        ApplicationContext ctx = new ApplicationContext(basePackages);
        ctx.refresh();

        Person person = ctx.getBean(Person.class);
        System.out.println(person);

        Object person1 = ctx.getBean("Person");
        System.out.println(person1);
    }
}
复制代码

控制台将会输出：

scan classes with Bean annotation : [class io.github.gcdd1993.ioc.util.Address, class io.github.gcdd1993.ioc.util.Person]
scan classes with Bean annotation : [class io.github.gcdd1993.ioc.util.Address, class io.github.gcdd1993.ioc.util.Person]
Person(address=Address(longitude=2222, latitude=1111), name=gaochen, age=27)
Person(address=Address(longitude=2222, latitude=1111), name=gaochen, age=27)
复制代码

能够看到，咱们成功将Address实例注入到了Person实例中，而且将它们存储在了咱们本身的IOC容器中。其实，Spring容器的原理大体就是如此，只不过为了应对企业级开发，提供了不少便捷的功能，例如bean的做用域、bean的自定义方法等等。

获取源码

完整源码能够在个人github仓库获取👉Simple-IOC-Container