webx3对请求的处理流程详解一

最近写了一个小的异步框架，顺便认真研究了下一个请求处理的内部流程，所以这篇文章是一个衍生品。我们的分析从pipeline开始，前面的filter到pipeline的过程就略过了！

整体简化版流程

 

 

我们以一个screen的处理为例来说明整体的处理流程，如下图所示：

在深入每一步的细节之前，我们先了解一些背景知识。

target

官方解释：target是一个抽象的概念，指明当前请求要完成的任务。Target由pipeline来解释，它可能被解释成模板名，也可能被解释成别的东西。

 

module

 

官方解释：在Webx Turbine中，module是指screen、action、control等，大致相当于其它框架中的action或者controller。

对于webx来说它是能被框架处理的独立单元，一个请求最终会被映射到某个module进行处理。

module在webx中被定义成了接口，这意味着我们可以实现module来扩展自定义module，例如webx-rpc框架就定制了自己的

RPCModule来处理异步请求。

好了，开始步入正题！

分析ＵＲＬ

分析url,最主要的目的是通过url得到target,这一过程需要依赖mappingRuleService来完成。

MappingRuleService

  类图(缺失，原网页就看不了)：

对应的sample配置如下：

 <services:mapping-rules xmlns= “http://www.alibaba.com/schema/services/mapping-rules” >

 

        <!– External target name => Internal target name –>

        <extension-rule id = “extension.input”>

            <!– 默认后缀 –>

            <mapping extension = “” to= “” />

 

            <!– JSP –>

            <mapping extension = “jhtml” to= “” />

            <mapping extension = “jsp” to= “” />

            <mapping extension = “php” to= “” />

 

            <!– Velocity –>

            <mapping extension = “htm” to= “” />

            <mapping extension = “vhtml” to= “” />

            <mapping extension = “vm” to= “” />

        </extension-rule>

 

        <!– Internal target name => External target name –>

        <extension-rule id = “extension.output”>

            <!– 默认后缀 –>

            <mapping extension = “” to= “htm” />

 

            <!– JSP –>

            <mapping extension = “jhtml” to= “jhtml” />

            <mapping extension = “jsp” to= “jhtml” />

            <mapping extension = “php” to= “jhtml” />

 

            <!– Velocity –>

            <mapping extension = “htm” to= “htm” />

            <mapping extension = “vhtml” to= “htm” />

            <mapping extension = “vm” to= “htm” />

        </extension-rule>

 

        <!– Target name => Action module name –>

        <direct-module-rule id = “action” />

 

        <!– Target name => Screen module name (*.do) –>

        <direct-module-rule id = “screen.notemplate” />

 

        <!– Target name => Screen module name (*.jsp, *.vm) –>

        <fallback-module-rule id = “screen” moduleType=  “screen” />

 

        <!– Target name => Screen template name –>

        <direct-template-rule id = “screen.template” templatePrefix= “screen” />

 

        <!– Target name => Layout template name –>

        <fallback-template-rule id = “layout.template” templatePrefix= “layout” />

 

        <!– Target name => Control module name (setControl method) –>

        <direct-module-rule id = “control.notemplate” />

 

        <!– Target name => Control module name (setTemplate method) –>

        <fallback-module-rule id = “control” moduleType=  “control” />

 

        <!– Target name => Control template name –>

        <direct-template-rule id = “control.template” templatePrefix= “control” />

 

    </services:mapping-rules>

 

 mappingRuleService 通过一系列的mappingRule来完成映射工作。比如，url的分析就是通过这段

 

        <!– External target name => Internal target name –>

        <extension-rule id =  “extension.input”>

            <!– 默认后缀 –>

            <mapping extension =  “” to=  “” />

 

            <!– JSP –>

            <mapping extension =  “jhtml” to=  “” />

            <mapping extension =  “jsp” to=  “” />

            <mapping extension =  “php” to=  “” />

 

            <!– Velocity –>

            <mapping extension =  “htm” to=  “” />

            <mapping extension =  “vhtml” to=  “” />

            <mapping extension =  “vm” to=  “” />

        </extension-rule>

 

