手把手带你实现一个萌芽版的Spring容器

什么是Spring容器

Spring容器是Spring框架的核心组件之一，主要负责管理Bean的生命周期，维护Bean之间的依赖关系，并提供各种应用上下文服务，是Spring框架的核心所在。Spring容器有多种类型，包括ApplicationContext、BeanFactory等。

实现一个Spring容器

实现概述

实现一个简单的Spring容器，需要掌握以下核心技术：

1. Bean的定义和加载
2. 依赖注入和解析
3. 生命周期管理
4. 容器启动和关闭

接下来，我们将使用Java编写一个简化版的Spring容器，具有以下功能：

1. 支持通过注解定义Bean
2. 支持通过Bean的ID获取Bean实例
3. 支持Bean之间的依赖注入
4. 支持Bean的初始化和销毁回调

实现步骤

1. 定义注解

我们需要定义一个注解，用于标识Bean类。该注解包含一个属性，用于设置Bean的ID。

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

2. 加载Bean定义

我们需要一个类，用于加载Bean的定义，并将其存储到容器中。

public class BeanDefinition {
    private Class<?> clazz;
    private String id;
    private boolean lazyInit;
    private List<String> dependsOn;
    //getter/setter
}

public class BeanDefinitionParser {
    private final Map<String, BeanDefinition> beanDefinitions = new ConcurrentHashMap<>();

    public BeanDefinition parse(Class<?> clazz) {
        Component annotation = clazz.getAnnotation(Component.class);
        if (annotation == null) {
            return null;
        }
        BeanDefinition beanDefinition = new BeanDefinition();
        beanDefinition.setClazz(clazz);
        beanDefinition.setId(annotation.value());
        //解析依赖
        beanDefinition.setLazyInit(false);
        if (!beanDefinitions.containsKey(beanDefinition.getId())) {
            beanDefinitions.put(beanDefinition.getId(), beanDefinition);
        }
        return beanDefinition;
    }

    public BeanDefinition getBeanDefinition(String id) {
        return beanDefinitions.get(id);
    }
}

3. Bean的初始化和销毁

我们需要定义一个接口，用于标识Bean可以被容器管理，并在Bean的初始化和销毁时执行相应的操作。

public interface Initializable {
    void initialize();
}

public interface Disposable {
    void destroy();
}

4. Bean的实例化和依赖注入

我们需要一个类，用于将Bean定义转换为Bean实例，并处理Bean之间的依赖注入。

public class BeanFactory {
    private final Map<String, Object> objects = new ConcurrentHashMap<>();
    private final Map<String, BeanDefinition> beanDefinitions;
    private final List<String> singletonList;

    public BeanFactory(BeanDefinitionParser parser) {
        beanDefinitions = parser.beanDefinitions;
        singletonList = new ArrayList<>(beanDefinitions.keySet());
    }

    public Object getBean(String id) {
        if (!beanDefinitions.containsKey(id)) {
            return null;
        }
        if (!objects.containsKey(id)) {
            BeanDefinition beanDefinition = beanDefinitions.get(id);
            Object object = createBean(beanDefinition);
            objects.put(id, object);
            if (object instanceof Initializable) {
                ((Initializable) object).initialize();
            }
        }
        return objects.get(id);
    }

    private Object createBean(BeanDefinition beanDefinition) {
        Class<?> clazz = beanDefinition.getClazz();
        try {
            Object obj = clazz.getDeclaredConstructor().newInstance();
            for (Field field : clazz.getDeclaredFields()) {
                Autowired annotation = field.getAnnotation(Autowired.class);
                if (annotation != null) {
                    String fieldId = annotation.value();
                    if (StringUtils.isEmpty(fieldId)) {
                        fieldId = field.getName();
                    }
                    Object fieldValue = getBean(fieldId);
                    field.setAccessible(true);
                    field.set(obj, fieldValue);
                }
            }
            return obj;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void destroy() {
        for (String id : singletonList) {
            Object object = objects.get(id);
            if (object instanceof Disposable) {
                ((Disposable) object).destroy();
            }
        }
    }
}

5. 启动和关闭容器

我们需要一个类，用于启动和关闭容器，并在容器关闭时调用所有Bean的销毁方法。

public class ApplicationContext {
    private final BeanFactory beanFactory;

    public ApplicationContext(String... packages) {
        BeanDefinitionParser parser = new BeanDefinitionParser();
        for (String pkg : packages) {
            Set<Class<?>> classes = ClassUtils.scanClasses(pkg, Component.class);
            for (Class<?> clazz : classes) {
                parser.parse(clazz);
            }
        }
        beanFactory = new BeanFactory(parser);
    }

    public void start() {

    }

    public void stop() {
        beanFactory.destroy();
    }

    public <T> T getBean(String id, Class<T> clazz) {
        return clazz.cast(beanFactory.getBean(id));
    }
}

示例

示例1：定义Bean类

我们定义一个Book类，用于演示如何通过注解定义Bean。

@Component("book")
public class Book {
    private final String title;
    private final String author;
    private final String publisher;

    public Book(String title, String author, String publisher) {
        this.title = title;
        this.author = author;
        this.publisher = publisher;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public String getPublisher() {
        return publisher;
    }
}

示例2：获取Bean实例

我们在Spring容器中获取Book实例。

public static void main(String[] args) {
    ApplicationContext context = new ApplicationContext("com.example");
    Book book = context.getBean("book", Book.class);
    System.out.println(book.getTitle());
}

运行结果为：

Java编程思想

总结

通过实现一个简单的Spring容器，我们学习了Bean的定义和加载、依赖注入和解析、生命周期管理以及容器启动和关闭等核心技术。学习完毕后，我们可以更加深入地理解Spring框架的设计思路和实现原理，从而更好地使用和理解Spring框架。