デザインパターン_カスタム Spring フレームワーク (IOC)

デザインパターン_カスタム Spring フレームワーク (IOC)

ダークホースプログラマによるJavaデザインパターンの詳細解説、23のJavaデザインパターン（図表＋フレームワークソースコード解析＋実戦）をノートとしてまとめています。

Spring の使用法のレビュー

Spring フレームワークをカスタマイズする前に、Spring フレームワークの使用法を確認して、Spring のコアを分析し、コア機能をシミュレートします。

• データアクセス層。UserDao インターフェイスとそのサブ実装クラスを定義する

  public interface UserDao {
        
        
      public void add();
  }
  
  public class UserDaoImpl implements UserDao {
        
        
  
      public void add() {
        
        
          System.out.println("UserDao ...");
      }
  }
  

• ビジネスロジック層。UserService インターフェイスとそのサブ実装クラスを定義する

  public interface UserService {
        
        
      public void add();
  }
  
  public class UserServiceImpl implements UserService {
        
        
  
      private UserDao userDao;
  
      public void setUserDao(UserDao userDao) {
        
        
          this.userDao = userDao;
      }
  
      public void add() {
        
        
          System.out.println("UserService ...");
          userDao.add();
      }
  }
  

• UserController クラスを定義し、main メソッドを使用してコントローラー層をシミュレートします。

  public class UserController {
        
        
      public static void main(String[] args) {
        
        
          // 1.创建spring容器对象
          ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
          // 2.从IOC容器中获取UserService对象
          UserService userService = applicationContext.getBean("userService", UserService.class);
          // 3.调用UserService对象的add方法 进行业务处理
          userService.add();
      }
  }
  

• 設定ファイルを書き込みます。applicationContext.xml という名前の構成ファイルをクラスパスの下に書き込みます。

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://www.springframework.org/schema/beans"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd">
  
      <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
          <property name="userDao" ref="userDao"></property>
      </bean>
  
      <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
  
  </beans>
  

  コードを実行した結果は次のようになります。

  

上記のコードと結果から、次のことがわかります。

• userService オブジェクトは applicationContext コンテナ オブジェクトから取得されます。つまり、userService オブジェクトは Spring によって管理されます。
• 上記の結果から、UserDao オブジェクトの add メソッドが呼び出されていることがわかります。これは、UserDao サブ実装クラス オブジェクトも Spring によって管理されていることを意味します。
• UserService の userDao 変数に値を割り当てていませんが、通常どおり使用できます。これは、Spring が UserDao オブジェクトを userDao 変数に割り当てたことを示します。

上記の 3 つの点は、Spring フレームワークの IOC (Inversion of Control) と DI (Dependency Injection、DI) を反映しています。

スプリングコア機能構造

Spring には、1,300 を超える異なるファイルで構成される約 20 のモジュールがあります。これらのモジュールは次のように分割できます。

コア コンテナー、AOP とデバイスのサポート、データ アクセスと統合、Web コンポーネント、通信メッセージと統合テストなど、Spring フレームワークの全体的なアーキテクチャ図は次のとおりです。

コア コンテナは、Bean、コア、コンテキスト、式 (Spring Expression Language、SpEL) の 4 つのモジュールで構成されます。

• spring-beans モジュールと spring-core モジュールは、制御の反転 (IOC) や依存関係の注入 (DI) を含む、Spring フレームワークのコア モジュールです。BeanFactory は、制御の反転を使用して、アプリケーションの構成および依存関係の仕様を実際のアプリケーション コードから分離します。BeanFactory は遅延ロードに属し、コンテナ オブジェクトがインスタンス化された後、Bean は自動的にインスタンス化されず、Bean が使用される場合にのみ Bean をインスタンス化し、依存関係をアセンブルします。
• spring-context モジュールは、BeanFactory を拡張し、Bean ライフサイクル制御、フレームワーク イベント システム、リソース読み込みの透過性などの機能を追加するコア モジュールの上に構築されます。さらに、このモジュールは、メール アクセス、リモート アクセス、タスク スケジュールなど、多くのエンタープライズ レベルのサポートも提供します。ApplicationContext はこのモジュールのコア インターフェイスであり、そのスーパークラスは BeanFactory です。BeanFactory とは異なり、ApplicationContext がインスタンス化されると、すべての単一インスタンス Bean の依存関係が自動的にインスタンス化されてアセンブルされ、スタンバイ状態になります。
• spring-context-support モジュールは、Spring IoC コンテナおよび IoC サブコンテナの拡張サポートです。
• spring-context-indexer モジュールは、Spring のクラス管理コンポーネントおよびクラスパス スキャン コンポーネントです。
• spring-expression モジュールは、統一式言語 (EL) の拡張モジュールであり、実行中のオブジェクトのクエリと管理ができるほか、オブジェクト メソッドの呼び出しや配列、コレクションなどの操作も簡単に行うことができます。その構文は従来の EL に似ていますが、追加機能、特に単純な文字列の関数呼び出しとテンプレート関数を提供します。EL の機能は Spring 製品の要件に基づいて設計されており、Spring IoC と非常に便利に対話できます。