来完成的。后面这些rule被用到的时候我们再去分析它们的作用。

moduleLoaderService的配置与初始化

 

target映射到module是通过moduleLoaderService来完成的。

我们不妨先看一段moduleLoaderService的配置

    <services:module-loader>

        <ml-factories:class-modules>

            <ml-factories:search-packages type = “$1″ packages= “com.tmall.tmcrm.admin.module.*” />

        </ml-factories:class-modules>

         <ml-adapters:adapter class= “com.alibaba.citrus.extension.rpc.integration.RPCModuleAdapterFactory” />

    </services:module-loader>

 

xml文件中定义了namespace

 

    xmlns:ml-adapters= “http://www.alibaba.com/schema/services/module-loader/adapters”

    xmlns:ml-factories= “http://www.alibaba.com/schema/services/module-loader/factories”

所以事实上adapters和factories都是module-loader的捐献（donation）

对应的parser文件分别是

文件名：services-module-loader-adapters.bean-definition-parsers

内容：

action-event-adapter=com.alibaba.citrus.service.moduleloader.impl.adapter.ActionEventAdapterFactoryDefinitionParser

data-binding-adapter=com.alibaba.citrus.service.moduleloader.impl.adapter.DataBindingAdapterFactoryDefinitionParser

 

文件名：services-module-loader-factories.bean-definition-parsers

内容：

class-modules=com.alibaba.citrus.service.moduleloader.impl.factory.ClassModuleFactoryDefinitionParser

script-modules=com.alibaba.citrus.service.moduleloader.impl.factory.ScriptModuleFactoryDefinitionParser

moduleFactory用来加载和生成module,而adaptor用来将module适配到对应的module类型，例如screen,action.

webx默认使用的moduleFactory是com.alibaba.citrus.service.moduleloader.impl.factory.ClassModuleFactory

它的definitionParser除了解析bean的定义之外，还完成了一件重要的初始化工作：

 

    protected void postProcessItems (Element element , ParserContext parserContext , BeanDefinitionBuilder builder ,

                                    Map  <String , ParsingModuleInfo > items , String tags ) {

        // 注册所有明确定义的beans

         for ( ParsingModuleInfo item  : items  .values ()) {

             if ( item .bd  != null ) {

                assertNotNull  (item . key , “Specificly-defined module could not be found in %s: %s” , tags , item  .itemName );

 

                item  .beanName  = SpringExtUtil .generateBeanName (item .getBaseBeanName  (), parserContext .getRegistry ());

                parserContext .getRegistry ().registerBeanDefinition (item  .beanName , item .bd );

             }

         }

 

        // 设置ModuleFactory.setModules()

        List  <Object > moduleList  = createManagedList  (element , parserContext );

 

        log  .debug ( “Defined {} modules with {}”  , items . size (), getBeanClass (null).getSimpleName ());

 

         for ( ParsingModuleInfo item  : items  .values ()) {

             if ( item .beanName  != null ) {

                BeanDefinitionBuilder bdb  = BeanDefinitionBuilder . genericBeanDefinition (ModuleInfo  .class );

 

                bdb  .addConstructorArgValue (item .key  );

                bdb  .addConstructorArgValue (item .beanName  );

                bdb  .addConstructorArgValue (item .itemName  ); // className or script resourceName

 

                moduleList  .add ( bdb .getBeanDefinition  ());

 

                log  .debug ( “Defined module {} with {}”  , new Object [] { item .key , item .itemName  });

             }

         }

 

        builder  .addPropertyValue (“modules”  , moduleList );

     }

 

这段代码完成了两件事:

 

第一件事，把扫描的每个module都生成一个beanDefinition（如果解析出来的beanDefinition不为空的话）,并注册到BeanDefinitionRegistry。

第二件事，把所有的module的beanDefinition放在一个数组里，并添加到BeanDefinitionBuilder中，后续再注册到BeanDefinitionRegistry。

