从零手写Spring IoC容器（二）：bean的定义与注册

从零手写Spring IoC容器（二）：bean的定义与注册

一. 回顾简单容器的不足之处

在第一章中，我们实现了一个最简单的 IoC 容器，但该版本存在诸多不足，例如：

• Bean 的管理方式过于简单，无法描述 Bean 之间的依赖关系。
• 缺少 Bean 作用域的管理，无法区分单例（singleton）和原型（prototype）。
• 无法设置 Bean 的属性，不能进行依赖注入。
• 没有生命周期管理，无法进行初始化与销毁操作。

为了克服上述缺陷，我们需要引入 Bean 的定义与注册机制。

二. 问题分析

1. 如何描述 Bean？

为了更灵活地管理 Bean，我们需要对其进行更详细的描述：

• 类信息（Bean 的具体实现类）
• 配置信息（属性值、环境相关配置）
• 依赖关系（需要注入哪些其他 Bean）

2. 如何管理 Bean 的定义？

IoC 容器不仅需要存储 Bean，还需要提供完善的管理机制：

• 统一注册机制：能够注册、移除、获取 Bean 定义。
• 运行时切换：支持不同的 Bean 作用域，例如单例（singleton）或原型（prototype）。
• 依赖分析和注入：支持属性注入，确保 Bean 能够正确构造。

三. 设计 BeanDefinition

我们先设计 BeanDefinition 接口来描述 Bean：

• 包含 Bean 的完整信息
• 支持属性配置
• 支持作用域管理
• 支持生命周期方法

1.设计BeanDefinition 接口

package com.fth.beans.factory.config;/*** 用于描述 Bean 的定义*/
public interface BeanDefinition {// Bean 作用域常量String SCOPE_SINGLETON = "singleton";String SCOPE_PROTOTYPE = "prototype";// 基本信息void setBeanClass(Class<?> beanClass);Class<?> getBeanClass();// 作用域void setScope(String scope);String getScope();boolean isSingleton();boolean isPrototype();// 是否延迟初始化void setLazyInit(boolean lazyInit);boolean isLazyInit();// 生命周期方法void setInitMethodName(String initMethodName);String getInitMethodName();void setDestroyMethodName(String destroyMethodName);String getDestroyMethodName();// 属性void setPropertyValues(PropertyValues propertyValues);PropertyValues getPropertyValues();
}

2. PropertyValue 和 PropertyValues

PropertyValue 用于存储单个 Bean 属性的信息，而 PropertyValues 作为容器，存储 Bean 的所有属性。

package com.fth.beans.factory.config;/*** Bean 属性值的封装类*/
public class PropertyValue {private final String name;private final Object value;private final Class<?> type;/*** 创建一个新的 PropertyValue 实例*/public PropertyValue(String name, Object value, Class<?> type) {if (name == null || name.isEmpty()) {throw new IllegalArgumentException("Property name must not be null or empty");}this.name = name;this.value = value;this.type = type;}/*** 不指定类型的 PropertyValue 构造方法*/public PropertyValue(String name, Object value) {this(name, value, value != null ? value.getClass() : Object.class);}public String getName() {return this.name;}public Object getValue() {return this.value;}public Class<?> getType() {return this.type;}@Overridepublic boolean equals(Object other) {if (this == other) {return true;}if (!(other instanceof PropertyValue)) {return false;}return this.name.equals(((PropertyValue) other).name);}@Overridepublic int hashCode() {return this.name.hashCode();}@Overridepublic String toString() {return "PropertyValue: name='" + this.name + "', value=[" + this.value + "]";}
}

3.实现BeanDefinition

GenericBeanDefinition 是 BeanDefinition 的一个具体实现，用于存储 Bean 的元数据。

package com.fth.beans.factory.support;import com.fth.beans.factory.config.BeanDefinition;
import com.fth.beans.factory.config.PropertyValues;/*** 通用 BeanDefinition 实现*/
public class GenericBeanDefinition implements BeanDefinition {private Class<?> beanClass;private String scope = SCOPE_SINGLETON;private boolean lazyInit = false;private String initMethodName;private String destroyMethodName;private PropertyValues propertyValues = new PropertyValues();@Overridepublic void setBeanClass(Class<?> beanClass) {this.beanClass = beanClass;}@Overridepublic Class<?> getBeanClass() {return this.beanClass;}@Overridepublic void setScope(String scope) {this.scope = scope;}@Overridepublic String getScope() {return this.scope;}@Overridepublic boolean isSingleton() {return SCOPE_SINGLETON.equals(this.scope);}@Overridepublic boolean isPrototype() {return SCOPE_PROTOTYPE.equals(this.scope);}@Overridepublic void setLazyInit(boolean lazyInit) {this.lazyInit = lazyInit;}@Overridepublic boolean isLazyInit() {return this.lazyInit;}@Overridepublic void setInitMethodName(String initMethodName) {this.initMethodName = initMethodName;}@Overridepublic String getInitMethodName() {return this.initMethodName;}@Overridepublic void setDestroyMethodName(String destroyMethodName) {this.destroyMethodName = destroyMethodName;}@Overridepublic String getDestroyMethodName() {return this.destroyMethodName;}@Overridepublic void setPropertyValues(PropertyValues propertyValues) {this.propertyValues = propertyValues;}@Overridepublic PropertyValues getPropertyValues() {return this.propertyValues;}
}

