org.noear.solon.core

类 BeanContainer

java.lang.Object

org.noear.solon.core.BeanContainer

直接已知子类:

AopContext

public abstract class BeanContainer
extends Object

Bean 容器，提供注册及关系映射管理（不直接使用；作为AopContext的基类）

从以下版本开始:

1.0

作者:

noear

字段概要

字段

限定符和类型	字段和说明
protected Map<Class<?>,BeanBuilder<?>>	beanBuilders bean 构建器
protected Map<Class<?>,BeanExtractor<?>>	beanExtractors bean 提取器
protected Map<Class<?>,BeanInjector<?>>	beanInjectors bean 注入器
protected Map<Class<?>,InterceptorEntity>	beanInterceptors bean 拦截器
protected Map<Object,Set<Consumer<BeanWrap>>>	beanSubscribers bean 订阅者
protected Set<Consumer<BeanWrap>>	wrapExternalConsumers wrap 外部消费者

构造器概要

构造器

构造器和说明
BeanContainer(ClassLoader classLoader, Props props)

方法概要

限定符和类型	方法和说明
AotCollector	aot()
<T extends Annotation> void	beanAroundAdd(Class<T> annoClz, Interceptor interceptor) 添加环绕处理
<T extends Annotation> void	beanAroundAdd(Class<T> annoClz, Interceptor interceptor, int index) 添加环绕处理
<T extends Annotation> InterceptorEntity	beanAroundGet(Class<T> annoClz) 获取环绕处理
<T extends Annotation> void	beanBuilderAdd(Class<T> annoClz, BeanBuilder<T> builder) 添加 bean builder, injector, extractor
<T extends Annotation> void	beanExtractorAdd(Class<T> annoClz, BeanExtractor<T> extractor) 添加提取处理
boolean	beanExtractorHas(Class<? extends Annotation> annoClz) 是否有提取处理
List<BeanWrap>	beanFind(BiPredicate<String,BeanWrap> condition) 查找bean包装
List<BeanWrap>	beanFind(Predicate<BeanWrap> condition) 查找bean包装
void	beanForeach(BiConsumer<String,BeanWrap> action) 遍历bean库 (拿到的是bean包装)
void	beanForeach(Consumer<BeanWrap> action) 遍历bean包装库
void	beanInject(VarHolder varH, String name) 尝试变量注入 字段或参数
protected void	beanInject(VarHolder varH, String name, boolean required, boolean autoRefreshed)
<T extends Annotation> void	beanInjectorAdd(Class<T> annoClz, BeanInjector<T> injector) 添加注入处理
protected void	beanInjectProperties(Class<?> clz, Object obj)
protected void	beanNotice(Object nameOrType, BeanWrap wrap) bean 通知，偏向对内
void	beanRegister(BeanWrap bw, String name, boolean typed) 尝试BEAN注册（按名字和类型存入容器；并进行类型映射）
protected void	beanRegisterSup0(BeanWrap bw) 尝试Bean的基类注册
protected void	beanSubscribe(Object nameOrType, Consumer<BeanWrap> callback) bean 订阅
Props	cfg() 获取属性（写法上，更接近 Solon.cfg()）
void	clear()
void	copyTo(BeanContainer container) 容器能力制复到另一个容器
protected String	findConfigKey(String name) 找到真实的name
Map<Class<?>,Object>	getAttrs() 获取特性
<T> T	getBean(Class<T> type) 获取 Bean
<T> T	getBean(String name) 获取 Bean
<T> void	getBeanAsync(Class<T> type, Consumer<T> callback) 异步获取 Bean
<T> void	getBeanAsync(String name, Consumer<T> callback) 异步获取 Bean
<T> T	getBeanOrNew(Class<T> type) 获取 或创建 bean
<T> List<T>	getBeansOfType(Class<T> baseType) 获取某类型的 bean
ClassLoader	getClassLoader() 获取类加载器
BeanWrap	getWrap(Object nameOrType) 获取一个bean包装
void	getWrapAsync(Object nameOrType, Consumer<BeanWrap> callback)
List<BeanWrap>	getWrapsOfType(Class<?> baseType)
boolean	hasWrap(Object nameOrType)
void	putWrap(Class<?> type, BeanWrap wrap) 存入到bean库（存入成功会进行通知）
void	putWrap(String name, BeanWrap wrap) 存入bean库（存入成功会进行通知）
<T> void	subBeansOfType(Class<T> baseType, Consumer<T> callback) 订阅某类型的 Bean
void	subWrapsOfType(Class<?> baseType, Consumer<BeanWrap> callback) 订阅某类型的 bean 包装
BeanWrap	wrap(Class<?> type) 包装
BeanWrap	wrap(Class<?> type, Object bean)
BeanWrap	wrap(String name, Object bean) 包装
BeanWrap	wrapAndPut(Class<?> type) 包装并推入
BeanWrap	wrapAndPut(Class<?> type, Object bean) 包装并推入
protected abstract BeanWrap	wrapCreate(Class<?> type, Object bean, String name)
protected void	wrapExternalSubscribe(Consumer<BeanWrap> callback) wrap 外部订阅
protected void	wrapPublish(BeanWrap wrap) wrap 发布，偏向对外 （只支持 @Bean 和 @Component 的 wrap）

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料