moduleLoaderService 的definitionParser除了读取配置之外，也做了额外的一件事：

   if (includeDefaultAdapters ) {

            // default adapter: action event adapter

            addDefaultAdapter  (adapterList , ActionEventAdapterFactory . class );

 

            // default adapter: data binding adapter

            addDefaultAdapter  (adapterList , DataBindingAdapterFactory . class );

         }

 

对用的xsd默认includeDefaultAdapters 为true,所有默认就添加了两个ActionEventAdapterFactory和DataBindingAdapterFactory 这两个AdaptorFactory

映射module

 

moduleFactory扫描了所有的module，并生成一个数组放到beanDefinition。当一个请求过来以后，我们会根据当前请求参数的名称获取对用的moduleName。

例如screen解析moduleName的方式如下：

    /**

     * 根据target取得 screen模块名。子类可以修改映射规则。

     */

    protected String getModuleName  (String target ) {

         return mappingRuleService . getMappedName (SCREEN_MODULE_NO_TEMPLATE  , target );

     }

 

这里用到了mappingRuleService里对应的这段配置

 

     <!– Target name => Screen module name (*.do) –>

        <direct-module-rule id = “screen.notemplate” />

 

对应的实现类是DirectModuleMappingRule,它是最简单模块映射规则。

1. 将"/"替换成"."。
2. 除去文件名后缀。
3. 将最后一个单词首字母改成大写，以符合模块命名的规则。
4. 该rule默认不cache结果。

例如：将模板名："about/directions/driving.vm"映射到screen module： "about.directions.Driving"。

 

action解析moduleName的方式如下：

 

action  = mappingRuleService  .getMappedName (ACTION_MODULE , action  );

 

对应的mappingRuleService 配置

 

    <!– Target name => Action module name –>

         <direct-module-rule id = “action” />

它的工作方式与screen module映射方式类似，只不过参数不是来自于target而是来自于请求参数里的action参数（可配置参数名）。

查找module的时候，我们除了提供moduleName,我们还需要提供module type。module type的值取决于我们在moduleLoaderService中配置:

        <ml-factories:class-modules>

            <ml-factories:search-packages type = “$1″ packages= “com.tmall.tmcrm.admin.module.*” />

        </ml-factories:class-modules>

 

也就说出现在package 路径module单词后面的第一个单词将作为type的值。

 

这当然只是一种配置方式，如果你有兴趣可以阅读对应的xsd文件，位置在 /META-INF/services/module-loader/factories/class-modules.xsd，你完全可以通过修改配置来实现type的另一个定义。

接下来就要真正开始查找module了。我们在moduleLoaderService的配置和初始化中提到，definitionParser在解析过程中做了一步工作，就是把ModuleList注册到beanDefinition中去。

ModuleFactory则是这个list的直接使用者，只不过它对数据又做了一次封装：

    public void setModules  (ModuleInfo [] modules ) {

         this.modules  = createHashMap ();

 

         if ( modules  != null) {

             for ( ModuleInfo module  : modules  ) {

                Map  <String , ModuleInfo > typedModules  = this.modules  .get ( module .getKey  ().getModuleType ());

 

                 if ( typedModules  == null) {

                    typedModules  = createHashMap ();

                     this.modules  .put ( module .getKey  ().getModuleType (), typedModules );

                 }

 

                typedModules  .put ( module .getKey  ().getModuleName (), module );

             }

         }

     }

 

也就是按类型存放了一下。

 

适配module

 

module的适配是一个很有背景的话题，我们知道在webx2中所有的screen,action和control等module事实上必须实现module接口,也即是：

 

/**

 * 代表一个模块。

 *

 *  @author Michael Zhou

 */

public interface Module  {

    /**

     * 执行模块。

     */

    void execute  () throws Exception ;

}

 

如果你的module实现了这个接口，那么事实上我们也不需要做适配了。但是这种设计的诟病在于

 

• 约束了代码的灵活性
• 参数的获取变得非常麻烦

