转：SpringMVC浅谈

因为项目文案需要，于是乎翻阅spring相关资料。顿觉该篇不错详尽易懂，特转载之。

转载出处：

http://blog.csdn.net/gane_cheng/article/details/52787040

http://www.ganecheng.tech/blog/52787040.html （浏览效果更好）

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架。它的主要目得是简化企业开发。

1. Spring框架包括什么？

转：SpringMVC浅谈

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.1. MVC在B/S系统下的应用

MVC是一个设计模式，MVC在B/S系统下的应用：

转：SpringMVC浅谈

1.2. SpringMVC框架

转：SpringMVC浅谈

执行步骤:

第一步：发起请求到前端控制器(DispatcherServlet)

第二步：前端控制器请求HandlerMapping查找 Handler 可以根据xml配置、注解进行查找

第三步：处理器映射器HandlerMapping向前端控制器返回Handler

第四步：前端控制器调用处理器适配器去执行Handler

第五步：处理器适配器去执行Handler

第六步：Handler执行完成给适配器返回ModelAndView

第七步：处理器适配器向前端控制器返回ModelAndView ModelAndView是SpringMVC框架的一个底层对象，包括 Model和view

第八步：前端控制器请求视图解析器去进行视图解析 根据逻辑视图名解析成真正的视图(jsp)

第九步：视图解析器向前端控制器返回View

第十步：前端控制器进行视图渲染 视图渲染将模型数据(在ModelAndView对象中)填充到request域

第十一步：前端控制器向用户响应结果

组件：

1、前端控制器DispatcherServlet（不需要程序员开发）作用接收请求，响应结果，相当于转发器，*处理器。有了DispatcherServlet减少了其它组件之间的耦合度。

2、处理器映射器HandlerMapping(不需要程序员开发) 作用：根据请求的url查找Handler

3、处理器适配器HandlerAdapter 作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler

4、处理器Handler(需要程序员开发) 注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler

5、视图解析器View resolver(不需要程序员开发) 作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）

6、视图View(需要程序员开发jsp) View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf...）

1.3. 配置前端控制器