beanBuilders

protected final Map<Class<?>,BeanBuilder<?>> beanBuilders

bean 构建器

beanInjectors

protected final Map<Class<?>,BeanInjector<?>> beanInjectors

bean 注入器

beanExtractors

protected final Map<Class<?>,BeanExtractor<?>> beanExtractors

bean 提取器

beanInterceptors

protected final Map<Class<?>,InterceptorEntity> beanInterceptors

bean 拦截器

beanSubscribers

protected final Map<Object,Set<Consumer<BeanWrap>>> beanSubscribers

bean 订阅者

wrapExternalConsumers

protected final Set<Consumer<BeanWrap>> wrapExternalConsumers

wrap 外部消费者

构造器详细资料

BeanContainer

public BeanContainer(ClassLoader classLoader,
                     Props props)

方法详细资料

cfg

public Props cfg()

获取属性（写法上，更接近 Solon.cfg()）

aot

public AotCollector aot()

getAttrs

public Map<Class<?>,Object> getAttrs()

获取特性

getClassLoader

public ClassLoader getClassLoader()

获取类加载器

clear

public void clear()

copyTo

public void copyTo(BeanContainer container)

容器能力制复到另一个容器

beanBuilderAdd

public <T extends Annotation> void beanBuilderAdd(Class<T> annoClz,
                                                  BeanBuilder<T> builder)

添加 bean builder, injector, extractor

beanInjectorAdd

public <T extends Annotation> void beanInjectorAdd(Class<T> annoClz,
                                                   BeanInjector<T> injector)

添加注入处理

beanExtractorAdd

public <T extends Annotation> void beanExtractorAdd(Class<T> annoClz,
                                                    BeanExtractor<T> extractor)

添加提取处理

beanExtractorHas

public boolean beanExtractorHas(Class<? extends Annotation> annoClz)

是否有提取处理

beanAroundAdd

public <T extends Annotation> void beanAroundAdd(Class<T> annoClz,
                                                 Interceptor interceptor,
                                                 int index)

添加环绕处理

参数:

index - 执行顺序

beanAroundAdd

public <T extends Annotation> void beanAroundAdd(Class<T> annoClz,
                                                 Interceptor interceptor)

添加环绕处理

beanAroundGet

public <T extends Annotation> InterceptorEntity beanAroundGet(Class<T> annoClz)

获取环绕处理

beanSubscribe

protected void beanSubscribe(Object nameOrType,
                             Consumer<BeanWrap> callback)

bean 订阅

wrapExternalSubscribe

protected void wrapExternalSubscribe(Consumer<BeanWrap> callback)

wrap 外部订阅

beanNotice

