webx中Module

（1）总览

              1.什么是Module

                 Module相当于controller，是用来处理逻辑的，target映射之后可以找到对应的Module来执行。

                 一般情况下（类都是java编写），相当于一个用来处理逻辑的java类

                 不使用AdapterFactory的情况下，Module都要实现Module，Module接口如下：

public interface Module {
    /** 执行模块。 */
    void execute() throws Exception;
}

                 execute()方法是自定义执行逻辑的地方，调用的时候也是通过execute()方法来触发Module的执行

              2.Module分类

                 action：主要用于处理表单数据

                   screen：处理页面的主题内容

                 control：处理页面的部分内容

              3.Module属性

                 moduleType：表示Module的类型，通常有screen、action

                 moduleName：Module的名称，通常就是target

              4.什么是ModuleLoaderService

                 Module定义之后如何才能被使用呢？这就必须要用到ModuleLoaderService了，它能够扫描特定的包或者特定类来加载类，从而供框架使用。

                 但是Module接口的execute()只有这一种类型，没有参数没有返回值，甚至有的类就没有实现Module接口，肯定不能满足需求，所以ModuleLoaderService的另一个功能就是将这些类转换为实现了Module接口、满足要求的Module，同时保持原来处理逻辑不变

                 而这两个功能不是ModuleLoaderService直接实现的，加载类是使用ModuleFactory，模块适配是使用ModuleAdapterFactory实现的。

（2）ModuleLoaderService

              1.接口

public interface ModuleLoaderService {
    /** 取得当前factory所支持的所有module类型。 */
    Set<String> getModuleTypes();

    /** 取得指定module类型的所有module名称。 */
    Set<String> getModuleNames(String moduleType);

    /** 取得指定名称和类型的module实例。 */
    Module getModule(String moduleType, String moduleName) throws ModuleLoaderException, ModuleNotFoundException;

    /**
     * 取得指定名称和类型的module实例。
     * <p>
     * 和<code>getModule()</code>不同的是，该方法不会抛出<code>ModuleNotFoundException</code>
     * 。如果模块不存在，则返回<code>null</code>。
     * </p>
     */
    Module getModuleQuiet(String moduleType, String moduleName) throws ModuleLoaderException;
}

              2.成员变量

public class ModuleLoaderServiceImpl extends AbstractService<ModuleLoaderService> implements ModuleLoaderService,
                                                                                             ProductionModeAware {
    private Map<ModuleKey, Module> moduleCache    = createConcurrentHashMap();
    private boolean                productionMode = true;
    private Boolean                cacheEnabled;
    private ModuleFactory[]        factories;
    private ModuleAdapterFactory[] adapters;
...
}

              可以看出其中存储了ModuleFactory和ModuleAdapterFactory

              3.关键方法

public Module getModuleQuiet(String moduleType, String moduleName) throws ModuleLoaderException {
        ....

        // 从factory中装载
        Object moduleObject = null;
        Module module = null;

        for (ModuleFactory factory : factories) {   //从多个Factory中查找
            moduleObject = factory.getModule(moduleType, moduleName);

            if (moduleObject != null) {
                break;
            }
        }

        // 通过适配器转换接口
        if (moduleObject != null) {
            if (moduleObject instanceof Module) {
                module = (Module) moduleObject; // 假如moduleObject直接实现了接口
            } else {   //如果没有则进行适配
                for (ModuleAdapterFactory adapter : adapters) {
                    module = adapter.adapt(moduleType, moduleName, moduleObject);

                    if (module != null) {
                        break;
                    }
                }
            }
        }
        ...
        return module;
    }

             核心代码如上：即先从factory中查找Module，然后进行适配转换

              4.总结

                 ModuleLoaderService就是一个高层接口，利用ModuleFactory和ModuleAdapterFactory实现加载并适配Module的功能

（3）ModuleFactory

              1.接口

/**
 * 用来创建modules的工厂。
 *
 * @author Michael Zhou
 */
public interface ModuleFactory {
    /** 取得当前factory所支持的所有module类型。 */
    Set<String> getModuleTypes();

    /** 取得指定module类型的所有module名称。 */
    Set<String> getModuleNames(String moduleType);

    /**
     * 取得指定名称和类型的module实例。
     * <p>
     * 如果未找到，则返回<code>null</code>。
     * </p>
     */
    Object getModule(String moduleType, String moduleName) throws ModuleLoaderException;
}

              2.关键方法

    public Object getModule(String moduleType, String moduleName) throws ModuleLoaderException {
        Map<String, ModuleInfo> typedModules = modules.get(moduleType);

        if (typedModules == null) {
            return null;
        } else {
            ModuleInfo module = typedModules.get(moduleName);

            if (module == null) {
                return null;
            }

            if (!beans.containsBean(module.getBeanName())) {
                return null;
            }

            try {
                return beans.getBean(module.getBeanName()); //获取Module
            } catch (Exception e) {
                throw new ModuleLoaderException("Failure loading module: " + moduleType + ":" + moduleName, e);
            }
        }
    }

                 其中modules为Map<String,ModulteInfo>，其中存储了Module的信息，内容如下