webx3对此做了改进，module pojo化了，也就是说module可以是任意pojo对象。这么做的结果当然让开发者更为舒适，同时扩展性也变好了。

 

但是想要灵活没错，但总归还得让框架能认识它，怎么做呢？答案是适配！

 

适配器要做的工作简单来说归结为两点

 

• 判断类型，决定是否要进行适配
• 实现module接口中定义execute方法

判断类型意味着我们可以针对不同的module类型进行不同的适配，不同的适配器只关注自己的module

 

实现module接口除了满足框架的身份要求外，我们还可以在这个过程中添加自己的逻辑，例如：参数绑定（下一部分会进行详解）。

 

如类图所示适配的过程其实是根据module类型找到对应的AdaptorFactory并生成对应的adapter.

值得注意的是：(缺失图片，原网页就看不了)

1. adapter中封装了MethodInvoker对象(通过分析方法的参数生成的)。
2. 在DataBindingAdapter中由于只定义了一个execute方法（对应screen module）,它是以一个对象存在，而在actionEventAdapter中则以map形似存在（对应action module的多个doxx方法）。
3. methodInvoker中封装了方法中每个参数对应的DataResolver。

这些都为参数绑定做好了准备。

 

参数绑定与业务方法执行

 

参数绑定是通过dataResolverService来完成的，首先看一段sample配置

    <!– 支持注入参数。 –>

    <services:data-resolver xmlns= “http://www.alibaba.com/schema/services/data-resolver/factories” >

        <turbine-rundata-resolver />

        <parameter-resolver />

        <form-resolver />

        <!– 自定义的data-resolver –>

        <custom-resolver />

    </services:data-resolver>

 

 除了最后一个，其它的默认都是webx3默认提供的，我们来看一下它的类图结构(缺失图片，原网页就看不了)

 

说明： DataResolver的实现类实在太多，所以上图并没有把它的实现类画出来。、

适配工作完成后，我们得到了一个module,接下来执行它的execute方法。

以screen module为例，事实上它执行的是DataBindingAdapter的execute,由于这个类整体很简单，我们把代码都贴出来

public class DataBindingAdapter  extends AbstractDataBindingAdapter  {

    private final MethodInvoker executeMethod  ;

 

    DataBindingAdapter  (Object moduleObject , MethodInvoker executeMethod ) {

         super(moduleObject  );

         this.executeMethod  = executeMethod ;

     }

 

    public void execute  () throws Exception  {

        executeMethod  .invoke ( moduleObject , log  );

     }

 

    @Override

    public String toString  () {

        MapBuilder mb  = new MapBuilder ();

 

        mb  .append ( “moduleClass” , moduleObject  .getClass ().getName ());

        mb  .append ( “executeMethod” , executeMethod  );

 

         return new ToStringBuilder (). append (getClass  ().getSimpleName ()).append (mb  ).toString ();

     }

}

真正处理业务逻辑的其实是methodInvoker的invoke方法

public void invoke (Object moduleObject  , Logger log ) throws Exception  {

        Object  [] args  = new Object [resolvers  .length ];

 

         for ( int i  = 0  ; i  < args .length  ; i ++) {

            Object value  ;

 

             try {

                value  = resolvers [i ].resolve  ();

             } catch (SkipModuleExecutionException e ) {

                 if ( skippable ) {

                    log  .debug ( “Module execution has been skipped. Method: {}, {}” , fastMethod , e  .getMessage ());

                     return;

                 }

 

                value  = e . getValueForNonSkippable ();

             }

 

            // 特别处理：防止对primitive类型设置 null

            Class  <?> paramType  = fastMethod .getJavaMethod ().getParameterTypes ()[i  ];

 

             if ( value  == null && paramType .isPrimitive  ()) {

                value  = getPrimitiveDefaultValue (paramType );

             }

 

            args  [i ] = value ;

         }

 

         try {

            fastMethod  .invoke ( moduleObject , args  );

         } catch (InvocationTargetException e ) {

            throwExceptionOrError  (e . getCause ());

             return;

         }

     }

 

这段代码简单来说干了两件事情：

