AbstractApplicationContext (Spring Framework API)

java.lang.ObjectSE
- org.springframework.core.io.DefaultResourceLoader
- - org.springframework.context.support.AbstractApplicationContext

実装されたすべてのインターフェース:
CloseableSE, AutoCloseableSE, BeanFactory, HierarchicalBeanFactory, ListableBeanFactory, ApplicationContext, ApplicationEventPublisher, ConfigurableApplicationContext, Lifecycle, MessageSource, EnvironmentCapable, ResourceLoader, ResourcePatternResolver
既知の直属サブクラス
AbstractRefreshableApplicationContext, GenericApplicationContext
```
public abstract class AbstractApplicationContext
extends DefaultResourceLoader
implements ConfigurableApplicationContext
```
ApplicationContext インターフェースの抽象的な実装。構成に使用されるストレージの型を強制しません。単に一般的なコンテキスト機能を実装します。テンプレートメソッドデザインパターンを使用します。抽象メソッドを実装するには、具象サブクラスが必要です。
プレーンな BeanFactory とは対照的に、ApplicationContext は、内部 Bean ファクトリで定義された特別な Bean を検出することになっています。このクラスは、コンテキストで Bean として定義される BeanFactoryPostProcessors、BeanPostProcessors、ApplicationListeners を自動的に登録します
MessageSource は、"messageSource" という名前のコンテキストで Bean としても提供されます。それ以外の場合、メッセージ解決は親コンテキストに委譲されます。さらに、アプリケーションイベントのマルチキャスターは、コンテキストで型 ApplicationEventMulticaster の "applicationEventMulticaster" Bean として提供できます。そうでない場合は、型 SimpleApplicationEventMulticaster のデフォルトマルチキャスターが使用されます。
DefaultResourceLoader を継承することにより、リソースのロードを実装します。DefaultResourceLoader.getResourceByPath(java.lang.String) メソッドがサブクラスでオーバーライドされない限り、非 URL リソースパスをクラスパスリソースとして処理します（パッケージパスを含む完全なクラスパスリソース名、たとえば "mypackage/myresource.dat" をサポート）。
導入:
2001 年 1 月 21 日
作成者:
Rod Johnson, Juergen Hoeller, Mark Fisher, Stephane Nicoll, Sam Brannen, Sebastien Deleuze, Brian Clozel
関連事項:
refreshBeanFactory(), getBeanFactory(), BeanFactoryPostProcessor, BeanPostProcessor, ApplicationEventMulticaster, ApplicationListener, MessageSource

ネストされたクラスのサマリー
- クラス org.springframework.core.io.DefaultResourceLoader から継承されたネストクラス / インターフェース
  DefaultResourceLoader.ClassPathContextResource

フィールドサマリー

フィールド
修飾子と型	フィールドと説明
`static StringSE`	`APPLICATION_EVENT_MULTICASTER_BEAN_NAME` ファクトリ内の ApplicationEventMulticaster Bean の名前。
`static StringSE`	`LIFECYCLE_PROCESSOR_BEAN_NAME` ファクトリ内の LifecycleProcessor Bean の名前。
`protected Log`	`logger` このクラスで使用されるロガー。
`static StringSE`	`MESSAGE_SOURCE_BEAN_NAME` ファクトリ内の MessageSource Bean の名前。

インターフェース org.springframework.context.ConfigurableApplicationContext から継承されたフィールド
APPLICATION_STARTUP_BEAN_NAME, CONFIG_LOCATION_DELIMITERS, CONVERSION_SERVICE_BEAN_NAME, ENVIRONMENT_BEAN_NAME, LOAD_TIME_WEAVER_BEAN_NAME, SHUTDOWN_HOOK_THREAD_NAME, SYSTEM_ENVIRONMENT_BEAN_NAME, SYSTEM_PROPERTIES_BEAN_NAME

インターフェース org.springframework.beans.factory.BeanFactory から継承されたフィールド
FACTORY_BEAN_PREFIX

インターフェース org.springframework.core.io.support.ResourcePatternResolver から継承されたフィールド
CLASSPATH_ALL_URL_PREFIX

インターフェース org.springframework.core.io.ResourceLoader から継承されたフィールド
CLASSPATH_URL_PREFIX

コンストラクターのサマリー

コンストラクター
コンストラクターと説明
`AbstractApplicationContext()` 親なしで新しい AbstractApplicationContext を作成します。
`AbstractApplicationContext(ApplicationContext parent)` 指定された親コンテキストで新しい AbstractApplicationContext を作成します。

メソッドのサマリー