[screen={multievent.SayHello2=Module {
  type:name = screen:multievent.SayHello2
  beanName  = module.screen.multievent.SayHello2
  source    = my_test.understand.app1.module.screen.multievent.SayHello2
}, simple.Download=Module {
  type:name = screen:simple.Download
  beanName  = module.screen.simple.Download
  source    = my_test.understand.app1.module.screen.simple.Download
}, form.Welcome=Module {
  type:name = screen:form.Welcome
  beanName  = module.screen.form.Welcome
  source    = my_test.understand.app1.module.screen.form.Welcome
}}, 
action={RegisterAction=Module {
  type:name = action:RegisterAction
  beanName  = module.action.RegisterAction
  source    = my_test.understand.app1.module.action.RegisterAction
}},  null]

             key为ModuleType，即screen、action等，ModuleInfo保留了Module必要的信息，如beanName，source等

             最终的Module实际上还是通过beanFactory来获取的

（4）ModuleAdapterFactory

              1.接口

public interface ModuleAdapterFactory {
    /** 将对象转换成module接口。 */
    Module adapt(String type, String name, Object moduleObject) throws ModuleLoaderException;
}

              2.DataBindingAdapterFactory

public class DataBindingAdapterFactory extends AbstractDataBindingAdapterFactory {
    public Module adapt(String type, String name, Object moduleObject) {
        ModuleInfo moduleInfo = new ModuleInfo(type, name);
        Class<?> moduleClass = moduleObject.getClass();
        Method executeMethod = getMethod(moduleClass, "execute");

        if (executeMethod != null) {
            FastClass fc = FastClass.create(moduleClass);
            FastMethod fm = fc.getMethod(executeMethod);

            // 对于action，可被“跳过”执行。
            boolean skippable = "action".equalsIgnoreCase(type);

            return new DataBindingAdapter(moduleObject, getMethodInvoker(fm, moduleInfo, skippable));
        }

        return null;
    }
}

              可以看出只支持execute方法

              3.AbstractModuleEventAdapterFactory  

public abstract class AbstractModuleEventAdapterFactory<A extends AbstractModuleEventAdapter>
        extends AbstractDataBindingAdapterFactory implements ApplicationContextAware {
    private static final String DEFAULT_EVENT = "perform";
    private static final String PRE_HANDLER   = "beforeExecution";
    private static final String POST_HANDLER  = "afterExecution";
    private ApplicationContext context;
    ....
}

             这种ModuleAdapterFactory可以支持do开头的方法，并且默认方法是doPerform，开始前可以执行beforeExecution，结束后可以执行afterExecution

（5）webx-xx.xml使用配置

              1.最简单配置

    <services:module-loader>
        <ml-factories:class-modules>
            <search-packages type="$1" packages="com.alibaba.sample.petstore.web.home.module.*" />
        </ml-factories:class-modules>
    </services:module-loader>

                <1>packages属性

                只用指定search-package即可，表示Module去哪里扫描

                *表示通配符，那么com.alibaba.sample.petstore.web.home.module以及其子包都可以被扫描到

            packages表达式中可以有多个通配符*，第一个*代表的字符串可以用$1表示，第二个使用$2... 那么type属性可以使用$1,$2来表示。

            比如有一个Module：com.alibaba.sample.petstore.web.home.module.screen.HelloScreen ，那么第一个就是screen，因为type是使用$1，所以type说就是screen，即moduleType为screen。而moduleName是type之后的所有字符，那么就是HelloScreen

               <2>class-modules属性

</ml-factories:class-modules>

                     表示模块是使用classes生成的module，对应ClassModuleFactory

                     如果是使用script生成的Module，可以使用<ml-factories:script-modules>，对应ScriptModuleFactory
                     如果使用自定义的ModuleFactory，那么使用<ml-factories:factory >

              2.adapter配置

<services:module-loader cacheEnabled="true" includeDefaultAdapters=" false" >
<ml-adapters:data-binding-adapter/>
<ml-adapters:action-event-adapter/>   
<ml-adapters:adapter class=" com.alibaba.sample.petstore.web. common .adapter.AjaxAdapterFactory"/>
</services:module-loader>

               data-bing-adapter绑定了DataBindingAdapterFactory，action-event-adapter绑定了ActionEventAdapterFactory，adapter绑定了自定义的Adapter 

              3.service：module-loader配置

<services:module-loader cacheEnabled="true" includeDefaultAdapters=" false" >
<ml-factories:class-modules>
    <ml-factories:search-packages type="$1" packages="com.alibaba.sample.petstore.web.store.module.*" />
</ml-factories:class-modules>
< ml-factories:factory class="com.alibaba.sample.petstore.web.common.factory.AjaxAdapterFactory"/>
</services:module-loader>

                cacheEnabled：表示查找的时候使用缓存

                includeDefaultAdapters：表示是否使用默认的Adapter，默认为true。当为true时，会自动加载DataBindingAdapterFactory、ActionEventAdapterFactory，所以可以不需要再用<ml-adapters:data-binding-adapter/>和<ml-adapters:action-event-adapter/>另外配置。

              2.service：module-loader配置

<services:module-loader cacheEnabled="true" includeDefaultAdapters=" false" >
<ml-factories:class-modules>
    <ml-factories:search-packages type="$1" packages="com.alibaba.sample.petstore.web.store.module.*" />
</ml-factories:class-modules>
< ml-factories:factory class="com.alibaba.sample.petstore.web.common.factory.AjaxAdapterFactory"/>
</services:module-loader>

                cacheEnabled：表示查找的时候使用缓存

                includeDefaultAdapters：表示是否使用默认的Adapter，默认为true