SpringMVC 知识点①

Spring MVC的特点：

  1. 轻量级，简单易学

  2. 高效 , 基于请求响应的MVC框架

  3. 与Spring兼容性好，无缝结合

  4. 约定优于配置

  5. 功能强大：RESTful、数据验证、格式化、本地化、主题等

  6. 简洁灵活

Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；

中心控制器：

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

 

SpringMVC的原理如下图所示：

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

 

 

 

SpringMVC建议执行原理：

 

简要分析执行流程

  1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

    我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

    如上url拆分成三部分：

    http://localhost:8080服务器域名

    SpringMVC部署在服务器上的web站点

    hello表示控制器

    通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

  2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。

  3. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。

  4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

  5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

  6. Handler让具体的Controller执行。

  7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

  8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

  9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

  10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。

  11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

  12. 最终视图呈现给用户。

 

 创建一个简单的SpringMVC程序：

1、新建一个Moudle ， springmvc-02-hello ， 添加web的支持！

2、确定导入了SpringMVC 的依赖！

<!--依懒-> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.9.RELEASE</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> </dependency> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.2</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> </dependencies>

3、配置web.xml  ， 注册DispatcherServlet

<?xml version=1.0 encoding=UTF-8?> <web-app xmlns=http://xmlns.jcp.org/xml/ns/javaee         xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance         xsi:schemaLocation=http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd         version=4.0>     <!--1.注册DispatcherServlet-->    <servlet>        <servlet-name>springmvc</servlet-name>        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->        <init-param>            <param-name>contextConfigLocation</param-name>            <param-value>classpath:springmvc-servlet.xml</param-value>        </init-param>        <!--启动级别-1-->        <load-on-startup>1</load-on-startup>    </servlet>     <!--/ 匹配所有的请求；（不包括.jsp）-->    <!--/* 匹配所有的请求；（包括.jsp）-->    <servlet-mapping>        <servlet-name>springmvc</servlet-name>        <url-pattern>/</url-pattern>    </servlet-mapping>  </web-app>

4、编写SpringMVC 的 配置文件！名称：springmvc-servlet.xml  : [servletname]-servlet.xml

 说明，这里的名称要求是按照官方来的

<?xml version=1.0 encoding=UTF-8?> <beans xmlns=http://www.springframework.org/schema/beans       xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance       xsi:schemaLocation=http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd>  </beans>

5、添加 处理映射器

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

6、添加 处理器适配器

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

 7、添加 视图解析器

<!--视图解析器:DispatcherServlet给他的ModelAndView--> <bean class=org.springframework.web.servlet.view.InternalResourceViewResolver id=InternalResourceViewResolver>    <!--前缀-->    <property name=prefix value=/WEB-INF/jsp//>    <!--后缀-->    <property name=suffix value=.jsp/> </bean>

8、编写我们要操作业务Controller ，要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图；

 

package com.kuang.controller;  import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.mvc.Controller;  import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse;  //注意：这里我们先导入Controller接口 public class HelloController implements Controller {     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {        //ModelAndView 模型和视图        ModelAndView mv = new ModelAndView();         //封装对象，放在ModelAndView中。Model        mv.addObject(msg,HelloSpringMVC!);        //封装要跳转的视图，放在ModelAndView中        mv.setViewName(hello); //: /WEB-INF/jsp/hello.jsp        return mv;   }     }

9、将自己的类交给SpringIOC容器，注册bean

<!--Handler--> <bean id=/hello class=com.kuang.controller.HelloController/>

10、写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面；

<%@ page contentType=text/html;charset=UTF-8 language=java %> <html> <head>    <title>Kuangshen</title> </head> <body> ${msg} </body> </html>

可能遇到的问题：访问出现404，排查步骤：

  1. 查看控制台输出，看一下是不是缺少了什么jar包。

  2. 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！

  3. 重启Tomcat 即可解决！

 

注解版

使用@Controller注解在对应的Controller类上面。

 配置web.xml