すべてのメソッドインスタンスメソッド抽象メソッド具象メソッド非推奨のメソッド
修飾子と型	メソッドと説明
`void`	`addApplicationListener(ApplicationListener<?> listener)` コンテキストのリフレッシュやシャットダウンなどのコンテキストイベントで通知される新しい ApplicationListener を追加します。
`void`	`addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor)` Bean 定義のいずれかが評価される前に、リフレッシュ時にこのアプリケーションコンテキストの内部 Bean ファクトリに適用される新しい BeanFactoryPostProcessor を追加します。
`protected void`	`assertBeanFactoryActive()` このコンテキストの BeanFactory が現在アクティブであることをアサートし、アクティブでない場合は `IllegalStateException`SE をスローします。
`protected void`	`cancelRefresh(BeansException ex)` このコンテキストのリフレッシュ試行をキャンセルし、例外がスローされた後に `active` フラグをリセットします。
`void`	`close()` このアプリケーションコンテキストを閉じ、Bean ファクトリ内のすべての Bean を破棄します。
`protected abstract void`	`closeBeanFactory()` サブクラスはこのメソッドを実装して、内部 Bean ファクトリを解放する必要があります。
`boolean`	`containsBean(StringSE name)` この Bean ファクトリには、指定された名前の Bean 定義または外部登録されたシングルトンインスタンスが含まれているか判定します。
`boolean`	`containsBeanDefinition(StringSE beanName)` この Bean ファクトリに、指定された名前の Bean 定義が含まれているかどうかを確認します。
`boolean`	`containsLocalBean(StringSE name)` 祖先コンテキストで定義された Bean を無視して、ローカル Bean ファクトリに、指定された名前の Bean が含まれているかどうかを返します。
`protected ConfigurableEnvironment`	`createEnvironment()` 新しい `StandardEnvironment` を作成して返します。
`void`	`destroy()` 使用すべきではありません。 Spring Framework 5.0 現在、`close()` を推奨
`protected void`	`destroyBeans()` このコンテキストが管理するすべての Bean を破棄するためのテンプレートメソッド。
`protected void`	`doClose()` 実際にコンテキストを閉じる: ContextClosedEvent を公開し、このアプリケーションコンテキストの Bean ファクトリ内のシングルトンを破棄します。
`<A extends AnnotationSE> A`	`findAnnotationOnBean(StringSE beanName, ClassSE<A> annotationType)` 指定された Bean で `annotationType` の `Annotation`SE を検索し、指定されたクラス自体にアノテーションが見つからない場合はインターフェースとスーパークラスを走査し、Bean のファクトリメソッド（存在する場合）を確認します。
`<A extends AnnotationSE> A`	`findAnnotationOnBean(StringSE beanName, ClassSE<A> annotationType, boolean allowFactoryBeanInit)` 指定された Bean で `annotationType` の `Annotation`SE を検索し、指定されたクラス自体にアノテーションが見つからない場合はインターフェースとスーパークラスを走査し、Bean のファクトリメソッド（存在する場合）を確認します。
`protected void`	`finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)` このコンテキストの Bean ファクトリの初期化を終了し、残りのすべてのシングルトン Bean を初期化します。
`protected void`	`finishRefresh()` このコンテキストのリフレッシュを完了し、LifecycleProcessor の onRefresh() メソッドを呼び出して、`ContextRefreshedEvent` を公開します。
`StringSE[]`	`getAliases(StringSE name)` 存在する場合、指定された Bean 名のエイリアスを返します。
`CollectionSE<ApplicationListener<?>>`	`getApplicationListeners()` 静的に指定された ApplicationListeners のリストを返します。
`StringSE`	`getApplicationName()` このコンテキストが属するデプロイされたアプリケーションの名前を返します。
`ApplicationStartup`	`getApplicationStartup()` このアプリケーションコンテキストの `ApplicationStartup` を返します。
`AutowireCapableBeanFactory`	`getAutowireCapableBeanFactory()` すでに利用可能な場合、このコンテキストの内部 Bean ファクトリを AutowireCapableBeanFactory として返します。
`<T> T`	`getBean(ClassSE<T> requiredType)` 指定されたオブジェクト型が存在する場合、一意に一致する Bean インスタンスを返します。
`<T> T`	`getBean(ClassSE<T> requiredType, ObjectSE... args)` 指定された Bean のインスタンス（共有または独立）を返します。
`ObjectSE`	`getBean(StringSE name)` 指定された Bean のインスタンス（共有または独立）を返します。
`<T> T`	`getBean(StringSE name, ClassSE<T> requiredType)` 指定された Bean のインスタンス（共有または独立）を返します。
`ObjectSE`	`getBean(StringSE name, ObjectSE... args)` 指定された Bean のインスタンス（共有または独立）を返します。
`int`	`getBeanDefinitionCount()` ファクトリで定義されている Bean の数を返します。
`StringSE[]`	`getBeanDefinitionNames()` このファクトリで定義されているすべての Bean の名前を返します。
`abstract ConfigurableListableBeanFactory`	`getBeanFactory()` サブクラスはここで内部 Bean ファクトリを返す必要があります。
`ListSE<BeanFactoryPostProcessor>`	`getBeanFactoryPostProcessors()` 内部 BeanFactory に適用される BeanFactoryPostProcessors のリストを返します。
`StringSE[]`	`getBeanNamesForAnnotation(ClassSE<? extends AnnotationSE> annotationType)` 対応する Bean インスタンスをまだ作成せずに、提供された `Annotation`SE 型でアノテーションが付けられている Bean のすべての名前を検索します。
`StringSE[]`	`getBeanNamesForType(ClassSE<?> type)` Bean 定義または FactoryBeans の場合は `getObjectType` の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
`StringSE[]`	`getBeanNamesForType(ClassSE<?> type, boolean includeNonSingletons, boolean allowEagerInit)` Bean 定義または FactoryBeans の場合は `getObjectType` の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
`StringSE[]`	`getBeanNamesForType(ResolvableType type)` Bean 定義または FactoryBeans の場合は `getObjectType` の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
`StringSE[]`	`getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)` Bean 定義または FactoryBeans の場合は `getObjectType` の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
`<T> ObjectProvider<T>`	`getBeanProvider(ClassSE<T> requiredType)` 指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
`<T> ObjectProvider<T>`	`getBeanProvider(ClassSE<T> requiredType, boolean allowEagerInit)` 指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
`<T> ObjectProvider<T>`	`getBeanProvider(ResolvableType requiredType)` 指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
`<T> ObjectProvider<T>`	`getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)` 指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
`<T> MapSE<StringSE,T>`	`getBeansOfType(ClassSE<T> type)` Bean 定義または FactoryBeans の場合は `getObjectType` の値から判断して、指定されたオブジェクト型（サブクラスを含む）に一致する Bean インスタンスを返します。
`<T> MapSE<StringSE,T>`	`getBeansOfType(ClassSE<T> type, boolean includeNonSingletons, boolean allowEagerInit)` Bean 定義または FactoryBeans の場合は `getObjectType` の値から判断して、指定されたオブジェクト型（サブクラスを含む）に一致する Bean インスタンスを返します。
`MapSE<StringSE, ObjectSE>`	`getBeansWithAnnotation(ClassSE<? extends AnnotationSE> annotationType)` 指定された `Annotation`SE 型でアノテーションが付けられたすべての Bean を検索し、対応する Bean インスタンスを持つ Bean 名のマップを返します。
`StringSE`	`getDisplayName()` このコンテキストのフレンドリ名を返します。
`ConfigurableEnvironment`	`getEnvironment()` このアプリケーションコンテキストの `Environment` を構成可能な形式で返し、さらにカスタマイズできるようにします。
`StringSE`	`getId()` このアプリケーションコンテキストの一意の ID を返します。
`protected BeanFactory`	`getInternalParentBeanFactory()` ConfigurableApplicationContext を実装する場合、親コンテキストの内部 Bean ファクトリを返します。それ以外の場合は、親コンテキスト自体を返します。
`protected MessageSource`	`getInternalParentMessageSource()` 親コンテキストの内部メッセージソースも AbstractApplicationContext の場合は返します。それ以外の場合は、親コンテキスト自体を返します。
`StringSE`	`getMessage(MessageSourceResolvable resolvable, LocaleSE locale)` 渡された `MessageSourceResolvable` 引数内に含まれるすべての属性を使用して、メッセージの解決を試みます。
`StringSE`	`getMessage(StringSE code, ObjectSE[] args, LocaleSE locale)` メッセージの解決を試みます。
`StringSE`	`getMessage(StringSE code, ObjectSE[] args, StringSE defaultMessage, LocaleSE locale)` メッセージの解決を試みます。
`ApplicationContext`	`getParent()` 親コンテキストを返します。親がない場合（つまり、このコンテキストがコンテキスト階層のルートである場合）は、`null` を返します。
`BeanFactory`	`getParentBeanFactory()` 親 Bean ファクトリ、または存在しない場合は `null` を返します。
`protected ResourcePatternResolver`	`getResourcePatternResolver()` ロケーションパターンをリソースインスタンスに解決するために使用する ResourcePatternResolver を返します。
`Resource[]`	`getResources(StringSE locationPattern)` 指定されたロケーションパターンを `Resource` オブジェクトに解決します。
`long`	`getStartupDate()` このコンテキストが最初にロードされたときのタイムスタンプ（ms）を返します。
`ClassSE<?>`	`getType(StringSE name)` 指定された名前の Bean の型を判別します。
`ClassSE<?>`	`getType(StringSE name, boolean allowFactoryBeanInit)` 指定された名前の Bean の型を判別します。
`protected void`	`initApplicationEventMulticaster()` ApplicationEventMulticaster を初期化します。
`protected void`	`initLifecycleProcessor()` LifecycleProcessor を初期化します。
`protected void`	`initMessageSource()` MessageSource を初期化します。
`protected void`	`initPropertySources()` スタブプロパティソースを実際のインスタンスに置き換えます。
`protected void`	`invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)` 登録されているすべての BeanFactoryPostProcessor Bean をインスタンス化して呼び出します。
`boolean`	`isActive()` このアプリケーションコンテキストがアクティブかどうか、つまり、少なくとも 1 回はリフレッシュされ、まだ閉じられていないかどうかを判断します。
`boolean`	`isPrototype(StringSE name)` この Bean はプロトタイプですか？つまり、`BeanFactory.getBean(java.lang.String)` は常に独立したインスタンスを返しますか？
`boolean`	`isRunning()` このコンポーネントが現在実行されているかどうかを確認します。
`boolean`	`isSingleton(StringSE name)` この Bean は共有シングルトンですか？つまり、`BeanFactory.getBean(java.lang.String)` は常に同じインスタンスを返しますか？
`boolean`	`isTypeMatch(StringSE name, ClassSE<?> typeToMatch)` 指定された名前の Bean が指定された型と一致するかどうかを確認します。
`boolean`	`isTypeMatch(StringSE name, ResolvableType typeToMatch)` 指定された名前の Bean が指定された型と一致するかどうかを確認します。
`protected ConfigurableListableBeanFactory`	`obtainFreshBeanFactory()` サブクラスに内部 Bean ファクトリをリフレッシュするよう指示します。
`protected void`	`onClose()` オーバーライドしてコンテキスト固有のシャットダウン作業を追加できるテンプレートメソッド。
`protected void`	`onRefresh()` コンテキスト固有のリフレッシュ作業を追加するためにオーバーライドできるテンプレートメソッド。
`protected void`	`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)` 標準の初期化後に、アプリケーションコンテキストの内部 Bean ファクトリを変更します。
`protected void`	`prepareBeanFactory(ConfigurableListableBeanFactory beanFactory)` コンテキストの ClassLoader やポストプロセッサーなど、ファクトリの標準コンテキスト特性を構成します。
`protected void`	`prepareRefresh()` このコンテキストをリフレッシュして、起動日とアクティブフラグを設定し、プロパティソースの初期化を実行する準備をします。
`void`	`publishEvent(ApplicationEvent event)` 指定されたイベントをすべてのリスナーに公開します。
`void`	`publishEvent(ObjectSE event)` 指定されたイベントをすべてのリスナーに公開します。
`protected void`	`publishEvent(ObjectSE event, ResolvableType eventType)` 指定されたイベントをすべてのリスナーに公開します。
`void`	`refresh()` Java ベースの構成、XML ファイル、プロパティファイル、リレーショナルデータベーススキーマ、その他の形式の構成の永続的な表現をロードまたはリフレッシュします。
`protected abstract void`	`refreshBeanFactory()` サブクラスは、実際の構成ロードを実行するためにこのメソッドを実装する必要があります。
`protected void`	`registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory)` すべての BeanPostProcessor Bean をインスタンス化して登録します（指定されている場合は明示的な順序に従います）。
`protected void`	`registerListeners()` ApplicationListener を実装する Bean をリスナーとして追加します。
`void`	`registerShutdownHook()` `SpringContextShutdownHook` という名前SEのシャットダウンフックを JVM ランタイムに登録し、その時点ですでに閉じられていない限り、JVM シャットダウン時にこのコンテキストを閉じます。
`protected void`	`resetCommonCaches()` Spring の一般的なリフレクションメタデータキャッシュ、特に `ReflectionUtils`、`AnnotationUtils`、`ResolvableType` および `CachedIntrospectionResults` キャッシュをリセットします。
`void`	`setApplicationStartup(ApplicationStartup applicationStartup)` このアプリケーションコンテキストに `ApplicationStartup` を設定します。
`void`	`setDisplayName(StringSE displayName)` このコンテキストにわかりやすい名前を設定します。
`void`	`setEnvironment(ConfigurableEnvironment environment)` このアプリケーションコンテキストの `Environment` を設定します。
`void`	`setId(StringSE id)` このアプリケーションコンテキストの一意の ID を設定します。
`void`	`setParent(ApplicationContext parent)` このアプリケーションコンテキストの親を設定します。
`void`	`start()` このコンポーネントを起動します。
`void`	`stop()` このメソッドを返すとコンポーネントが完全に停止するように、通常は同期的にこのコンポーネントを停止します。
`StringSE`	`toString()` このコンテキストに関する情報を返します。

クラス org.springframework.core.io.DefaultResourceLoader から継承されたメソッド
addProtocolResolver, clearResourceCaches, getClassLoader, getProtocolResolvers, getResource, getResourceByPath, getResourceCache, setClassLoader

クラス java.lang.ObjectSE から継承されたメソッド
cloneSE, equalsSE, finalizeSE, getClassSE, hashCodeSE, notifySE, notifyAllSE, waitSE, waitSE, waitSE

インターフェース org.springframework.context.ConfigurableApplicationContext から継承されたメソッド
addProtocolResolver, setClassLoader

インターフェース org.springframework.core.io.ResourceLoader から継承されたメソッド
getClassLoader, getResource

- フィールドの詳細
  - MESSAGE_SOURCE_BEAN_NAME
```
public static final StringSE MESSAGE_SOURCE_BEAN_NAME
```
    ファクトリでの MessageSource Bean の名前。何も指定されていない場合、メッセージ解決は親に委譲されます。
    関連事項:
    MessageSource, 定数フィールド値
  - LIFECYCLE_PROCESSOR_BEAN_NAME
```
public static final StringSE LIFECYCLE_PROCESSOR_BEAN_NAME
```
    ファクトリでの LifecycleProcessor Bean の名前。何も指定されていない場合は、DefaultLifecycleProcessor が使用されます。
    関連事項:
    LifecycleProcessor, DefaultLifecycleProcessor, 定数フィールド値
  - APPLICATION_EVENT_MULTICASTER_BEAN_NAME
```
public static final StringSE APPLICATION_EVENT_MULTICASTER_BEAN_NAME
```
    ファクトリでの ApplicationEventMulticaster Bean の名前。何も指定しない場合、デフォルトの SimpleApplicationEventMulticaster が使用されます。
    関連事項:
    ApplicationEventMulticaster, SimpleApplicationEventMulticaster, 定数フィールド値
  - logger
```
protected final Log logger
```
    このクラスで使用されるロガー。サブクラスで使用できます。
- コンストラクターの詳細
  - AbstractApplicationContext
```
public AbstractApplicationContext()
```
    親なしで新しい AbstractApplicationContext を作成します。
  - AbstractApplicationContext
```
public AbstractApplicationContext(@Nullable
                                  ApplicationContext parent)
```
    指定された親コンテキストで新しい AbstractApplicationContext を作成します。
    パラメーター:
    parent - 親コンテキスト
- メソッドの詳細
  - setId
```
public void setId(StringSE id)
```
    このアプリケーションコンテキストの一意の ID を設定します。
    デフォルトは、コンテキストインスタンスのオブジェクト ID、またはコンテキスト自体が Bean として定義されている場合はコンテキスト Bean の名前です。
    次で指定:
    インターフェース ConfigurableApplicationContext の setId
    パラメーター:
    id - コンテキストの一意の ID
  - getId
