`

设计 REST 风格的 MVC 框架

    博客分类：
  • REST
框架MVCREST设计模式正则表达式 
阅读更多

设计 REST 风格的 MVC 框架

 

廖 雪峰 , 软件工程师, HP

简介：  传统的 JavaEE MVC 框架如 Struts 等都是基于 Action 设计的后缀式映射，然而，流行的 Web 趋势是 REST 风格的架构。尽管使用 Filter 或者 Apache mod_rewrite 能够通过 URL 重写实现 REST 风格的 URL，为什么不直接设计一个全新的 REST 风格的 MVC 框架呢？ 本文将讲述如何从头设计一个基于 REST 风格的 Java MVC 框架，配合 Annotation，最大限度地简化 Web 应用的开发，您甚至编写一行代码就可以实现“Hello, world”。

本文的标签:   rest

标记本文！

发布日期：  2010 年 1 月 04 日
级别：  中级
访问情况  4007 次浏览
建议：  0 (添加评论 )

1 star 2 stars 3 stars 4 stars 5 stars 平均分 （共 8 个评分 ）

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

有经验的 Java Web 开发人员会使用 URL 重写的方式来实现类似的 URL，例如，为前端 Apache 服务器配置 mod_rewrite 模块，并依次为每个需要实现 URL 重写的地址编写负责转换的正则表达式，或者，通过一个自定义的 RewriteFilter，使用 Java Web 服务器提供的 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 定义 

				
public class Blog { 
    @Mapping("/create/$1") 
    Public void create(int userId) { ... } 

    @Mapping("/display/$1/$2") 
    Public void display(int userId, int postId) { ... } 

    @Mapping("/edit/$1/$2") 
    Public void edit(int userId, int postId) { ... } 

    @Mapping("/delete/$1/$2") 
    Public String delete(int userId, int postId) { ... } 
}

 

@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 

				
public interface ContainerFactory { 

    void init(Config config); 

    List<Object> findAllBeans(); 

    void destroy(); 
}

 

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

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


清单 3. 定义 SpringContainerFactory 

				
public class SpringContainerFactory implements ContainerFactory { 
    private ApplicationContext appContext; 

    public List<Object> findAllBeans() { 
        String[] beanNames = appContext.getBeanDefinitionNames(); 
        List<Object> beans = new ArrayList<Object>(beanNames.length); 
        for (int i=0; i<beanNames.length; i++) { 
            beans.add(appContext.getBean(beanNames[i])); 
        } 
        return beans; 
    } 
    ... 
}

 

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


清单 4. 定义 GuiceContainerFactory 

				
public class GuiceContainerFactory implements ContainerFactory { 
    private Injector injector; 

    public List<Object> findAllBeans() { 
        Map<Key<?>, Binding<?>> map = injector.getBindings(); 
        Set<Key<?>> keys = map.keySet(); 
        List<Object> list = new ArrayList<Object>(keys.size()); 
        for (Key<?> key : keys) { 
            Object bean = injector.getInstance(key); 
            list.add(bean); 
        } 
        return list; 
    } 
    ... 
}

 

类似的，通过扩展 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. 请求处理流程
图 1. 请求处理流程

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


清单 5. 定义 UrlMatcher 

				
final class UrlMatcher { 
    final String url; 
    int[] orders; 
    Pattern pattern; 

    public UrlMatcher(String url) { 
        ... 
    } 
}

 

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

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

 

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

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


清单 6. 定义 Action 

				
class Action { 
    public final Object instance; 
    public final Method method; 
    public final Class<?>[] arguments; 

    public Action(Object instance, Method method) { 
        this.instance = instance; 
        this.method = method; 
        this.arguments = method.getParameterTypes(); 
    } 
}

 

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


清单 7. 定义 Dispatcher 

				
class Dispatcher  { 
    private UrlMatcher[] urlMatchers; 
    private Map<UrlMatcher, Action> urlMap = new HashMap<UrlMatcher, Action>(); 
    .... 
}

 

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


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

				
final class UrlMatcher { 
    ... 

    /** 
     * 根据正则表达式匹配 URL，若匹配成功，返回从 URL 中提取的参数，
     * 若匹配失败，返回 null 
     */ 
    public String[] getMatchedParameters(String url) { 
        Matcher m = pattern.matcher(url); 
        if (!m.matches()) 
            return null; 
        if (orders.length==0) 
            return EMPTY_STRINGS; 
        String[] params = new String[orders.length]; 
        for (int i=0; i<orders.length; i++) { 
            params[orders[i]] = m.group(i+1); 
        } 
        return params; 
    } 
}

 

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


清单 9. 构造 Exectuion 

				
class Execution { 
    public final HttpServletRequest request; 
    public final HttpServletResponse response; 
    private final Action action; 
    private final Object[] args; 
    ... 

    public Object execute() throws Exception { 
        try { 
            return action.method.invoke(action.instance, args); 
        } 
        catch (InvocationTargetException e) { 
            Throwable t = e.getCause(); 
            if (t!=null && t instanceof Exception) 
                throw (Exception) t; 
            throw e; 
        } 
    } 
}

 

调用 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. 处理静态文件 

				
class StaticFileHandler { 
    ... 
    public void handle(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException { 
        String url = request.getRequestURI(); 
        String path = request.getServletPath(); 
        url = url.substring(path.length()); 
        if (url.toUpperCase().startsWith("/WEB-INF/")) { 
            response.sendError(HttpServletResponse.SC_NOT_FOUND); 
            return; 
        } 
        int n = url.indexOf('?'); 
        if (n!=(-1)) 
            url = url.substring(0, n); 
        n = url.indexOf('#'); 
        if (n!=(-1)) 
            url = url.substring(0, n); 
        File f = new File(servletContext.getRealPath(url)); 
        if (! f.isFile()) { 
            response.sendError(HttpServletResponse.SC_NOT_FOUND); 
            return; 
        } 
        long ifModifiedSince = request.getDateHeader("If-Modified-Since"); 
        long lastModified = 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 

				
public abstract class TemplateFactory { 
    private static TemplateFactory instance; 
    public static TemplateFactory getTemplateFactory() { 
        return instance; 
    } 

    public abstract Template loadTemplate(String path) throws Exception; 
}

 

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


清单 12. 定义 Template 

				
public interface Template { 
    void render(HttpServletRequest request, HttpServletResponse response, 
        Map<String, Object> model) throws Exception; 
}

 

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


清单 13. 定义 JspTemplateFactory 

				
public class JspTemplateFactory extends TemplateFactory { 
    private Log log = LogFactory.getLog(getClass()); 

    public Template loadTemplate(String path) throws Exception { 
        if (log.isDebugEnabled()) 
            log.debug("Load JSP template '" + path + "'."); 
        return new JspTemplate(path); 
    } 

    public void init(Config config) { 
        log.info("JspTemplateFactory init ok."); 
    } 
}

 

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


清单 14. 定义 JspTemplate 

				
public class JspTemplate implements Template { 
    private String path; 

    public JspTemplate(String path) { 
        this.path = path; 
    } 

    public void render(HttpServletRequest request, HttpServletResponse response, 
            Map<String, Object> model) throws Exception { 
        Set<String> keys = model.keySet(); 
        for (String key : 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 

				
public class TemplateRenderer extends Renderer { 
    private String path; 
    private Map<String, Object> model; 

    public TemplateRenderer(String path, Map<String, Object> model) { 
        this.path = path; 
        this.model = model; 
    } 

    @Override 
    public void render(ServletContext context, HttpServletRequest request, 
            HttpServletResponse response) throws Exception { 
        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 

				
public interface Interceptor { 
    void intercept(Execution execution, InterceptorChain chain) throws Exception; 
}

 

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


清单 19. 定义 InterceptorChain 

				
public interface InterceptorChain { 
    void doInterceptor(Execution execution) throws Exception; 
}

 

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


清单 20. 实现 InterceptorChain 接口 

				
class InterceptorChainImpl implements InterceptorChain { 
    private final Interceptor[] interceptors; 
    private int index = 0; 
    private Object result = null; 

    InterceptorChainImpl(Interceptor[] interceptors) { 
        this.interceptors = interceptors; 
    } 

    Object getResult() { 
        return result; 
    } 

    public void doInterceptor(Execution execution) throws Exception { 
        if(index==interceptors.length) 
            result = execution.execute(); 
        else { 
            // must update index first, otherwise will cause stack overflow: 
            index++; 
            interceptors[index-1].intercept(execution, this); 
        } 
    } 
}

 

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


清单 21. 调用拦截器链 

				
class Dispatcher  { 
    ... 
    private Interceptor[] interceptors; 
    void handleExecution(Execution execution, HttpServletRequest request, 
        HttpServletResponse response) throws ServletException, IOException { 
        InterceptorChainImpl chains = new InterceptorChainImpl(interceptors); 
        chains.doInterceptor(execution); 
        handleResult(request, response, chains.getResult()); 
    } 
}

 

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

回页首

渲染

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


清单 22. 处理返回值 

				
class Dispatcher  { 
    ... 
    void handleResult(HttpServletRequest request, HttpServletResponse response, 
            Object result) throws Exception { 
        if (result==null) 
            return; 
        if (result instanceof Renderer) { 
            Renderer r = (Renderer) result; 
            r.render(this.servletContext, request, response); 
            return; 
        } 
        if (result instanceof String) { 
            String s = (String) result; 
            if (s.startsWith("redirect:")) { 
                response.sendRedirect(s.substring(9)); 
                return; 
            } 
            new TextRenderer(s).render(servletContext, request, response); 
            return; 
        } 
        throw new ServletException("Cannot handle result with type '"
                + result.getClass().getName() + "'."); 
    } 
}

 

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


清单 23. 重定向 

				
@Mapping("/register") 
String register() { 
    ... 
    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 

				
public class DispatcherFilter implements Filter { 
    ... 
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) 
    throws IOException, ServletException { 
        HttpServletRequest httpReq = (HttpServletRequest) req; 
        HttpServletResponse httpResp = (HttpServletResponse) resp; 
        String method = 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 

				
public final class ActionContext { 
    private static final ThreadLocal<ActionContext> actionContextThreadLocal 
            = new ThreadLocal<ActionContext>(); 

    private ServletContext context; 
    private HttpServletRequest request; 
    private HttpServletResponse response; 

    public ServletContext getServletContext() { 
        return context; 
    } 

    public HttpServletRequest getHttpServletRequest() { 
        return request; 
    } 

    public HttpServletResponse getHttpServletResponse() { 
        return response; 
    } 

    public HttpSession getHttpSession() { 
        return request.getSession(); 
    } 

    public static ActionContext getActionContext() { 
        return actionContextThreadLocal.get(); 
    } 

    static void setActionContext(ServletContext context, 
            HttpServletRequest request, HttpServletResponse response) { 
        ActionContext ctx = new ActionContext(); 
        ctx.context = context; 
        ctx.request = request; 
        ctx.response = response; 
        actionContextThreadLocal.set(ctx); 
    } 

    static void removeActionContext() { 
        actionContextThreadLocal.remove(); 
    } 
}

 

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


清单 27. 初始化 ActionContext 

				
class Dispatcher { 
    ... 
    void handleExecution(Execution execution, HttpServletRequest request, 
    HttpServletResponse response) throws ServletException, IOException { 
        ActionContext.setActionContext(servletContext, request, response); 
        try { 
            InterceptorChainImpl chains = new InterceptorChainImpl(interceptors); 
            chains.doInterceptor(execution); 
            handleResult(request, response, chains.getResult()); 
        } 
        catch (Exception e) { 
            handleException(request, response, e); 
        } 
        finally { 
            ActionContext.removeActionContext(); 
        } 
    } 
}

 

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

处理文件上传

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

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

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


清单 28. 定义 MultipartHttpServletRequest 

				
public class MultipartHttpServletRequest extends HttpServletRequestWrapper { 
    final HttpServletRequest target; 
    final Map<String, List<FileItemStream>> fileItems; 
    final Map<String, List<String>> formItems; 

    public MultipartHttpServletRequest(HttpServletRequest request, long maxFileSize) 
    throws IOException { 
        super(request); 
        this.target = request; 
        this.fileItems = new HashMap<String, List<FileItemStream>>(); 
        this.formItems = new HashMap<String, List<String>>(); 
        ServletFileUpload upload = new ServletFileUpload(); 
        upload.setFileSizeMax(maxFileSize); 
        try {

 

... 解析 Multipart ... 

        } 
        catch (FileUploadException e) { 
            throw new IOException(e); 
        } 
    } 

    public InputStream getFileInputStream(String fieldName) throws IOException { 
        List<FileItemStream> list = fileItems.get(fieldName); 
        if (list==null) 
            throw new IOException("No file item with name '" + fieldName + "'."); 
        return list.get(0).openStream(); 
    }; 
}

 

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


清单 29. 覆写 getParameter 

				
public class MultipartHttpServletRequest extends HttpServletRequestWrapper { 
    ... 
    @Override 
    public String getParameter(String name) { 
        List<String> list = formItems.get(name); 
        if (list==null) 
            return null; 
        return list.get(0); 
    } 

    @Override 
    @SuppressWarnings("unchecked") 
    public Map getParameterMap() { 
        Map<String, String[]> map = new HashMap<String, String[]>(); 
        Set<String> keys = formItems.keySet(); 
        for (String key : keys) { 
            List<String> list = formItems.get(key); 
            map.put(key, list.toArray(new String[list.size()])); 
        } 
        return Collections.unmodifiableMap(map); 
    } 

    @Override 
    @SuppressWarnings("unchecked") 
    public Enumeration getParameterNames() { 
        return Collections.enumeration(formItems.keySet()); 
    } 

    @Override 
    public String[] getParameterValues(String name) { 
        List<String> list = formItems.get(name); 
        if (list==null) 
            return null; 
        return list.toArray(new String[list.size()]); 
    } 
}

 

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


清单 30. 检测 Commons FileUpload 

				
class Dispatcher { 
    private boolean multipartSupport = false; 
    ... 
    void initAll(Config config) throws Exception { 
        try { 
            Class.forName("org.apache.commons.fileupload.servlet.ServletFileUpload"); 
            this.multipartSupport = true; 
        } 
        catch (ClassNotFoundException e) { 
            log.info("CommonsFileUpload not found."); 
        } 
        ... 
    } 

    void handleExecution(Execution execution, HttpServletRequest request, 
            HttpServletResponse response) throws ServletException, IOException { 
        if (this.multipartSupport) { 
            if (MultipartHttpServletRequest.isMultipartRequest(request)) { 
                request = new MultipartHttpServletRequest(request, maxFileSize); 
            } 
        } 
        ... 
    } 
    ... 
}

 

回页首

小结

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

 

参考资料

学习

获得产品和技术

讨论

关于作者

作者照片

廖 雪峰，精通 Java/Java EE/Java ME/Android/Python/C#/Visual Basic，对开源框架有深入研究，著有《Spring 2.0 核心技术与最佳实践》一书，创建有开源框架 JOpenID，其官方博客是 http://www.liaoxuefeng.com/ 和 http://michael-liao.appspot.com/。

分享到：
| 基于 REST 的 Web 服务：基础
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    开源mvc框架源码

    3. **设计模式**：在开源MVC框架中，设计模式如工厂模式用于创建对象，单例模式用于确保类只有一个实例，观察者模式则用于对象间的事件通知。这些模式帮助框架实现灵活、可扩展的结构。 4. **AOP**：面向切面编程...

    第四章 Spring MVC Rest风格的url、静态资源标签

    在本章中，我们将深入探讨Spring MVC框架中的RESTful风格URL设计以及如何处理静态资源。REST（Representational State Transfer）是一种软件架构风格，常用于Web服务设计，它强调通过HTTP方法（如GET、POST、PUT、...

    Spring MVC REST Demo

    "Spring MVC REST Demo"是一个示例项目，旨在展示如何在Spring MVC框架中实现RESTful Web服务。下面将详细讨论Spring MVC与RESTful API的结合，以及如何创建和测试此类服务。 首先，Spring MVC是Spring框架的一部分...

    用WCFWebAPI在MVC3.0下实现REST

    当然，REST不光限于web service，网页服务也可以RESTful，微软的ASP.NET MVC框架提供了直接的REST支持。 有关.net,MVC实现REST风格的方法请参见张善友老师的博客：...

    spring-rest.rar_DEMO_employeeDS.java_rest spring mvc_spring mvc_

    在本示例中，我们将深入探讨如何利用Spring MVC框架构建RESTful API，主要涉及`employeeDS.java`这个可能的数据服务类以及与`rest_spring_mvc`、`spring_mvc`和`spring_rest`相关的概念。`spring-rest.rar`是一个...

    mavin spring4 mvc mybatis 整合 带事务，REST风格

    【标题】"mavin spring4 mvc mybatis 整合 带事务，REST风格" 涉及到的是一个基于Java技术栈的Web应用程序开发，整合了Maven、Spring4 MVC、MyBatis框架，并且实现了RESTful API设计以及事务管理。下面将对这些关键...

    REST风格的架构

    REST风格的架构是一种基于HTTP协议，使用统一的接口来交互数据和实现功能的软件设计模式。在Web服务领域，REST（Representational State Transfer，表述性状态转移）已经成为构建可伸缩、高性能网络应用的重要选择。...

    rest风格+jdbctemplate的CRUD操作.rar

    使用SpringMVC+jdbctemplate实现REST风格的CRUD功能 完成功能：能够对用户进行CRUD操作，界面粗糙，只做演示 运行环境：eclipse2019.03+JDK8+Tomcat9.0.41+MySQL5.5 运用到的技术：spring+springMVC+jdbctemplate+...

    Spring MVC 框架学习总结

    11. **RESTful 风格的 API**：Spring MVC 支持创建符合 REST 原则的 API，通过 HTTP 方法（GET、POST、PUT、DELETE）和 @RequestMapping 来实现资源操作。 12. **单例和原型控制器**：Spring MVC 中的 Controller ...

    Spring Boot——2分钟构建spring web mvc REST风格HelloWorld

    REST（Representational State Transfer）是一种网络应用程序的设计风格和开发方式，基于HTTP协议，以JSON或XML格式传输数据。在Spring Boot中，我们可以轻松地创建RESTful Web服务。 **Spring MVC** Spring MVC是...

    ssm框架整合及Rest风格接口实现

    SSM框架整合及Rest风格接口实现涉及到的技术领域主要包括Spring、SpringMVC、Mybatis三大流行Java框架的整合以及基于RESTful风格的接口设计与实现。 首先，Spring、SpringMVC、Mybatis是Java后端开发中经常组合使用...

    mavin spring4 mvc mybatis 整合 带REST风格

    【标题】"mavin spring4 mvc mybatis 整合 带REST风格"涉及到的知识点主要涵盖了Java Web开发中的三大核心框架：Maven、Spring 4 MVC以及MyBatis，以及RESTful服务的设计和实现。以下是这些技术的详细介绍： 1. ...

    springMVC rest风格视图解析

    在现代Web应用开发中，Spring MVC作为Java领域最流行的MVC框架之一，为开发者提供了强大的功能，包括构建RESTful API。REST（Representational State Transfer）风格的架构设计是Web服务的一种理想模式，它强调资源...

    springmvc之rest风格的crud

    在Spring MVC框架中，REST（Representational State Transfer）风格是一种设计Web服务的常见方式，它强调资源的概念，并通过HTTP协议中的方法（GET、POST、PUT、DELETE）来操作这些资源。本教程主要针对初学者，讲解...

    Spring4+SpringMVC4+Mybatis3+IDEA+REST风格框架(微信小程序+APP+Boss后台).zip

    标题 "Spring4+SpringMVC4+Mybatis3+IDEA+REST风格框架(微信小程序+APP+Boss后台).zip" 提供的信息显示，这是一个基于Java技术栈的项目，使用了Spring 4、SpringMVC 4、Mybatis 3等流行框架，集成在IntelliJ IDEA...

    精通Spring_Web_MVC优秀框架.pdf

    ### Spring Web MVC 框架核心知识点解析 #### 一、Spring Web MVC 概述 - **Spring Web MVC** 是...通过上述内容的学习，可以全面掌握Spring Web MVC框架的核心开发知识，为构建高质量的Web应用程序打下坚实的基础。

Magicbox
Global site tag (gtag.js) - Google Analytics