在web.xml中配置前端控制器。

  <!-- SpringMVC前端控制器 -->

  <servlet>

      <servlet-name>springmvc</servlet-name>

      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

      <!-- contextConfigLocation配置SpringMVC加载的配置文件（配置处理器映射器、适配器等等）

      如果不配置contextConfigLocation，默认加载的是/WEB-INF/servlet名称-serlvet.xml（springmvc-servlet.xml）

       -->

      <init-param>

          <param-name>contextConfigLocation</param-name>

          <param-value>classpath:springmvc.xml</param-value>

      </init-param>

  </servlet>

  <servlet-mapping>

      <servlet-name>springmvc</servlet-name>

      <!--

      第一种：*.action，访问以.action结尾 由DispatcherServlet进行解析

      第二种：/，所以访问的地址都由DispatcherServlet进行解析，对于静态文件的解析需要配置不让DispatcherServlet进行解析

      使用此种方式可以实现 RESTful风格的url

      第三种：/*，这样配置不对，使用这种配置，最终要转发到一个jsp页面时，

      仍然会由DispatcherServlet解析jsp地址，不能根据jsp页面找到handler，会报错。

       -->

      <url-pattern>*.action</url-pattern>

  </servlet-mapping>

1.4. 配置处理器适配器(非注解方式)

在classpath下的springmvc.xml中配置处理器适配器

    <!-- 处理器适配器 所有处理器适配器都实现 HandlerAdapter接口 -->

    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />

    <!-- 另一个非注解的适配器 -->

    <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>

查看源码

SimpleControllerHandlerAdapter.java

public class SimpleControllerHandlerAdapter implements HandlerAdapter

{

    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)

            throws Exception

    {

        return ((Controller) handler).handleRequest(request, response);

    }

}

public interface Controller

{

    ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;

}

HttpRequestHandlerAdapter.java

public class HttpRequestHandlerAdapter implements HandlerAdapter

{

    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)

            throws Exception

    {

        ((HttpRequestHandler) handler).handleRequest(request, response);

        return null;

    }

}

public interface HttpRequestHandler

{

    void handleRequest(HttpServletRequest request, HttpServletResponse response)

            throws ServletException, IOException;

}

1.5. 配置处理器Handler(非注解方式)

编写Handler类

方式①：需要实现 Controller接口，才能由org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter适配器执行。

public class ItemsController1 implements Controller

{

    @Override

    public ModelAndView handleRequest(HttpServletRequest request,

            HttpServletResponse response) throws Exception

    {

        //调用Service查找 数据库，查询商品列表，这里使用静态数据模拟

        List<Items> itemsList = new ArrayList<Items>();

        //向list中填充静态数据

        Items items_1 = new Items();

        items_1.setName("联想笔记本");

        items_1.setPrice(6000f);

        items_1.setDetail("ThinkPad T430 联想笔记本电脑！");

        Items items_2 = new Items();

        items_2.setName("苹果手机");

        items_2.setPrice(5000f);

        items_2.setDetail("iphone6苹果手机！");

        itemsList.add(items_1);

        itemsList.add(items_2);

        //返回ModelAndView

        ModelAndView modelAndView =  new ModelAndView();

        //相当 于request的setAttribut，在jsp页面中通过itemsList取数据

        modelAndView.addObject("itemsList", itemsList);

        //指定视图

        modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

        return modelAndView;

    }

}

方式②：需要实现 HttpRequestHandler接口，才能由org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter 适配器执行。

public class ItemsController2 implements HttpRequestHandler

{

    @Override

    public void handleRequest(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException

    {

        //调用Service查找 数据库，查询商品列表，这里使用静态数据模拟

        List<Items> itemsList = new ArrayList<Items>();

        //向list中填充静态数据

        Items items_1 = new Items();

        items_1.setName("联想笔记本");

        items_1.setPrice(6000f);

        items_1.setDetail("ThinkPad T430 联想笔记本电脑！");

        Items items_2 = new Items();

        items_2.setName("苹果手机");

        items_2.setPrice(5000f);

        items_2.setDetail("iphone6苹果手机！");

        itemsList.add(items_1);

        itemsList.add(items_2);

        //设置模型数据

        request.setAttribute("itemsList", itemsList);

        //设置转发的视图

        request.getRequestDispatcher("/WEB-INF/jsp/items/itemsList.jsp").forward(request, response);

        //使用此方法可以通过修改response，设置响应的数据格式，比如响应json数据

        /*

        response.setCharacterEncoding("utf-8");

        response.setContentType("application/json;charset=utf-8");

        response.getWriter().write("json串");*/

    }

}

将编写Handler在spring容器加载。

<!-- 配置Handler -->

<bean id="itemsController1" name="/queryItems.action" class="cn.itcast.ssm.controller.ItemsController1" />

<!-- 配置另外一个Handler -->

<bean id="itemsController2" class="cn.itcast.ssm.controller.ItemsController2" />

1.6. 配置处理器映射器(非注解方式)

在classpath下的springmvc.xml中配置处理器映射器

处理器映射器： org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

另一个映射器： org.springframework.web.servlet.handler.SimpleUrlHandlerMapping

<!-- 处理器映射器① 将bean的name作为url进行查找 ，需要在配置Handler时指定beanname（就是url）

所有的映射器都实现 HandlerMapping接口。

-->

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

<!--处理器映射器② 简单url映射  -->

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

        <property name="mappings">

            <props>

                <!-- 对itemsController1的Handler进行url映射，url是/queryItems1.action -->

                <prop key="/queryItems1.action">itemsController1</prop>

                <prop key="/queryItems2.action">itemsController1</prop>

                <prop key="/queryItems3.action">itemsController2</prop>

            </props>

        </property>

</bean>

1.7. 配置视图解析器

需要配置解析jsp的视图解析器。

    <!-- 视图解析器

    解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包

     -->

    <bean

        class="org.springframework.web.servlet.view.InternalResourceViewResolver">

        <!-- 配置jsp路径的前缀 -->

        <property name="prefix" value="/WEB-INF/jsp/"/>

        <!-- 配置jsp路径的后缀 -->

        <property name="suffix" value=".jsp"/>

    </bean>