```
public StringSE getId()
```
    インターフェースからコピーされた説明: ApplicationContext
    このアプリケーションコンテキストの一意の ID を返します。
    次で指定:
    インターフェース ApplicationContext の getId
    戻り値:
    コンテキストの一意の ID、または存在しない場合は null
  - getApplicationName
```
public StringSE getApplicationName()
```
    インターフェースからコピーされた説明: ApplicationContext
    このコンテキストが属するデプロイされたアプリケーションの名前を返します。
    次で指定:
    インターフェース ApplicationContext の getApplicationName
    戻り値:
    デプロイされたアプリケーションの名前、またはデフォルトで空の文字列
  - setDisplayName
```
public void setDisplayName(StringSE displayName)
```
    このコンテキストにわかりやすい名前を設定します。通常、具体的なコンテキスト実装の初期化中に行われます。
    デフォルトは、コンテキストインスタンスのオブジェクト ID です。
  - getDisplayName
```
public StringSE getDisplayName()
```
    このコンテキストのフレンドリ名を返します。
    次で指定:
    インターフェース ApplicationContext の getDisplayName
    戻り値:
    このコンテキストの表示名 (非 null)
  - getParent
```
@Nullable
public ApplicationContext getParent()
```
    親コンテキストを返します。親がない場合（つまり、このコンテキストがコンテキスト階層のルートである場合）は、null を返します。
    次で指定:
    インターフェース ApplicationContext の getParent
    戻り値:
    親コンテキスト、または親がない場合は null
  - setEnvironment
```
public void setEnvironment(ConfigurableEnvironment environment)
```
    このアプリケーションコンテキストの Environment を設定します。
    デフォルト値は createEnvironment() によって決定されます。この方法でデフォルトを置き換えることは 1 つのオプションですが、getEnvironment() による構成も検討する必要があります。どちらの場合も、そのような変更は refresh() の前に実行する必要があります。
    次で指定:
    インターフェース ConfigurableApplicationContext の setEnvironment
    パラメーター:
    environment - 新しい環境
    関連事項:
    createEnvironment()
  - getEnvironment
```
public ConfigurableEnvironment getEnvironment()
```
    このアプリケーションコンテキストの Environment を構成可能な形式で返し、さらにカスタマイズできるようにします。
    何も指定されていない場合、デフォルトの環境は createEnvironment() を介して初期化されます。
    次で指定:
    インターフェース ConfigurableApplicationContext の getEnvironment
    次で指定:
    インターフェース EnvironmentCapable の getEnvironment
  - createEnvironment
```
protected ConfigurableEnvironment createEnvironment()
```
    新しい StandardEnvironment を作成して返します。
    サブクラスは、カスタム ConfigurableEnvironment 実装を提供するためにこのメソッドをオーバーライドできます。
  - getAutowireCapableBeanFactory
```
public AutowireCapableBeanFactory getAutowireCapableBeanFactory()
                                                         throws IllegalStateExceptionSE
```
    すでに利用可能な場合、このコンテキストの内部 Bean ファクトリを AutowireCapableBeanFactory として返します。
    次で指定:
    インターフェース ApplicationContext の getAutowireCapableBeanFactory
    戻り値:
    このコンテキストの AutowireCapableBeanFactory
    例外:
    IllegalStateExceptionSE - コンテキストが AutowireCapableBeanFactory インターフェースをサポートしていない場合、またはオートワイヤー可能な Bean ファクトリをまだ保持していない場合（たとえば、refresh() が呼び出されたことがない場合）、コンテキストがすでに閉じられている場合
    関連事項:
    getBeanFactory()
  - getStartupDate
```
public long getStartupDate()
```
    このコンテキストが最初にロードされたときのタイムスタンプ（ms）を返します。
    次で指定:
    インターフェース ApplicationContext の getStartupDate
    戻り値:
    このコンテキストが最初にロードされたときのタイムスタンプ（ミリ秒）
  - publishEvent
```
public void publishEvent(ApplicationEvent event)
```
    指定されたイベントをすべてのリスナーに公開します。
    メモ: リスナーは、MessageSource の後に初期化され、リスナー実装内でそれにアクセスできるようになります。MessageSource 実装はイベントを公開できません。
    次で指定:
    インターフェース ApplicationEventPublisher の publishEvent
    パラメーター:
    event - 公開するイベント (アプリケーション固有または標準のフレームワークイベント)
    関連事項:
    ApplicationEventPublisher.publishEvent(Object), ContextRefreshedEvent, ContextClosedEvent
  - publishEvent
```
public void publishEvent(ObjectSE event)
```
    指定されたイベントをすべてのリスナーに公開します。
    メモ: リスナーは、MessageSource の後に初期化され、リスナー実装内でそれにアクセスできるようになります。MessageSource 実装はイベントを公開できません。
    次で指定:
    インターフェース ApplicationEventPublisher の publishEvent
    パラメーター:
    event - 公開するイベント (ApplicationEvent または PayloadApplicationEvent に変換されるペイロードオブジェクト)
    関連事項:
    ApplicationEventPublisher.publishEvent(ApplicationEvent), PayloadApplicationEvent
  - publishEvent
```
protected void publishEvent(ObjectSE event,
                            @Nullable
                            ResolvableType eventType)
```
    指定されたイベントをすべてのリスナーに公開します。
    パラメーター:
    event - 公開するイベント (ApplicationEvent または PayloadApplicationEvent に変換されるペイロードオブジェクト)
    eventType - 解決済みのイベント型（わかっている場合）
    導入:
    4.2
  - setApplicationStartup
```
public void setApplicationStartup(ApplicationStartup applicationStartup)
```
    インターフェースからコピーされた説明: ConfigurableApplicationContext
    このアプリケーションコンテキストに ApplicationStartup を設定します。
    これにより、アプリケーションコンテキストは起動時にメトリクスを記録できます。
    次で指定:
    インターフェース ConfigurableApplicationContext の setApplicationStartup
    パラメーター:
    applicationStartup - 新しいコンテキストイベントファクトリ
  - getApplicationStartup
```
public ApplicationStartup getApplicationStartup()
```
    インターフェースからコピーされた説明: ConfigurableApplicationContext
    このアプリケーションコンテキストの ApplicationStartup を返します。
    次で指定:
    インターフェース ConfigurableApplicationContext の getApplicationStartup
  - getResourcePatternResolver
```
protected ResourcePatternResolver getResourcePatternResolver()
```
    ロケーションパターンを Resource インスタンスに解決するために使用する ResourcePatternResolver を返します。デフォルトは PathMatchingResourcePatternResolver で、Ant スタイルのロケーションパターンをサポートしています。
    たとえば Web 環境など、拡張解決戦略のために、サブクラスでオーバーライドできます。
    ロケーションパターンを解決する必要がある場合は、これを呼び出さないでください。代わりに、コンテキストの getResources メソッドを呼び出します。これにより、ResourcePatternResolver に委譲されます。
    戻り値:
    このコンテキストの ResourcePatternResolver
    関連事項:
    getResources(java.lang.String), PathMatchingResourcePatternResolver
  - setParent
```
public void setParent(@Nullable
                      ApplicationContext parent)
```
    このアプリケーションコンテキストの親を設定します。
    親が非 null であり、その環境が ConfigurableEnvironment のインスタンスである場合、親環境はこの（子）アプリケーションコンテキスト環境とマージされます。
    次で指定:
    インターフェース ConfigurableApplicationContext の setParent
    パラメーター:
    parent - 親コンテキスト
    関連事項:
    ConfigurableEnvironment.merge(ConfigurableEnvironment)
  - addBeanFactoryPostProcessor
```
public void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor)
```
    インターフェースからコピーされた説明: ConfigurableApplicationContext
    Bean 定義のいずれかが評価される前に、リフレッシュ時にこのアプリケーションコンテキストの内部 Bean ファクトリに適用される新しい BeanFactoryPostProcessor を追加します。コンテキスト設定中に呼び出されます。
    次で指定:
    インターフェース ConfigurableApplicationContext の addBeanFactoryPostProcessor
    パラメーター:
    postProcessor - 登録するファクトリプロセッサー
  - getBeanFactoryPostProcessors
```
public ListSE<BeanFactoryPostProcessor> getBeanFactoryPostProcessors()
```
    内部 BeanFactory に適用される BeanFactoryPostProcessors のリストを返します。
  - addApplicationListener
```
public void addApplicationListener(ApplicationListener<?> listener)
```
    インターフェースからコピーされた説明: ConfigurableApplicationContext
    コンテキストのリフレッシュやシャットダウンなどのコンテキストイベントで通知される新しい ApplicationListener を追加します。
    ここに登録されている ApplicationListener は、コンテキストがまだアクティブでない場合はリフレッシュ時に適用されます。コンテキストがすでにアクティブな場合は、現在のイベントマルチキャスターでオンザフライで適用されます。
    次で指定:
    インターフェース ConfigurableApplicationContext の addApplicationListener
    パラメーター:
    listener - 登録する ApplicationListener
    関連事項:
    ContextRefreshedEvent, ContextClosedEvent
  - getApplicationListeners
```
public CollectionSE<ApplicationListener<?>> getApplicationListeners()
```
    静的に指定された ApplicationListeners のリストを返します。
  - refresh
```
public void refresh()
             throws BeansException,
                    IllegalStateExceptionSE
```
    インターフェースからコピーされた説明: ConfigurableApplicationContext
    Java ベースの構成、XML ファイル、プロパティファイル、リレーショナルデータベーススキーマ、その他の形式の構成の永続的な表現をロードまたはリフレッシュします。
    これはスタートアップメソッドであるため、リソースがぶら下がらないように、失敗した場合はすでに作成されているシングルトンを破棄する必要があります。つまり、このメソッドを呼び出した後は、シングルトンをインスタンス化するか、まったくインスタンス化しないかのどちらかです。
    次で指定:
    インターフェース ConfigurableApplicationContext の refresh
    例外:
    BeansException - Bean ファクトリを初期化できなかった場合
    IllegalStateExceptionSE - すでに初期化されていて、複数回のリフレッシュ試行がサポートされていない場合
  - prepareRefresh
```
protected void prepareRefresh()
```
    このコンテキストをリフレッシュして、起動日とアクティブフラグを設定し、プロパティソースの初期化を実行する準備をします。
  - initPropertySources
```
protected void initPropertySources()
```
    スタブプロパティソースを実際のインスタンスに置き換えます。
    関連事項:
    PropertySource.StubPropertySource, WebApplicationContextUtils.initServletPropertySources(org.springframework.core.env.MutablePropertySources, javax.servlet.ServletContext)
  - obtainFreshBeanFactory