protected void beanNotice(Object nameOrType,
                          BeanWrap wrap)

bean 通知，偏向对内

wrapPublish

protected void wrapPublish(BeanWrap wrap)

wrap 发布，偏向对外 （只支持 @Bean 和 @Component 的 wrap）

putWrap

public void putWrap(String name,
                    BeanWrap wrap)

存入bean库（存入成功会进行通知）

参数:

wrap - 如果raw为null，拒绝注册

putWrap

public void putWrap(Class<?> type,
                    BeanWrap wrap)

存入到bean库（存入成功会进行通知）

参数:

wrap - 如果raw为null，拒绝注册

hasWrap

public boolean hasWrap(Object nameOrType)

getWrap

public BeanWrap getWrap(Object nameOrType)

获取一个bean包装

参数:

nameOrType - bean name or type

getWrapsOfType

public List<BeanWrap> getWrapsOfType(Class<?> baseType)

getWrapAsync

public void getWrapAsync(Object nameOrType,
                         Consumer<BeanWrap> callback)

subWrapsOfType

public void subWrapsOfType(Class<?> baseType,
                           Consumer<BeanWrap> callback)

订阅某类型的 bean 包装

参数:

baseType - 基类

getBean

public <T> T getBean(String name)

获取 Bean

参数:

name - 名字

getBean

public <T> T getBean(Class<T> type)

获取 Bean

参数:

type - 类型

getBeansOfType

public <T> List<T> getBeansOfType(Class<T> baseType)

获取某类型的 bean

参数:

baseType - 基类

getBeanOrNew

public <T> T getBeanOrNew(Class<T> type)

获取 或创建 bean

参数:

type - 类型

getBeanAsync

public <T> void getBeanAsync(String name,
                             Consumer<T> callback)

异步获取 Bean

参数:

name - 名字

getBeanAsync

public <T> void getBeanAsync(Class<T> type,
                             Consumer<T> callback)

异步获取 Bean

参数:

type - 类型

subBeansOfType

public <T> void subBeansOfType(Class<T> baseType,
                               Consumer<T> callback)

订阅某类型的 Bean

参数:

baseType - 基类

wrap

public BeanWrap wrap(Class<?> type)

包装

wrap

public BeanWrap wrap(Class<?> type,
                     Object bean)

wrap

public BeanWrap wrap(String name,
                     Object bean)

包装

wrapAndPut

public BeanWrap wrapAndPut(Class<?> type)

包装并推入

wrapAndPut

public BeanWrap wrapAndPut(Class<?> type,
                           Object bean)

包装并推入

wrapCreate

protected abstract BeanWrap wrapCreate(Class<?> type,
                                       Object bean,
                                       String name)

beanRegister

public void beanRegister(BeanWrap bw,
                         String name,
                         boolean typed)

尝试BEAN注册（按名字和类型存入容器；并进行类型映射）

beanRegisterSup0

protected void beanRegisterSup0(BeanWrap bw)

尝试Bean的基类注册

beanInject

public void beanInject(VarHolder varH,
                       String name)

尝试变量注入 字段或参数

参数:

varH - 变量包装器

name - 名字（bean name || config ${name}）

beanInject

protected void beanInject(VarHolder varH,
                          String name,
                          boolean required,
                          boolean autoRefreshed)

beanInjectProperties

protected void beanInjectProperties(Class<?> clz,
                                    Object obj)

findConfigKey

protected String findConfigKey(String name)

找到真实的name

参数:

name - 原始name，${a:${b:3}}

返回:

返回真实的name

beanForeach

public void beanForeach(BiConsumer<String,BeanWrap> action)

遍历bean库 (拿到的是bean包装)

beanForeach

public void beanForeach(Consumer<BeanWrap> action)

遍历bean包装库

beanFind

public List<BeanWrap> beanFind(BiPredicate<String,BeanWrap> condition)

查找bean包装

beanFind

public List<BeanWrap> beanFind(Predicate<BeanWrap> condition)

查找bean包装