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

估计大家可能对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程序）和上下文的有关性质。