```
protected ConfigurableListableBeanFactory obtainFreshBeanFactory()
```
    サブクラスに内部 Bean ファクトリをリフレッシュするよう指示します。
    戻り値:
    新しい BeanFactory インスタンス
    関連事項:
    refreshBeanFactory(), getBeanFactory()
  - prepareBeanFactory
```
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory)
```
    コンテキストの ClassLoader やポストプロセッサーなど、ファクトリの標準コンテキスト特性を構成します。
    パラメーター:
    beanFactory - 設定する BeanFactory
  - postProcessBeanFactory
```
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
```
    標準の初期化後に、アプリケーションコンテキストの内部 Bean ファクトリを変更します。すべての Bean 定義がロードされますが、Bean はまだインスタンス化されていません。これにより、特定の ApplicationContext 実装で特別な BeanPostProcessors などを登録できます。
    パラメーター:
    beanFactory - アプリケーションコンテキストで使用される Bean ファクトリ
  - invokeBeanFactoryPostProcessors
```
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)
```
    登録されているすべての BeanFactoryPostProcessor Bean をインスタンス化して呼び出します。
    シングルトンのインスタンス化の前に呼び出す必要があります。
  - registerBeanPostProcessors
```
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory)
```
    すべての BeanPostProcessor Bean をインスタンス化して登録します（指定されている場合は明示的な順序に従います）。
    アプリケーション Bean をインスタンス化する前に呼び出す必要があります。
  - initMessageSource
```
protected void initMessageSource()
```
    MessageSource を初期化します。このコンテキストで定義されていない場合は、親を使用します。
  - initApplicationEventMulticaster
```
protected void initApplicationEventMulticaster()
```
    ApplicationEventMulticaster を初期化します。コンテキストで何も定義されていない場合は、SimpleApplicationEventMulticaster を使用します。
    関連事項:
    SimpleApplicationEventMulticaster
  - initLifecycleProcessor
```
protected void initLifecycleProcessor()
```
    LifecycleProcessor を初期化します。コンテキストで何も定義されていない場合は、DefaultLifecycleProcessor を使用します。
    関連事項:
    DefaultLifecycleProcessor
  - onRefresh
```
protected void onRefresh()
                  throws BeansException
```
    コンテキスト固有のリフレッシュ作業を追加するためにオーバーライドできるテンプレートメソッド。シングルトンのインスタンス化の前に、特別な Bean の初期化で呼び出されます。
    この実装は空です。
    例外:
    BeansException - エラーの場合
    関連事項:
    refresh()
  - registerListeners
```
protected void registerListeners()
```
    ApplicationListener を実装する Bean をリスナーとして追加します。Bean でなくても追加できる他のリスナーには影響しません。
  - finishBeanFactoryInitialization
```
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)
```
    このコンテキストの Bean ファクトリの初期化を終了し、残りのすべてのシングルトン Bean を初期化します。
  - finishRefresh
```
protected void finishRefresh()
```
    このコンテキストのリフレッシュを完了し、LifecycleProcessor の onRefresh() メソッドを呼び出して、ContextRefreshedEvent を公開します。
  - cancelRefresh
```
protected void cancelRefresh(BeansException ex)
```
    このコンテキストのリフレッシュ試行をキャンセルし、例外がスローされた後に active フラグをリセットします。
    パラメーター:
    ex - キャンセルに至った例外
  - resetCommonCaches
```
protected void resetCommonCaches()
```
    Spring の一般的なリフレクションメタデータキャッシュ、特に ReflectionUtils、AnnotationUtils、ResolvableType および CachedIntrospectionResults キャッシュをリセットします。
    導入:
    4.2
    関連事項:
    ReflectionUtils.clearCache(), AnnotationUtils.clearCache(), ResolvableType.clearCache(), CachedIntrospectionResults.clearClassLoader(ClassLoader)
  - registerShutdownHook
```
public void registerShutdownHook()
```
    SpringContextShutdownHook という名前SEのシャットダウンフックを JVM ランタイムに登録し、その時点ですでに閉じられていない限り、JVM シャットダウン時にこのコンテキストを閉じます。
    実際のクロージング手順については、doClose() に委譲します。
    次で指定:
    インターフェース ConfigurableApplicationContext の registerShutdownHook
    関連事項:
    Runtime.addShutdownHook(java.lang.Thread)SE, ConfigurableApplicationContext.SHUTDOWN_HOOK_THREAD_NAME, close(), doClose()
  - destroy
```
@DeprecatedSE
public void destroy()
```
    非推奨。Spring Framework 5.0 現在、close() を推奨
    このインスタンスを破棄するためのコールバック。最初は DisposableBean 実装にアタッチされていました（5.0 ではもう使用されていません）。
    close() メソッドは、ApplicationContext をシャットダウンするネイティブな方法であり、このメソッドが委譲するだけです。
  - close
```
public void close()
```
    このアプリケーションコンテキストを閉じ、Bean ファクトリ内のすべての Bean を破棄します。
    実際のクロージング手順については、doClose() に委譲します。また、JVM シャットダウンフックが登録されている場合は、不要になったため削除します。
    次で指定:
    インターフェース CloseableSE の closeSE
    次で指定:
    インターフェース AutoCloseableSE の closeSE
    次で指定:
    インターフェース ConfigurableApplicationContext の close
    関連事項:
    doClose(), registerShutdownHook()
  - doClose
```
protected void doClose()
```
    実際にコンテキストを閉じる: ContextClosedEvent を公開し、このアプリケーションコンテキストの Bean ファクトリ内のシングルトンを破棄します。
    close() と JVM シャットダウンフック（存在する場合）の両方によって呼び出されます。
    関連事項:
    ContextClosedEvent, destroyBeans(), close(), registerShutdownHook()
  - destroyBeans
```
protected void destroyBeans()
```
    このコンテキストが管理するすべての Bean を破棄するためのテンプレートメソッド。デフォルトの実装は、このコンテキストでキャッシュされたすべてのシングルトンを破棄し、DisposableBean.destroy() または指定された「破棄メソッド」、あるいはその両方を呼び出します。
    オーバーライドして、コンテキストの BeanFactory がアクティブな間に、標準のシングルトン破棄の直前または直後にコンテキスト固有の Bean 破棄ステップを追加できます。
    関連事項:
    getBeanFactory(), ConfigurableBeanFactory.destroySingletons()
  - onClose
```
protected void onClose()
```
    コンテキスト固有のシャットダウン作業を追加するためにオーバーライドできるテンプレートメソッド。デフォルトの実装は空です。
    このコンテキストの BeanFactory が閉じられた後、doClose() のシャットダウン手順の最後に呼び出されます。BeanFactory がアクティブな間にカスタムシャットダウンロジックを実行する必要がある場合は、代わりに destroyBeans() メソッドをオーバーライドします。
  - isActive
```
public boolean isActive()
```
    インターフェースからコピーされた説明: ConfigurableApplicationContext
    このアプリケーションコンテキストがアクティブかどうか、つまり、少なくとも 1 回はリフレッシュされ、まだ閉じられていないかどうかを判断します。
    次で指定:
    インターフェース ConfigurableApplicationContext の isActive
    戻り値:
    コンテキストがまだアクティブかどうか
    関連事項:
    ConfigurableApplicationContext.refresh(), ConfigurableApplicationContext.close(), ConfigurableApplicationContext.getBeanFactory()
  - assertBeanFactoryActive
```
protected void assertBeanFactoryActive()
```
    このコンテキストの BeanFactory が現在アクティブであることをアサートし、アクティブでない場合は IllegalStateExceptionSE をスローします。
    アクティブなコンテキストに依存するすべての BeanFactory 委譲メソッド、特にすべての Bean アクセサーメソッドによって呼び出されます。
    デフォルトの実装では、このコンテキスト全体の 'active' ステータスをチェックします。より具体的なチェックの場合、またはそのような場合に getBeanFactory() 自体が例外をスローする場合は何もしない場合はオーバーライドされます。
  - getBean
```
public ObjectSE getBean(StringSE name)
               throws BeansException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された Bean のインスタンス（共有または独立）を返します。
    この方法では、Spring BeanFactory をシングルトンまたはプロトタイプの設計パターンの代わりとして使用できます。シングルトン Bean の場合、呼び出し元は返されたオブジェクトへの参照を保持できます。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の getBean
    パラメーター:
    name - 取得する Bean の名前
    戻り値:
    Bean のインスタンス
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    BeansException - Bean を取得できなかった場合
  - getBean
```
public <T> T getBean(StringSE name,
                     ClassSE<T> requiredType)
              throws BeansException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された Bean のインスタンス（共有または独立）を返します。
    BeanFactory.getBean(String) と同じように動作しますが、Bean が必要な型でない場合は BeanNotOfRequiredTypeException をスローすることにより、型安全の基準を提供します。これは、BeanFactory.getBean(String) で発生する可能性があるように、結果を正しくキャストすると ClassCastException がスローされないことを意味します。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の getBean
    パラメーター:
    name - 取得する Bean の名前
    requiredType - Bean が一致する必要があることを入力します。インターフェースまたはスーパークラスにすることができます
    戻り値:
    Bean のインスタンス
    例外:
    NoSuchBeanDefinitionException - そのような Bean 定義がない場合
    BeanNotOfRequiredTypeException - Bean が必要な型でない場合
    BeansException - Bean を作成できなかった場合
  - getBean
```
public ObjectSE getBean(StringSE name,
                      ObjectSE... args)
               throws BeansException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された Bean のインスタンス（共有または独立）を返します。
    Bean 定義で指定されたデフォルト引数（存在する場合）をオーバーライドして、明示的なコンストラクター引数 / ファクトリメソッド引数を指定できます。
    次で指定:
    インターフェース BeanFactory の getBean
    パラメーター:
    name - 取得する Bean の名前
    args - 明示的な引数を使用して Bean インスタンスを作成するときに使用する引数 (既存のインスタンスを取得するのではなく、新しいインスタンスを作成するときにのみ適用されます)
    戻り値:
    Bean のインスタンス
    例外:
    NoSuchBeanDefinitionException - そのような Bean 定義がない場合
    BeanDefinitionStoreException - 引数は指定されているが、影響を受ける Bean がプロトタイプではない場合
    BeansException - Bean を作成できなかった場合
  - getBean
```
public <T> T getBean(ClassSE<T> requiredType)
              throws BeansException