Bean の概要

Spring は Bean Oriented BeanProgramming (BOP、Bean Oriented Programming) であり、Bean は Spring の中核です。Bean to Spring の意味は Object to OOP の意味と同じで、Spring に Bean がなければ Spring の意味はありません。Spring IoC コンテナは、構成ファイルまたはアノテーションを通じて Bean オブジェクト間の依存関係を管理します。

Spring の Bean はクラスをカプセル化するために使用されます。次のような構成のようになります。

<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>

なぜ豆がそれほど重要なのでしょうか？

• Spring は管理のために Bean オブジェクトを IOC と呼ばれるコンテナに渡します。
• Bean オブジェクト間の依存関係は設定ファイルに反映され、Spring によって行われます。

Spring IOC関連のインターフェース分析

BeanFactory 分析

Spring での Bean の作成は典型的なファクトリ パターンです。この一連の Bean ファクトリ、つまり IoC コンテナは、オブジェクト間の依存関係を管理するための多くの利便性と基本的なサービスを開発者に提供します。Spring には、ユーザー向けの IoC コンテナの実装が多数あります。を選択し、それらの間の関係を次の図に示します。

その中で、BeanFactory はトップレベルのインターフェースとして IoC コンテナの基本的な機能仕様を定義しており、BeanFactory には 3 つの重要なサブインターフェースがあります。

• ListableBeanFactory
• 階層型BeanFactory
• AutowireCapableBeanFactory

しかし、クラス図から、最終的なデフォルト実装クラスは DefaultListableBeanFactory であり、これがすべてのインターフェイスを実装していることがわかります。

では、なぜこれほど多くのレベルのインターフェイスを定義するのでしょうか?

各インターフェースには利用シーンがあり、主にSpring内部の演算処理におけるオブジェクトの転送や変換、オブジェクトデータへのアクセス制限などを区別するために使用されます。例えば、

• ListableBeanFactory インターフェースは、これらの Bean をリスト化できる (Bean オブジェクトをリストの形式で保管できる) ことを示します。
• HierarchicalBeanFactory は、これらの Bean に継承関係があること、つまり、各 Bean が親 Bean を持つ可能性があることを示します。
• AutowireCapableBeanFactory インターフェースは、Bean の自動配線ルールを定義します。

これら 3 つのインターフェイスは、Bean のコレクション、Bean 間の関係、Bean の動作を共同で定義します。最も基本的な IoC コンテナ インターフェイスは BeanFactory です。そのソース コードを見てください。

public interface BeanFactory {
    
    

	String FACTORY_BEAN_PREFIX = "&";

	// 根据bean的名称获取IOC容器中的的bean对象
	Object getBean(String name) throws BeansException;
	// 根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	<T> T getBean(Class<T> requiredType) throws BeansException;
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	// 判断容器中是否包含指定名称的bean对象
	boolean containsBean(String name);
	// 根据bean的名称判断是否是单例
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	String[] getAliases(String name);
}

BeanFactory では、IoC コンテナの基本的な動作のみが定義されており、Bean がどのように定義されロードされるかは考慮されません。私たちが工場からどのような製品が得られるかだけを気にするのと同じように、工場がこれらの製品をどのように生産するかには関心がありません。

BeanFactory には、ApplicationContext インターフェイスという非常に重要なサブインターフェイスがあります。このインターフェイスは主に、コンテナ内での Bean オブジェクトの非遅延ロードを制御するために使用されます。コンテナに保管されています。

ファクトリがオブジェクトを生成する方法を知るには、特定の IoC コンテナ実装を確認する必要があります。Spring では、次のような多くの IoC コンテナ実装が提供されています。

• ClasspathXmlApplicationContext: クラスパスに従って XML 構成ファイルをロードし、IOC コンテナ オブジェクトを作成します。
• FileSystemXmlApplicationContext: システム パスに従って XML 構成ファイルをロードし、IOC コンテナ オブジェクトを作成します。
• AnnotationConfigApplicationContext: アノテーション クラス設定をロードし、IOC コンテナを作成します。

BeanDefinition解析

Spring IoC コンテナは、定義したさまざまな Bean オブジェクトとその相互関係を管理します。次の構成ファイルに示すように、Bean オブジェクトは Spring 実装の BeanDefinition によって記述されます。

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>

bean标签还有很多属性：
	scope、init-method、destory-method等。

その継承システムを次の図に示します。

BeanDefinitionReader解析

Bean の解析処理は非常に複雑であり、拡張すべき箇所が多く、変更に対応できる十分な柔軟性を確保する必要があるため、機能が細かく分割されています。Bean の分析は主に Spring 設定ファイルの分析です。この解析プロセスは主に BeanDefinitionReader を通じて行われます。次の図に示すように、Spring の BeanDefinitionReader のクラス構造図を見てください。

上の図は構造の一部にすぎません。BeanDefinitionReader のサブ実装クラスには と が含まれていることがわかります。PropertiesBeanDefinitionReader はProperties特別Xmlに解析された構成ファイルです.propertiesが、ほとんどの人は の.xml構成ファイルを解析するために XmlBeanDefinitionReader を使用します。

