论坛首页 → Java企业应用论坛 →

XWorker 介绍（2）－构建web框架

浏览 3032 次
锁定老帖子 主题：XWorker 介绍（2）－构建web框架
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (0)
作者 正文
  • magic_seek
  • 等级: 二星会员
  • 性别:
  • 文章: 139
  • 积分: 216
   发表时间：2007-02-25  

估计大家可能对XWorker的介绍（1）已经看过了，看样子似乎还不是很了解，不过没关系，从XWorker介绍（2）开始介绍一些XWorker的实际用途，了解如何使用XWorker是不需要明白它的基本原理的。下面就说说使用XWorker开发的好处：

  • 敏捷的开发过程
    XWorker一开始就是一个可运行的程序，从开发的开始到开发的结束始终都是在运行中的XWorker上进行的操作，原则上是可以做到动态添加和修改功能而不用重启的。
  • 通过编辑器修改数据对象
    不用麻烦的用txt编辑器修改繁杂的配置文件
  • 灵活性和可重用性
    如果理解了XWorker，那可能你会发现在XWorker中诸如框架、模式之类的东西渐渐变得模糊了，因为在某种角度上看XWorker中的每一个数据对象都是一个框架程序。另外XWorker可以动态的添加数据和功能，当数据和功能添加到XWorker中时这些数据和功能就是XWorker的一部分了，修改XWorker的数据就等于在改变XWorker，XWorker中的任何一个数据都是XWorker的一个部分，而所有的数据在XWorker中实质上是平等的，因而你添加的每一个数据和功能都可以被重复利用。

下面我们以大家都比较熟悉的Web架构为例说明一下如何在XWorker中如何搭建Web框架程序，并在XWorker中使用这些框架程序构建web应用。

构建第一个Web框架

第一个Web框架我们功能定义的简单一些，这个框架的功能就是调用Groovy脚本，由Groovy脚本执行业务并做界面输出。

首先我们定义一个这个Web框架的结构数据对象，这个结构数据对象也就是这个Web框架的主程序（可以理解成就是一个Java类）。

这个结构数据对象是这么定义的：

xml 代码
  1. <structure name="MyControl1">  
  2.     <field label="名称" description="Web ctontrol的名称。" name="name"/>  
  3.     <field type="cdata" colspan="2" label="脚本" inputtype="textarea" name="script" inputattrs="cols=&quot;60&quot; rows=&quot;20&quot;"/>  
  4.     <scripts>  
  5.         <scrip name="httpDo">  
  6.             <script>  
  7.                 dataCenter.runScript(self.metadata.path, binding);   
  8.                 return;   
  9.             </script>  
  10.         <script>  
  11.     </scripts>  
  12. </structure>  

在XWorker编辑以上的数据对象后（通过界面动态编辑），第一个Web框架就全部编完了，我们就可以使用它编写web应用了，比如编写一个在浏览器输出Hello World!的最简单的web应用，这个应用的数据对象是这个样子的：

xml 代码
  1. <MyControl1 name="MyControl1">  
  2.     <script>  
  3.      response.writer.write("Hello World!");   
  4.     </script>  
  5. </MyControl1>  

编辑好Hello World的数据对象后（也是在界面编辑，界面是通过那个结构数据对象动态生成的），那么在浏览器的地址栏里输入地址就可以访问了：比如http://localhost:8080/xworker/do?sc=example:config:webaction.MyControl1（example:config:webaction.MyControl1）是应用数据对象的地址。

运行后我们可以在IE中得到下面的结果：

Hello World!

到此为止第一个Web架构就已经全部完成了，你可以在XWorker中用这个web架构去编写只能处理Groovy的web应用了。

构建第二个Web框架

第二个Web框架的功能我们接第一个Web框架的功能，做一个完整的MVC的架构来。第二个web框架的功能是业务逻辑使用Groovy脚本，执行完业务程序后业务程序会返回一个字符串，然后通过这个字符串会在result的子节点去找相匹配的结果处理（和webwork一样），找到匹配后的结构后就调用结果的处理程序，返回给客户端页面。结果的类型我们在例子中实现三种，这三种类型的结果是Groovy类型（由Groovy脚本输出页面），freemarker（有freemarker模版生成页面），form（有view插件输出页面）。

那么这个结构数据对象我们可以定义成：