• 为方法的每个参数绑定值
• 执行业务方法

action module的逻辑稍微复杂一些。它需要查找对应doxx方法，另外如果你在action里提供了beforeExecution 或者afterExecution方法 它会在业务代码执行前后执行这两个方法。

定制自己的dataResolver

 

尽管webx3为我们提供了很多DataResolver,如下图：(缺失图片，原网页就看不了)

但是很多情况下，这些resolver还是不够用，我们还需要定制自己的DataResolver. 那么如何定义自己的dataResolver?

步骤一，编写自定义类实现DataResolverFactory接口。

 webx3会扫描所有的DataResolverFactory寻找第一个合适的DataResolver,我们无法修改webx3现有的DataResolverFactory的实现类，所以只能自己先添加一个

步骤二，编写自己的类实现DataResolver接口。

 

最常用的两个方式，一种是通过annotation的方式匹配DataResolver,另一种是通过参数类型的方式匹配参数

步骤三，编写webx3 donation

 

1.编写{donation}.xsd，并放到META-INF/services/data-resolver/factories/ 目录下

例如：

(缺失图片，原网页就看不了)
 

2.在META-INF目录下新增services-data-resolver-factories.bean-definition-parsers文件，并配置对应的映射

例如：

 

步骤四，根据添加的donation，修改DataResolverService的配置(缺失图片，原网页就看不了)

 

例如红色部分：

    <!– 支持注入参数。 –>

    <services:data-resolver xmlns= “http://www.alibaba.com/schema/services/data-resolver/factories” >

        <turbine-rundata-resolver />

        <parameter-resolver />

        <form-resolver />

        <!– 自定义的data-resolver –>

        <custom-resolver />

    </services:data-resolver>

sample code:

public class CustomResolverFactory  implements DataResolverFactory  {

    @Autowired

    private UicReadServiceClient       uicReadServiceClient  ;

 

    @Autowired

    private HttpServletRequest         request  ;

 

    private final ParserRequestContext parserRequestContext  ;

 

    public CustomResolverFactory  (ParserRequestContext parserRequestContext ) {

         this.parserRequestContext  = assertProxy (parserRequestContext );

     }

 

    public DataResolver getDataResolver  (DataResolverContext context ) {

        assertNotNull  (parserRequestContext , “no ParserRequestContext defined” );

        OwnerId ownerIdAnnotation  = context .getAnnotation (OwnerId .class  );

         if ( ownerIdAnnotation  != null) {

             return new OwnerIdResolver (ownerIdAnnotation  );

         }

        BizId bizIdAnnotation  = context .getAnnotation (BizId  .class );

         if ( bizIdAnnotation  != null) {

             return new BizIdResolver (bizIdAnnotation  );

         }

         return null ;

     }

 

    /**

     * 类 OwnerIdResolver 的实现描述：用来解析 ownerId

     *

     *  @author 晓飞 2013-10-11 上午10:16:53

     */

    private class OwnerIdResolver  implements DataResolver  {

        private OwnerId annotation ;

 

        public OwnerIdResolver (OwnerId annotation ) {

             this.annotation  = annotation ;

         }

 

        public Object resolve () throws IllegalArgumentException  {

             if ( request  == null) {

                 throw new IllegalArgumentException (“No httpServletRequest in context” );

             }

            HttpSession session  = request .getSession ();

             if ( session  == null) {

                 throw new IllegalArgumentException (“No session in request” );

             }

            String userId  = ( String ) session .getAttribute (SessionKeeper .ATTRIBUTE_USER_ID_NUM  );

 

            ResultDO  <BaseUserDO > result  = uicReadServiceClient . getBaseUserByUserId (Long

                     .parseLong (userId ));

            BaseUserDO data  = null ;

             if ( result .isSuccess  ()) {

                data  = result .getModule ();

             } else {

                 throw new IllegalArgumentException (“error reading userId from uic” );

             }

             if ( data  == null) {

                 throw new IllegalArgumentException (“error reading userId from uic” );

             }

            //检查是否是小二

             if ( data .getUserRank  ().longValue () == 46 ) {

                String name  = annotation .name ();

                String value  = trimToNull (request .getParameter  (name ));

 

                 if ( value  == null) {

                    value  = annotation .defaultValue ();

                 }

                 return Long . parseLong (value  );

             }

            //如果是子账号则获取父账号 userId

             if ( MMPTools .isSubUserLogin  ()) {

                long id  = MMPTools .getUserId  ();

                 return id ;

             } else {

                 return Long . parseLong (userId  );

             }

         }

 

     }

 