BeanDefinitionReader インターフェースによって定義されている関数を見て、その具体的な役割を理解してください。

public interface BeanDefinitionReader {
    
    

	// 获取BeanDefinitionRegistry注册器对象
	BeanDefinitionRegistry getRegistry();

	@Nullable       

	@Nullable
	ClassLoader getBeanClassLoader();

	BeanNameGenerator getBeanNameGenerator();

	/*
	 * 下面的loadBeanDefinitions都是加载bean定义，从指定的资源(配置文件)中，封装成BeanDefinition对象
	 */
	int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
	int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
}

BeanDefinitionRegistry解析

BeanDefinitionReader は、Bean 定義を解析して BeanDefinition オブジェクトをカプセル化するために使用されます。定義した構成ファイルは多くの Bean タグを定義します。そのため、解析された BeanDefinition オブジェクトはどこに保存されるのかという疑問があります。答えは BeanDefinition の登録センターであり、登録センターの最上位インターフェイスは BeanDefinitionRegistry です。

public interface BeanDefinitionRegistry extends AliasRegistry {
    
    

	// 往注册表中注册bean
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	// 从注册表中删除指定名称的bean
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 获取注册表中指定名称的bean
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    
	// 判断注册表中是否已经注册了指定名称的bean
	boolean containsBeanDefinition(String beanName);
    
	// 获取注册表中所有的bean的名称
	String[] getBeanDefinitionNames();
    
	int getBeanDefinitionCount();
	boolean isBeanNameInUse(String beanName);
}

継承構造図は次のとおりです。

上記のクラス図から、BeanDefinitionRegistry インターフェースのサブ実装クラスには主に次のものが含まれていることがわかります。

• SimpleBeanDefinitionRegistry

  これは単純な BeanDefinition 登録センターです。解析された BeanDefinition オブジェクトは BeanDefinition 登録センターに格納されるため、コンテナーである必要があります。このクラスにはさらに注意が必要です。

  このクラスには次のコードが定義されており、Bean を登録するために使用されます。

  private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);
  

• DefaultListableBeanFactory

  このクラスは BeanFactory インターフェースを実装するだけでなく、BeanDefinitionRegistry インターフェースも実装するため、このクラスはコンテナーとレジストリーの両方になります。

  このクラスには次のコードが定義されており、Bean を登録するために使用されます。

  private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
  

• 汎用アプリケーションコンテキスト

  このクラスは ApplicationContext インターフェイスを間接的に実装するため、コンテナーでもありレジストリでもあります。

コンテナを作成する

コンテナー クラス ClassPathXmlApplicationContext のソース コードを見て、コンテナーの作成プロセスを簡単に分析してみましょう。

public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
    
    
    
    // 无参构造方法
    public ClassPathXmlApplicationContext() {
    
    
    }

    // 再传入一个ApplicationContext对象，即父容器
    public ClassPathXmlApplicationContext(ApplicationContext parent) {
    
    
       super(parent);
    }

    /*
     * 我们创建ClassPathXmlApplicationContext时，一般都传递的是一个字符串，就是使用的这个构造方法
     * configLocation：就是类路径下面的配置文件的路径
     * 它底层又套娃的另一个构造方法
     */
    public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    
    
       this(new String[] {
    
    configLocation}, true, null);
    }
    	||
        \/
    /*
     * @param
     * String[] configLocations：配置文件位置
     * boolean refresh：上面的构造方法传入 refresh值固定为true
     * ApplicationContext parent：上面的构造方法传入 父容器固定为null
     */
    public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
    
    

		super(parent);
		setConfigLocations(configLocations);
        // 判断refresh是否为true 在此逻辑中必定满足 进入if
		if (refresh) {
    
    
            // 真正的核心就是这个 refresh 方法
			refresh();
		}
	}