```
    インターフェースからコピーされた説明: BeanFactory
    指定されたオブジェクト型が存在する場合、一意に一致する Bean インスタンスを返します。
    このメソッドは、ListableBeanFactory の型別ルックアップ領域に入りますが、指定された型の名前に基づいた従来の名前別ルックアップにも変換できます。Bean のセット全体でより広範な検索操作を行うには、ListableBeanFactory または BeanFactoryUtils（あるいはその両方）を使用します。
    次で指定:
    インターフェース BeanFactory の getBean
    パラメーター:
    requiredType - Bean が一致する必要があることを入力します。インターフェースまたはスーパークラスにすることができます
    戻り値:
    必要な型に一致する単一の Bean のインスタンス
    例外:
    NoSuchBeanDefinitionException - 指定された型の Bean が見つからなかった場合
    NoUniqueBeanDefinitionException - 指定された型の複数の Bean が見つかった場合
    BeansException - Bean を作成できなかった場合
    関連事項:
    ListableBeanFactory
  - getBean
```
public <T> T getBean(ClassSE<T> requiredType,
                     ObjectSE... args)
              throws BeansException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された Bean のインスタンス（共有または独立）を返します。
    Bean 定義で指定されたデフォルト引数（存在する場合）をオーバーライドして、明示的なコンストラクター引数 / ファクトリメソッド引数を指定できます。
    このメソッドは、ListableBeanFactory の型別ルックアップ領域に入りますが、指定された型の名前に基づいた従来の名前別ルックアップにも変換できます。Bean のセット全体でより広範な検索操作を行うには、ListableBeanFactory または BeanFactoryUtils（あるいはその両方）を使用します。
    次で指定:
    インターフェース BeanFactory の getBean
    パラメーター:
    requiredType - Bean が一致する必要があることを入力します。インターフェースまたはスーパークラスにすることができます
    args - 明示的な引数を使用して Bean インスタンスを作成するときに使用する引数 (既存のインスタンスを取得するのではなく、新しいインスタンスを作成するときにのみ適用されます)
    戻り値:
    Bean のインスタンス
    例外:
    NoSuchBeanDefinitionException - そのような Bean 定義がない場合
    BeanDefinitionStoreException - 引数は指定されているが、影響を受ける Bean がプロトタイプではない場合
    BeansException - Bean を作成できなかった場合
  - getBeanProvider
```
public <T> ObjectProvider<T> getBeanProvider(ClassSE<T> requiredType)
```
    インターフェースからコピーされた説明: BeanFactory
    指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
    ジェネリクス型を照合するには、BeanFactory.getBeanProvider(ResolvableType) を検討してください。
    次で指定:
    インターフェース BeanFactory の getBeanProvider
    パラメーター:
    requiredType - Bean が一致する必要があることを入力します。インターフェースまたはスーパークラスにすることができます
    戻り値:
    対応するプロバイダーのハンドル
    関連事項:
    BeanFactory.getBeanProvider(ResolvableType)
  - getBeanProvider
```
public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType)
```
    インターフェースからコピーされた説明: BeanFactory
    指定された Bean のプロバイダーを返します。これにより、可用性と一意性のオプションを含む、インスタンスの遅延オンデマンド取得が可能になります。このバリアントでは、メソッド / コンストラクターパラメーターでジェネリクス型宣言を使用するリフレクションインジェクションポイントと同様に、一致するジェネリクス型を指定できます。
    リフレクティブインジェクションポイントとは対照的に、ここでは Bean のコレクションはサポートされていないことに注意してください。特定の型に一致する Bean のリストをプログラムで取得するには、ここで引数として実際の Bean 型を指定し、その後 ObjectProvider.orderedStream() またはその遅延ストリーミング / 反復オプションを使用します。
    また、Java の割り当て規則に従って、ジェネリクスのマッチングはここでは厳密です。未チェックのセマンティクス（「未チェック」の Java コンパイラー警告と同様）を使用した寛大なフォールバックマッチングの場合、このバリアントとの完全な汎用一致が available でない場合は、2 番目のステップとして raw 型を使用して BeanFactory.getBeanProvider(Class) を呼び出すことを検討してください。
    次で指定:
    インターフェース BeanFactory の getBeanProvider
    パラメーター:
    requiredType - Bean が一致する必要があると入力します。ジェネリクス型宣言にすることができます
    戻り値:
    対応するプロバイダーのハンドル
    関連事項:
    ObjectProvider.iterator(), ObjectProvider.stream(), ObjectProvider.orderedStream()
  - containsBean
```
public boolean containsBean(StringSE name)
```
    インターフェースからコピーされた説明: BeanFactory
    この Bean ファクトリには、指定された名前の Bean 定義または外部登録されたシングルトンインスタンスが含まれているか判定します。
    指定された名前がエイリアスの場合、対応する正規の Bean 名に変換されます。
    このファクトリが階層的である場合、このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに問い合わせます。
    指定された名前に一致する Bean 定義またはシングルトンインスタンスが見つかった場合、このメソッドは、名前付き Bean 定義がスコープ内で具体的または抽象的、遅延または先行であるかどうかにかかわらず、true を返します。このメソッドからの true 戻り値は、必ずしも BeanFactory.getBean(java.lang.String) が同じ名前のインスタンスを取得できることを示しているわけではないことに注意してください。
    次で指定:
    インターフェース BeanFactory の containsBean
    パラメーター:
    name - 照会する Bean の名前
    戻り値:
    指定された名前の Bean が存在するかどうか
  - isSingleton
```
public boolean isSingleton(StringSE name)
                    throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: BeanFactory
    この Bean は共有シングルトンですか？つまり、BeanFactory.getBean(java.lang.String) は常に同じインスタンスを返しますか？
    メモ: false を返すこのメソッドは、独立したインスタンスを明確に示していません。これは、スコープが設定された Bean にも対応している可能性がある非シングルトンインスタンスを示します。BeanFactory.isPrototype(java.lang.String) 操作を使用して、独立したインスタンスを明示的にチェックします。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の isSingleton
    パラメーター:
    name - 照会する Bean の名前
    戻り値:
    この Bean がシングルトンインスタンスに対応するかどうか
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    BeanFactory.getBean(java.lang.String), BeanFactory.isPrototype(java.lang.String)
  - isPrototype
```
public boolean isPrototype(StringSE name)
                    throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: BeanFactory
    この Bean はプロトタイプですか？つまり、BeanFactory.getBean(java.lang.String) は常に独立したインスタンスを返しますか？
    メモ: false を返すこのメソッドは、シングルトンオブジェクトを明確に示していません。これは独立したインスタンスを示し、スコープ付き Bean にも対応する場合があります。BeanFactory.isSingleton(java.lang.String) 操作を使用して、共有シングルトンインスタンスを明示的に確認します。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の isPrototype
    パラメーター:
    name - 照会する Bean の名前
    戻り値:
    この Bean が常に独立したインスタンスを配信するかどうか
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    BeanFactory.getBean(java.lang.String), BeanFactory.isSingleton(java.lang.String)
  - isTypeMatch
```
public boolean isTypeMatch(StringSE name,
                           ResolvableType typeToMatch)
                    throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された名前の Bean が指定された型と一致するかどうかを確認します。より具体的には、指定された名前の BeanFactory.getBean(java.lang.String) 呼び出しが、指定されたターゲット型に割り当て可能なオブジェクトを返すかどうかを確認します。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の isTypeMatch
    パラメーター:
    name - 照会する Bean の名前
    typeToMatch - 照合する型 (ResolvableType として)
    戻り値:
    Bean 型が一致する場合は true、一致しないかまだ判別できない場合は false
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    BeanFactory.getBean(java.lang.String), BeanFactory.getType(java.lang.String)
  - isTypeMatch
```
public boolean isTypeMatch(StringSE name,
                           ClassSE<?> typeToMatch)
                    throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された名前の Bean が指定された型と一致するかどうかを確認します。より具体的には、指定された名前の BeanFactory.getBean(java.lang.String) 呼び出しが、指定されたターゲット型に割り当て可能なオブジェクトを返すかどうかを確認します。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の isTypeMatch
    パラメーター:
    name - 照会する Bean の名前
    typeToMatch - 照合する型 (Class として)
    戻り値:
    Bean 型が一致する場合は true、一致しないかまだ判別できない場合は false
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    BeanFactory.getBean(java.lang.String), BeanFactory.getType(java.lang.String)
  - getType
```
@Nullable
public ClassSE<?> getType(StringSE name)
                           throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された名前の Bean の型を判別します。具体的には、指定された名前に対して BeanFactory.getBean(java.lang.String) が返すオブジェクトの型を決定します。
    FactoryBean の場合は、FactoryBean.getObjectType() によって公開されている、FactoryBean が作成するオブジェクトの型を返します。これにより、以前に初期化されていない FactoryBean （BeanFactory.getType(String, boolean) を参照）が初期化される可能性があります。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の getType
    パラメーター:
    name - 照会する Bean の名前
    戻り値:
    Bean の型、または判別できない場合は null
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    BeanFactory.getBean(java.lang.String), BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)
  - getType
```
@Nullable
public ClassSE<?> getType(StringSE name,
                                  boolean allowFactoryBeanInit)
                           throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: BeanFactory
    指定された名前の Bean の型を判別します。具体的には、指定された名前に対して BeanFactory.getBean(java.lang.String) が返すオブジェクトの型を決定します。
    FactoryBean の場合は、FactoryBean.getObjectType() によって公開されている、FactoryBean が作成するオブジェクトの型を返します。allowFactoryBeanInit フラグによっては、初期の型情報が利用できない場合、以前に初期化されていない FactoryBean が初期化される可能性があります。
    エイリアスを対応する正規の Bean 名に変換します。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の getType
    パラメーター:
    name - 照会する Bean の名前
    allowFactoryBeanInit - FactoryBean がオブジェクト型を判別する目的でのみ初期化されるかどうか
    戻り値:
    Bean の型、または判別できない場合は null
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    BeanFactory.getBean(java.lang.String), BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)
  - getAliases
```
public StringSE[] getAliases(StringSE name)
```
    インターフェースからコピーされた説明: BeanFactory
    存在する場合、指定された Bean 名のエイリアスを返します。
    これらのエイリアスはすべて、BeanFactory.getBean(java.lang.String) 呼び出しで使用される場合、同じ Bean を指します。
    指定された名前がエイリアスの場合、対応する元の Bean 名と他のエイリアス（存在する場合）が返され、元の Bean 名が配列の最初の要素になります。
    このファクトリインスタンスで Bean が見つからないかどうかを親ファクトリに確認します。
    次で指定:
    インターフェース BeanFactory の getAliases
    パラメーター:
    name - エイリアスをチェックする Bean 名
    戻り値:
    エイリアス、または存在しない場合は空の配列
    関連事項:
    BeanFactory.getBean(java.lang.String)
  - containsBeanDefinition