1.8. DispatcherSerlvet.properties

转：SpringMVC浅谈

前端控制器从上边的文件中加载处理映射器、适配器、视图解析器等组件，如果不在springmvc.xml中配置，使用默认加载的。

# Default implementation classes for DispatcherServlet's strategy interfaces.

# Used as fallback when no matching beans are found in the DispatcherServlet context.

# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

#处理器映射器

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\

    org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

#处理器适配器

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\

    org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\

    org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\

    org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\

    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

#视图解析器

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

手动在配置文件中配置处理器Handler，处理器映射器HandlerMapping，如果在文件太多的情况下会比较麻烦。而且每次都要实现Controller接口和HttpRequestHandler接口，并且只有一个实现方法。每次为了一个方法去实现接口，会造成Handler类越来越多。太麻烦。SpringMVC提供了注解模式开发处理器Handler，大大降低了工作量，提高了易用性。

1.9. 注解模式开发处理器Handler

注解模式的处理器映射器HandlerMapping和处理器适配器HandlerAdapter需要这样配置。

使用注解的映射器和注解的适配器。（注解的映射器和注解的适配器必须配对使用）

<!--注解映射器 -->

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

<!--注解适配器 -->

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

<!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置

    mvc:annotation-driven默认加载很多的参数绑定方法，

    比如json转换解析器就默认加载了，如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter

    实际开发时使用mvc:annotation-driven

     -->

    <!-- <mvc:annotation-driven></mvc:annotation-driven> -->

编写Handler，无需继承任何接口，仅需加入@Controller注解

//使用Controller标识 它是一个控制器

@Controller

public class ItemsController3

{

    //商品查询列表

    //@RequestMapping实现 对queryItems方法和url进行映射，一个方法对应一个url

    //一般建议将url和方法写成一样

    @RequestMapping("/queryItems")

    public ModelAndView queryItems()throws Exception

    {

        //调用Service查找 数据库，查询商品列表，这里使用静态数据模拟

        List<Items> itemsList = new ArrayList<Items>();

        //向list中填充静态数据

        Items items_1 = new Items();

        items_1.setName("联想笔记本");

        items_1.setPrice(6000f);

        items_1.setDetail("ThinkPad T430 联想笔记本电脑！");

        Items items_2 = new Items();

        items_2.setName("苹果手机");

        items_2.setPrice(5000f);

        items_2.setDetail("iphone6苹果手机！");

        itemsList.add(items_1);

        itemsList.add(items_2);

        //返回ModelAndView

        ModelAndView modelAndView =  new ModelAndView();

        //相当 于request的setAttribut，在jsp页面中通过itemsList取数据

        modelAndView.addObject("itemsList", itemsList);

        //指定视图

        modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

        return modelAndView;

    }

在spring容器中加载Handler（使用注解扫描方式加载）

    <!-- 对于注解的Handler可以单个配置

    实际开发中建议使用组件扫描

     -->

    <!-- <bean class="cn.itcast.ssm.controller.ItemsController3" /> -->

    <!-- 可以扫描Controller、Service、...

    这里让扫描Controller，指定Controller的包

     -->

    <context:component-scan base-package="cn.itcast.ssm.controller"></context:component-scan>

使用以上配置，就可以运行起来SpringMVC程序了。

1.10. 注解方式开发总结

对标记@Controller类中标识有@RequestMapping的方法进行映射。在@RequestMapping里边定义映射的url。使用注解的映射器不用在xml中配置url和Handler的映射关系。

注解处理器适配器和注解的处理器映射器是配对使用。理解为不能使用非注解映射器进行映射。

<mvc:annotation-driven></mvc:annotation-driven>可以代替下边的配置：

<!--注解映射器 -->

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

<!--注解适配器 -->

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

视图解析器配置前缀和后缀：

    <!-- 视图解析器

    解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包

     -->

    <bean

        class="org.springframework.web.servlet.view.InternalResourceViewResolver">

        <!-- 配置jsp路径的前缀 -->