xml 代码
  1. <structure name="MyControl2">     
  2.     <field label="名称" name="name"/>     
  3.     <field type="cdata" colspan="2" label="脚本" inputtype="textarea" name="script" inputattrs="cols=&quot;60&quot; rows=&quot;20&quot;"/>     
  4.     <structure label="结果" name="result">     
  5.         <field label="名称" name="name"/>     
  6.         <structure label="groovy界面输出" name="groovy">     
  7.             <field type="cdata" colspan="2" label="脚本" inputtype="textarea" name="script" inputattrs="cols=&quot;60&quot; rows=&quot;20&quot;"/>     
  8.             <scripts>     
  9.                 <script script="dataCenter.runScript(self.metadata.path, binding);" name="run"/>     
  10.             </scripts>     
  11.         </structure>     
  12.         <structure label="freemarker模版输出" name="freemarker">     
  13.             <field label="名称" description="&lt;p&gt;模板的路径。&lt;/p&gt;" name="name"/>     
  14.             <scripts>     
  15.                 <script script="      
  16.                 import com.xworker.util.UtilTemplate;      
  17.                 UtilTemplate.process(binding.getVariables(), self.name, &quot;freemarker&quot;, response.writer);" name="run"/>     
  18.             </scripts>     
  19.         </structure>     
  20.         <structure label="view插件输出" extends="view:structure:view" name="view">     
  21.             <scripts>     
  22.                 <script script="      
  23.                 import com.xworker.util.UtilForm;      
  24.                 UtilForm.processAsFreemarker(binding.getVariables(), self.metadata.path, response.writer);" name="run"/>     
  25.             </scripts>     
  26.         </structure>     
  27.         <scripts>     
  28.             <script script="      
  29.             //取自己的第一个子节点      
  30.             childs = self.getChilds();      
  31.             if(childs.size() == 0){      
  32.                 response.writer.write(&quot;doResult:结果没有定义输出方式！&quot;);      
  33.             }else{      
  34.                 //run方法名是约定的      
  35.                 childs[0].exec(&quot;run&quot;, binding);      
  36.             }" name="doResult"/>     
  37.         </scripts>     
  38.     </structure>     
  39.     <scripts>     
  40.         <script script="      
  41.         result = dataCenter.runScript(self.metadata.path, binding);      
  42.      
  43.         resultObject = self.getDataObject(&quot;result@&quot; + result);      
  44.         if(resultObject == null){      
  45.             response.writer.write(&quot;httpDo:没有找到相匹配的结果！&quot;);      
  46.         }else{      
  47.             //执行doResult方法，doResult的名字是约定的      
  48.             resultObject.exec(&quot;doResult&quot;, binding);      
  49.         }      
  50.         return;" name="httpDo"/>     
  51.     </scripts>     
  52. </structure>     

在这个里面Web框架的逻辑程序是这样，这段程序负责调用业务Groovy脚本，并负责找到适配结果，并执行结果的方法输出界面，这里我们约定子节点都应该有一个doResult方法，这个方法是执行结果的。可以看出doResult方法是个约定的结构，只要result的子节点数据对象实现了这个接口，那么就可以处理其相关类型了。这部分代码是：

java 代码
  1. result = dataCenter.runScript(self.metadata.path, binding);   
  2.   
  3. resultObject = self.getDataObject("result@"; + result);   
  4. if(resultObject == null){   
  5.     response.writer.write("httpDo:没有找到相匹配的结果！");   
  6. }else{   
  7.     //执行doResult方法，doResult的名字是约定的   
  8.     resultObject.exec("doResult", binding);   
  9. }   
  10. return; 

结果的doResult方法：

java 代码
  1. //取自己的第一个子节点   
  2. childs = self.getChilds();   
  3. if(childs.size() == 0){   
  4.     response.writer.write("doResult:结果没有定义输出方式！");   
  5. }else{   
  6.     //run方法名是约定的   
  7.     childs[0].exec("run", binding);   
  8. }

groovy结果类型的方法：

java 代码
  1. dataCenter.runScript(self.metadata.path, binding);  

freemarker的类型处理方法：

java 代码
  1. import com.xworker.util.UtilTemplate;   
  2. UtilTemplate.process(binding.getVariables(), self.name, "freemarker", response.writer);   

form类型的处理方法：

java 代码
  1. import com.xworker.util.UtilForm;   
  2. UtilForm.processAsFreemarker(binding.getVariables(), self.metadata.path, response.writer);  

那么使用上面的Web框架结构我们可以编辑以这个框架为基础的web应用了，比如我们编写一个测试的应用，这个应用接受web客户端提交的参数result，通过result的值分别执行相应的结果，这个应用的数据对象是：