<?xml version=1.0 encoding=UTF-8?> <web-app xmlns=http://xmlns.jcp.org/xml/ns/javaee         xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance         xsi:schemaLocation=http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd         version=4.0>     <!--1.注册servlet-->    <servlet>        <servlet-name>SpringMVC</servlet-name>        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->        <init-param>            <param-name>contextConfigLocation</param-name>            <param-value>classpath:springmvc-servlet.xml</param-value>        </init-param>        <!-- 启动顺序，数字越小，启动越早 -->        <load-on-startup>1</load-on-startup>    </servlet>     <!--所有请求都会被springmvc拦截 -->    <servlet-mapping>        <servlet-name>SpringMVC</servlet-name>        <url-pattern>/</url-pattern>    </servlet-mapping>  </web-app>

/ 和 /* 的区别：< url-pattern > / </ url-pattern > 不会匹配到.jsp， 只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类 。< url-pattern > /* </ url-pattern > 会匹配 *.jsp，会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。

 

 Spring MVC配置文件

 

<?xml version=1.0 encoding=UTF-8?> <beans xmlns=http://www.springframework.org/schema/beans       xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance       xmlns:context=http://www.springframework.org/schema/context       xmlns:mvc=http://www.springframework.org/schema/mvc       xsi:schemaLocation=http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/context        https://www.springframework.org/schema/context/spring-context.xsd        http://www.springframework.org/schema/mvc        https://www.springframework.org/schema/mvc/spring-mvc.xsd>     <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->    <context:component-scan base-package=com.kuang.controller/>    <!-- 让Spring MVC不处理静态资源 -->    <mvc:default-servlet-handler />    <!--    支持mvc注解驱动        在spring中一般采用@RequestMapping注解来完成映射关系        要想使@RequestMapping注解生效        必须向上下文中注册DefaultAnnotationHandlerMapping        和一个AnnotationMethodHandlerAdapter实例        这两个实例分别在类级别和方法级别处理。        而annotation-driven配置帮助我们自动完成上述两个实例的注入。     -->    <mvc:annotation-driven />     <!-- 视图解析器 -->    <bean class=org.springframework.web.servlet.view.InternalResourceViewResolver          id=internalResourceViewResolver>        <!-- 前缀 -->        <property name=prefix value=/WEB-INF/jsp/ />        <!-- 后缀 -->        <property name=suffix value=.jsp />    </bean>  </beans>

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

  • 让IOC的注解生效
  • 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 .....
  • MVC的注解驱动
  • 配置视图解析器

小结

实现步骤其实非常的简单：

  1. 新建一个web项目

  2. 导入相关jar包

  3. 编写web.xml , 注册DispatcherServlet

  4. 编写springmvc配置文件

  5. 接下来就是去创建对应的控制类 , controller

  6. 最后完善前端视图和controller之间的对应

  7. 测试运行调试.

使用springMVC必须配置的三大件：

处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

 知道什么是Rest Ful 风格！！！！

 Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

 

结果跳转方式

ModelAndView

设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .

页面 : {视图解析器前缀} + viewName +{视图解析器后缀}

<!-- 视图解析器 --> <bean class=org.springframework.web.servlet.view.InternalResourceViewResolver      id=internalResourceViewResolver>    <!-- 前缀 -->    <property name=prefix value=/WEB-INF/jsp/ />    <!-- 后缀 -->    <property name=suffix value=.jsp /> </bean>

对应的controller类

public class ControllerTest1 implements Controller {     public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {        //返回一个模型视图对象        ModelAndView mv = new ModelAndView();        mv.addObject(msg,ControllerTest1);        mv.setViewName(test);        return mv;   } }

SpringMVC

通过SpringMVC来实现转发和重定向 - 无需视图解析器；

测试前，需要将视图解析器注释掉

@Controller public class ResultSpringMVC {    @RequestMapping(/rsm/t1)    public String test1(){        //转发        return /index.jsp;   }     @RequestMapping(/rsm/t2)    public String test2(){        //转发二        return forward:/index.jsp;   }     @RequestMapping(/rsm/t3)    public String test3(){        //重定向        return redirect:/index.jsp;   } }

通过SpringMVC来实现转发和重定向 - 有视图解析器；

重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题.

可以重定向到另外一个请求实现 .

@Controller public class ResultSpringMVC2 {    @RequestMapping(/rsm2/t1)    public String test1(){        //转发        return test;   }     @RequestMapping(/rsm2/t2)    public String test2(){        //重定向        return redirect:/index.jsp;        //return redirect:hello.do; //hello.do为另一个请求/   }  }

数据显示到前端

第一种 : 通过ModelAndView

我们前面一直都是如此 . 就不过多解释

public class ControllerTest1 implements Controller {     public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {        //返回一个模型视图对象        ModelAndView mv = new ModelAndView();        mv.addObject(msg,ControllerTest1);        mv.setViewName(test);        return mv;   } }

第二种 : 通过ModelMap

ModelMap

@RequestMapping(/hello) public String hello(@RequestParam(username) String name, ModelMap model){    //封装要显示到视图中的数据    //相当于req.setAttribute(name,name);    model.addAttribute(name,name);    System.out.println(name);    return hello; }

第三种 : 通过Model

Model

@RequestMapping(/ct2/hello) public String hello(@RequestParam(username) String name, Model model){    //封装要显示到视图中的数据    //相当于req.setAttribute(name,name);    model.addAttribute(msg,name);    System.out.println(name);    return test; }

对比

就对于新手而言简单来说使用区别就是：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

 

乱码问题的解决：

1、通过Spring提供的一个过滤器，可以在web.xml文件中配置

<filter>    <filter-name>encoding</filter-name>    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>    <init-param>        <param-name>encoding</param-name>        <param-value>utf-8</param-value>    </init-param> </filter> <filter-mapping>    <filter-name>encoding</filter-name>    <url-pattern>/*</url-pattern> </filter-mapping>

2、自定义过滤器

package com.kuang.filter;  import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.util.Map;  /** * 解决get和post请求 全部乱码的过滤器 */ public class GenericEncodingFilter implements Filter {     @Override    public void destroy() {   }     @Override    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {        //处理response的字符编码        HttpServletResponse myResponse=(HttpServletResponse) response;        myResponse.setContentType(text/html;charset=UTF-8);         // 转型为与协议相关对象        HttpServletRequest httpServletRequest = (HttpServletRequest) request;        // 对request包装增强        HttpServletRequest myrequest = new MyRequest(httpServletRequest);        chain.doFilter(myrequest, response);   }     @Override    public void init(FilterConfig filterConfig) throws ServletException {   }  }  //自定义request对象，HttpServletRequest的包装类 class MyRequest extends HttpServletRequestWrapper {     private HttpServletRequest request;    //是否编码的标记    private boolean hasEncode;    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰    public MyRequest(HttpServletRequest request) {        super(request);// super必须写        this.request = request;   }     // 对需要增强方法 进行覆盖    @Override    public Map getParameterMap() {        // 先获得请求方式        String method = request.getMethod();        if (method.equalsIgnoreCase(post)) {            // post请求            try {                // 处理post乱码                request.setCharacterEncoding(utf-8);                return request.getParameterMap();           } catch (UnsupportedEncodingException e) {                e.printStackTrace();           }       } else if (method.equalsIgnoreCase(get)) {            // get请求            Map<String, String[]> parameterMap = request.getParameterMap();            if (!hasEncode) { // 确保get手动编码逻辑只运行一次                for (String parameterName : parameterMap.keySet()) {                    String[] values = parameterMap.get(parameterName);                    if (values != null) {                        for (int i = 0; i < values.length; i++) {                            try {                                // 处理get乱码                                values[i] = new String(values[i]                                       .getBytes(ISO-8859-1), utf-8);                           } catch (UnsupportedEncodingException e) {                                e.printStackTrace();                           }                       }                   }               }                hasEncode = true;           }            return parameterMap;       }        return super.getParameterMap();   }     //取一个值    @Override    public String getParameter(String name) {        Map<String, String[]> parameterMap = getParameterMap();        String[] values = parameterMap.get(name);        if (values == null) {            return null;       }        return values[0]; // 取回参数的第一个值   }     //取所有值    @Override    public String[] getParameterValues(String name) {        Map<String, String[]> parameterMap = getParameterMap();        String[] values = parameterMap.get(name);        return values;   } }

一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了！

然后在web.xml中配置这个过滤器即可！