springMVC

最新推荐文章于 2022-06-08 18:52:45 发布

Mr_Literature

最新推荐文章于 2022-06-08 18:52:45 发布

阅读量213

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_31792281/article/details/80063579

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

springMVC

这里写图片描述

一、介绍

1、关于springmvc

springmvc是spring框架的一个模块，是一个基于mvc的web框架，它与spring无需通过中间整合层进行整合。

2、组件

前端控制器DispatcherServlet：拦截匹配的请求，j进行全局的流程控制。
处理器映射器HandlerMapping：根据请求的url查找处理器Handler。
处理器适配器HandlerAdapter：按照特定规则去执行Handler。
视图解析器ViewResolver：进行视图解析，根据逻辑视图名解析成真正的视图对象(view)。
视图View：是一个接口，实现类支持不同的View类型(jsp、freemaker、pdf)，它可以进行视图渲染。

3、执行过程

1）图解

这里写图片描述

2）叙述

核心架构的具体流程步骤如下：
首先用户发送请求给前端控制器，前端控制器进行全局的流程控制，将请求委托给处理器映射器进行处理。处理器映射器将请求映射到处理器，然后前端控制器会根据这个处理器得到相应的处理器适配器，处理器适配器就调用处理器方法进行执行，产生ModelAndView对象。前端控制器根据ModelAndView对象得到逻辑视图名，调用视图解析器将逻辑视图名解析成视图对象View，然后视图对象调用自身方法填充模型数据进行视图渲染。

3）源码

DispatcherServlet核心代码如下：

（1）doDispatch

处理器适配器根据请求得到处理器，然后生成相应的处理器适配器执行处理器方法，得到ModelAndView对象，然后调用下个方法进行处理。

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 {
                //检查请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // 请求到处理器的映射，处理器映射器根据请求得到处理器执行链，在这个过程中会实例化Handler给处理器执行链的handler属性
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null || mappedHandler.getHandler() == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // 根据处理器执行链的handler属性得到处理器对象，从而产生相应的处理器适配器
            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()) {
                    logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }

            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // 处理器适配器执行当前的处理器，获得ModelAndView对象
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            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
            if (mappedHandler != null) {
            mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

（2）processDispatchResult

对处理器执行的结果ModelAndView进行处理，然后调用下个方法进行视图解析。

处理处理器执行的结果，它可能是一个ModelAndView或是一个被视作为ModelAndView的异常
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
    HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {

    boolean errorView = false;

    if (exception != null) {
        if (exception instanceof ModelAndViewDefiningException) {
            logger.debug("ModelAndViewDefiningException encountered", exception);
            mv = ((ModelAndViewDefiningException) exception).getModelAndView();
        }else {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            mv = processHandlerException(request, response, handler, exception);
            errorView = (mv != null);
        }
    }

    // Did the handler return a view to render?
    if (mv != null && !mv.wasCleared()) {
        //递交得到的ModelAndView
        render(mv, request, response);
        if (errorView) {
            WebUtils.clearErrorRequestAttributes(request);
        }
    }else {
        if (logger.isDebugEnabled()) {
            logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                    "': assuming HandlerAdapter completed request handling");
        }
    }

    if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
        // Concurrent handling started during a forward
        return;
    }

    if (mappedHandler != null) {
        mappedHandler.triggerAfterCompletion(request, response, null);
    }
}

（3）render

视图解析器根据逻辑视图名解析出视图对象，然后视图对象View调用本身方法填充模型数据并进行视图渲染。

//递交得到的ModelAndView，这是处理请求的最后一个位置，它会通过逻辑视图名解析出视图View
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()) {
        //根据视图名解析出视图View
        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() + "'");
    }
    try {
        //视图View填充模型数据并进行渲染
        view.render(mv.getModelInternal(), request, response);
    }catch (Exception ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '" +
            getServletName() + "'", ex);
        }
        throw ex;
    }
}

二、前端控制器

1、引入

在web.xml文件中：

<servlet>
    <servlet-name></servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--
        1、*.action，访问以.action结尾，由DispatcherServlet进行解析
        2、/，所以访问的地址都由DispatcherServlet进行解析，对于静态文件的解析需要配置不让DispatcherServlet进行解析，使用此种方式可以实现restful风格的url
        3、/*，这样配置不对，使用此种配置，最终要转发到一个jsp页面时，仍然会由DispatcherServlet解析jsp地址，不能根据jsp页面找到handler，会报错。
    -->
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

2、默认配置

前端控制器的默认配置文件和DispatcherServlet类在同一个包下，dispatcherServlet.properties文件中。DispatcherServlet 在启动时会自动注册返些特殊的 Bean，无需我们注册，如果我们注册了，默认的将不会注册。

# 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

3、特殊bean

DispatcherServlet 默认使用 WebApplicationContext 作为上下文，其中包含很多特殊的bean。

Controller：处理器，做的是 MVC 中的 C 的事情，但控制逻辑转移到前端控制器了，用于对请求进行处理。
HandlerMapping：请求到处理器的映射，如果映射成功返回一个HandlerExecutionChain对象（包含一个 Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象。
HandlerAdapter：处理器适配器会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；如SimpleControllerHandlerAdapter 将对实现了 Controller 接口的 Bean 进行适配，去掉处理器的 handleRequest 方法进行功能处理。
ViewResolver：ViewResolver 将把逻辑视图名解析为具体的 View，通过这种策略模式，很容易更换其他视图技术；如 InternalResourceViewResolver 将逻辑视图名映射为 jsp视图。
LocalResover：本地化解析，因为 Spring 支持国际化，因此 LocalResover 解析客户端的 Locale 信息从而方便迕行国际化。
ThemeResovler：主题解析，通过它来实现一个页面多套风格，即常见的类似于软件皮肤效果。
MultipartResolver：文件上传解析，用于支持文件上传。
HandlerExceptionResolver：处理器异常解析，可以将异常映射到相应的统一指挥界面，从而显示用户友好的界面（而不是给用户看到具体的错误信息）。
RequestToViewNameTranslator：当处理器没有返回逻辑视图名等相关信息时，自动将请求 URL 映射为逻辑视图名。
FlashMapManager：用于管理 FlashMap 的策略接口，FlashMap 用于存储一个请求的输出，当进入另一个请求时作为该请求的输入，通常用于重定向场景。

三、非注解的处理器映射器、处理器适配器

1、非注解的处理器映射器

1）BeanNameUrlHandlerMapping

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<bean name="/queryItems.action" class="com.wenxue.controller.ItemsController"/>

2）SimpleUrlHandlerMapping

<bean id="itemsController" class="com.wenxue.controller.ItemsController"/>
<!--简单url映射-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <!--对itemController进行映射，url是queryItems1.action-->
            <prop key="queryItems1.action">itemsController</prop>
            <prop key="queryItems2.action">itemsController</prop>
        </props>
    </property>
</bean>

多个映射器可以并存，前端控制器判断url能让哪些映射器映射，就让正确的映射器处理。

2、非注解的处理器适配器

1）SimpleControllerHandlerAdapter，按照要求编写Handler实现Controller接口

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

2）HttpRequestHandlerAdapter，按照要求编写Handler实现HttpRequestHandler接口

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

3、非注解开发Handler

编写Handler实现HttpRequestHandler接口，里面操作与原始的servlet类似。使用此方法可以通过修改response，设置响应的数据格式，比如响应json数据。

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

四、注解的处理器映射器、处理器适配器

在spring3.1之前

注解映射器
org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
注解适配器
org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

在spring3.1之后

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

1、配置注解映射器、注解适配器

<!--注解映射器-->
<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默认加载很多的参数绑定方法-->
<mvc-annotation-driven/>

2、注解开发Handler

新建一个类，现在不用实现接口，在类名上添加@Controller标识，用@Controller标识该类是一个控制器。新建一个方法，返回值是ModelAndView，向上进行抛异常，在该方法上添加@RequestMapping标识，实现对queryItems方法和url进行映射，一个方法对应一个url。

@Controller
public class HelloWorld{
    @RequestMapping("/queryItems")
    public ModelAndView queryItems()throw Exception{

    }
}

配置Handler

<bean name="/queryItems.action" class="com.wenxue.controller.ItemsController"/>

实际开发中会有大量的Handler，每个Handler都进行配置会很麻烦，所以我们使用组件扫描。

<context:component-scan base-package="com.wenxue.controller"/>

五、视图解析器

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <property name="suffix" value=".jsp"/>
</bean>

六、控制器

1、介绍

Controller控制器收集、验证请求参数并绑定到命令对象，再交给业务对象，由业务对象进行处理并返回模型数据。Controller控制器与前端控制器共同组成MVC中的C，只是Controller控制器只进行功能处理，把流程控制交给了前端控制器。

定义一个控制器：

@Controller
public class HelloController{

}

控制器通用请求前缀：

@Controller
@RequestMapping(value="/user")
public class HelloController{

}

2、请求映射

1）url路径映射

关于请求的URL路径与控制器方法进行映射。

（1）基本使用

@RequestMapping(value="/create")
public String create(User user){

}

访问时要加控制器的请求前缀，如：http://www.xxx.com/user/create

（2）组合使用

@RequestMapping(value={"/create","update"})
public String create(User user){

}

组合使用是“或”的关系，多个URL路径可以映射到同一个控制器方法中。

2）请求方式限定

限定该控制器方法只能处理指定请求方式的请求。

（1）基本使用

@RequestMapping(value="/create",method=RequestMethod.GET)
public String create(User user){

}

该方法只能处理路径为http://www.xxx.com/user/create，且请求方式为GET的请求。

（2）组合使用

@RequestMapping(value="/create",method={RequestMethod.GET,RequestMethod.POST)
public String create(User user){

}

组合使用是“或”的关系，该方法既可以处理GET方式的请求也可以处理POST方式的请求。

3）请求参数限定

限定该控制器方法只能处理具有指定参数数据的请求。

（1）有指定参数名

@RequestMapping(params="create")
public String create(User user){

}

表示该控制器方法只能处理带有create参数名的请求，如http://www.xxx.com/user?create。

（2）没有指定参数名

@RequestMapping(params="!create")
public String create(User user){

}

表示该控制器方法只能处理没有create参数名的请求，如http://www.xxx.com/user?abc。

（2）指定参数名=值

@RequestMapping(params="submit=create")
public String create(User user){

}

表示该控制器方法只能处理带有submit=create参数的请求，如http://www.xxx.com/user?submit=create。

（4）指定参数名!=值

@RequestMapping(params="submit!=create")
public String create(User user){

}

表示该控制器方法只能处理参数submit!=create的请求，如http://www.xxx.com/user?submit=abc。

（5）组合使用

@RequestMapping(params={"test","submit=create"})
public String create(User user){

}

组合使用是“且”的关系，表示该控制器方法只能处理具有test参数名且具有submit=create参数的请求，如http://www.xxx.com/user?test&submit=create。

4）请求头数据限定

限定该控制器方法只能处理具有指定头数据的请求。

（1）指定参数名

@RequestMapping(value="create"，headers="flag")
public String create(User user){

}

表示请求的URL必须是http://www.xxx.com/user/create，且请求头中必须有参数flag才能匹配。

（2）没有指定参数名

@RequestMapping(value="create"，headers="!flag")
public String create(User user){

}

表示请求的URL必须是http://www.xxx.com/user/create，且请求头中必须没有参数flag才能匹配。

（3）指定参数名=值

@RequestMapping(value="create"，headers="Content-Type=application/json")
public String create(User user){

}

表示请求的URL必须是http://www.xxx.com/user/create，且请求头中必须有参数Content-Type=application/json才能匹配。

（4）指定参数名!=值

@RequestMapping(value="create"，headers="Content-Type!=application/json")
public String create(User user){

}

表示请求的URL必须是http://www.xxx.com/user/create，且请求头中必须有参数Content-Type但值不等于application/json才能匹配。

（5）组合使用

@RequestMapping(value="create"，headers={"Content-Type!=application/json","flag=1"})
public String create(User user){

}

表示请求的URL必须是http://www.xxx.com/user/create，且请求头中必须有参数Content-Type但值不等于application/json且请求中必须有参数flag=1才能匹配。

3、参数绑定

从客户端请求key/value数据，经过参数绑定，将key/value数据绑定到controller方法的形参上。springmvc中，接收页面提交的数据是通过方法形参来接收，而不是在controller类定义成员变量接收。

1）默认类型

HttpServletRequest：通过request对象获取请求信息。
HttpServletResponse：通过response处理响应的信息。
HttpSession：通过session对象得到session对象。
Model/ModelMap：Model是一个接口，ModelMap是一个接口实现，用来将model数据填充到request域中。
InputStream/OutputStream：获取请求/响应的内容区字节流。
Reader/Writer：获取请求/响应的内容区字符流。

这些类型控制器方法默认支持，只需在控制器方法中定义这些类型的形参，即可使用。

2）简单类型

（1）自动绑定

需要传入的参数名称和控制器方法的形参名称一致，就能自动绑定成功，如果有多个同样的参数名称，则绑定为数组。

@RequestMapping("/create")
public String create(String name,int age){
    return "hello";
}

（2）注解绑定

通过@RequestParam注解对简单类型的参数进行绑定，不用限制传入参数名称和控制器方法的形参名称一致。

required属性：指定参数是否必须要传入。
defaultValue：设置默认值，如果id参数没有传入，将默认值和形参绑定。

@RequestMapping(value="/get",method={RequestMethod.POST,RequestMethod.GET})
public String get(@RequestParam(value="id",required=true,defaultValue="1") Integer id){
    return "hello";
}

3）pojo类型

（1）普通pojo

传入的参数名称和控制器的pojo形参中的字段名称一致，即可将页面中数据绑定到pojo。

pojo类

public class user {
    private String name;
    private int age;
}

页面

<input type="text" name="name"/>
<input type="text" name="age"/>

控制器方法

@RequestMapping("/create")
public String create(User user){
    System.out.println(user.getName()+" "+user.getAge());
    return "hello";
}

（2）包装pojo

public class UserQueryVo{
    private User user;
    private UserCustom userCustom;
}

页面

<input type="text" name="userCustom.name"/>
<input type="text" name="userCustom.age"/>

控制器方法

@RequestMapping("/create")
public String create(UserQueryVo user){
    System.out.println(user.getUserCustom.getName()+" "+user.getUserCustom.getAge());
    return "hello";
}

4）集合类型

（1）list

public class UserQueryVo{
    private User user;
    private UserCustom userCustom;
    private List<UserCustom> userList;
}

页面

<input type="text" name="userList[${status.index}].name"/>
<input type="text" name="userList[${status.index}].age"/>

控制器方法

@RequestMapping("/create")
public String create(UserQueryVo userQV){
    return "hello";
}

（2）map

Public class UserQueryVo {
    private Map<String, User> userMap = new HashMap<String, User>();
}

页面

<input type="text" name="userMap['name']"/>

控制器方法

@RequestMapping("/create")
public String create(UserQueryVo userQV){
    return "hello";
}

5）json/xml数据

json

{
    "name":"wenxue",
    "age":22
}

xml

<?xml version="1.0" encoding="UTF-8"?>
<user>
    <name>wenxue</name>
    <age>22</age>
</user>

使用@RequestBody将json/xml数据绑定到对象，使用@ResponseBody将对象转成json输出。

@RequestMapping("/create")
public @ResponseBody User create(@RequestBody User user){
    return user;
}

6）自定义类型

自定义参数绑定实现日期类型绑定。在springmvc.xml中配置：

<!-- 自定义参数绑定 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <!-- 转换器 -->
    <property name="converters">
        <list>
            <!-- 日期类型转换器 -->
            <bean class="com.ssm.controller.CustomDateConverter"/>
        </list>
    </property>
</bean>

新建CustomDateConverter类

package com.ssm.controller;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.core.convert.converter.Converter;


public class CustomDateConverter implements Converter<String,Date>{

    @Override
    public Date convert(String source) {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        try {
            return simpleDateFormat.parse(source);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //如果参数绑定失败返回null
        return null;
    }

}

4、返回值

1）返回ModelAndView

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

@RequestMapping(value="/get",method={RequestMethod.POST,RequestMethod.GET})
public ModelAndView get()throws Exception{
    User user=userService.findUserById(1);
    ModelAndView modelAndView=new ModelAndView();
    modelAndView.addObject("user",user);
    modelAndView.setViewName("user");
    return modelAndView;
}

2）返回String

（1）逻辑视图名

真正的视图=前缀+逻辑视图名+后缀。

@RequestMapping(value="/get",method={RequestMethod.POST,RequestMethod.GET})
public String get(Model model)throws Exception{
    User user=userService.findUserById(1);
    model.addAttribute("user",user);
    return "user";
}

（2）转发

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

不加斜线：表示是在当前类级别下转发，会转发到/user/get。

@RequestMapping("/create")
public User create(){
    return "forward:get";
}

加斜线：表示是从项目根路径开始的，会转发到/user/get。

@RequestMapping("/create")
public User create(){
    return "forward:/user/get";
}

转发到jsp页面：会转发到根路径下的index.jsp页面。

@RequestMapping("/create")
public User create(){
    return "forward:/index.jsp";
}

（3）重定向

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

不加斜线：表示是在当前类级别下重定向，会重定向到到/user/get。

@RequestMapping("/create")
public User create(){
    return "redirect:get";
}

加斜线：表示是从项目根路径开始的，会重定向到到/user/get。

@RequestMapping("/create")
public User create(){
    return "redirect:/user/get";
}

重定向到jsp页面：会重定向到根路径下的index.jsp页面。

@RequestMapping("/create")
public User create(){
    return "redirect:/index.jsp";
}

3）返回void

在controller方法形参上可以定义reques和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串");

4）返回对象

返回json格式的字符串。

@Controller
@RequestMapping("/json")
public class jsonController {

    @RequestMapping("/user")
    public @ResponseBody User get(){
        User user = new User();
        user.setName("jayjay");
        user.setAge(22);
        return user;
    }
}

5、restful

1）介绍

restful本身是为分布式超媒体系统设计的一种架构风格，适合开发web service服务，它可以把网络上所有资源进行唯一的URL定位，资源类型没有限制，目前主要基于HTTP协议实现，其目的是为了提高系统的可伸缩性、降低应用之间的耦合度、便于架构分布式处理程序。

对url进行规范，使用restful格式的url
对http的方法规范（GET、POST等）
对http的contentType规范，请求时指定contentType，要json数据，就设置json格式的type

2）URL变量解析

@Controller
@RequestMapping("/")
public class HelloController {

    @RequestMapping("/hello/{name}")
    public String hello(@PathVariable("name") String name,HttpServletRequest request)throws Exception{
        request.setAttribute("message","Hello!"+name);
        return "hello";
    }
}

@RequestMapping(“/viewItems/{id}”)：{xxx}占位符，请求的URL可以是/viewItems/1或者是/viewItems/2。
@PathVariable：使用@PathVariable获取URL占位符{xxx}中的变量，映射到功能处理方法的参数上。

3）静态资源解析

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

或

<mvc:default-servlet-handler/>

对于静态资源先通过 DefaultAnnotationHandlerMapping 来找处理器，一定是找不到的，再 SimpleUrlHandlerMapping 匹配 “/**”。

七、拦截器

1、介绍

处理器拦截器：对处理器进行拦截，相当于servlet中的filter过滤器，常用于日志记录、权限检查、性能监控、通用行为（读取cookie，提取Locale、Theme信息等）等。

2、拦截器接口

拦截器具有三个回调方法：

public interface HandlerInterceptor {
    //预处理回调方法，实现处理器的预处理（如登录检查），返回true表示继续流程，返回false表示流程中断，此时需要通过response来产生响应
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception;

    //后处理回调方法，处理器处理后，视图渲染前执行，可以通过ModelAndView对模型数据进行处理或视图进行处理
    void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
            throws Exception;
    //整个请求处理完毕回调方法，即在视图渲染完毕后回调，如性能监控，可以在此记录结束时间，输出消耗时间，还可以进行一些资源清理
    void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception;
}

3、拦截器适配器

实现HandlerInterceptor接口，三个方法必须实现，但是有时我们只需要实现其中某一个，此时spring提供了HandlerInterceptorAdapter适配器，允许我们只实现需要的回调方法，使用时继承HandlerInterceptorAdapter抽象类即可。

HandlerInterceptorAdapter是一个抽象类，实现了AsyncHandlerInterceptor接口，而AsyncHandlerInterceptor接口继承了拦截器接口HandlerInterceptor，并增加了一个关于线程同步的方法，HandlerInterceptorAdapter只是具有一个空实现。

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {

    /**
    * This implementation always returns {@code true}.
    */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
        return true;
    }

    /**
    * This implementation is empty.
    */
    @Override
    public void postHandle(
    HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
        throws Exception {
    }

    /**
    * This implementation is empty.
    */
    @Override
    public void afterCompletion(
    HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
        throws Exception {
    }

    /**
    * This implementation is empty.
    */
    @Override
    public void afterConcurrentHandlingStarted(
        HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
    }

}

4、拦截器配置

1）针对HandlerMapping进行拦截

springmvc拦截器针对HandlerMapping进行拦截设置，如果在某个HandlerMapping中配置拦截，经过该HandlerMapping映射成功的Handler最终使用该拦截器。

2）类似全局拦截器

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

<mvc:interceptors>
    <mvc:interceptor>
        <!-- /**表示所有url和子url路径 -->
        <mvc:mapping path="/**"/>
        <bean class="com.ssm.controller.HandlerIntercetor1"/>
    </mvc:interceptor>
</mvc:interceptors>

3）总结：拦截器1、2

12 21 21：

preHandler方法按顺序执行，postHandler和afterCompletion按拦截器配置的逆向顺序执行。
统一日志处理拦截器，需要该拦截器preHandler一定要放行，且将它放在拦截器链接中第一个位置。
登录认证拦截器，放在拦截器的第一个位置，权限校验拦截器，放在登录认证拦截器之后(登录通过后才能进行校验)

5、示例：登录验证

//进入Handler方法之前
//用于身份认证、身份授权
//比如身份认证，如果认证不通过表示当前用户没有登录，需要此方法拦截不在向下执行
@Override
public boolean preHandle(HttpServletRequest request,
        HttpServletResponse response, Object handler) throws Exception {
    //获取请求的url
    String url=request.getRequestURI();
    //判断url是否是公开地址，实际上是将公开地址配置到配置文件中
    if(url.indexOf("login.action")>=0){
        return true;
    }
    HttpSession session=request.getSession();
    String user=request.getParameter("user");
    if(user!=null){
        return true;
    }

    request.getRequestDispatcher("/login.jsp").forward(request, response);
    return false;
}

配置：

<mvc:interceptors>
    <mvc:interceptor>
        <!-- /**表示所有url和子url路径 -->
        <mvc:mapping path="/**"/>
        <bean class="com.ssm.controller.LoginIntercetor"/>
    </mvc:interceptor>
</mvc:interceptors>

八、异常处理

1、异常处理思路

系统中异常包括两类，预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发，测试通过手段减少运行时异常发生。
系统的dao、service、controller出现都通过throws Exception，最后由springmvc前端控制器交由异常处理器进行异常处理，springmvc提供全局异常处理器进行统一异常处理。

2、自定义异常处理类

定义异常类继承Exception

public class CustomException extends Exception{
    private String message;
    public CustomException(String message){
        this.message=message;
    }
}

3、全局异常处理器

思路：系统遇到异常后，在程序中手动抛出，dao抛给service、service抛给controller、controller抛给前端控制器，前端控制器调用全局异常处理器。
全局异常处理思路：解析出异常类型，如果该异常类型时系统自定义的异常，直接取出异常信息，在错误页面显示。如果异常类型不是系统自定义的异常，构造一个自定义的异常处理类型。

public class CustomExceptionResolver implements HandlerExceptionResolver{
    public ModelAndView resolveException(HttpServletRequest request,HttpServletResponse response,Object handler,Exception ex){
        CustomException customException=null;
        if(ex instanceof CustomException){
            customException=(CustomException)ex;
        }else{
            customException=new CustomException("未知错误");
        }
        String message=customException.getMessage();
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.addObject("message",message);
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

4、配置全局异常处理器

<!--全局异常处理器，只要实现HandlerExceptionResolver接口就是全局异常处理器-->
<bean class="com.wenxue.exception.CustomExceptionResolver"/>

另一种处理全局异常的方法，在SpringMVC配置文件中配置，（error是出错页面）

<!-- configure SimpleMappingExceptionResolver -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
</bean>

九、上传

1、需求

添加上传文件功能。

2、配置multipart类型解析器

<!--文件上传-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--设置文件上传最大尺寸为5MB-->       
    <property name="maxUpLoadSize">
        <value>5242880</value>
    </property>
</bean>

3、form表单

<form action="upload" method="post" enctype="multipart/form-data">
    <input type="file" name="file"><br>
    <input type="submit" value="submit">
</form>

4、Controller

@RequestMapping(value="/upload",method=RequestMethod.POST)
public String upload(HttpServletRequest req) throws Exception{
    MultipartHttpServletRequest mreq = (MultipartHttpServletRequest)req;
    MultipartFile file = mreq.getFile("file");
    String fileName = file.getOriginalFilename();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
    FileOutputStream fos = new FileOutputStream(req.getSession().getServletContext().getRealPath("/")+
            "upload/"+sdf.format(new Date())+fileName.substring(fileName.lastIndexOf('.')));
    fos.write(file.getBytes());
    fos.flush();
    fos.close();
    return "hello";
}

Mr_Literature

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springMVC

springMVC一、介绍1、关于springmvcspringmvc是spring框架的一个模块，是一个基于mvc的web框架，它与spring无需通过中间整合层进行整合。 2、组件前端控制器DispatcherServlet：拦截匹配的请求，j进行全局的流程控制。处理器映射器HandlerMapping：根据请求的url查找处理器Handler。 ...
复制链接

扫一扫