```
public boolean containsBeanDefinition(StringSE beanName)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    この Bean ファクトリに、指定された名前の Bean 定義が含まれているかどうかを確認します。
    このファクトリが参加する可能性のある階層を考慮せず、Bean 定義以外の方法で登録されたシングルトン Bean を無視します。
    次で指定:
    インターフェース ListableBeanFactory の containsBeanDefinition
    パラメーター:
    beanName - 検索する Bean の名前
    戻り値:
    この Bean ファクトリに、指定された名前の Bean 定義が含まれている場合
    関連事項:
    BeanFactory.containsBean(java.lang.String)
  - getBeanDefinitionCount
```
public int getBeanDefinitionCount()
```
    インターフェースからコピーされた説明: ListableBeanFactory
    ファクトリで定義されている Bean の数を返します。
    このファクトリが参加する可能性のある階層を考慮せず、Bean 定義以外の方法で登録されたシングルトン Bean を無視します。
    次で指定:
    インターフェース ListableBeanFactory の getBeanDefinitionCount
    戻り値:
    ファクトリで定義された Bean の数
  - getBeanDefinitionNames
```
public StringSE[] getBeanDefinitionNames()
```
    インターフェースからコピーされた説明: ListableBeanFactory
    このファクトリで定義されているすべての Bean の名前を返します。
    このファクトリが参加する可能性のある階層を考慮せず、Bean 定義以外の方法で登録されたシングルトン Bean を無視します。
    次で指定:
    インターフェース ListableBeanFactory の getBeanDefinitionNames
    戻り値:
    このファクトリで定義されているすべての Bean の名前。定義されていない場合は空の配列
  - getBeanProvider
```
public <T> ObjectProvider<T> getBeanProvider(ClassSE<T> requiredType,
                                             boolean allowEagerInit)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
    次で指定:
    インターフェース ListableBeanFactory の getBeanProvider
    パラメーター:
    requiredType - Bean が一致する必要があることを入力します。インターフェースまたはスーパークラスにすることができます
    allowEagerInit - ストリームベースのアクセスが、型チェックのために FactoryBeans （または "factory-bean" 参照を使用するファクトリメソッド）によって作成された lazy-init シングルトンおよびオブジェクトを初期化できるかどうか
    戻り値:
    対応するプロバイダーのハンドル
    関連事項:
    ListableBeanFactory.getBeanProvider(ResolvableType, boolean), BeanFactory.getBeanProvider(Class), ListableBeanFactory.getBeansOfType(Class, boolean, boolean), ListableBeanFactory.getBeanNamesForType(Class, boolean, boolean)
  - getBeanProvider
```
public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType,
                                             boolean allowEagerInit)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    指定された Bean のプロバイダーを返します。これにより、可用性および一意性オプションを含め、インスタンスの遅延オンデマンド取得が可能になります。
    次で指定:
    インターフェース ListableBeanFactory の getBeanProvider
    パラメーター:
    requiredType - Bean が一致する必要がある型。ジェネリクス型宣言にすることができます。ここでは、反射インジェクションポイントとは対照的に、コレクション型はサポートされていません。プログラムで特定の型に一致する Bean のリストを取得するには、実際の Bean 型をここで引数として指定し、その後 ObjectProvider.orderedStream() またはその遅延ストリーミング / 反復オプションを使用します。
    allowEagerInit - ストリームベースのアクセスが、型チェックのために FactoryBeans （または "factory-bean" 参照を使用するファクトリメソッド）によって作成された lazy-init シングルトンおよびオブジェクトを初期化できるかどうか
    戻り値:
    対応するプロバイダーのハンドル
    関連事項:
    BeanFactory.getBeanProvider(ResolvableType), ObjectProvider.iterator(), ObjectProvider.stream(), ObjectProvider.orderedStream(), ListableBeanFactory.getBeanNamesForType(ResolvableType, boolean, boolean)
  - getBeanNamesForType
```
public StringSE[] getBeanNamesForType(ResolvableType type)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    Bean 定義または FactoryBeans の場合は getObjectType の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
    注: このメソッドは、最上位の Bean のみをイントロスペクトします。指定された型と一致する可能性のあるネストされた Bean もチェックしません。
    FactoryBeans によって作成されたオブジェクトは考慮されません。つまり、FactoryBeans は初期化されます。FactoryBean によって作成されたオブジェクトが一致しない場合、生の FactoryBean 自体が型と一致します。
    このファクトリが参加する可能性のある階層を考慮しません。BeanFactoryUtils の beanNamesForTypeIncludingAncestors を使用して、祖先ファクトリにも Bean を含めます。
    メモ: Bean 定義以外の方法で登録されたシングルトン Bean を無視しません。
    このバージョンの getBeanNamesForType は、シングルトン、プロトタイプ、FactoryBeans など、あらゆる種類の Bean に一致します。ほとんどの実装では、結果は getBeanNamesForType(type, true, true) の場合と同じになります。
    このメソッドによって返される Bean 名は、常に、可能な限りバックエンド構成での定義順に Bean 名を返す必要があります。
    次で指定:
    インターフェース ListableBeanFactory の getBeanNamesForType
    パラメーター:
    type - 一致する一般的に型指定されたクラスまたはインターフェース
    戻り値:
    指定されたオブジェクト型（サブクラスを含む）と一致する Bean（または FactoryBeans によって作成されたオブジェクト）の名前。存在しない場合は空の配列
    関連事項:
    BeanFactory.isTypeMatch(String, ResolvableType), FactoryBean.getObjectType(), BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ListableBeanFactory, ResolvableType)
  - getBeanNamesForType
```
public StringSE[] getBeanNamesForType(ResolvableType type,
                                    boolean includeNonSingletons,
                                    boolean allowEagerInit)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    Bean 定義または FactoryBeans の場合は getObjectType の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
    注: このメソッドは、最上位の Bean のみをイントロスペクトします。指定された型と一致する可能性のあるネストされた Bean もチェックしません。
    "allowEagerInit" フラグが設定されている場合、FactoryBeans が初期化されることを意味する場合、FactoryBeans によって作成されたオブジェクトを考慮します。FactoryBean によって作成されたオブジェクトが一致しない場合、生の FactoryBean 自体が型と一致します。"allowEagerInit" が設定されていない場合、未加工の FactoryBeans のみがチェックされます（各 FactoryBean の初期化は不要です）。
    このファクトリが参加する可能性のある階層を考慮しません。BeanFactoryUtils の beanNamesForTypeIncludingAncestors を使用して、祖先ファクトリにも Bean を含めます。
    メモ: Bean 定義以外の方法で登録されたシングルトン Bean を無視しません。
    このメソッドによって返される Bean 名は、常に、可能な限りバックエンド構成での定義順に Bean 名を返す必要があります。
    次で指定:
    インターフェース ListableBeanFactory の getBeanNamesForType
    パラメーター:
    type - 一致する一般的に型指定されたクラスまたはインターフェース
    includeNonSingletons - プロトタイプ Bean またはスコープ Bean も含めるか、シングルトンのみを含めるか (FactoryBeans にも適用)
    allowEagerInit - 型チェックのために FactoryBeans （または "factory-bean" 参照を含むファクトリメソッド）によって作成された lazy-init シングルトンとオブジェクトを初期化するかどうか。FactoryBeans は、型を判別するために積極的に初期化する必要があることに注意してください。このフラグに "true" を渡すと、FactoryBeans および "factory-bean" 参照が初期化されることに注意してください。
    戻り値:
    指定されたオブジェクト型（サブクラスを含む）と一致する Bean（または FactoryBeans によって作成されたオブジェクト）の名前。存在しない場合は空の配列
    関連事項:
    FactoryBean.getObjectType(), BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ListableBeanFactory, ResolvableType, boolean, boolean)
  - getBeanNamesForType
```
public StringSE[] getBeanNamesForType(@Nullable
                                    ClassSE<?> type)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    Bean 定義または FactoryBeans の場合は getObjectType の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
    注: このメソッドは、最上位の Bean のみをイントロスペクトします。指定された型と一致する可能性のあるネストされた Bean もチェックしません。
    FactoryBeans によって作成されたオブジェクトは考慮されません。つまり、FactoryBeans は初期化されます。FactoryBean によって作成されたオブジェクトが一致しない場合、生の FactoryBean 自体が型と一致します。
    このファクトリが参加する可能性のある階層を考慮しません。BeanFactoryUtils の beanNamesForTypeIncludingAncestors を使用して、祖先ファクトリにも Bean を含めます。
    メモ: Bean 定義以外の方法で登録されたシングルトン Bean を無視しません。
    このバージョンの getBeanNamesForType は、シングルトン、プロトタイプ、FactoryBeans など、あらゆる種類の Bean に一致します。ほとんどの実装では、結果は getBeanNamesForType(type, true, true) の場合と同じになります。
    このメソッドによって返される Bean 名は、常に、可能な限りバックエンド構成での定義順に Bean 名を返す必要があります。
    次で指定:
    インターフェース ListableBeanFactory の getBeanNamesForType
    パラメーター:
    type - 一致させるクラスまたはインターフェース、またはすべての Bean 名の null
    戻り値:
    指定されたオブジェクト型（サブクラスを含む）と一致する Bean（または FactoryBeans によって作成されたオブジェクト）の名前。存在しない場合は空の配列
    関連事項:
    FactoryBean.getObjectType(), BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class)
  - getBeanNamesForType
```
public StringSE[] getBeanNamesForType(@Nullable
                                    ClassSE<?> type,
                                    boolean includeNonSingletons,
                                    boolean allowEagerInit)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    Bean 定義または FactoryBeans の場合は getObjectType の値から判断して、指定された型（サブクラスを含む）に一致する Bean の名前を返します。
    注: このメソッドは、最上位の Bean のみをイントロスペクトします。指定された型と一致する可能性のあるネストされた Bean もチェックしません。
    "allowEagerInit" フラグが設定されている場合、FactoryBeans が初期化されることを意味する場合、FactoryBeans によって作成されたオブジェクトを考慮します。FactoryBean によって作成されたオブジェクトが一致しない場合、生の FactoryBean 自体が型と一致します。"allowEagerInit" が設定されていない場合、未加工の FactoryBeans のみがチェックされます（各 FactoryBean の初期化は不要です）。
    このファクトリが参加する可能性のある階層を考慮しません。BeanFactoryUtils の beanNamesForTypeIncludingAncestors を使用して、祖先ファクトリにも Bean を含めます。
    メモ: Bean 定義以外の方法で登録されたシングルトン Bean を無視しません。
    このメソッドによって返される Bean 名は、常に、可能な限りバックエンド構成での定義順に Bean 名を返す必要があります。
    次で指定:
    インターフェース ListableBeanFactory の getBeanNamesForType
    パラメーター:
    type - 一致させるクラスまたはインターフェース、またはすべての Bean 名の null
    includeNonSingletons - プロトタイプ Bean またはスコープ Bean も含めるか、シングルトンのみを含めるか (FactoryBeans にも適用)
    allowEagerInit - 型チェックのために FactoryBeans （または "factory-bean" 参照を含むファクトリメソッド）によって作成された lazy-init シングルトンとオブジェクトを初期化するかどうか。FactoryBeans は、型を判別するために積極的に初期化する必要があることに注意してください。このフラグに "true" を渡すと、FactoryBeans および "factory-bean" 参照が初期化されることに注意してください。
    戻り値:
    指定されたオブジェクト型（サブクラスを含む）と一致する Bean（または FactoryBeans によって作成されたオブジェクト）の名前。存在しない場合は空の配列
    関連事項:
    FactoryBean.getObjectType(), BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
  - getBeansOfType
```
public <T> MapSE<StringSE,T> getBeansOfType(@Nullable
                                        ClassSE<T> type)
                                 throws BeansException