xml 代码
  1. <MyControl2 script="   
  2.         //取要显示那个结果   
  3.         result = requestBean.result;   
  4.            
  5.         if(result == null){   
  6.             result = "form";   
  7.         }   
  8.            
  9.         return result;" name="MyControl2_1">  
  10.     <result name="groovy">  
  11.         <groovy script="   
  12.                 response.writer.write("""   
  13.                 <html>  
  14.                 <body>  
  15.                  <h2>Groovy</h2>  
  16.                  <a href="do?sc=example:config:webaction.MyControl2_1&result=groovy">groovy</a><p/>  
  17.                  <a href="do?sc=example:config:webaction.MyControl2_1&result=freemarker">freemarker</a><p/>  
  18.                  <a href="do?sc=example:config:webaction.MyControl2_1&result=form">form</a><p/>  
  19.                 </body>  
  20.                 </html>  
  21.                 """);"/>  
  22.     </result>  
  23.     <result name="freemarker">  
  24.         <freemarker name="example:webaction/MyControl2_1.ftl"/>  
  25.     </result>  
  26.     <result name="form">  
  27.         <view name="view">  
  28.             <group title="Form" haveLabel="false" showTitle="false" name="group">  
  29.                 <htmlCode label="htmlCode" name="htmlCode">  
  30.                     <htmlCode><![CDATA[  
  31.                         <p><a href="do?sc=example:config:webaction.MyControl2_1&amp;result=groovy">groovy</a></p>  
  32.                                         <p><a href="do?sc=example:config:webaction.MyControl2_1&amp;result=freemarker">freemarker</a></p>  
  33.                                         <p><a href="do?sc=example:config:webaction.MyControl2_1&amp;result=form">form</a></p>]]>  
  34.                                  </htmlCode>  
  35.                 </htmlCode>  
  36.             </group>  
  37.         </view>  
  38.     </result>  
  39. </MyControl2>  

和第一个web框架的web应用的执行方式一样，在地址栏中输入相应的地址就可以马上出结果了。

扩展web框架的功能

以上两个例子是实现了需求的web框架的基本功能，r果我们要扩展一些web框架的功能怎么办呢，比如控制web的编码输出，用户权限控制，性能做个监控等。这些功能都可以通过添加脚本的上下文来实现。

XWorker中的山下文同时有上下文、控制者双重作用，上下文一般是具有公共功能的数据对象，如：事务的处理，权限处理等，上下文可以有自己的属性，上下文有inherit（继承）、init（初始化）、success（成功）和exception（失败）这四个方法，在执行脚本的前后会根据情况调用上下文的这几个方法，上下文可以在这几个方法里实现变量注入、流程控制等功能，另外上下文的方法也可以有它自己的上下文。

了解上下文的基本概念后，我们在在第二个web框架的基础上构建第三个web框架，实现对输出界面的编码、缓存等的控制并监控其性能。第三个web框架的代码这里就不全部贴出来了，我们只贴脚本和上下文的部分：

xml 代码
  1. <script name="httpDo">  
  2.     <script>  
  3.     dataCenter.runScript(self.metadata.path, binding);   
  4.        
  5.     resultObject = self.getDataObject(&quot;result@&quot; + result);   
  6.     if(resultObject == null){   
  7.         response.writer.write(&quot;httpDo:没有找到相匹配的结果！&quot;);   
  8.     }else{   
  9.         //执行doResult方法，doResult的名字是约定的   
  10.         resultObject.exec(&quot;doResult&quot;, binding);   
  11.     }   
  12.     return;   
  13.     <script>  
  14.     <contexts>  
  15.         <context label="httpDo执行时间：" name="performance"/>  
  16.         <context label="httpContext" responseEncoding="GBK" noCache="false" requestEncoding="GBK" expires="1" name="httpContext"/>  
  17.     </contexts>  
  18. </script>  

扩展了以上上下文后，我们再运行程序，这时候控制台就会打印出执行的时间：

INFO (com.xworker.context.PerformanceContext:36) - httpDo执行时间：耗时：31毫秒

后记

以上就是演示如何在XWorker构建web框架的全部过程，这些都是在XWorker用编辑器编辑的，基本上即编即用，所以这个过程绝对是敏捷的。

限于篇幅的限制，我们将在下一个介绍中讲述XWorker编辑数据的原理以及脚本（不仅是Groovy还可以是Java程序）和上下文的有关性质。
返回顶楼
         
论坛首页 → Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics