MVC设计思想

wangcaipang 2011-03-21

Java开发者对MVC框架一定不陌生,从Struts到WebWork,JavaMVC框架层出不穷。我们已经习惯了处理*.do或*.action风格的URL,为每一个URL编写一个控制器,并继承一个Action或者Controller接口。然而,流行的Web趋势是使用更加简单,对用户和搜索引擎更加友好的REST风格的URL。例如,来自豆瓣的一本书的链接是http://www.douban.com/subject/2129650/,而非http://www.douban.com/subject.do?id=2129650。

有经验的JavaWeb开发人员会使用URL重写的方式来实现类似的URL,例如,为前端Apache服务器配置mod_rewrite模块,并依次为每个需要实现URL重写的地址编写负责转换的正则表达式,或者,通过一个自定义的RewriteFilter,使用JavaWeb服务器提供的Filter和请求转发(Forward)功能实现URL重写,不过,仍需要为每个地址编写正则表达式。

既然URL重写如此繁琐,为何不直接设计一个原生支持REST风格的MVC框架呢?

要设计并实现这样一个MVC框架并不困难,下面,我们从零开始,仔细研究如何实现REST风格的URL映射,并与常见的IoC容器如Spring框架集成。这个全新的MVC框架暂命名为WebWind。

术语

MVC:Model-View-Controller,是一种常见的UI架构模式,通过分离Model(模型)、View(视图)和Controller(控制器),可以更容易实现易于扩展的UI。在Web应用程序中,Model指后台返回的数据;View指需要渲染的页面,通常是JSP或者其他模板页面,渲染后的结果通常是HTML;Controller指Web开发人员编写的处理不同URL的控制器(在Struts中被称之为Action),而MVC框架本身还有一个前置控制器,用于接收所有的URL请求,并根据URL地址分发到Web开发人员编写的Controller中。

IoC:Invertion-of-Control,控制反转,是目前流行的管理所有组件生命周期和复杂依赖关系的容器,例如Spring容器。

Template:模板,通过渲染,模板中的变量将被Model的实际数据所替换,然后,生成的内容即是用户在浏览器中看到的HTML。模板也能实现判断、循环等简单逻辑。本质上,JSP页面也是一种模板。此外,还有许多第三方模板引擎,如Velocity,FreeMarker等。

设计目标

和传统的Struts等MVC框架完全不同,为了支持REST风格的URL,我们并不把一个URL映射到一个Controller类(或者Struts的Action),而是直接把一个URL映射到一个方法,这样,Web开发人员就可以将多个功能类似的方法放到一个Controller中,并且,Controller没有强制要求必须实现某个接口。一个Controller通常拥有多个方法,每个方法负责处理一个URL。例如,一个管理Blog的Controller定义起来就像清单1所示。

清单1.管理Blog的Controller定义

publicclassBlog{

@Mapping("/create/$1")

Publicvoidcreate(intuserId){...}

@Mapping("/display/$1/$2")

Publicvoiddisplay(intuserId,intpostId){...}

@Mapping("/edit/$1/$2")

Publicvoidedit(intuserId,intpostId){...}

@Mapping("/delete/$1/$2")

PublicStringdelete(intuserId,intpostId){...}

}

@Mapping()注解指示了这是一个处理URL映射的方法,URL中的参数$1、$2……则将作为方法参数传入。对于一个“/blog/1234/5678”的URL,对应的方法将自动获得参数userId=1234和postId=5678。同时,也无需任何与URL映射相关的XML配置文件。

使用$1、$2……来定义URL中的可变参数要比正则表达式更简单,我们需要在MVC框架内部将其转化为正则表达式,以便匹配URL。

此外,对于方法返回值,也未作强制要求。

集成IoC

当接收到来自浏览器的请求,并匹配到合适的URL时,应该转发给某个Controller实例的某个标记有@Mapping的方法,这需要持有所有Controller的实例。不过,让一个MVC框架去管理这些组件并不是一个好的设计,这些组件可以很容易地被IoC容器管理,MVC框架需要做的仅仅是向IoC容器请求并获取这些组件的实例。

为了解耦一种特定的IoC容器,我们通过ContainerFactory来获取所有Controller组件的实例,如清单2所示。