```
    インターフェースからコピーされた説明: ListableBeanFactory
    Bean 定義または FactoryBeans の場合は getObjectType の値から判断して、指定されたオブジェクト型（サブクラスを含む）に一致する Bean インスタンスを返します。
    注: このメソッドは、最上位の Bean のみをイントロスペクトします。指定された型と一致する可能性のあるネストされた Bean もチェックしません。
    FactoryBeans によって作成されたオブジェクトは考慮されません。つまり、FactoryBeans は初期化されます。FactoryBean によって作成されたオブジェクトが一致しない場合、生の FactoryBean 自体が型と一致します。
    このファクトリが参加する可能性のある階層を考慮しません。BeanFactoryUtils の beansOfTypeIncludingAncestors を使用して、祖先ファクトリにも Bean を含めます。
    メモ: Bean 定義以外の方法で登録されたシングルトン Bean を無視しません。
    このバージョンの getBeansOfType は、シングルトン、プロトタイプ、FactoryBeans など、あらゆる種類の Bean に一致します。ほとんどの実装では、結果は getBeansOfType(type, true, true) の場合と同じになります。
    このメソッドによって返されるマップは、常に、可能な限り、バックエンド構成での定義順に Bean 名と対応する Bean インスタンスを返す必要があります。
    次で指定:
    インターフェース ListableBeanFactory の getBeansOfType
    パラメーター:
    type - 一致するクラスまたはインターフェース、またはすべての具象 Bean の null
    戻り値:
    キーとしての Bean 名と値としての対応する Bean インスタンスを含む、一致する Bean を持つマップ
    例外:
    BeansException - Bean を作成できなかった場合
    関連事項:
    FactoryBean.getObjectType(), BeanFactoryUtils.beansOfTypeIncludingAncestors(ListableBeanFactory, Class)
  - getBeansOfType
```
public <T> MapSE<StringSE,T> getBeansOfType(@Nullable
                                        ClassSE<T> type,
                                        boolean includeNonSingletons,
                                        boolean allowEagerInit)
                                 throws BeansException
```
    インターフェースからコピーされた説明: ListableBeanFactory
    Bean 定義または FactoryBeans の場合は getObjectType の値から判断して、指定されたオブジェクト型（サブクラスを含む）に一致する Bean インスタンスを返します。
    注: このメソッドは、最上位の Bean のみをイントロスペクトします。指定された型と一致する可能性のあるネストされた Bean もチェックしません。
    "allowEagerInit" フラグが設定されている場合、FactoryBeans が初期化されることを意味する場合、FactoryBeans によって作成されたオブジェクトを考慮します。FactoryBean によって作成されたオブジェクトが一致しない場合、生の FactoryBean 自体が型と一致します。"allowEagerInit" が設定されていない場合、未加工の FactoryBeans のみがチェックされます（各 FactoryBean の初期化は不要です）。
    このファクトリが参加する可能性のある階層を考慮しません。BeanFactoryUtils の beansOfTypeIncludingAncestors を使用して、祖先ファクトリにも Bean を含めます。
    メモ: Bean 定義以外の方法で登録されたシングルトン Bean を無視しません。
    このメソッドによって返されるマップは、常に、可能な限り、バックエンド構成での定義順に Bean 名と対応する Bean インスタンスを返す必要があります。
    次で指定:
    インターフェース ListableBeanFactory の getBeansOfType
    パラメーター:
    type - 一致するクラスまたはインターフェース、またはすべての具象 Bean の null
    includeNonSingletons - プロトタイプ Bean またはスコープ Bean も含めるか、シングルトンのみを含めるか (FactoryBeans にも適用)
    allowEagerInit - 型チェックのために FactoryBeans （または "factory-bean" 参照を含むファクトリメソッド）によって作成された lazy-init シングルトンとオブジェクトを初期化するかどうか。FactoryBeans は、型を判別するために積極的に初期化する必要があることに注意してください。このフラグに "true" を渡すと、FactoryBeans および "factory-bean" 参照が初期化されることに注意してください。
    戻り値:
    キーとしての Bean 名と値としての対応する Bean インスタンスを含む、一致する Bean を持つマップ
    例外:
    BeansException - Bean を作成できなかった場合
    関連事項:
    FactoryBean.getObjectType(), BeanFactoryUtils.beansOfTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
  - getBeanNamesForAnnotation
```
public StringSE[] getBeanNamesForAnnotation(ClassSE<? extends AnnotationSE> annotationType)
```
    インターフェースからコピーされた説明: ListableBeanFactory
    対応する Bean インスタンスをまだ作成せずに、提供された AnnotationSE 型でアノテーションが付けられている Bean のすべての名前を検索します。
    このメソッドは FactoryBeans によって作成されたオブジェクトを考慮することに注意してください。つまり、FactoryBeans はオブジェクト型を決定するために初期化されます。
    次で指定:
    インターフェース ListableBeanFactory の getBeanNamesForAnnotation
    パラメーター:
    annotationType - 検索するアノテーションの型 (指定された Bean のクラス、インターフェース、ファクトリメソッドレベル)
    戻り値:
    一致するすべての Bean の名前
    関連事項:
    ListableBeanFactory.findAnnotationOnBean(java.lang.String, java.lang.Class<A>)
  - getBeansWithAnnotation
```
public MapSE<StringSE,ObjectSE> getBeansWithAnnotation(ClassSE<? extends AnnotationSE> annotationType)
                                          throws BeansException
```
    インターフェースからコピーされた説明: ListableBeanFactory
    指定された AnnotationSE 型でアノテーションが付けられたすべての Bean を検索し、対応する Bean インスタンスを持つ Bean 名のマップを返します。
    このメソッドは FactoryBeans によって作成されたオブジェクトを考慮することに注意してください。つまり、FactoryBeans はオブジェクト型を決定するために初期化されます。
    次で指定:
    インターフェース ListableBeanFactory の getBeansWithAnnotation
    パラメーター:
    annotationType - 検索するアノテーションの型 (指定された Bean のクラス、インターフェース、ファクトリメソッドレベル)
    戻り値:
    キーとしての Bean 名と値としての対応する Bean インスタンスを含む、一致する Bean を持つマップ
    例外:
    BeansException - Bean を作成できなかった場合
    関連事項:
    ListableBeanFactory.findAnnotationOnBean(java.lang.String, java.lang.Class<A>)
  - findAnnotationOnBean
```
@Nullable
public <A extends AnnotationSE> A findAnnotationOnBean(StringSE beanName,
                                                               ClassSE<A> annotationType)
                                                        throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: ListableBeanFactory
    指定された Bean で annotationType の AnnotationSE を検索し、指定されたクラス自体にアノテーションが見つからない場合はインターフェースとスーパークラスを走査し、Bean のファクトリメソッド（存在する場合）を確認します。
    次で指定:
    インターフェース ListableBeanFactory の findAnnotationOnBean
    パラメーター:
    beanName - アノテーションを探す Bean の名前
    annotationType - 検索するアノテーションの型 (指定された Bean のクラス、インターフェース、ファクトリメソッドレベル)
    戻り値:
    見つかった場合は指定された型のアノテーション、そうでない場合は null
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    ListableBeanFactory.getBeanNamesForAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>), ListableBeanFactory.getBeansWithAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>), BeanFactory.getType(String)
  - findAnnotationOnBean
```
@Nullable
public <A extends AnnotationSE> A findAnnotationOnBean(StringSE beanName,
                                                               ClassSE<A> annotationType,
                                                               boolean allowFactoryBeanInit)
                                                        throws NoSuchBeanDefinitionException
```
    インターフェースからコピーされた説明: ListableBeanFactory
    指定された Bean で annotationType の AnnotationSE を検索し、指定されたクラス自体にアノテーションが見つからない場合はインターフェースとスーパークラスを走査し、Bean のファクトリメソッド（存在する場合）を確認します。
    次で指定:
    インターフェース ListableBeanFactory の findAnnotationOnBean
    パラメーター:
    beanName - アノテーションを探す Bean の名前
    annotationType - 検索するアノテーションの型 (指定された Bean のクラス、インターフェース、ファクトリメソッドレベル)
    allowFactoryBeanInit - FactoryBean がオブジェクト型を判別する目的でのみ初期化されるかどうか
    戻り値:
    見つかった場合は指定された型のアノテーション、そうでない場合は null
    例外:
    NoSuchBeanDefinitionException - 指定された名前の Bean がない場合
    関連事項:
    ListableBeanFactory.getBeanNamesForAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>), ListableBeanFactory.getBeansWithAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>), BeanFactory.getType(String, boolean)
  - getParentBeanFactory
```
@Nullable
public BeanFactory getParentBeanFactory()
```
    インターフェースからコピーされた説明: HierarchicalBeanFactory
    親 Bean ファクトリ、または存在しない場合は null を返します。
    次で指定:
    インターフェース HierarchicalBeanFactory の getParentBeanFactory
  - containsLocalBean
```
public boolean containsLocalBean(StringSE name)
```
    インターフェースからコピーされた説明: HierarchicalBeanFactory
    祖先コンテキストで定義された Bean を無視して、ローカル Bean ファクトリに、指定された名前の Bean が含まれているかどうかを返します。
    これは containsBean の代替であり、祖先の Bean ファクトリから指定された名前の Bean を無視します。
    次で指定:
    インターフェース HierarchicalBeanFactory の containsLocalBean
    パラメーター:
    name - 照会する Bean の名前
    戻り値:
    指定された名前の Bean がローカルファクトリで定義されているかどうか
    関連事項:
    BeanFactory.containsBean(java.lang.String)
  - getInternalParentBeanFactory
```
@Nullable
protected BeanFactory getInternalParentBeanFactory()
```
    ConfigurableApplicationContext を実装する場合、親コンテキストの内部 Bean ファクトリを返します。それ以外の場合は、親コンテキスト自体を返します。
    関連事項:
    ConfigurableApplicationContext.getBeanFactory()
  - getMessage