        <property name="prefix" value="/WEB-INF/jsp/"/>

        <!-- 配置jsp路径的后缀 -->

        <property name="suffix" value=".jsp"/>

    </bean>

程序中不用指定前缀和后缀：

//没有前缀和后缀时

modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");

//有前缀和后缀时

modelAndView.setViewName("items/itemsList");

1.11. SpringMVC源码分析

通过前端控制器源码分析SpringMVC的执行过程。

第一步：前端控制器接收请求

调用doDiapatch

public class DispatcherServlet extends FrameworkServlet

{

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {

        HttpServletRequest processedRequest = request;

        HandlerExecutionChain mappedHandler = null;

        boolean multipartRequestParsed = false;

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {

            ModelAndView mv = null;

            Exception dispatchException = null;

            try {

                processedRequest = checkMultipart(request);

                multipartRequestParsed = processedRequest != request;

                // Determine handler for the current request.

                mappedHandler = getHandler(processedRequest, false);

                if (mappedHandler == null || mappedHandler.getHandler() == null) {

                    noHandlerFound(processedRequest, response);

                    return;

                }

                // Determine handler adapter for the current request.

                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.

                String method = request.getMethod();

                boolean isGet = "GET".equals(method);

                if (isGet || "HEAD".equals(method)) {

                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());

                    if (logger.isDebugEnabled()) {

                        String requestUri = urlPathHelper.getRequestUri(request);

                        logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);

                    }

                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {

                        return;

                    }

                }

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {

                    return;

                }

                try {

                    // Actually invoke the handler.

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                }

                finally {

                    if (asyncManager.isConcurrentHandlingStarted()) {

                        return;

                    }

                }

                applyDefaultViewName(request, mv);

                mappedHandler.applyPostHandle(processedRequest, response, mv);

            }

            catch (Exception ex) {

                dispatchException = ex;

            }

            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

        }

        catch (Exception ex) {

            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);

        }

        catch (Error err) {

            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);

        }

        finally {

            if (asyncManager.isConcurrentHandlingStarted()) {

                // Instead of postHandle and afterCompletion

                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);

                return;

            }

            // Clean up any resources used by a multipart request.

            if (multipartRequestParsed) {

                cleanupMultipart(processedRequest);

            }

        }

    }

}

第二步：前端控制器调用处理器映射器查找 Handler



// Determine handler for the current request.

mappedHandler = getHandler(processedRequest, false);

public class DispatcherServlet extends FrameworkServlet

{

    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {

        for (HandlerMapping hm : this.handlerMappings) {

            if (logger.isTraceEnabled()) {

                logger.trace(

                        "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");

            }

            HandlerExecutionChain handler = hm.getHandler(request);

            if (handler != null) {

                return handler;

            }

        }

        return null;

    }

}

第三步：调用处理器适配器执行Handler，得到执行结果ModelAndView

// Actually invoke the handler.

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

第四步：视图渲染，将model数据填充到request域。

视图解析，得到view:

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

render(mv, request, response);

    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {

        // Determine locale for request and apply it to the response.

        Locale locale = this.localeResolver.resolveLocale(request);

        response.setLocale(locale);

        View view;

        if (mv.isReference()) {

            // We need to resolve the view name.

            view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);

            if (view == null) {

                throw new ServletException(

                        "Could not resolve view with name '" + mv.getViewName() + "' in servlet with name '" +

                                getServletName() + "'");

            }

        }

        else {

            // No need to lookup: the ModelAndView object contains the actual View object.

            view = mv.getView();

            if (view == null) {

                throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +

                        "View object in servlet with name '" + getServletName() + "'");

            }

        }

        // Delegate to the View object for rendering.

        if (logger.isDebugEnabled()) {

            logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");

        }

        view.render(mv.getModelInternal(), request, response);

    }

// We need to resolve the view name.

view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);

调用view的渲染方法，将model数据填充到request域

渲染方法：