清单2.定义ContainerFactory

publicinterfaceContainerFactory{

voidinit(Configconfig);

List<Object>findAllBeans();

voiddestroy();

}

其中,关键方法findAllBeans()返回IoC容器管理的所有Bean,然后,扫描每一个Bean的所有public方法,并引用那些标记有@Mapping的方法实例。

我们设计目标是支持Spring和Guice这两种容器,对于Spring容器,可以通过ApplicationContext获得所有的Bean引用,代码见清单3。

清单3.定义SpringContainerFactory

publicclassSpringContainerFactoryimplementsContainerFactory{

privateApplicationContextappContext;

publicList<Object>findAllBeans(){

String[]beanNames=appContext.getBeanDefinitionNames();

List<Object>beans=newArrayList<Object>(beanNames.length);

for(inti=0;i<beanNames.length;i++){

beans.add(appContext.getBean(beanNames[i]));

}

returnbeans;

}

...

}

对于Guice容器,通过Injector实例可以返回所有绑定对象的实例,代码见清单4。

清单4.定义GuiceContainerFactory

publicclassGuiceContainerFactoryimplementsContainerFactory{

privateInjectorinjector;

publicList<Object>findAllBeans(){

Map<Key<?>,Binding<?>>map=injector.getBindings();

Set<Key<?>>keys=map.keySet();

List<Object>list=newArrayList<Object>(keys.size());

for(Key<?>key:keys){

Objectbean=injector.getInstance(key);

list.add(bean);

}

returnlist;

}

...

}

类似的,通过扩展ContainerFactory,就可以支持更多的IoC容器,如PicoContainer。

出于效率的考虑,我们缓存所有来自IoC的Controller实例,无论其在IoC中配置为Singleton还是Prototype类型。当然,也可以修改代码,每次都从IoC容器中重新请求实例。

设计请求转发

和Struts等常见MVC框架一样,我们也需要实现一个前置控制器,通常命名为DispatcherServlet,用于接收所有的请求,并作出合适的转发。在Servlet规范中,有以下几种常见的URL匹配模式:

/abc:精确匹配,通常用于映射自定义的Servlet;

*.do:后缀模式匹配,常见的MVC框架都采用这种模式;

/app/*:前缀模式匹配,这要求URL必须以固定前缀开头;

/:匹配默认的Servlet,当一个URL没有匹配到任何Servlet时,就匹配默认的Servlet。一个Web应用程序如果没有映射默认的Servlet,Web服务器会自动为Web应用程序添加一个默认的Servlet。

REST风格的URL一般不含后缀,我们只能将DispatcherServlet映射到“/”,使之变为一个默认的Servlet,这样,就可以对任意的URL进行处理。

由于无法像Struts等传统的MVC框架根据后缀直接将一个URL映射到一个Controller,我们必须依次匹配每个有能力处理HTTP请求的@Mapping方法。完整的HTTP请求处理流程如图1所示。

图1.请求处理流程

当扫描到标记有@Mapping注解的方法时,需要首先检查URL与方法参数是否匹配,UrlMatcher用于将@Mapping中包含$1、$2……的字符串变为正则表达式,进行预编译,并检查参数个数是否符合方法参数,代码见清单5。

清单5.定义UrlMatcher

finalclassUrlMatcher{

finalStringurl;

int[]orders;

Patternpattern;

publicUrlMatcher(Stringurl){

...

}

}

将@Mapping中包含$1、$2……的字符串变为正则表达式的转换规则是,依次将每个$n替换为([^\\/]*),其余部分作精确匹配。例如,“/blog/$1/$2”变化后的正则表达式为:

^\\/blog\\/([^\\/]*)\\/([^\\/]*)$

请注意,Java字符串需要两个连续的“\\”表示正则表达式中的转义字符“\”。将“/”排除在变量匹配之外可以避免很多歧义。

调用一个实例方法则由Action类表示,它持有类实例、方法引用和方法参数类型,代码见清单6。

清单6.定义Action

classAction{

publicfinalObjectinstance;

publicfinalMethodmethod;

publicfinalClass<?>[]arguments;

publicAction(Objectinstance,Methodmethod){

this.instance=instance;

this.method=method;

this.arguments=method.getParameterTypes();

}

}

负责请求转发的Dispatcher通过关联UrlMatcher与Action,就可以匹配到合适的URL,并转发给相应的Action,代码见清单7。

清单7.定义Dispatcher

classDispatcher{

privateUrlMatcher[]urlMatchers;

privateMap<UrlMatcher,Action>urlMap=newHashMap<UrlMatcher,Action>();

....

}

当Dispatcher接收到一个URL请求时,遍历所有的UrlMatcher,找到第一个匹配URL的UrlMatcher,并从URL中提取方法参数,代码见清单8。

清单8.匹配并从URL中提取参数

finalclassUrlMatcher{

...

/**

*根据正则表达式匹配URL,若匹配成功,返回从URL中提取的参数,

*若匹配失败,返回null

*/