refresh()

    // 父类AbstractApplicationContext中的方法
	@Override
    public void refresh() throws BeansException, IllegalStateException {
    
    
       synchronized (this.startupShutdownMonitor) {
    
    
          StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

          // Prepare this context for refreshing. 准备此容器以进行刷新。
          prepareRefresh(); // #1 准备刷新上下文环境

          // Tell the subclass to refresh the internal bean factory. 告诉子类刷新内部bean工厂。
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // #2 初始化BeanFactory 并加载bean definitions信息

          // Prepare the bean factory for use in this context. 准备用于此容器的bean工厂。
          prepareBeanFactory(beanFactory); // #3 对beanFacotry进行配置

          try {
    
    
             // Allows post-processing of the bean factory in context subclasses. 允许在容器子类中对bean工厂进行后处理。
             postProcessBeanFactory(beanFactory); // #4 提供给子类扩展的预留方法

             StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
             // Invoke factory processors registered as beans in the context. 在容器中调用注册为bean的工厂处理器。
             invokeBeanFactoryPostProcessors(beanFactory); // #5 激活BeanFactoryPostProcessors

             // Register bean processors that intercept bean creation. 注册拦截bean创建的bean处理器。
             registerBeanPostProcessors(beanFactory);  // #6 注册BeanPostProcessors
             beanPostProcess.end();

             // Initialize message source for this context. 初始化此容器的消息源。
             initMessageSource(); // #7 初始化MessageSource

             // Initialize event multicaster for this context. 为此容器初始化事件多播。
             initApplicationEventMulticaster(); // #8 初始化事件广播器

             // Initialize other special beans in specific context subclasses. 初始化特定容器子类中的其他特殊bean。
             onRefresh(); // #9 提供给子类初始化其他的Bean

             // Check for listener beans and register them. 检查侦听器bean并注册它们。
             registerListeners(); // #10 注册事件监听器

             // Instantiate all remaining (non-lazy-init) singletons. 实例化所有剩余的（非惰性初始化）单例。
             finishBeanFactoryInitialization(beanFactory); // #11 构造热加载单例bean

             // Last step: publish corresponding event. 最后一步：发布相应的事件。
             finishRefresh(); // #12 完成刷新过程，通知生命周期处理器
          }

          catch (BeansException ex) {
    
    
             if (logger.isWarnEnabled()) {
    
    
                logger.warn("Exception encountered during context initialization - " +
                      "cancelling refresh attempt: " + ex);
             }

             // Destroy already created singletons to avoid dangling resources. 销毁已创建的单实例以避免悬空资源。
             destroyBeans(); // #13 出错了，销毁bean

             // Reset 'active' flag. 重置“激活”标志。
             cancelRefresh(ex); // #14 出错了，修改active标识

             // Propagate exception to caller. 向调用方传播异常。
             throw ex;
          }

          finally {
    
    
             // Reset common introspection caches in Spring's core, since we  重置Spring核心中的常见内省缓存，因为我们
             // might not ever need metadata for singleton beans anymore...   可能不再需要单例bean的元数据...
             resetCommonCaches();
             contextRefresh.end();
          }
       }
    }

fresh() メソッドは多くのことを行います。簡単に要約すると、refresh メソッドが行うことは、構成ファイルをロードして Bean オブジェクトを初期化し、その Bean オブジェクトをコンテナーに格納することです。

私たちが通常言う Spring の起動は、実際には AbstractApplicationContext#refresh を呼び出して、Spring コンテキストの初期化と起動のプロセスを完了します。Spring コンテキストの初期化の最初から最後までのプロセス全体と起動は、refresh メソッド内にあります。リフレッシュ・メソッドは、いくつかの Spring コンテキストの準備、つまり BeanFactory の作成、BeanFactoryPostProcessor の登録などの Spring コンテキストの初期化を開始したばかりであり、これらの準備が完了した後でのみ Spring コンテキストを開始できます。

要約:

ClassPathXmlApplicationContextによるBean構成リソースの読み込みはrefresh()メソッドから開始されます。fresh() メソッドは、IoC コンテナの起動プロセスを指定するテンプレート メソッドであり、実装のために一部のロジックをそのサブクラスに渡す必要があります。これにより、Bean 構成リソースがロードされ、ClassPathXmlApplicationContext は、その親クラス AbstractApplicationContext のfresh() メソッドを呼び出して、IoC コンテナ全体で Bean 定義をロードするプロセスを開始します。

カスタム Spring IOC

次に、次の構成ファイルを分析し、関連オブジェクトを管理するために Spring フレームワークの IOC をカスタマイズする必要があります。

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
</beans>

全体構造

Bean 関連の pojo クラスを定義する

PropertyValue クラス

これは Bean のプロパティをカプセル化するために使用され、上記の構成ファイルにはパッケージ Bean ラベルのサブラベル プロパティ ラベル データが反映されています。

/**
 * 用来封装bean标签下的property标签的属性
 * name属性
 * ref属性
 * value属性：给基本数据类型及String类型数据赋的值
 */
public class PropertyValue {
    
    

  	private String name;
  	private String ref;
  	private String value;

  	public PropertyValue() {
    
    
  	}

  	public PropertyValue(String name, String ref, String value) {
    
    
    	this.name = name;
    	this.ref = ref;
    	this.value = value;
  	}

  	public String getName() {
    
    
    	return name;
  	}

  	public void setName(String name) {
    
    
    	this.name = name;
  	}

  	public String getRef() {
    
    
    	return ref;
  	}

  	public void setRef(String ref) {
    
    
    	this.ref = ref;
  	}

  	public String getValue() {
    
    
    	return value;
  	}

  	public void setValue(String value) {
    
    
    	this.value = value;
  	}
}

MutablePropertyValues

Bean タグには複数のプロパティ サブタグを含めることができるため、複数の PropertyValue オブジェクトを格納および管理する MutablePropertyValues クラスを定義します。

中古です迭代器模式。

/**
 * 用来存储和管理多个PropertyValue对象
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {
    
    

    // 定义list集合对象，用来存储PropertyValue对象
    private final List<PropertyValue> propertyValueList;

    public MutablePropertyValues() {
    
    
        this.propertyValueList = new ArrayList<PropertyValue>();
    }

    public MutablePropertyValues(List<PropertyValue> propertyValueList) {
    
    
        this.propertyValueList = (propertyValueList != null ? propertyValueList : new ArrayList<PropertyValue>());
    }

    // 获取所有的PropertyValue对象，返回以数组的形式
    public PropertyValue[] getPropertyValues() {
    
    
        // 将集合转换为数组并返回
        return this.propertyValueList.toArray(new PropertyValue[0]);
    }

    // 根据name属性值获取PropertyValue对象
    public PropertyValue getPropertyValue(String propertyName) {
    
    
        // 遍历集合对象
        for (PropertyValue pv : this.propertyValueList) {
    
    
            if (pv.getName().equals(propertyName)) {
    
    
                return pv;
            }
        }
        return null;
    }

    // 获取迭代器对象
    @Override
    public Iterator<PropertyValue> iterator() {
    
    
        return propertyValueList.iterator();
    }

    // 判断集合是否为空
    public boolean isEmpty() {
    
    
        return this.propertyValueList.isEmpty();
    }

    // 添加PropertyValue对象
    public MutablePropertyValues addPropertyValue(PropertyValue pv) {
    
    
        // 判断集合中存储的PropertyValue对象是否和传递进行的重复了，如果重复了，进行覆盖
        for (int i = 0; i < this.propertyValueList.size(); i++) {
    
    
            // 获取集合中每一个PropertyValue对象
            PropertyValue currentPv = this.propertyValueList.get(i);
            if (currentPv.getName().equals(pv.getName())) {
    
    
                this.propertyValueList.set(i, new PropertyValue(pv.getName(), pv.getRef(), pv.getValue()));
                return this; // 目的就是实现链式编程
            }
        }
        this.propertyValueList.add(pv);
        return this; // 目的就是实现链式编程
    }

    // 判断是否有指定name属性值的对象
    public boolean contains(String propertyName) {
    
    
        return getPropertyValue(propertyName) != null;
    }
}

実際、Spring には PropertyValue クラスがありますが、インターフェイスもあります。Iterable インターフェイスを継承する PropertyValues はイテレータの一部のメソッドを書き換え、MutablePropertyValues クラスは PropertyValues インターフェイスを実装します。

public interface PropertyValues extends Iterable<PropertyValue> {
     
     
}

public class MutablePropertyValues implements PropertyValues, Serializable {
     
     

	private final List<PropertyValue> propertyValueList;
}

BeanDefinition クラス

BeanDefinition クラスは、主に ID (つまり、Bean オブジェクトの名前)、クラス (Spring によって管理されるクラスの完全なクラス名)、およびサブラベルのプロパティ データを含む Bean 情報をカプセル化するために使用されます。

/**
 * 用来封装bean标签数据
 * id属性
 * class属性
 * property子标签的数据
 */
public class BeanDefinition {
    
    
    private String id;
    private String className;

    private MutablePropertyValues propertyValues;

    public BeanDefinition() {
    
    
        propertyValues = new MutablePropertyValues();
    }

    public String getId() {
    
    
        return id;
    }

    public void setId(String id) {
    
    
        this.id = id;
    }

    public String getClassName() {
    
    
        return className;
    }

    public void setClassName(String className) {
    
    
        this.className = className;
    }

    public void setPropertyValues(MutablePropertyValues propertyValues) {
    
    
        this.propertyValues = propertyValues;
    }

    public MutablePropertyValues getPropertyValues() {
    
    
        return propertyValues;
    }
}

レジストリ関連のクラスを定義する

BeanDefinitionRegistry インターフェース

BeanDefinitionRegistry インターフェースは、レジストリの関連操作を定義し、次の関数を定義します。

• BeanDefinition オブジェクトをレジストリに登録します
• 指定された名前の BeanDefinition オブジェクトをレジストリから削除します
• レジストリから BeanDefinition オブジェクトを名前で取得します
• 指定された名前の BeanDefinition オブジェクトがレジストリに含まれているかどうかを確認します。
• レジストリ内の BeanDefinition オブジェクトの数を取得します
• レジストリ内のすべての BeanDefinition の名前を取得します。

// 注册表对象
public interface BeanDefinitionRegistry {
    
    

    // 注册BeanDefinition对象到注册表中
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    // 从注册表中删除指定名称的BeanDefinition对象
    void removeBeanDefinition(String beanName) throws Exception;

    // 根据名称从注册表中获取BeanDefinition对象
    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    boolean containsBeanDefinition(String beanName);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();
}

SimpleBeanDefinitionRegistry クラス

このクラスは BeanDefinitionRegistry インターフェースを実装し、Map コレクションをレジストリ コンテナとして定義します。

