DependCenter (simple-robot-core-码云(gitee.com))

java.lang.Object
- com.forte.qqrobot.depend.DependCenter

All Implemented Interfaces:

DependGetter, DependInjector
```
public class DependCenter
extends Object
implements DependGetter, DependInjector
```
依赖资源管理中心可以通过配置类来配置优先资源获取方法资源存入时不可覆盖，key值不可重复

Since:

JDK1.8

Author:

ForteScarlet <[163邮箱地址]ForteScarlet@163.com>

Constructor Summary

Constructors
Constructor and Description

DependCenter()
构造

DependCenter(DependGetter dependGetter)
构造

Constructors
Constructor and Description
`DependCenter()` 构造
`DependCenter(DependGetter dependGetter)` 构造

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Object`	`constant(String name)` 获取常量值常量只能通过名称获取
`<T> T`	`constant(String name, Class<T> type)` 获取常量值，转化数据类型
`<T> T`	`get(Class<T> type)` 获取依赖
`<T> T`	`get(Class<T> type, DependGetter additionalDepends)` 通过额外参数对某个对象进行强制注入
`Object`	`get(String name)` 获取依赖，当使用名称获取时，以非常量类型依赖为准
`<T> T`	`get(String name, Class<T> type)` 获取依赖
`<T> T`	`get(String name, Class<T> type, DependGetter additionalDepends)` 通过额外参数对某个对象进行强制注入
`Object`	`get(String name, DependGetter additionalDepends)` 通过额外参数对某个对象进行强制注入
`<T> List<T>`	`getByType(Class<T> superType)` 根据一个父类类型，获取所有存在的子类。理论上效率较低
`<T> T[]`	`getByType(Class<T> superType, T[] a)` 根据一个父类类型，获取所有存在的子类。理论上效率较低
`Object`	`getConstant(String name)` 获取常量值常量只能通过名称获取
`<T> T`	`getConstant(String name, Class<T> type)` 获取常量值，转化数据类型
`<T> Depend<T>`	`getDepend(Class<T> type)` 通过类型获取依赖对象
`Depend`	`getDepend(String name)` 通过名称获取依赖对象
`<T> Depend<T>`	`getDepend(String name, Class<T> type)`
`<T> T`	`getDependInstance(Class<T> type)` 通过类型获取依赖
`Object`	`getDependInstance(String name)` 通过名称获取依赖
`<T> T`	`getDependInstance(String name, Class<T> type)` 通过名称获取依赖，转化为指定类型
`Object[]`	`getMethodParameters(Method method)` 通过方法获取可以注入的参数
`Object[]`	`getMethodParameters(Method method, AdditionalDepends addParams)` 通过方法获取可以注入的参数
`Object[]`	`getMethodParameters(Parameter[] parameters)` 通过方法获取可以注入的参数
`Object[]`	`getMethodParameters(Parameter[] parameters, AdditionalDepends addParams)` 获取可以注入的参数
`<T> List<Class<? extends T>>`	`getTypesBySuper(Class<T> superType)` 根据父类类型寻找依赖池中的存在的子类类型列表
`DependCenter`	`load(Beans beanAnno, Class<?>... loadsClasses)` 判断规则默认为非接口、非抽象类且存在@Beans注解的class对象
`DependCenter`	`load(Beans BeansAnno, Predicate<Class> classTest, Class<?>... loadsClasses)` 加载一批依赖对象
`DependCenter`	`load(Class<?>... loadsClasses)` 判断规则默认为非接口、抽象类且存在@Beans注解的class对象
`DependCenter`	`load(Collection<Class<?>> list)` 判断规则默认为非接口、抽象类且存在@Beans注解的class对象
`DependCenter`	`load(Predicate<Class> classTest, Class<?>... loadsClasses)` 加载一批依赖对象
`DependCenter`	`load(Predicate<Class> classTest, Collection<Class<?>> list)` 加载一批依赖对象
`<T> DependCenter`	`load(String name, T bean)` 根据一个对象直接添加，默认为单例模式
`<T> DependCenter`	`load(T bean)` 根据一个对象直接添加，默认为单例模式依赖名称默认使用类名
`<T> DependCenter`	`loadIgnoreThrow(T bean)` 根据一个对象直接添加，默认为单例模式依赖名称默认使用类名无视出现的异常

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DependCenter
```
public DependCenter()
```
    构造
  - DependCenter
```
public DependCenter(DependGetter dependGetter)
```
    构造
- Method Detail
  - load
```
public <T> DependCenter load(T bean)
```
    根据一个对象直接添加，默认为单例模式依赖名称默认使用类名
    
    Parameters:
    
    bean - 实例对象
    
    Returns:
  - loadIgnoreThrow
```
public <T> DependCenter loadIgnoreThrow(T bean)
```
    根据一个对象直接添加，默认为单例模式依赖名称默认使用类名
    无视出现的异常
    
    Parameters:
    
    bean - 实例对象
    
    Returns:
  - load
```
public <T> DependCenter load(String name,
                             T bean)
```
    根据一个对象直接添加，默认为单例模式
    
    Parameters:
    
    name - 依赖名称
    
    bean - 实例对象
  - load
```
public DependCenter load(Predicate<Class> classTest,
                         Collection<Class<?>> list)
```
    加载一批依赖对象
  - load
```
public DependCenter load(Collection<Class<?>> list)
```
    判断规则默认为非接口、抽象类且存在@Beans注解的class对象
    
    Parameters:
    
    list - classes对象列表
  - load
```
public DependCenter load(Class<?>... loadsClasses)
```
    判断规则默认为非接口、抽象类且存在@Beans注解的class对象
    
    Parameters:
    
    loadsClasses - classes对象列表
  - load
```
public DependCenter load(Beans beanAnno,
                         Class<?>... loadsClasses)