publicString[]getMatchedParameters(Stringurl){

Matcherm=pattern.matcher(url);

if(!m.matches())

returnnull;

if(orders.length==0)

returnEMPTY_STRINGS;

String[]params=newString[orders.length];

for(inti=0;i<orders.length;i++){

params[orders[i]]=m.group(i+1);

}

returnparams;

}

}

根据URL找到匹配的Action后,就可以构造一个Execution对象,并根据方法签名将URL中的String转换为合适的方法参数类型,准备好全部参数,代码见清单9。

清单9.构造Exectuion

classExecution{

publicfinalHttpServletRequestrequest;

publicfinalHttpServletResponseresponse;

privatefinalActionaction;

privatefinalObject[]args;

...

publicObjectexecute()throwsException{

try{

returnaction.method.invoke(action.instance,args);

}

catch(InvocationTargetExceptione){

Throwablet=e.getCause();

if(t!=null&&tinstanceofException)

throw(Exception)t;

throwe;

}

}

}

调用execute()方法就可以执行目标方法,并返回一个结果。请注意,当通过反射调用方法失败时,我们通过查找InvocationTargetException的根异常并将其抛出,这样,客户端就能捕获正确的原始异常。

为了最大限度地增加灵活性,我们并不强制要求URL的处理方法返回某一种类型。我们设计支持以下返回值:

String:当返回一个String时,自动将其作为HTML写入HttpServletResponse;

void:当返回void时,不做任何操作;

Renderer:当返回Renderer对象时,将调用Renderer对象的render方法渲染HTML页面。

最后需要考虑的是,由于我们将DispatcherServlet映射为“/”,即默认的Servlet,则所有的未匹配成功的URL都将由DispatcherServlet处理,包括所有静态文件,因此,当未匹配到任何Controller的@Mapping方法后,DispatcherServlet将试图按URL查找对应的静态文件,我们用StaticFileHandler封装,主要代码见清单10。

清单10.处理静态文件

classStaticFileHandler{

...

publicvoidhandle(HttpServletRequestrequest,HttpServletResponseresponse)

throwsServletException,IOException{

Stringurl=request.getRequestURI();

Stringpath=request.getServletPath();

url=url.substring(path.length());

if(url.toUpperCase().startsWith("/WEB-INF/")){

response.sendError(HttpServletResponse.SC_NOT_FOUND);

return;

}

intn=url.indexOf('?');

if(n!=(-1))

url=url.substring(0,n);

n=url.indexOf('#');

if(n!=(-1))

url=url.substring(0,n);

Filef=newFile(servletContext.getRealPath(url));

if(!f.isFile()){

response.sendError(HttpServletResponse.SC_NOT_FOUND);

return;

}

longifModifiedSince=request.getDateHeader("If-Modified-Since");

longlastModified=f.lastModified();

if(ifModifiedSince!=(-1)&&ifModifiedSince>=lastModified){

response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);

return;

}

response.setDateHeader("Last-Modified",lastModified);

response.setContentLength((int)f.length());

response.setContentType(getMimeType(f));

sendFile(f,response.getOutputStream());

}

}

处理静态文件时要过滤/WEB-INF/目录,否则将造成安全漏洞。

集成模板引擎

