充分利用多核优势，高效并行渲染页面－－改造nutz使其成为支持并行计算的MVC框架

首先我们来看一个场景：

       此图为sohu 首页的一部分。

这个页面比较典型，其实只要是复杂一些的页面通常都由许多不同模块的数据内容组成。如该页面就包含了新闻、体育、娱乐、视频等内容。每一个模块都需要单独查询，然后将结果填充到页面的各个部分。

如果由你来实现这个页面，你会怎么写呢？

通常，我们的写法是 (struts2.0)：

Java代码   

1. public String index() {  
2.     //查询新闻  
3.     newsList = service.queryNewsList();  
4.     //查询体育  
5.     sportsList = service.querySportsList();  
6.     //查询视频  
7.     videoList = service.queryVideoList();  
8.     return SUCCESS;  
9. }  

 这样是可以完成任务的，但是每一个查询都必须等待上一个查询结束后才能开始。假设查询比较耗时（不考虑缓存的因素）：新闻查了20秒，体育查了10秒，视频查了5秒，则总页面至少需要 35 秒后才能打开。

如果老板对性能要求较高，且 SQL优化已经起不到帮助作用，那么还有没有其它办法可以提高程序的效率呢？

对了，最简单的就是在页面中使用 iframe，将页面拆分成若干个子页面并行加载。这样每个部分执行快慢并不影响页面的整体打开速度，从总体上讲页面的加载速度提高了。但是过多的使用iframe，会带来许多负面影响。如session问题、内存占用问题、样式问题等等，而且页面的可维护性也将变差。因此这并不是一种好的解决方案。

或者也可以采用 ajax 动态获取各个部分并填充页面。但这样大大增加了前端的代码量及实现难度。

现在我们的服务器往往都是4核、甚至是8核的了，我们能不能充分利用多核优势在后台并行运算结果并统一渲染页面呢？

思路1：当用户请求到 indexAction 的时候，启动n个子线程分别查询不同模块数据。最终当所有线程处理结束后，合并结果，渲染页面。

使用多线程，就必须解决线程同步、加解锁等等问题。需要大大增加代码量，且要求程序员水平较高。如果一个项目中，程序员水平参差不齐，那么最好别采用这种方案，否则不知哪里的出了问题就会影响整个项目的质量。

思路2：让框架去干脏活、累活。当用户请求到 indexAction 的时候，我们利用框架的功能，动态将该请求模拟成为n个子action的请求，并在子action结束时自动合并结果，渲染页面。这样我们就通过框架虚拟出了iframe 的效果，同时避免了页面中使用 iframe 带来的问题，且降低了程序的复杂度。

采用这种方案，原有的项目无需大改，程序员也可以用熟悉的方法去开发，无需关注多线程及数据合并等等问题，可谓一举多得。

现在我们来改造 NutzMVC 框架，使其能支持并行计算功能。

Nutz是一个国产的开源框架，融合了MVC、Ioc、AOP、Dao诸多功能，且设计合理，预留了多处扩展点，用户可以很容易的动态给它增、减功能。因此今天就拿它来开刀。

Nutz地址为：http://code.google.com/p/nutz/ 有兴趣的同学可以去看看。下面的内容假设您已经对 Nutz有所了解。

为了在程序中虚拟出对 action 请求，需要用到 UrlMapping 类的实例。这个类在系统启动时会自动创建，但默认为 private 直接获取不到。因此需要自定义一个加载器，将UrlMapping 实例开放出来。

这个类很简单，只需重载下 NutLoading 即可。

Java代码   

1. /** 
2.  * 缺省加载器的基础上公开 urlMaping 属性，使 MVC 运行时可以并行执行其它 URL 
3.  * @author Gongqin(gongqin@gmail.com) 
4.  */  
5. public class ProLoading extends NutLoading {  
6.       
7.     private static UrlMapping urlMaping = null;  
8.   
9.     @Override  
10.     public UrlMapping load(NutConfig config) {  
11.         urlMaping = super.load(config);  
12.         return urlMaping;  
13.     }  
14.   
15.     /** 
16.      * 返回 urlMaping 实例 
17.      * @return  
18.      */  
19.     public static UrlMapping getUrlMaping() {  
20.         return urlMaping;  
21.     }  
22. }  

新增加一个注解，用于标识需要异步请求的子 action 地址

Java代码   