    /**

     * 类 BizIdResolver 的实现描述：用来解析 BizId

     *

     *  @author 晓飞 2013-10-11 上午10:16:53

     */

    private class BizIdResolver  implements DataResolver  {

        private BizId annotation ;

 

        public BizIdResolver (BizId annotation ) {

             this.annotation  = annotation ;

         }

 

        public Object resolve () throws IllegalArgumentException  {

 

             if ( request  == null) {

                 throw new IllegalArgumentException (“No httpServletRequest in context” );

             }

 

            HttpSession session  = request .getSession ();

             if ( session  == null) {

                 throw new IllegalArgumentException (“No session in request” );

             }

            String userId  = ( String ) session .getAttribute (SessionKeeper .ATTRIBUTE_USER_ID_NUM  );

            ResultDO  <BaseUserDO > result  = uicReadServiceClient . getBaseUserByUserId (Long

                     .parseLong (userId ));

            BaseUserDO data  = null ;

             if ( result .isSuccess  ()) {

                data  = result .getModule ();

             } else {

                 throw new IllegalArgumentException (“error reading userId from uic” );

             }

             if ( data  == null) {

                 throw new IllegalArgumentException (“error reading userId from uic” );

             }

            //检查是否是小二

             if ( data .getUserRank  ().longValue () == 46 ) {

                 if(StringUtil  .isBlank (annotation .valueIfStaff  ())){

                     return null ;

                 }

                 try{

                 return Long . parseLong (annotation  .valueIfStaff ());

                 }catch(NumberFormatException e ){

                     throw new IllegalArgumentException (“error parse value if staff string into Long type” );

                 }

             }

            //如果是子账号则获取父账号 userId

             if ( MMPTools .isSubUserLogin  ()) {

                long id  = MMPTools .getUserId  ();

                 return id ;

             } else {

                 return Long . parseLong (userId  );

             }

         }

 

     }

 

    public static class DefinitionParser  extends

            AbstractSingleBeanDefinitionParser  <CustomResolverFactory > {

        @Override

        protected void doParse (Element element  , ParserContext parserContext ,

                               BeanDefinitionBuilder builder  ) {

            addConstructorArg  (builder , false, ParserRequestContext . class );

         }

     }

}

 

 

 

@Retention(RetentionPolicy. RUNTIME)

@Target({ ElementType. PARAMETER })

public @interface OwnerId {

    /**

     * 参数名字

     *  @author 晓飞

     * 2013 -10- 9下午4:23:17

     *  @return

     */

    String name();

    /**

     * 参数默认值

     *  @author 晓飞

     * 2013 -10- 9下午4:23:25

     *  @return

     */

    String defaultValue()  default “0″ ;

}

 

 

@Retention(RetentionPolicy. RUNTIME)

@Target({ ElementType. PARAMETER })

public @interface BizId {

    /**

     * 如果是小二时返回的值

     *

     *  @author 晓飞 2013- 10-12下午5:02:54

     *  @return

     */

    String valueIfStaff()  default “0″;

}

完成这些后你就可以在screen或者action类中使用@BizId和@OwnerId绑定参数了。

渲染模板

 

我们在执行完module后，会往context放入数据，这些数据会作为数据源的一部分被模板引擎使用，渲染模板并生成response返回到客户端。由于篇幅的原因，这里不再扩展，我会再单独写一篇介绍velocity引擎如何在webx3中工作并渲染模板的。

转自： http://ju.outofmemory.cn/entry/96975