```
    判断规则默认为非接口、非抽象类且存在@Beans注解的class对象
    
    Parameters:
    
    loadsClasses - classes对象列表
  - load
```
public DependCenter load(Predicate<Class> classTest,
                         Class<?>... loadsClasses)
```
    加载一批依赖对象
    
    Parameters:
    
    classTest - class判断类，如果有特殊规则则填写，例如全部包扫描的时候，没有注解的类也可以通过
  - load
```
public DependCenter load(Beans BeansAnno,
                         Predicate<Class> classTest,
                         Class<?>... loadsClasses)
```
    加载一批依赖对象
    
    Parameters:
    
    classTest - class判断类，如果有特殊规则则填写，例如全部包扫描的时候，没有注解的类也可以通过
  - getMethodParameters
```
public Object[] getMethodParameters(Method method,
                                    AdditionalDepends addParams)
```
    通过方法获取可以注入的参数
    
    Parameters:
    
    method - 方法对象
    
    addParams - 额外参数当存在额外参数的时候，优先使用额外参数进行注入
  - getMethodParameters
```
public Object[] getMethodParameters(Parameter[] parameters,
                                    AdditionalDepends addParams)
```
    获取可以注入的参数
    
    Parameters:
    
    parameters - 参数列表
    
    addParams - 额外参数，当存在额外参数的时候，优先使用额外参数进行注入
    
    Returns:
  - getMethodParameters
```
public Object[] getMethodParameters(Method method)
```
    通过方法获取可以注入的参数
    
    Parameters:
    
    method - 方法对象
  - getMethodParameters
```
public Object[] getMethodParameters(Parameter[] parameters)
```
    通过方法获取可以注入的参数
    
    Parameters:
    
    parameters - 方法对象
  - getTypesBySuper
```
public <T> List<Class<? extends T>> getTypesBySuper(Class<T> superType)
```
    根据父类类型寻找依赖池中的存在的子类类型列表
    
    Type Parameters:
    
    T -
    
    Parameters:
    
    superType - 父类类型
    
    Returns:
  - getByType
```
public <T> List<T> getByType(Class<T> superType)
```
    根据一个父类类型，获取所有存在的子类。理论上效率较低
    
    Type Parameters:
    
    T - 父类类型，例如一个接口类型
    
    Returns:
    
    所有实现类
  - getByType
```
public <T> T[] getByType(Class<T> superType,
                         T[] a)
```
    根据一个父类类型，获取所有存在的子类。理论上效率较低
    
    Parameters:
    
    superType - 父类类型，例如一个接口类型
    
    a - 转化为数组
    
    Returns:
    
    所有实现类
    
    See Also:
    
    getByType(Class, Object[])
  - getDepend
```
public <T> Depend<T> getDepend(Class<T> type)
```
    通过类型获取依赖对象
  - getDepend
```
public <T> Depend<T> getDepend(String name,
                               Class<T> type)
```
  - getDepend
```
public Depend getDepend(String name)
```
    通过名称获取依赖对象
    
    Parameters:
    
    name - 名称
  - getConstant
```
public Object getConstant(String name)
```
    获取常量值常量只能通过名称获取
  - getConstant
```
public <T> T getConstant(String name,
                         Class<T> type)
```
    获取常量值，转化数据类型
  - getDependInstance
```
public <T> T getDependInstance(String name,
                               Class<T> type)
```
    通过名称获取依赖，转化为指定类型
    
    Throws:
    
    ClassCastException
  - getDependInstance
```
public Object getDependInstance(String name)
```
    通过名称获取依赖
  - getDependInstance
```
public <T> T getDependInstance(Class<T> type)
```
    通过类型获取依赖
  - get
```
public <T> T get(Class<T> type,
                 DependGetter additionalDepends)
```
    通过额外参数对某个对象进行强制注入
  - get
```
public Object get(String name,
                  DependGetter additionalDepends)
```
    通过额外参数对某个对象进行强制注入
  - get
```
public <T> T get(String name,
                 Class<T> type,
                 DependGetter additionalDepends)
```
    通过额外参数对某个对象进行强制注入
  - get
```
public <T> T get(Class<T> type)
```
    获取依赖
    
    Specified by:
    
    get in interface DependGetter
  - get
```
public <T> T get(String name,
                 Class<T> type)
```
    获取依赖
    
    Specified by:
    
    get in interface DependGetter
  - get
```
public Object get(String name)
```
    获取依赖，当使用名称获取时，以非常量类型依赖为准
    
    Specified by:
    
    get in interface DependGetter
  - constant
```
public Object constant(String name)
```
    获取常量值常量只能通过名称获取
    
    Specified by:
    
    constant in interface DependGetter
  - constant
```
public <T> T constant(String name,
                      Class<T> type)
```
    获取常量值，转化数据类型
    
    Specified by:
    
    constant in interface DependGetter

Class DependCenter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DependCenter

DependCenter

Method Detail

load

loadIgnoreThrow

load

load

load

load

load

load

load

getMethodParameters

getMethodParameters

getMethodParameters

getMethodParameters

getTypesBySuper

getByType

getByType

getDepend

getDepend

getDepend

getConstant

getConstant

getDependInstance

getDependInstance

getDependInstance

get

get

get

get

get

get

constant

constant