FineModule

java.lang.Object
- com.fr.stable.lifecycle.AbstractLifecycle
- - com.fr.module.engine.FineModule

所有已实现的接口:

EventEntry, Module, ModuleSelector, ModuleStableRepository, ModuleStableRepositoryAccessor, Lifecycle
```
public class FineModule
extends AbstractLifecycle
implements Module
```
Created by juhaoyu on 2017/12/26. 模块树实现

构造器概要

构造器
构造器和说明
`FineModule(java.lang.String name, Activator activator, Module parent, java.util.Map<ModuleAttribute,java.lang.String> attributes)` 只要调用FineModule的构造函数，就必须保证当前模块是一个正确的、可用的模块。

方法概要

方法
限定符和类型	方法和说明
`<T> void`	`addMutable(StableKey<T> key, T... mutable)` 添加mutable
`java.util.List<FineModule>`	`calculateStartSequence()` 动态计算模块的启动次序，用于Builder连接left、right
`void`	`clearMutable(StableKey key)` 清除当前模块中注册的mutable
`boolean`	`equals(java.lang.Object obj)`
`protected void`	`executeStart()`
`protected void`	`executeStop()`
`Module`	`findAncestor(java.lang.Class<? extends Activator> clazz)` 查找上级
`Module`	`findDescendant(java.lang.Class<? extends Activator> clazz)` 查找下级
`Activator`	`getActivator()`
`java.lang.String`	`getAttribute(ModuleAttribute attribute)` 获取模块扩展属性（不包含name、activator和ref）
`FineModule`	`getFirst()` 获取左右视图中的第一个
`<T> java.util.List<T>`	`getMutable(StableKey<T> key)` 获取当前注册进来的Mutable
`java.lang.String`	`getName()` 模块名
`FineModule`	`getNext()` 获取左右视图中的下一个
`Module`	`getParent()` 父模块
`java.lang.Class<? extends Activator>`	`getRelevantActivator()` 获取相关联的Activator类，用作模块的ID
`Module`	`getRoot()` 根模块
`<T> T`	`getSingleton(java.lang.Class<T> clazz)` 获取实现了某个接口的单例
`Module`	`getSub(java.lang.Class<? extends Activator> clazz)` 根据Activator的class对象获取子Module
`Module`	`getSub(java.lang.String name)` 获取子模块
`FineModuleGroup`	`getSubRepo()` 获取子模块仓库
`int`	`hashCode()`
`<T> T`	`leftFindSingleton(java.lang.Class<T> clazz)` 向左查找singleton
`<T> void`	`listenEvent(Event<T>[] events, Listener<T> listener)` 监听一大堆事件
`<T> void`	`listenEvent(Event<T> eventType, Listener<T> listener)` 监听某事件
`<T> void`	`listenEvent(Event<T> eventType, Listener<T> listener, Filter<T> filter)` 包含事件过滤器
`java.util.List<Module>`	`listSubs()` 以配置的顺序获取子模块
`<T> void`	`registerMutable(StableKey<T> key, StableKeyExecutor<T> executor)` 向右（所有比当前模块后启动的模块）收集对象，用于实现上层向下层的注册收集到的List顺序是注册的顺序同时接收插件提供的StableKey
`<T> T`	`removeSingleton(java.lang.Class<T> clazz)` 删除singleton
`<T> java.util.List<T>`	`rightCollectMutable(StableKey<T> key)` 向右（所有比当前模块后启动的模块）收集对象，用于实现上层向下层的注册收集到的List顺序是注册的顺序
`void`	`setLeft(FineModule left)`
`void`	`setParent(FineModule parent)`
`void`	`setRight(FineModule right)`
`<T> void`	`setSingleton(java.lang.Class<T> clazz, T singleton)` 注册一个单例到Context中，通常是一个实现了某接口的单例，用于桥接一个模块的接口部分和实现部分如已经存在了该类型的单例，会抛RuntimeException
`void`	`start()` 启动
`void`	`stop()` 关闭
`java.lang.String`	`toString()`
`<T> T`	`upFindSingleton(java.lang.Class<T> clazz)` 向上查找singleton，即当前模块不存在的话，会请求parent的findSingleton方法，直到root 这种模式可以用来让子模块覆盖上层模块的某些实现（overwrite）用于模块的父子关系中，更具体（也就是更小的模块）可以覆盖所在大模块的某种实现，从而实现在局部范围内的特殊性上下关系是父子关系

从类继承的方法 com.fr.stable.lifecycle.AbstractLifecycle
isRunning, once

从类继承的方法 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

从接口继承的方法 com.fr.stable.lifecycle.Lifecycle
isRunning, once

- 构造器详细资料
  - FineModule