1. /** 
2.  * 声明一个需要异步请求的 url 地址<br/> 
3.  * 例如:  
4.  * <code> 
5.  * @Asyn({"retb:/b", "retc:/c"}) 
6.  * </code>  
7.  * 对 /b 和 /c 请求的返回值会分别存入 req 的 retb 和 retc 的属性中。 
8.  *  
9.  * @author Gongqin(gongqin@gmail.com) 
10.  */  
11. @Retention(RetentionPolicy.RUNTIME)  
12. @Target({ElementType.TYPE, ElementType.METHOD})  
13. @Documented  
14. public @interface  Asyn {  
15.       
16.     /** 
17.      * 需要异步请求的 url，支持同时进行多个请求<p/>  
18.      * 每行的格式为 key:url 。运行完成后会将 key 做为主键存入 req 中去。如果没有写 key，则认为您已经自己把返回值做了处理 
19.      */  
20.     String[] value();  
21.       
22.     /** 
23.      * 异步执行的子action最长处理时间，默认为 30 秒 
24.      * @return  
25.      */  
26.     int timeout() default 30;  
27.       
28. }  

 这里到了今天的核心：定制一个动作链处理器，用于解析注解，并异步执行子 action ，最后合并处理结果。

Java代码   

1. /** 
2.  * 异步执行的动作链处理器 
3.  * @author Gongqin(gongqin@gmail.com) 
4.  */  
5. public class AsynProcessor extends AbstractProcessor {  
6.   
7.     /** 
8.      * 解析 Asyn 注解并异步执行子 action，最后合并处理结果 
9.      */  
10.     @Override  
11.     public void process(final ActionContext ac) throws Throwable {  
12.         Asyn asyn = ac.getMethod().getAnnotation(Asyn.class);  
13.         // 如果没有异步任务，则处理完毕后直接返回  
14.         if (null == asyn || null == asyn.value() || asyn.value().length == 0) {  
15.             doNext(ac);  
16.             return;  
17.         }  
18.   
19.         // 开始处理异步任务  
20.         ExecutorService executor = Executors.newCachedThreadPool();  
21.         List<Future<Pair<Object>>> tasks = new ArrayList<Future<Pair<Object>>>(asyn.value().length);  
22.         for (final String url : asyn.value()) {  
23.             //增加一个异步请求  
24.             tasks.add(executor.submit(new Callable<Pair<Object>>() {  
25.                 @Override  
26.                 public Pair<Object> call() throws Exception {  
27.                     if (url == null)  
28.                         return null;  
29.                     String key = null;  
30.                     String tourl = url;  
31.                     int pos = url == null ? 0 : url.indexOf(":");  
32.                     if (pos > 0) {  
33.                         key = url.substring(0, pos);  
34.                         tourl = url.substring(pos + 1);  
35.                     }  
36.                     ActionContext subAc = new ActionContext();  
37.                     subAc.setRequest(new PathInfoRequest(tourl, ac.getRequest())).setResponse(ac.getResponse());  
38.   
39.                     ActionInvoker ai = ProLoading.getUrlMaping().get(subAc);  
40.                     ai.invoke(subAc);  
41.                     return new Pair<Object>(key, subAc.getMethodReturn());  
42.                 }  
43.   
44.             }));  
45.         }  
46.   
47.         doNext(ac);  
48.   
49.         // 获取其它 action 的返回值，供页面渲染  
50.         for (Future<Pair<Object>> future : tasks) {  
51.             try {  
52.                 Pair<Object> ret = future.get(asyn.timeout(), TimeUnit.SECONDS);  
53.                 if (ret != null && !Strings.isBlank(ret.getName())) {  
54.                     ac.getRequest().setAttribute(ret.getName(), ret.getValue());  
55.                 }  
56.             }  
57.             catch (TimeoutException e) {  
58.                 //忽略处理超时的任务  
59.             }  
60.         }  
61.     }  
62. }  

 发起虚拟请求时，要修改req的请求路径。默认的 HttpServletRequest 无法修改其 pathInfo 属性。为了虚拟出多个请求，因此对HttpServletRequest 进行了薄封装，使其允许修改 pathInfo

Java代码   

1. public class PathInfoRequest implements HttpServletRequest {  
2.     //其它方法省略  
3.     private String url;  
4.     public void setPathInfo(String url) {  
5.             this.url = url;  
6.         }  
7.         @Override  
8.         public String getPathInfo() {  
9.             return url;  
10.     }  
11. }  