四. 设计 BeanDefinitionRegistry

为了注册和管理 Bean 定义，我们设计 BeanDefinitionRegistry 接口：

package com.fth.beans.factory.support;import com.fth.beans.factory.config.BeanDefinition;/*** BeanDefinition 注册表*/
public interface BeanDefinitionRegistry {void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);void removeBeanDefinition(String beanName);BeanDefinition getBeanDefinition(String beanName);boolean containsBeanDefinition(String beanName);String[] getBeanDefinitionNames();int getBeanDefinitionCount();
}

五.实现第二版 IoC 容器

我们现在基于 BeanDefinition 和 BeanDefinitionRegistry 来实现一个基本的 IoC 容器，支持手动注册 BeanDefinition，并能够根据 BeanDefinition 创建 Bean 实例，同时支持 单例 和 原型 两种作用域。

1. 设计 DefaultBeanFactory

DefaultBeanFactory 负责：

• 维护 BeanDefinition 的注册表
• 根据 BeanDefinition 创建 Bean
• 处理单例和原型作用域

package com.fth.beans.factory.support;import com.fth.beans.BeansException;
import com.fth.beans.factory.BeanFactory;
import com.fth.beans.factory.config.BeanDefinition;
import com.fth.beans.factory.config.BeanDefinitionRegistry;import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;/*** 默认 Bean 工厂，负责管理 BeanDefinition 和 Bean 实例*/
public class DefaultBeanFactory implements BeanDefinitionRegistry, BeanFactory {// 存储 BeanDefinitionprivate final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();// 存储单例 Beanprivate final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();// === 实现 BeanDefinitionRegistry ===@Overridepublic void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {beanDefinitionMap.put(beanName, beanDefinition);// 如果是单例且非懒加载，则立即创建实例if (beanDefinition.isSingleton() && !beanDefinition.isLazyInit()) {singletonObjects.put(beanName, createBean(beanDefinition));}}@Overridepublic void removeBeanDefinition(String beanName) {beanDefinitionMap.remove(beanName);singletonObjects.remove(beanName);}@Overridepublic BeanDefinition getBeanDefinition(String beanName) {return beanDefinitionMap.get(beanName);}@Overridepublic boolean containsBeanDefinition(String beanName) {return beanDefinitionMap.containsKey(beanName);}@Overridepublic String[] getBeanDefinitionNames() {return beanDefinitionMap.keySet().toArray(new String[0]);}@Overridepublic int getBeanDefinitionCount() {return beanDefinitionMap.size();}// === 实现 BeanFactory ===@Overridepublic Object getBean(String name) throws BeansException {BeanDefinition beanDefinition = getBeanDefinition(name);if (beanDefinition == null) {throw new BeansException("No bean named '" + name + "' is defined");}if (beanDefinition.isSingleton()) {return singletonObjects.computeIfAbsent(name, k -> createBean(beanDefinition));}return createBean(beanDefinition);}@Overridepublic <T> T getBean(String name, Class<T> requiredType) throws BeansException {Object bean = getBean(name);if (!requiredType.isInstance(bean)) {throw new BeansException("Bean named '" + name + "' is not of type " + requiredType.getName());}return requiredType.cast(bean);}@Overridepublic <T> T getBean(Class<T> requiredType) throws BeansException {for (String beanName : beanDefinitionMap.keySet()) {Object bean = getBean(beanName);if (requiredType.isInstance(bean)) {return requiredType.cast(bean);}}throw new BeansException("No bean of type " + requiredType.getName() + " is defined");}@Overridepublic boolean containsBean(String name) {return beanDefinitionMap.containsKey(name);}@Overridepublic boolean isSingleton(String name) throws BeansException {BeanDefinition beanDefinition = getBeanDefinition(name);return beanDefinition != null && beanDefinition.isSingleton();}@Overridepublic boolean isPrototype(String name) throws BeansException {BeanDefinition beanDefinition = getBeanDefinition(name);return beanDefinition != null && beanDefinition.isPrototype();}@Overridepublic Class<?> getType(String name) throws BeansException {BeanDefinition beanDefinition = getBeanDefinition(name);return (beanDefinition != null) ? beanDefinition.getBeanClass() : null;}/*** 根据 BeanDefinition 创建 Bean 实例*/private Object createBean(BeanDefinition beanDefinition) {try {// 获取无参构造函数Constructor<?> constructor = beanDefinition.getBeanClass().getDeclaredConstructor();constructor.setAccessible(true);  // 设置可访问return constructor.newInstance();  // 使用构造函数创建实例} catch (Exception e) {throw new RuntimeException("Failed to create bean: " + beanDefinition.getBeanClass(), e);}}
}