// 注册表接口子实现类
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
    
    

    // 定义一个容器，用来存储BeanDefinition对象
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
    
    
        beanDefinitionMap.put(beanName, beanDefinition);
    }

    @Override
    public void removeBeanDefinition(String beanName) throws Exception {
    
    
        beanDefinitionMap.remove(beanName);
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws Exception {
    
    
        return beanDefinitionMap.get(beanName);
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
    
    
        return beanDefinitionMap.containsKey(beanName);
    }

    @Override
    public int getBeanDefinitionCount() {
    
    
        return beanDefinitionMap.size();
    }

    @Override
    public String[] getBeanDefinitionNames() {
    
    
        return beanDefinitionMap.keySet().toArray(new String[0]);
    }
}

パーサー関連のクラスを定義する

BeanDefinitionReader インターフェース

なぜ BeanDefinitionReader インターフェースを作成する必要があるのでしょうか? Spring IoC 関数に関連するインターフェイスを分析する場合、Spring は分析するさまざまな構成ファイルにさまざまなサブクラスを提供します。たとえば、propertiesPropertiesBeanDefinitionReader クラスは、この形式の構成ファイルを解析するために使用され、XmlBeanDefinitionReader は、「xml」形式の構成ファイルを解析するために使用されます。BeanDefinitionReader インターフェースの継承システムでは、これら 2 つのクラスはそのサブ実装クラスです。

ここでは、Spring IoC 機能をカスタマイズするときに、xml形式の設定ファイルの解析クラスのみを作成します。

BeanDefinitionReader は、構成ファイルを解析し、レジストリに Bean を登録するために使用されます。次の 2 つの仕様が定義されています。

• レジストリの機能を取得し、外部の世界がこのオブジェクトを通じてレジストリ オブジェクトを取得できるようにします。
• 設定ファイルを読み込み、Beanデータを登録します。

// 用来解析配置文件的，而该接口只是定义了规范
public interface BeanDefinitionReader {
    
    

	// 获取注册表对象
    BeanDefinitionRegistry getRegistry();
    
	// 加载配置文件并在注册表中进行注册
    void loadBeanDefinitions(String configLocation) throws Exception;
}

XmlBeanDefinitionReader クラス

XmlBeanDefinitionReader クラスは、構成ファイルの解析専用ですxml。このクラスは BeanDefinitionReader インターフェースを実装し、インターフェースに 2 つの関数を実装します。

// 针对xml配置文件进行解析的类
public class XmlBeanDefinitionReader implements BeanDefinitionReader {
    
    

    /*
     * 声明注册表对象
     * 为什么要在成员变量位置处声明注册表对象呢？
     * XmlBeanDefinitionReader对象（即解析器）是专门用来解析XML格式的配置文件的，
     * 解析完之后，自然是会将配置文件里面的<bean>标签封装成BeanDefinition对象，这些BD对象最终都要存放到注册表中。
     */
    private BeanDefinitionRegistry registry;

    public XmlBeanDefinitionReader() {
    
    
        this.registry = new SimpleBeanDefinitionRegistry();
    }

    // 获取注册表对象
    @Override
    public BeanDefinitionRegistry getRegistry() {
    
    
        return registry;
    }

    /*
     * 加载配置文件，并在注册表中进行注册
     * @param configLocation 类路径下配置文件的路径
     */
    @Override
    public void loadBeanDefinitions(String configLocation) throws Exception {
    
    
        // 获取类路径下的配置文件。注意，这里我们只实现类路径下的配置文件的加载
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(configLocation);
        // 使用dom4j进行xml配置文件的解析（需要在pom.xml导入对应的jar包）
        SAXReader reader = new SAXReader();
        Document document = reader.read(is);
        // 根据Document对象获取根标签对象（根标签很明显就是<beans>标签）
        Element rootElement = document.getRootElement();
        /*
         * 解析bean标签
         */
        // 获取根标签下所有的<bean>子标签对象
        List<Element> beanElements = rootElement.elements("bean");
        // 遍历集合
        for (Element beanElement : beanElements) {
    
    
            // 获取id属性
            String id = beanElement.attributeValue("id");
            // 获取class属性
            String className = beanElement.attributeValue("class");

            // 将id属性和class属性封装到BeanDefinition对象中
            // 1.创建BeanDefinition对象
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            // 2.创建MutablePropertyValues对象
            MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();

            // 3.获取<bean>标签下所有的<property>子标签对象
            List<Element> propertyElements = beanElement.elements("property");
            for (Element propertyElement : propertyElements) {
    
    
                String name = propertyElement.attributeValue("name");
                String ref = propertyElement.attributeValue("ref");
                String value = propertyElement.attributeValue("value");
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                mutablePropertyValues.addPropertyValue(propertyValue);
            }
            // 4.将MutablePropertyValues对象封装到BeanDefinition对象中
            beanDefinition.setPropertyValues(mutablePropertyValues);

            // 5.将BeanDefinition对象注册到注册表中
            registry.registerBeanDefinition(id, beanDefinition);
        }
    }
}

pom.xml

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>

IOCコンテナ関連のクラス

BeanFactory インターフェース

このインタフェースでIOCコンテナの統一仕様を定義することは、Beanオブジェクトを取得することになります。

// IOC容器父接口
public interface BeanFactory {
    
    
    