view.render(mv.getModelInternal(), request, response);

    protected void exposeModelAsRequestAttributes(Map<String, Object> model, HttpServletRequest request) throws Exception

    {

        for (Map.Entry<String, Object> entry : model.entrySet()) {

            String modelName = entry.getKey();

            Object modelValue = entry.getValue();

            if (modelValue != null) {

                request.setAttribute(modelName, modelValue);

                if (logger.isDebugEnabled()) {

                    logger.debug("Added model object '" + modelName + "' of type [" + modelValue.getClass().getName() +

                            "] to request in view with name '" + getBeanName() + "'");

                }

            }

            else {

                request.removeAttribute(modelName);

                if (logger.isDebugEnabled()) {

                    logger.debug("Removed model object '" + modelName +

                            "' from request in view with name '" + getBeanName() + "'");

                }

            }

        }

    }

1.12. Controller的@RequestMapping

① url映射

定义Controller方法对应的url，进行处理器映射使用。

② 窄化请求映射

@Controller

// 为了对url进行分类管理 ，可以在这里定义根路径，最终访问url是根路径+子路径

// 比如：商品列表：/items/queryItems.action

@RequestMapping("/items")

public class ItemsController

{

}

③ 限制http请求方法

出于安全性考虑，对http的链接进行方法限制。如果限制请求为post方法，进行get请求，则会报错。

//限制http请求方法，只可以post

@RequestMapping(value="/editItems",method={RequestMethod.POST})

public ModelAndView editItems()throws Exception

{

}

1.13. Controller方法的返回值

在编写控制器Handler可以有三种返回值。

返回ModelAndView
返回String
返回void

① 返回ModelAndView

需要方法结束时，定义ModelAndView，将model和view分别进行设置。

② 返回String

如果Controller方法返回String，可以有以下三种形式。

（1）、表示返回逻辑视图名。

真正视图(jsp路径)=前缀+逻辑视图名+后缀

@RequestMapping(value="/editItems",method={RequestMethod.POST,RequestMethod.GET})

public String editItems(Model model)throws Exception

{

     //调用Service根据商品id查询商品信息

     ItemsCustom itemsCustom = itemsService.findItemsById(1);

     //将商品信息放到model

     model.addAttribute("itemsCustom", itemsCustom);

     return "items/editItems";

}

（2）、redirect重定向

redirect重定向特点：浏览器地址栏中的url会变化。修改提交的request数据无法传到重定向的地址。因为重定向后重新进行request（request无法共享）

return "redirect:items/queryItems.action";

（3）、forward页面转发

通过forward进行页面转发，浏览器地址栏url不变，request可以共享。

return "forward:items/queryItems.action";

③ 返回void

在Controller方法形参上可以定义request和response，使用request或response指定响应结果：

（1）、使用request转向页面，如下：

request.getRequestDispatcher("页面路径").forward(request, response);

（2）、也可以通过response页面重定向：

response.sendRedirect("url");

（3）、也可以通过response指定响应结果，例如响应json数据如下：

response.setCharacterEncoding("utf-8");

response.setContentType("application/json;charset=utf-8");

response.getWriter().write("json串");

1.14. Controller参数绑定

SpringMVC参数绑定过程

从客户端请求key/value数据，经过参数绑定，将key/value数据绑定到Controller方法的形参上。

SpringMVC中，接收页面提交的数据是通过方法形参来接收。而不是在Controller类定义成员变量接收！！！！（与Struts2明显不同的实现逻辑）

转：SpringMVC浅谈

(1) 默认支持的类型

直接在Controller方法形参上定义下边类型的对象，就可以使用这些对象。在参数绑定过程中，如果遇到下边类型直接进行绑定。

① HttpServletRequest

通过request对象获取请求信息

② HttpServletResponse

通过response处理响应信息

③ HttpSession

通过session对象得到session中存放的对象

④ Model/ModelMap

model是一个接口，modelMap是一个接口实现。

作用：将model数据填充到request域。

(2) 简单类型

通过@RequestParam对简单类型的参数进行绑定。

如果不使用@RequestParam，要求request传入参数名称和Controller方法的形参名称一致，方可绑定成功。

如果使用@RequestParam，不用限制request传入参数名称和Controller方法的形参名称一致。