2.测试使用

package com.fth.test;import com.fth.beans.factory.BeanFactory;
import com.fth.beans.factory.support.DefaultBeanFactory;
import com.fth.beans.factory.support.GenericBeanDefinition;/*** 测试 IoC 容器*/
public class BeanFactoryTest {public static void main(String[] args) {// 创建 BeanFactoryDefaultBeanFactory beanFactory = new DefaultBeanFactory();// 注册一个单例 BeanGenericBeanDefinition singletonDefinition = new GenericBeanDefinition();singletonDefinition.setBeanClass(TestService.class);singletonDefinition.setScope(GenericBeanDefinition.SCOPE_SINGLETON);beanFactory.registerBeanDefinition("testService", singletonDefinition);// 获取单例 BeanTestService service1 = beanFactory.getBean("testService", TestService.class);TestService service2 = beanFactory.getBean("testService", TestService.class);System.out.println("service1 == service2: " + (service1 == service2)); // true// 注册一个原型 BeanGenericBeanDefinition prototypeDefinition = new GenericBeanDefinition();prototypeDefinition.setBeanClass(TestService.class);prototypeDefinition.setScope(GenericBeanDefinition.SCOPE_PROTOTYPE);beanFactory.registerBeanDefinition("prototypeService", prototypeDefinition);// 获取原型 BeanTestService proto1 = beanFactory.getBean("prototypeService", TestService.class);TestService proto2 = beanFactory.getBean("prototypeService", TestService.class);System.out.println("proto1 == proto2: " + (proto1 == proto2)); // false}
}/*** 测试用 Bean*/
class TestService {public void sayHello() {System.out.println("Hello from TestService!");}
}

六.与Spring的对比与下一步实现

与Spring的对比

1. Bean 的注册与获取

• Spring:
  • Spring 使用 ApplicationContext 来管理 Bean。
  • Bean 的定义可以通过注解、XML 配置或者 Java 配置类来进行。
  • ApplicationContext 允许根据名称或类型来获取 Bean，并且支持 Bean 的自动装配。
• 自定义 IoC 容器:
  • 在自定义容器中，我们通过手动注册 BeanDefinition 和 BeanFactory 来管理 Bean。
  • 目前的实现只能通过名称获取单个 Bean，且只支持单例和原型的基本功能。

2. Bean 的生命周期管理

• Spring:
  • Spring 提供了丰富的生命周期管理功能，例如：
    • 初始化方法：支持 @PostConstruct 注解、init-method 属性等。
    • 销毁方法：支持 @PreDestroy 注解、destroy-method 属性等。
    • BeanPostProcessor：可以在 Bean 初始化前后执行特定操作。
    • ApplicationContextAware、BeanFactoryAware 等：使 Bean 可以访问容器的相关信息。
• 自定义 IoC 容器:
  • 当前实现没有处理 Bean 的初始化、销毁等生命周期管理，功能相对简单，主要关注 Bean 的创建和作用域（单例、原型）。

3. 作用域管理

• Spring:
  • Spring 支持多种作用域，包括：
    • singleton（默认）：每个 Bean 在容器中只有一个实例。
    • prototype：每次请求都会返回一个新的 Bean 实例。
    • request, session, application 等：在 Web 环境下，Spring 支持更多基于 HTTP 请求的作用域。
• 自定义 IoC 容器:
  • 当前实现仅支持 singleton 和 prototype 两种作用域。

4. 自动装配与依赖注入

• Spring:
  • Spring 支持基于注解（如 @Autowired）和 XML 配置的自动装配。
  • 可以自动解析 Bean 之间的依赖关系，通过构造函数、Setter 或字段注入方式注入依赖。
• 自定义 IoC 容器:
  • 当前版本没有实现依赖注入和自动装配，需要手动处理 Bean 的依赖关系。

下一步安排：Bean 的生命周期管理

为了让自定义的 IoC 容器更加完善，下一步实现 Bean 的生命周期管理，这包括以下几个方面：

1. 初始化与销毁

• 初始化方法：可以为每个 Bean 定义一个初始化方法，在 Bean 创建后、依赖注入完成后执行。
• 销毁方法：可以为每个 Bean 定义销毁方法，在 Bean 被销毁前执行，释放资源。

2. 添加 BeanPostProcessor 机制

Spring 提供了 BeanPostProcessor 接口，允许开发者在 Bean 初始化前后执行特定操作。你可以在自定义容器中实现类似机制：

• 初始化前：在 Bean 实例化后、依赖注入前执行。
• 初始化后：在 Bean 初始化完成后执行。