	// 根据bean对象的名称获取bean对象
    Object getBean(String name) throws Exception;

	// 根据bean对象的名称获取bean对象，并进行类型转换
    <T> T getBean(String name, Class<? extends T> clazz) throws Exception;
}

ApplicationContext インターフェース

このインターフェースのすべてのサブ実装クラスは Bean オブジェクトを作成します遅延なしはい、つまり、(ユーザーは) コンテナ オブジェクトの作成時に構成ファイルをロードし、Bean オブジェクトをインスタンス化し、最後にそれをコンテナに格納します。

refresh()したがって、メソッドはこのインターフェイスで定義されており、主に次の 2 つの機能を完了します。

• 設定ファイルをロードします。
• Bean オブジェクトは、レジストリ内の BeanDefinition オブジェクトによってカプセル化されたデータに従って作成されます。

// 定义非延时加载功能
public interface ApplicationContext extends BeanFactory {
    
    
    
	// 进行配置文件加载并进行对象创建
    void refresh() throws IllegalStateException, Exception;
}

抽象アプリケーションコンテキストクラス

• ApplicationContext インターフェースのサブクラスとして、このクラスも非遅延ロードであるため、Bean オブジェクトを格納するコンテナーとしてこのクラスに Map コレクションを定義する必要があります。
• BeanDefinitionReader 型の変数を宣言します。これは XML 構成ファイルの解析に使用され、単一責任の原則に準拠します。
  • BeanDefinitionReader タイプのオブジェクトの作成はサブクラスによって実装されます。これは、サブクラスのみが BeanDefinitionReader サブクラス オブジェクトを明確に作成するためです。

// ApplicationContext接口的子实现类，用于立即加载
public abstract class AbstractApplicationContext implements ApplicationContext {
    
    

    // 声明解析器变量。注意，这里我们只是声明解析器变量而已，具体的对象交由子类去创建。
    protected BeanDefinitionReader beanDefinitionReader;
    // 用来存储bean对象的容器 key存储的是bean的id值，value存储的是bean对象
    protected Map<String, Object> singletonObjects = new HashMap<String, Object>();

    // 存储配置文件的路径
    protected String configLocation;

    public void refresh() throws IllegalStateException, Exception {
    
    
        // 加载BeanDefinition对象。我们只需要去调用解析器里面的方法即可。
        beanDefinitionReader.loadBeanDefinitions(configLocation);
        // 初始化bean（创建bean对象）
        finishBeanInitialization();
    }
  
    /*
     * bean对象的初始化
     * 如果我们要进行bean对象的初始化，很显然，我们需要先获取BeanDefinition对象，
     * 因为BeanDefinition对象里面记录了bean的相关信息，只有拿到这些信息，你才能去创建对象。
     * 而BeanDefinition对象又是被注册在注册表里面的，所以首先我们还得先去获取对应的注册表对象！
     */
    private void finishBeanInitialization() throws Exception {
    
    
        // 获取注册表对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        // 获取BeanDefinition对象
        String[] beanNames = registry.getBeanDefinitionNames();

        for (String beanName : beanNames) {
    
    
            // 进行bean的初始化
            getBean(beanName);
        }
    }
}

注: getBean() メソッドは、このクラスのfinishBeanInitialization() メソッドで使用されます模板方法模式。

ClassPathXmlApplicationContextクラス

このクラスは主にクラスパスの下に設定ファイルをロードして Bean オブジェクトを作成し、主に次の機能を実行します。

• コンストラクターで、BeanDefinitionReader オブジェクトを作成します。
• 構築メソッドでは、refresh() メソッドを呼び出して構成ファイルをロードし、Bean オブジェクトを作成してコンテナーに保存します。
• 親インターフェースの getBean() メソッドをオーバーライドし、依存関係注入 (DI) を実装します。

/**
 * IOC容器具体的子实现类
 * 用于加载类路径下的xml格式的配置文件
 */
public class ClassPathXmlApplicationContext extends AbstractApplicationContext {
    
    

    public ClassPathXmlApplicationContext(String configLocation) {
    
    
        this.configLocation = configLocation;
        // 构建XmlBeanDefinitionReader对象
        beanDefinitionReader = new XmlBeanDefinitionReader();
        try {
    
    
            this.refresh();
        } catch (Exception e) {
    
    
        }
    }