通过required属性指定参数是否必须要传入，如果设置为true，没有传入参数，则会报错。

    // @RequestParam里边指定request传入参数名称和形参进行绑定。

    // 通过required属性指定参数是否必须要传入

    // 通过defaultValue可以设置默认值，如果id参数没有传入，将默认值和形参绑定。

    public String editItems(Model model,@RequestParam(value = "id", required = true) Integer items_id) throws Exception

    {

    }

(3) pojo绑定

页面中input的name和Controller的pojo形参中的属性名称一致，将页面中数据绑定到pojo对应的属性。

页面定义：

转：SpringMVC浅谈

Controller的pojo形参的定义：

转：SpringMVC浅谈

需要说明的是：简单类型的参数绑定和pojo参数绑定互不影响。

    // @RequestParam里边指定request传入参数名称和形参进行绑定。

    // 通过required属性指定参数是否必须要传入

    // 通过defaultValue可以设置默认值，如果id参数没有传入，将默认值和形参绑定。

    public String editItems(Model model,@RequestParam(value = "id", required = true) Integer items_id, Items item) throws Exception

    {

    }

1.15. SpringMVC 和 Struts2 的区别

1、SpringMVC基于方法开发的，struts2基于类开发的。

SpringMVC将url和Controller方法映射。映射成功后SpringMVC生成一个Handler对象，对象中只包括了一个method。方法执行结束，形参数据销毁。 SpringMVC的Controller开发类似Service开发。

2、SpringMVC可以进行单例开发，并且建议使用单例开发，struts2通过类的成员变量接收参数，无法使用单例，只能使用多例。（原因就是第一句）

3、经过实际测试，struts2速度慢，在于使用struts标签，如果使用struts建议使用jstl。

1.16. SpringMVC 上传文件

在页面form中提交enctype="multipart/form-data"的数据时，需要SpringMVC对multipart类型的数据进行解析。

在springmvc.xml中配置multipart类型解析器。

    <!-- 文件上传 -->

    <bean id="multipartResolver"

        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

        <!-- 设置上传文件的最大尺寸为5MB -->

        <property name="maxUploadSize">

            <value>5242880</value>

        </property>

    </bean>

<form id="itemForm" action="${pageContext.request.contextPath }/items/editItemsSubmit.action" method="post" enctype="multipart/form-data">

<input type="hidden" name="id" value="${items.id }"/>

修改商品信息：

<table width="100%" border=1>

<tr>

    <td>商品图片</td>

    <td>

        <c:if test="${items.pic !=null}">

            <img src="/pic/${items.pic}" width=100 height=100/>

            <br/>

        </c:if>

        <input type="file"  name="items_pic"/>

    </td>

</tr>

<tr>

<td colspan="2" align="center"><input type="submit" value="提交"/>

</td>

</tr>

</table>

</form>

    @RequestMapping("/editItemsSubmit")

    public String editItemsSubmit(Model model,HttpServletRequest request,Integer id,

            MultipartFile items_pic//接收商品图片

            ) throws Exception

    {

    }

1.17. RESTful支持

RESTful架构，就是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

RESTful（即Representational State Transfer的缩写）其实是一个开发理念，是对http的很好的诠释。

1、对url进行规范，写RESTful格式的url

非REST的url：http://...../queryItems.action?id=001&type=T01 REST的url风格：http://..../items/001 特点：url简洁，将参数通过url传到服务端

2、http的方法规范

不管是删除、添加、更新。。使用url是一致的，如果进行删除，需要设置http的方法为delete，同理添加。。。

后台Controller方法：判断http方法，如果是delete执行删除，如果是post执行添加。

3、对http的contentType规范

请求时指定contentType，要json数据，设置成json格式的type。。

Controller中设置

定义方法，进行url映射使用REST风格的url，将查询商品信息的id传入Controller .

输出json使用@ResponseBody将java对象输出json。

    //查询商品信息，输出json

    ///itemsView/{id}里边的{id}表示占位符，通过@PathVariable获取占位符中的参数，

    //如果占位符中的名称和形参名一致，在@PathVariable可以不指定名称

    @RequestMapping("/itemsView/{id}")

    public @ResponseBody ItemsCustom itemsView(@PathVariable("id") Integer id)throws Exception

    {

        //调用Service查询商品信息

        ItemsCustom itemsCustom = itemsService.findItemsById(id);

        return itemsCustom;

    }