```
public FineModule(java.lang.String name,
          Activator activator,
          Module parent,
          java.util.Map<ModuleAttribute,java.lang.String> attributes)
```
    只要调用FineModule的构造函数，就必须保证当前模块是一个正确的、可用的模块。子模块可以后续配置，除此之外的其他信息和组件必须创建完整校验无误 name和activator是必须配置的，独立于其他attributes之外
- 方法详细资料
  - getName
```
public java.lang.String getName()
```
    从接口复制的说明: Module
    
    模块名
    
    指定者:
    
    getName 在接口中 Module
  - getRelevantActivator
```
public java.lang.Class<? extends Activator> getRelevantActivator()
```
    从接口复制的说明: Module
    
    获取相关联的Activator类，用作模块的ID
    
    指定者:
    
    getRelevantActivator 在接口中 Module
  - start
```
public void start()
```
    从接口复制的说明: Lifecycle
    
    启动
    
    指定者:
    
    start 在接口中 Lifecycle
    
    覆盖:
    
    start 在类中 AbstractLifecycle
  - stop
```
public void stop()
```
    从接口复制的说明: Lifecycle
    
    关闭
    
    指定者:
    
    stop 在接口中 Lifecycle
    
    覆盖:
    
    stop 在类中 AbstractLifecycle
  - executeStart
```
protected void executeStart()
```
    指定者:
    
    executeStart 在类中 AbstractLifecycle
  - executeStop
```
protected void executeStop()
```
    指定者:
    
    executeStop 在类中 AbstractLifecycle
  - upFindSingleton
```
public <T> T upFindSingleton(java.lang.Class<T> clazz)
```
    从接口复制的说明: ModuleStableRepositoryAccessor
    
    向上查找singleton，即当前模块不存在的话，会请求parent的findSingleton方法，直到root 这种模式可以用来让子模块覆盖上层模块的某些实现（overwrite）用于模块的父子关系中，更具体（也就是更小的模块）可以覆盖所在大模块的某种实现，从而实现在局部范围内的特殊性上下关系是父子关系
    
    指定者:
    
    upFindSingleton 在接口中 ModuleStableRepositoryAccessor
  - leftFindSingleton
```
public <T> T leftFindSingleton(java.lang.Class<T> clazz)
```
    从接口复制的说明: ModuleStableRepositoryAccessor
    
    向左查找singleton
    
    指定者:
    
    leftFindSingleton 在接口中 ModuleStableRepositoryAccessor
  - rightCollectMutable
```
public <T> java.util.List<T> rightCollectMutable(StableKey<T> key)
```
    从接口复制的说明: ModuleStableRepositoryAccessor
    
    向右（所有比当前模块后启动的模块）收集对象，用于实现上层向下层的注册收集到的List顺序是注册的顺序
    
    指定者:
    
    rightCollectMutable 在接口中 ModuleStableRepositoryAccessor
  - registerMutable
```
public <T> void registerMutable(StableKey<T> key,
                       StableKeyExecutor<T> executor)
```
    从接口复制的说明: ModuleStableRepositoryAccessor
    
    向右（所有比当前模块后启动的模块）收集对象，用于实现上层向下层的注册收集到的List顺序是注册的顺序同时接收插件提供的StableKey
    
    指定者:
    
    registerMutable 在接口中 ModuleStableRepositoryAccessor
  - getParent
```
public Module getParent()
```
    从接口复制的说明: ModuleSelector
    
    父模块
    
    指定者:
    
    getParent 在接口中 ModuleSelector
  - getRoot
```
public Module getRoot()
```
    从接口复制的说明: ModuleSelector
    
    根模块
    
    指定者:
    
    getRoot 在接口中 ModuleSelector
  - findAncestor
```
public Module findAncestor(java.lang.Class<? extends Activator> clazz)
```
    从接口复制的说明: ModuleSelector
    
    查找上级
    
    指定者:
    
    findAncestor 在接口中 ModuleSelector
  - findDescendant
```
public Module findDescendant(java.lang.Class<? extends Activator> clazz)
```
    从接口复制的说明: ModuleSelector
    
    查找下级
    
    指定者:
    
    findDescendant 在接口中 ModuleSelector
  - getSub
```
public Module getSub(java.lang.String name)
```
    从接口复制的说明: ModuleSelector
    
    获取子模块
    
    指定者:
    
    getSub 在接口中 ModuleSelector
  - getSub
```
public Module getSub(java.lang.Class<? extends Activator> clazz)
```
    从接口复制的说明: ModuleSelector
    
    根据Activator的class对象获取子Module
    
    指定者:
    
    getSub 在接口中 ModuleSelector
  - listSubs
```
public java.util.List<Module> listSubs()
```
    从接口复制的说明: ModuleSelector
    
    以配置的顺序获取子模块
    
    指定者:
    
    listSubs 在接口中 ModuleSelector
  - getSubRepo