作为示例,返回一个“<h1>Hello,world!</h1>”作为HTML页面非常容易。然而,实际应用的页面通常是极其复杂的,需要一个模板引擎来渲染出HTML。可以把JSP看作是一种模板,只要不在JSP页面中编写复杂的Java代码。我们的设计目标是实现对JSP和Velocity这两种模板的支持。

和集成IoC框架类似,我们需要解耦MVC与模板系统,因此,TemplateFactory用于初始化模板引擎,并返回Template模板对象。TemplateFactory定义见清单11。

清单11.定义TemplateFactory

publicabstractclassTemplateFactory{

privatestaticTemplateFactoryinstance;

publicstaticTemplateFactorygetTemplateFactory(){

returninstance;

}

publicabstractTemplateloadTemplate(Stringpath)throwsException;

}

Template接口则实现真正的渲染任务。定义见清单12。

清单12.定义Template

publicinterfaceTemplate{

voidrender(HttpServletRequestrequest,HttpServletResponseresponse,

Map<String,Object>model)throwsException;

}

以JSP为例,实现JspTemplateFactory非常容易。代码见清单13。

清单13.定义JspTemplateFactory

publicclassJspTemplateFactoryextendsTemplateFactory{

privateLoglog=LogFactory.getLog(getClass());

publicTemplateloadTemplate(Stringpath)throwsException{

if(log.isDebugEnabled())

log.debug("LoadJSPtemplate'"+path+"'.");

returnnewJspTemplate(path);

}

publicvoidinit(Configconfig){

log.info("JspTemplateFactoryinitok.");

}

}

JspTemplate用于渲染页面,只需要传入JSP的路径,将Model绑定到HttpServletRequest,就可以调用Servlet规范的forward方法将请求转发给指定的JSP页面并渲染。代码见清单14。

清单14.定义JspTemplate

publicclassJspTemplateimplementsTemplate{

privateStringpath;

publicJspTemplate(Stringpath){

this.path=path;

}

publicvoidrender(HttpServletRequestrequest,HttpServletResponseresponse,

Map<String,Object>model)throwsException{

Set<String>keys=model.keySet();

for(Stringkey:keys){

request.setAttribute(key,model.get(key));

}

request.getRequestDispatcher(path).forward(request,response);

}

}

另一种比JSP更加简单且灵活的模板引擎是Velocity,它使用更简洁的语法来渲染页面,对页面设计人员更加友好,并且完全阻止了开发人员试图在页面中编写Java代码的可能性。使用Velocity编写的页面示例如清单15所示。

清单15.Velocity模板页面

<html>

<head><title>${title}</title></head>

<body><h1>Hello,${name}!</body>

</html>

通过VelocityTemplateFactory和VelocityTemplate就可以实现对Velocity的集成。不过,从Web开发人员看来,并不需要知道具体使用的模板,客户端仅需要提供模板路径和一个由Map<String,Object>组成的Model,然后返回一个TemplateRenderer对象。代码如清单16所示。

清单16.定义TemplateRenderer

publicclassTemplateRendererextendsRenderer{

privateStringpath;

privateMap<String,Object>model;

publicTemplateRenderer(Stringpath,Map<String,Object>model){

this.path=path;

this.model=model;

}

@Override

publicvoidrender(ServletContextcontext,HttpServletRequestrequest,

HttpServletResponseresponse)throwsException{

TemplateFactory.getTemplateFactory()

.loadTemplate(path)

.render(request,response,model);

}

}

TemplateRenderer通过简单地调用render方法就实现了页面渲染。为了指定Jsp或Velocity,需要在web.xml中配置DispatcherServlet的初始参数。配置示例请参考清单17。

清单17.配置Velocity作为模板引擎

<servlet>

<servlet-name>dispatcher</servlet-name>

<servlet-class>org.expressme.webwind.DispatcherServlet</servlet-class>

<init-param>

<param-name>template</param-name>

<param-value>Velocity</param-value>

</init-param>

</servlet>

如果没有该缺省参数,那就使用默认的Jsp。

类似的,通过扩展TemplateFactory和Template,就可以添加更多的模板支持,例如FreeMarker。

设计拦截器