OK，这样就全部搞定了。不复杂吧。下面我们来测试一下。

重新定义一个处理器链的配置文件 default-chains.js，把异步执行的动作链处理器声明进去。

Js代码   

1. {  
2.     "default" : {  
3.         "ps" : [  
4.               "org.nutz.mvc.impl.processor.UpdateRequestAttributesProcessor",  
5.               "org.nutz.mvc.impl.processor.EncodingProcessor",  
6.               "org.nutz.mvc.impl.processor.ModuleProcessor",  
7.               "com.nutz.mvc.AsynProcessor", //自行实现的处理器  
8.               "org.nutz.mvc.impl.processor.ActionFiltersProcessor",  
9.               "org.nutz.mvc.impl.processor.AdaptorProcessor",  
10.               "org.nutz.mvc.impl.processor.MethodInvokeProcessor",  
11.               "org.nutz.mvc.impl.processor.ViewProcessor"  
12.               ],  
13.         "error" : 'org.nutz.mvc.impl.processor.FailProcessor'  
14.     }  
15. }  

 写个主模块，把自定义的加载器和处理器链声明进去。

Java代码   

1. /** 
2.  * @author Gongqin(gongqin@gmail.com) 
3.  */  
4. //使用自定义的加载器，暴露 urlMaping  
5. @LoadingBy(ProLoading.class)  
6. @ChainBy(args={"com/nutz/mvc/default-chains.js"})  
7. public class MainModule {  
8.       
9.     /** 
10.      * 主 action，请求时自动产生两个子action的请求 
11.      */  
12.     @At("/a")  
13.     @Asyn({"retb:/b", "retc:/c"})  
14.     @Ok ("jsp:a")  
15.     public String a(@Param("a") String str, HttpServletRequest req, HttpServletResponse resp) {  
16.         System.out.println("接收参数a=" + str);  
17.         //模拟耗时操作  
18.         try {  
19.             TimeUnit.SECONDS.sleep(1);  
20.         }catch (InterruptedException e) {}  
21.         return "请求到了 a";  
22.     }  
23.       
24.     @At("/b")  
25.     @Ok ("void")  
26.     public String b(@Param("b") String str) {  
27.         //子 action 也一样可以获取到表单提交的参数  
28.         System.out.println("接收参数b=" + str);  
29.         System.out.println("b处理完成");  
30.         return "请求到了 b";  
31.     }  
32.       
33.     @At("/c")  
34.     @Ok ("void")  
35.     public String c(@Param("c") String str) {  
36.         System.out.println("接收参数c=" + str);  
37.         System.out.println("c处理完成");  
38.         return "请求到了 c";  
39.     }  
40. }  

开始进行测试：

Java代码   

1. /** 
2.  * @author Gongqin(gongqin@gmail.com) 
3.  */  
4. public class MvcTest extends AbstractMvcTest {  
5.   
6.     @Override  
7.     protected void initServletConfig() {  
8.         servletConfig.addInitParameter("modules", "com.nutz.test.MainModule");  
9.     }  
10.   
11.     @Test   
12.     public void test1() throws Throwable {  
13.         //模拟一个 http 请求  
14.         request.setPathInfo("/a");  
15.         request.setParameter("a", "this_is_a");  
16.         request.setParameter("b", "this_is_b");  
17.         request.setParameter("c", "this_is_c");  
18.         request.setMethod("GET");  
19.         servlet.service(request, response);  
20.           
21.         //验证返回值   
22.         Assert.assertEquals("obj属性返回不正确",  "请求到了 a", request.getAttribute("obj"));  
23.         Assert.assertEquals("retb属性返回不正确", "请求到了 b", request.getAttribute("retb"));  
24.         Assert.assertEquals("retc属性返回不正确", "请求到了 c", request.getAttribute("retc"));  
25.     }  
26. }  

执行后通过日志可以看出，虽然我们只请求了 /a ，但框架自动将此请求分解到了 /b 和 /c 的 action 上，并且 /b 和 /c 比 /a 处理完成时间还早，说明它们是真正的并行执行了。

今后，您只需对action 声明一个注解，即可灵活的并行执行多个子action，最终统一渲染页面啦。

拿开头举的场景的例子来说，则总页面只需20 秒即可打开。

注意，虽然子action还可以再嵌套子 action ，但一定要避免循环嵌套。如果出现循环嵌套的情况，则只能等待处理超时了。默认的超时时间为 30 秒。