```
public FineModuleGroup getSubRepo()
```
    从接口复制的说明: ModuleSelector
    
    获取子模块仓库
    
    指定者:
    
    getSubRepo 在接口中 ModuleSelector
  - getAttribute
```
public java.lang.String getAttribute(ModuleAttribute attribute)
```
    从接口复制的说明: Module
    
    获取模块扩展属性（不包含name、activator和ref）
    
    指定者:
    
    getAttribute 在接口中 Module
  - setSingleton
```
public <T> void setSingleton(java.lang.Class<T> clazz,
                    T singleton)
```
    从接口复制的说明: ModuleStableRepository
    
    注册一个单例到Context中，通常是一个实现了某接口的单例，用于桥接一个模块的接口部分和实现部分如已经存在了该类型的单例，会抛RuntimeException
    
    指定者:
    
    setSingleton 在接口中 ModuleStableRepository
  - getSingleton
```
public <T> T getSingleton(java.lang.Class<T> clazz)
```
    从接口复制的说明: ModuleStableRepository
    
    获取实现了某个接口的单例
    
    指定者:
    
    getSingleton 在接口中 ModuleStableRepository
  - removeSingleton
```
public <T> T removeSingleton(java.lang.Class<T> clazz)
```
    从接口复制的说明: ModuleStableRepository
    
    删除singleton
    
    指定者:
    
    removeSingleton 在接口中 ModuleStableRepository
  - addMutable
```
public <T> void addMutable(StableKey<T> key,
                  T... mutable)
```
    从接口复制的说明: ModuleStableRepository
    
    添加mutable
    
    指定者:
    
    addMutable 在接口中 ModuleStableRepository
  - getMutable
```
public <T> java.util.List<T> getMutable(StableKey<T> key)
```
    从接口复制的说明: ModuleStableRepository
    
    获取当前注册进来的Mutable
    
    指定者:
    
    getMutable 在接口中 ModuleStableRepository
  - clearMutable
```
public void clearMutable(StableKey key)
```
    从接口复制的说明: ModuleStableRepository
    
    清除当前模块中注册的mutable
    
    指定者:
    
    clearMutable 在接口中 ModuleStableRepository
  - getActivator
```
public Activator getActivator()
```
  - calculateStartSequence
```
public java.util.List<FineModule> calculateStartSequence()
```
    动态计算模块的启动次序，用于Builder连接left、right
  - setParent
```
public void setParent(FineModule parent)
```
  - setLeft
```
public void setLeft(FineModule left)
```
  - setRight
```
public void setRight(FineModule right)
```
  - getNext
```
public FineModule getNext()
```
    获取左右视图中的下一个
  - getFirst
```
public FineModule getFirst()
```
    获取左右视图中的第一个
  - listenEvent
```
public <T> void listenEvent(Event<T>[] events,
                   Listener<T> listener)
```
    从接口复制的说明: EventEntry
    
    监听一大堆事件
    
    指定者:
    
    listenEvent 在接口中 EventEntry
  - listenEvent
```
public <T> void listenEvent(Event<T> eventType,
                   Listener<T> listener)
```
    从接口复制的说明: EventEntry
    
    监听某事件
    
    指定者:
    
    listenEvent 在接口中 EventEntry
  - listenEvent
```
public <T> void listenEvent(Event<T> eventType,
                   Listener<T> listener,
                   Filter<T> filter)
```
    从接口复制的说明: EventEntry
    
    包含事件过滤器
    
    指定者:
    
    listenEvent 在接口中 EventEntry
  - equals
```
public final boolean equals(java.lang.Object obj)
```
    覆盖:
    
    equals 在类中 java.lang.Object
  - hashCode
```
public final int hashCode()
```
    覆盖:
    
    hashCode 在类中 java.lang.Object
  - toString
```
public java.lang.String toString()
```
    覆盖:
    
    toString 在类中 java.lang.Object

类 FineModule

构造器概要

方法概要

从类继承的方法 com.fr.stable.lifecycle.AbstractLifecycle

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

从接口继承的方法 com.fr.stable.lifecycle.Lifecycle

构造器详细资料

FineModule

方法详细资料

getName

getRelevantActivator

start

stop

executeStart

executeStop

upFindSingleton

leftFindSingleton

rightCollectMutable

registerMutable

getParent

getRoot

findAncestor

findDescendant

getSub

getSub

listSubs

getSubRepo

getAttribute

setSingleton

getSingleton

removeSingleton

addMutable

getMutable

clearMutable

getActivator

calculateStartSequence

setParent

setLeft

setRight

getNext

getFirst

listenEvent

listenEvent

listenEvent

equals

hashCode

toString