拦截器和Servlet规范中的Filter非常类似,不过Filter的作用范围是整个HttpServletRequest的处理过程,而拦截器仅作用于Controller,不涉及到View的渲染,在大多数情况下,使用拦截器比Filter速度要快,尤其是绑定数据库事务时,拦截器能缩短数据库事务开启的时间。

拦截器接口Interceptor定义如清单18所示。

清单18.定义Interceptor

publicinterfaceInterceptor{

voidintercept(Executionexecution,InterceptorChainchain)throwsException;

}

和Filter类似,InterceptorChain代表拦截器链。InterceptorChain定义如清单19所示。

清单19.定义InterceptorChain

publicinterfaceInterceptorChain{

voiddoInterceptor(Executionexecution)throwsException;

}

实现InterceptorChain要比实现FilterChain简单,因为Filter需要处理Request、Forward、Include和Error这4种请求转发的情况,而Interceptor仅拦截Request。当MVC框架处理一个请求时,先初始化一个拦截器链,然后,依次调用链上的每个拦截器。请参考清单20所示的代码。

清单20.实现InterceptorChain接口

classInterceptorChainImplimplementsInterceptorChain{

privatefinalInterceptor[]interceptors;

privateintindex=0;

privateObjectresult=null;

InterceptorChainImpl(Interceptor[]interceptors){

this.interceptors=interceptors;

}

ObjectgetResult(){

returnresult;

}

publicvoiddoInterceptor(Executionexecution)throwsException{

if(index==interceptors.length)

result=execution.execute();

else{

//mustupdateindexfirst,otherwisewillcausestackoverflow:

index++;

interceptors[index-1].intercept(execution,this);

}

}

}

成员变量index表示当前链上的第N个拦截器,当最后一个拦截器被调用后,InterceptorChain才真正调用Execution对象的execute()方法,并保存其返回结果,整个请求处理过程结束,进入渲染阶段。清单21演示了如何调用拦截器链的代码。

清单21.调用拦截器链

classDispatcher{

...

privateInterceptor[]interceptors;

voidhandleExecution(Executionexecution,HttpServletRequestrequest,

HttpServletResponseresponse)throwsServletException,IOException{

InterceptorChainImplchains=newInterceptorChainImpl(interceptors);

chains.doInterceptor(execution);

handleResult(request,response,chains.getResult());

}

}

当Controller方法被调用完毕后,handleResult()方法用于处理执行结果。

渲染

由于我们没有强制HTTP处理方法的返回类型,因此,handleResult()方法针对不同的返回值将做不同的处理。代码如清单22所示。

清单22.处理返回值

classDispatcher{

...

voidhandleResult(HttpServletRequestrequest,HttpServletResponseresponse,

Objectresult)throwsException{

if(result==null)

return;

if(resultinstanceofRenderer){

Rendererr=(Renderer)result;

r.render(this.servletContext,request,response);

return;

}

if(resultinstanceofString){

Strings=(String)result;

if(s.startsWith("redirect:")){

response.sendRedirect(s.substring(9));

return;

}

newTextRenderer(s).render(servletContext,request,response);

return;

}

thrownewServletException("Cannothandleresultwithtype'"

+result.getClass().getName()+"'.");

}

}

如果返回null,则认为HTTP请求已处理完成,不做任何处理;如果返回Renderer,则调用Renderer对象的render()方法渲染视图;如果返回String,则根据前缀是否有“redirect:”判断是重定向还是作为HTML返回给浏览器。这样,客户端可以不必访问HttpServletResponse对象就可以非常方便地实现重定向。代码如清单23所示。

清单23.重定向

@Mapping("/register")

Stringregister(){

...

if(success)

return"redirect:/reg/success";

return"redirect:/reg/failed";

}

扩展Renderer还可以处理更多的格式,例如,向浏览器返回JavaScript代码等。

扩展

使用Filter转发

对于请求转发,除了使用DispatcherServlet外,还可以使用Filter来拦截所有请求,并直接在Filter内实现请求转发和处理。使用Filter的一个好处是如果URL没有被任何Controller的映射方法匹配到,则可以简单地调用FilterChain.doFilter()将HTTP请求传递给下一个Filter,这样,我们就不必自己处理静态文件,而由Web服务器提供的默认Servlet处理,效率更高。和DispatcherServlet类似,我们编写一个DispatcherFilter作为前置处理器,负责转发请求,代码见清单24。