    // 根据bean的id属性值(名称)获取bean对象
    @Override
    public Object getBean(String name) throws Exception {
    
    

        // 判断对象容器中是否包含指定名称的bean对象，如果包含，直接返回即可，如果不包含，需要自行创建
        Object obj = singletonObjects.get(name);
        if (obj != null) {
    
    
            return obj;
        }

        // 获取BeanDefinition对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = registry.getBeanDefinition(name);
        if (beanDefinition == null) {
    
    
            return null;
        }
        // 获取bean信息中的className(全类名)
        String className = beanDefinition.getClassName();
        // 通过反射创建对象
        Class<?> clazz = Class.forName(className);
        // 这里的beanObj就是UserService对象 只不过现在还是个空壳
        Object beanObj = clazz.newInstance();

        // 进行依赖注入操作
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        for (PropertyValue propertyValue : propertyValues) {
    
    
            // 获取name属性值
            String propertyName = propertyValue.getName();
            // 获取value属性
            String value = propertyValue.getValue();
            // 获取ref属性
            String ref = propertyValue.getRef();
            // 对于value属性和ref属性必然只能存在一个 所以需要进行判断
            // ref一般是一个bean对象，而value只是一个普通的属性值
            if (ref != null && !"".equals(ref)) {
    
    
                // 获取依赖的bean对象
                Object bean = getBean(ref);
                // 拼接方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
                // 获取所有的方法对象
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
    
    
                    if (methodName.equals(method.getName())) {
    
    
                        // 执行该setter方法
                        // 往beanObj中注入bean对象
                        method.invoke(beanObj, bean);
                    }
                }
            }

            if (value != null && !"".equals(value)) {
    
    
                // 拼接方法名
                String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
                // 获取method对象
                Method method = clazz.getMethod(methodName, String.class);
                // 往beanObj中注入value值
                method.invoke(beanObj, value);
            }
        }

        // 在返回beanObj对象之前，将该对象存储到map容器中
        singletonObjects.put(name, beanObj);
        return beanObj;
    }

    @Override
    public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
    
    
        Object bean = getBean(name);
        if (bean != null) {
    
    
            // 类型强转
            return clazz.cast(bean);
        }
        return null;
    }
}

StringUtils

// String工具类
public class StringUtils {
    
    
    
    private StringUtils() {
    
    
    }

    // userDao ==> setUserDao
    public static String getSetterMethodByFieldName(String fieldName) {
    
    
        String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
        return methodName;
    }
}

全体的なロジックはおそらく次のとおりです。

• まず第一に、統一された仕様を定義する BeanFactory のトップレベルの親インターフェースがあります。
• 次に、BeanFactory を継承する ApplicationContext インターフェイスを作成します。目的は、次のことを達成することです。非遅延読み込みBD オブジェクト。
• 次に、AbstractApplicationContext サブ実​​装クラスを作成します。
  • それは主に達成します遅延のないロード時間function は、refresh()XmlBeanDefinitionReader#loadBeanDefinitions メソッドを呼び出すメソッドです。このメソッドは、XML ファイルをロードして解析し、すべての Bean タグを BD オブジェクトにカプセル化し、それらをレジストリに登録します。
    • 次に、メソッドを呼び出してgetBean()、特定のサブクラスに実装されているすべての Bean オブジェクトを初期化します。
  • 特定の BeanDefinitionReader 型オブジェクトはサブクラスによって作成されます。これは、その型がサブクラスだけが知っているためです。
• ClassPathXmlApplicationContext を実装する具体的なサブクラスを作成する
  • このクラスの構築メソッドで特定の XmlBeanDefinitionReader オブジェクトを作成し、それを親クラスの BeanDefinitionReader に割り当て、refresh()メソッドを呼び出して構成ファイルをロードし、Bean オブジェクトを作成してコンテナに格納します。
  • 親インターフェイスのメソッドを書き換えてgetBean()、依存関係注入操作 (DI) を実装します。**これは、リフレクションを通じてオブジェクトを作成するロジックです。**最後にオブジェクトをコンテナに保存します。

テスト

参考ビデオ

カスタム Spring IOC の概要

使用したデザインパターン

• 工場パターン。この使い方工厂模式 + 配置文件。
• シングルトンパターン。Spring IOC が管理する Bean オブジェクトはすべてシングルトンですが、ここでのシングルトンはコンストラクターによって制御されませんが、Spring フレームワークは Bean ごとにオブジェクトを 1 つだけ作成します。
• テンプレートメソッドパターン。getBean() の実装は環境と密接に関連しているため、AbstractApplicationContext クラスのfinishBeanInitialization() メソッドはサブクラスの getBean() メソッドを呼び出します。
• イテレータパターン。MutablePropertyValues クラス定義の場合、このクラスは PropertyValue オブジェクトを保存および管理し、コンテナーにも属しているため、コンテナーのトラバーサル メソッドを提供するため、イテレーター モードが使用されます。

Spring フレームワークは実際に多くの設計パターンを使用します。たとえば、AOP はプロキシ モードを使用し、JDK プロキシまたは CGLIB プロキシを選択してストラテジ モードを使用するほか、アダプタ モード、デコレータ モード、オブザーバ モードなどを使用します。

ほとんどの設計原則に準拠しています。

全体のデザインと Spring のデザインの間にはまだ一定の不一致があります。

Spring フレームワークの最下層は非常に複雑で、深くカプセル化されており、外部に対して優れたスケーラビリティを提供します。そして、カスタム Spring IOC には次の目的があります。

• Spring の基礎となるオブジェクトの一般的な管理メカニズムを理解します。
• 特定の開発におけるデザイン パターンの使用を理解します。
• この事例を実現することで、今後 Spring のソースコードを学習する際に、Spring のソースコード学習のエントリーコストを削減することができます。