```
public StringSE getMessage(StringSE code,
                         @Nullable
                         ObjectSE[] args,
                         @Nullable
                         StringSE defaultMessage,
                         LocaleSE locale)
```
    インターフェースからコピーされた説明: MessageSource
    メッセージの解決を試みます。メッセージが見つからなかった場合、デフォルトのメッセージを返します。
    次で指定:
    インターフェース MessageSource の getMessage
    パラメーター:
    code - 検索するメッセージコード。"calculator.noRateSet"。MessageSource ユーザーは、潜在的な競合を回避し、最大限の明確性を確保して、修飾されたクラスまたはパッケージ名に基づいてメッセージ名を作成することをお勧めします。
    args - メッセージ内のパラメーター（パラメーターはメッセージ内で "{0}", "{1,date}", "{2,time}" のように見えます）、または存在しない場合は null に入力される引数の配列
    defaultMessage - ルックアップが失敗した場合に返すデフォルトのメッセージ
    locale - ルックアップを行うロケール
    戻り値:
    検索が成功した場合は解決されたメッセージ、そうでない場合はパラメーターとして渡されたデフォルトのメッセージ (null の可能性があります)
    関連事項:
    MessageSource.getMessage(MessageSourceResolvable, Locale), MessageFormatSE
  - getMessage
```
public StringSE getMessage(StringSE code,
                         @Nullable
                         ObjectSE[] args,
                         LocaleSE locale)
                  throws NoSuchMessageException
```
    インターフェースからコピーされた説明: MessageSource
    メッセージの解決を試みます。メッセージが見つからない場合はエラーとして扱います。
    次で指定:
    インターフェース MessageSource の getMessage
    パラメーター:
    code - 検索するメッセージコード。"calculator.noRateSet"。MessageSource ユーザーは、潜在的な競合を回避し、最大限の明確性を確保して、修飾されたクラスまたはパッケージ名に基づいてメッセージ名を作成することをお勧めします。
    args - メッセージ内のパラメーター（パラメーターはメッセージ内で "{0}", "{1,date}", "{2,time}" のように見えます）、または存在しない場合は null に入力される引数の配列
    locale - ルックアップを行うロケール
    戻り値:
    解決されたメッセージ (非 null)
    例外:
    NoSuchMessageException - 対応するメッセージが見つからなかった場合
    関連事項:
    MessageSource.getMessage(MessageSourceResolvable, Locale), MessageFormatSE
  - getMessage
```
public StringSE getMessage(MessageSourceResolvable resolvable,
                         LocaleSE locale)
                  throws NoSuchMessageException
```
    インターフェースからコピーされた説明: MessageSource
    渡された MessageSourceResolvable 引数内に含まれるすべての属性を使用して、メッセージの解決を試みます。
    NOTE: このメソッドを呼び出す時点で、解決可能なオブジェクトの defaultMessage プロパティが null であるかどうかを判断できないため、このメソッドで NoSuchMessageException をスローする必要があります。
    次で指定:
    インターフェース MessageSource の getMessage
    パラメーター:
    resolvable - メッセージの解決に必要な属性を格納する値オブジェクト (デフォルトのメッセージを含めることができます)
    locale - ルックアップを行うロケール
    戻り値:
    解決されたメッセージ (MessageSourceResolvable -provided のデフォルトメッセージでさえ null 以外である必要があるため、null を使用しない)
    例外:
    NoSuchMessageException - 対応するメッセージが見つからなかった場合 (MessageSourceResolvable によって提供されるデフォルトメッセージはありません)
    関連事項:
    MessageSourceResolvable.getCodes(), MessageSourceResolvable.getArguments(), MessageSourceResolvable.getDefaultMessage(), MessageFormatSE
  - getInternalParentMessageSource
```
@Nullable
protected MessageSource getInternalParentMessageSource()
```
    親コンテキストの内部メッセージソースも AbstractApplicationContext の場合は返します。それ以外の場合は、親コンテキスト自体を返します。
  - getResources
```
public Resource[] getResources(StringSE locationPattern)
                        throws IOExceptionSE
```
    インターフェースからコピーされた説明: ResourcePatternResolver
    指定されたロケーションパターンを Resource オブジェクトに解決します。
    同じ物理リソースを指すリソースエントリの重複は、できる限り避ける必要があります。結果にはセマンティクスが設定されている必要があります。
    次で指定:
    インターフェース ResourcePatternResolver の getResources
    パラメーター:
    locationPattern - 解決する位置パターン
    戻り値:
    対応する Resource オブジェクト
    例外:
    IOExceptionSE - I/O エラーの場合
  - start
```
public void start()
```
    インターフェースからコピーされた説明: Lifecycle
    このコンポーネントを起動します。
    コンポーネントがすでに実行されている場合は、例外をスローしないでください。
    コンテナーの場合、これは適用されるすべてのコンポーネントに開始信号を伝播します。
    次で指定:
    インターフェース Lifecycle の start
    関連事項:
    SmartLifecycle.isAutoStartup()
  - stop
```
public void stop()
```
    インターフェースからコピーされた説明: Lifecycle
    このメソッドを返すとコンポーネントが完全に停止するように、通常は同期的にこのコンポーネントを停止します。非同期停止動作が必要な場合は、SmartLifecycle とその stop(Runnable) バリアントの実装を検討してください。
    この停止通知は破棄前に送信されるとは限らないことに注意してください。通常のシャットダウンでは、一般的な破棄コールバックが伝播される前に、Lifecycle Bean は最初に停止通知を受信します。ただし、コンテキストの存続期間中のホットリフレッシュまたは中断されたリフレッシュ試行では、特定の Bean の destroy メソッドが、停止信号を事前に考慮することなく呼び出されます。
    コンポーネントが実行されていない（まだ開始されていない）場合は、例外をスローしないでください。
    コンテナーの場合、これは停止信号を適用するすべてのコンポーネントに伝播します。
    次で指定:
    インターフェース Lifecycle の stop
    関連事項:
    SmartLifecycle.stop(Runnable), DisposableBean.destroy()
  - isRunning
```
public boolean isRunning()
```
    インターフェースからコピーされた説明: Lifecycle
    このコンポーネントが現在実行されているかどうかを確認します。
    コンテナーの場合、これは、適用されるすべてのコンポーネントが現在実行されている場合にのみ、true を返します。
    次で指定:
    インターフェース Lifecycle の isRunning
    戻り値:
    コンポーネントが現在実行中かどうか
  - refreshBeanFactory
```
protected abstract void refreshBeanFactory()
                                    throws BeansException,
                                           IllegalStateExceptionSE
```
    サブクラスは、実際の構成ロードを実行するためにこのメソッドを実装する必要があります。このメソッドは、他の初期化作業の前に refresh() によって呼び出されます。
    サブクラスは、新しい Bean ファクトリを作成してそれへの参照を保持するか、保持する単一の BeanFactory インスタンスを返します。後者の場合、コンテキストを複数回リフレッシュすると、通常は IllegalStateException がスローされます。
    例外:
    BeansException - Bean ファクトリの初期化が失敗した場合
    IllegalStateExceptionSE - すでに初期化されていて、複数回のリフレッシュ試行がサポートされていない場合
  - closeBeanFactory
```
protected abstract void closeBeanFactory()
```
    サブクラスはこのメソッドを実装して、内部 Bean ファクトリを解放する必要があります。このメソッドは、他のすべてのシャットダウン作業の後に close() によって呼び出されます。
    例外をスローするべきではなく、シャットダウンの失敗をログに記録します。
  - getBeanFactory
```
public abstract ConfigurableListableBeanFactory getBeanFactory()
                                                        throws IllegalStateExceptionSE
```
    サブクラスはここで内部 Bean ファクトリを返す必要があります。ルックアップを効率的に実装して、パフォーマンスを低下させることなく繰り返し呼び出すことができるようにする必要があります。
    メモ: サブクラスは、内部 Bean ファクトリを返す前に、コンテキストがまだアクティブかどうかを確認する必要があります。コンテキストが閉じられると、内部ファクトリは通常、使用不可と見なされます。
    次で指定:
    インターフェース ConfigurableApplicationContext の getBeanFactory
    戻り値:
    このアプリケーションコンテキストの内部 Bean ファクトリ (非 null)
    例外:
    IllegalStateExceptionSE - コンテキストが内部 Bean ファクトリをまだ保持していない場合（通常は refresh() が呼び出されていない場合）、またはコンテキストがすでに閉じられている場合
    関連事項:
    refreshBeanFactory(), closeBeanFactory()
  - toString
```
public StringSE toString()
```
    このコンテキストに関する情報を返します。
    オーバーライド:
    クラス ObjectSE の toStringSE

クラス AbstractApplicationContext

ネストされたクラスのサマリー

クラス org.springframework.core.io.DefaultResourceLoader から継承されたネストクラス / インターフェース

フィールドサマリー

インターフェース org.springframework.context.ConfigurableApplicationContext から継承されたフィールド

インターフェース org.springframework.beans.factory.BeanFactory から継承されたフィールド

インターフェース org.springframework.core.io.support.ResourcePatternResolver から継承されたフィールド

インターフェース org.springframework.core.io.ResourceLoader から継承されたフィールド

コンストラクターのサマリー

メソッドのサマリー

クラス org.springframework.core.io.DefaultResourceLoader から継承されたメソッド

クラス java.lang.ObjectSE から継承されたメソッド

インターフェース org.springframework.context.ConfigurableApplicationContext から継承されたメソッド

インターフェース org.springframework.core.io.ResourceLoader から継承されたメソッド

フィールドの詳細

MESSAGE_SOURCE_BEAN_NAME

LIFECYCLE_PROCESSOR_BEAN_NAME

APPLICATION_EVENT_MULTICASTER_BEAN_NAME

logger

コンストラクターの詳細

AbstractApplicationContext

AbstractApplicationContext

メソッドの詳細

setId

getId

getApplicationName

setDisplayName

getDisplayName

getParent

setEnvironment

getEnvironment

createEnvironment

getAutowireCapableBeanFactory

getStartupDate

publishEvent

publishEvent

publishEvent

setApplicationStartup

getApplicationStartup

getResourcePatternResolver

setParent

addBeanFactoryPostProcessor

getBeanFactoryPostProcessors

addApplicationListener

getApplicationListeners

refresh

prepareRefresh

initPropertySources

obtainFreshBeanFactory

prepareBeanFactory

postProcessBeanFactory

invokeBeanFactoryPostProcessors

registerBeanPostProcessors

initMessageSource

initApplicationEventMulticaster

initLifecycleProcessor

onRefresh

registerListeners

finishBeanFactoryInitialization

finishRefresh

cancelRefresh

resetCommonCaches

registerShutdownHook

destroy

close

doClose

destroyBeans

onClose

isActive

assertBeanFactoryActive

getBean

getBean

getBean

getBean

getBean

getBeanProvider

getBeanProvider

containsBean

isSingleton

isPrototype