清单24.定义DispatcherFilter

publicclassDispatcherFilterimplementsFilter{

...

publicvoiddoFilter(ServletRequestreq,ServletResponseresp,FilterChainchain)

throwsIOException,ServletException{

HttpServletRequesthttpReq=(HttpServletRequest)req;

HttpServletResponsehttpResp=(HttpServletResponse)resp;

Stringmethod=httpReq.getMethod();

if("GET".equals(method)||"POST".equals(method)){

if(!dispatcher.service(httpReq,httpResp))

chain.doFilter(req,resp);

return;

}

httpResp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);

}

}

如果用DispatcherFilter代替DispatcherServlet,则我们需要过滤“/*”,在web.xml中添加声明如清单25所示。

清单25.声明DispatcherFilter

<filter>

<filter-name>dispatcher</servlet-name>

<filter-class>org.expressme.webwind.DispatcherFilter</servlet-class>

</filter>

<filter-mapping>

<filter-name>dispatcher</servlet-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

访问Request和Response对象

如何在@Mapping方法中访问Servlet对象?如HttpServletRequest,HttpServletResponse,HttpSession和ServletContext。ThreadLocal是一个最简单有效的解决方案。我们编写一个ActionContext,通过ThreadLocal来封装对Request等对象的访问。代码见清单26。

清单26.定义ActionContext

publicfinalclassActionContext{

privatestaticfinalThreadLocal<ActionContext>actionContextThreadLocal

=newThreadLocal<ActionContext>();

privateServletContextcontext;

privateHttpServletRequestrequest;

privateHttpServletResponseresponse;

publicServletContextgetServletContext(){

returncontext;

}

publicHttpServletRequestgetHttpServletRequest(){

returnrequest;

}

publicHttpServletResponsegetHttpServletResponse(){

returnresponse;

}

publicHttpSessiongetHttpSession(){

returnrequest.getSession();

}

publicstaticActionContextgetActionContext(){

returnactionContextThreadLocal.get();

}

staticvoidsetActionContext(ServletContextcontext,

HttpServletRequestrequest,HttpServletResponseresponse){

ActionContextctx=newActionContext();

ctx.context=context;

ctx.request=request;

ctx.response=response;

actionContextThreadLocal.set(ctx);

}

staticvoidremoveActionContext(){

actionContextThreadLocal.remove();

}

}

在Dispatcher的handleExecution()方法中,初始化ActionContext,并在finally中移除所有已绑定变量,代码见清单27。

清单27.初始化ActionContext

classDispatcher{

...

voidhandleExecution(Executionexecution,HttpServletRequestrequest,

HttpServletResponseresponse)throwsServletException,IOException{

ActionContext.setActionContext(servletContext,request,response);

try{

InterceptorChainImplchains=newInterceptorChainImpl(interceptors);

chains.doInterceptor(execution);

handleResult(request,response,chains.getResult());

}

catch(Exceptione){

handleException(request,response,e);

}

finally{

ActionContext.removeActionContext();

}

}

}

这样,在@Mapping方法内部,可以随时获得需要的Request、Response、Session和ServletContext对象。

处理文件上传

ServletAPI本身并没有提供对文件上传的支持,要处理文件上传,我们需要使用CommonsFileUpload之类的第三方扩展包。考虑到CommonsFileUpload是使用最广泛的文件上传包,我们希望能集成CommonsFileUpload,但是,不要暴露CommonsFileUpload的任何API给MVC的客户端,客户端应该可以直接从一个普通的HttpServletRequest对象中获取上传文件。

要让MVC客户端直接使用HttpServletRequest,我们可以用自定义的MultipartHttpServletRequest替换原始的HttpServletRequest,这样,客户端代码可以通过instanceof判断是否是一个Multipart格式的Request,如果是,就强制转型为MultipartHttpServletRequest,然后,获取上传的文件流。

核心思想是从HttpServletRequestWrapper派生MultipartHttpServletRequest,这样,MultipartHttpServletRequest具有HttpServletRequest接口。MultipartHttpServletRequest的定义如清单28所示。

清单28.定义MultipartHttpServletRequest

publicclassMultipartHttpServletRequestextendsHttpServletRequestWrapper{

finalHttpServletRequesttarget;

finalMap<String,List<FileItemStream>>fileItems;

finalMap<String,List<String>>formItems;

publicMultipartHttpServletRequest(HttpServletRequestrequest,longmaxFileSize)

throwsIOException{

super(request);

this.target=request;

this.fileItems=newHashMap<String,List<FileItemStream>>();

this.formItems=newHashMap<String,List<String>>();

ServletFileUploadupload=newServletFileUpload();

upload.setFileSizeMax(maxFileSize);

try{

...解析Multipart...

}

catch(FileUploadExceptione){

thrownewIOException(e);

}

}

publicInputStreamgetFileInputStream(StringfieldName)throwsIOException{

List<FileItemStream>list=fileItems.get(fieldName);

if(list==null)

thrownewIOException("Nofileitemwithname'"+fieldName+"'.");

returnlist.get(0).openStream();

};

}

对于正常的Field参数,保存在成员变量Map<String,List<String>>formItems中,通过覆写getParameter()、getParameters()等方法,就可以让客户端把MultipartHttpServletRequest也当作一个普通的Request来操作,代码见清单29。

清单29.覆写getParameter

publicclassMultipartHttpServletRequestextendsHttpServletRequestWrapper{

...

@Override

publicStringgetParameter(Stringname){

List<String>list=formItems.get(name);

if(list==null)

returnnull;

returnlist.get(0);

}

@Override

@SuppressWarnings("unchecked")

publicMapgetParameterMap(){

Map<String,String[]>map=newHashMap<String,String[]>();

Set<String>keys=formItems.keySet();

for(Stringkey:keys){

List<String>list=formItems.get(key);

map.put(key,list.toArray(newString[list.size()]));

}

returnCollections.unmodifiableMap(map);

}

@Override

@SuppressWarnings("unchecked")

publicEnumerationgetParameterNames(){

returnCollections.enumeration(formItems.keySet());

}

@Override

publicString[]getParameterValues(Stringname){

List<String>list=formItems.get(name);

if(list==null)

returnnull;

returnlist.toArray(newString[list.size()]);

}

}

为了简化配置,在Web应用程序启动的时候,自动检测当前ClassPath下是否有CommonsFileUpload,如果存在,文件上传功能就自动开启,如果不存在,文件上传功能就不可用,这样,客户端只需要简单地把CommonsFileUpload的jar包放入/WEB-INF/lib/,不需任何配置就可以直接使用。核心代码见清单30。

清单30.检测CommonsFileUpload

classDispatcher{

privatebooleanmultipartSupport=false;

...

voidinitAll(Configconfig)throwsException{

try{

Class.forName("org.apache.commons.fileupload.servlet.ServletFileUpload");

this.multipartSupport=true;

}

catch(ClassNotFoundExceptione){

log.info("CommonsFileUploadnotfound.");

}

...

}

voidhandleExecution(Executionexecution,HttpServletRequestrequest,

HttpServletResponseresponse)throwsServletException,IOException{

if(this.multipartSupport){

if(MultipartHttpServletRequest.isMultipartRequest(request)){

request=newMultipartHttpServletRequest(request,maxFileSize);

}

}

...

}

...

}

小结

浅析十二个最佳ASP.NETMVC实践

揭秘WCFREST架构背后隐含概念

深入挖掘WCFREST服务

正确理解PHP开发MVC模型

JAX-RS的参考实现:Jersey构建RESTfulWe

要从头设计并实现一个MVC框架其实并不困难,设计WebWind的目标是改善Web应用程序的URL结构,并通过自动提取和映射URL中的参数,简化控制器的编写。WebWind适合那些从头构造的新的互联网应用,以便天生支持REST风格的URL。但是,它不适合改造已有的企业应用程序,企业应用的页面不需要搜索引擎的索引,其用户对URL地址的友好程度通常也并不关心。

相关推荐

homesmile / 0评论 2012-04-25