@RequestMapping(value="/ itemsView/{id}")：{×××}占位符，请求的URL可以是“/viewItems/1”或“/viewItems/2”，通过在方法中使用@PathVariable获取{×××}中的×××变量。

@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。如果RequestMapping中表示为"/ itemsView /{id}"，id和形参名称一致，@PathVariable不用指定名称。

REST方法的前端控制器配置

在web.xml配置：

<!-- SpringMVC前端控制器，rest配置 -->

    <servlet>

        <servlet-name>springmvc_rest</servlet-name>

        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- contextConfigLocation配置SpringMVC加载的配置文件（配置处理器映射器、适配器等等） 如果不配置contextConfigLocation，默认加载的是/WEB-INF/servlet名称-serlvet.xml（springmvc-servlet.xml） -->

        <init-param>

            <param-name>contextConfigLocation</param-name>

            <param-value>classpath:spring/springmvc.xml</param-value>

        </init-param>

    </servlet>

    <servlet-mapping>

        <servlet-name>springmvc_rest</servlet-name>

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

    </servlet-mapping>

对静态资源的解析

配置前端控制器的url-pattern中指定/，对静态资源的解析出现问题：

在springmvc.xml中添加静态资源解析方法。

    <!-- 静态资源解析

    包括 ：js、css、img、..

     -->

     <mvc:resources location="/js/" mapping="/js/**"/>

     <mvc:resources location="/img/" mapping="/img/**"/>

1.18. SpringMVC拦截器

拦截定义

定义拦截器，实现HandlerInterceptor接口。接口中提供三个方法。

public class HandlerInterceptor1 implements HandlerInterceptor

{

    //进入 Handler方法之前执行

    //用于身份认证、身份授权

    //比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行

    @Override

    public boolean preHandle(HttpServletRequest request,

            HttpServletResponse response, Object handler) throws Exception

    {

        //return false表示拦截，不向下执行

        //return true表示放行

        return false;

    }

    //进入Handler方法之后，返回modelAndView之前执行

    //应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图

    @Override

    public void postHandle(HttpServletRequest request,

            HttpServletResponse response, Object handler,

            ModelAndView modelAndView) throws Exception

    {

    }

    //执行Handler完成执行此方法

    //应用场景：统一异常处理，统一日志处理

    @Override

    public void afterCompletion(HttpServletRequest request,

            HttpServletResponse response, Object handler, Exception ex)

            throws Exception

    {

    }

}

拦截器配置

SpringMVC配置类似全局的拦截器，SpringMVC框架将配置的类似全局的拦截器注入到每个HandlerMapping中。

<!--拦截器 -->

<mvc:interceptors>

    <!--多个拦截器,顺序执行 -->

    <!-- 登陆认证拦截器 -->

    <mvc:interceptor>

        <mvc:mapping path="/**"/>

        <bean class="cn.itcast.ssm.interceptor.LoginInterceptor"></bean>

    </mvc:interceptor>

    <mvc:interceptor>

        <!-- /**表示所有url包括子url路径 -->

        <mvc:mapping path="/**"/>

        <bean class="cn.itcast.ssm.interceptor.HandlerInterceptor1"></bean>

    </mvc:interceptor>

    <mvc:interceptor>

        <mvc:mapping path="/**"/>

        <bean class="cn.itcast.ssm.interceptor.HandlerInterceptor2"></bean>

    </mvc:interceptor>

</mvc:interceptors>

根据测试结果，对拦截器应用。

比如：统一日志处理拦截器，需要该拦截器preHandle一定要放行，且将它放在拦截器链接中第一个位置。

比如：登陆认证拦截器，放在拦截器链接中第一个位置。权限校验拦截器，放在登陆认证拦截器之后。（因为登陆通过后才校验权限）

1.19. 参考文献

http://v.itcast.cn/course/8.html