SpringMVC学习笔记

1、回顾MVC

1.1、什么是MVC

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。

是将业务逻辑、数据、显示分离的方法来组织代码。

MVC主要作用是降低了视图与业务逻辑间的双向偶合。

MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。

1.2、Model1时代

  • 在web早期的开发中，通常采用的都是Model1。

  • Model1中，主要分为两层，视图层和模型层。


Model1优点：架构简单，比较适合小型项目开发；

Model1缺点：JSP职责不单一，职责过重，不便于维护；

1.3、Model2时代

Model2把一个项目分成三部分，包括视图、控制、模型。

  1. 用户发请求
  2. Servlet接收请求数据，并调用对应的业务逻辑方法
  3. 业务处理完毕，返回更新后的数据给servlet
  4. servlet转向到JSP，由JSP来渲染页面
  5. 响应给前端更新后的页面

职责分析：

Controller：控制器

  1. 取得表单数据
  2. 调用业务逻辑
  3. 转向指定的页面

Model：模型

  1. 业务逻辑
  2. 保存数据的状态

View：视图

  1. 显示页面

Model2这样不仅提高的代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。

1.4、回顾Servlet

  1. 新建一个Maven工程当做父工程！pom依赖！
 <dependencies>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.6</version>
        </dependency>

    </dependencies>

  1. 建立一个Moudle：springmvc-01-servlet ， 添加Web app的支持！

  2. 编写一个Servlet类，用来处理用户的请求

package com.gmt.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

// 实现了HttpServlet接口
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获得参数
        String method = req.getParameter("method");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        // 业务逻辑
        // 视图跳转
        req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
  1. 编写hello.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>

<head>
    <title>gmt</title>
</head>

<body>
${msg}
</body>
</html>
  1. 在web.xml中注册Servlet
<?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">
  <display-name>Archetype Created Web Application</display-name>
  
  <servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.gmt.servlet.HelloServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  
</web-app>
  1. 配置Tomcat，并启动测试

  • localhost:8080/hello?method=add

  • localhost:8080/hello?method=delete

MVC框架要做哪些事情

  1. 将url映射到java类或java类的方法 .

  2. 封装用户提交的数据 .

  3. 处理请求--调用相关的业务处理--封装响应数据 .

  4. 将响应的数据进行渲染 . jsp / html 等表示层数据 .

说明：

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM 等等....

2、什么是SpringMVC

2.1、概述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

查看官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

我们为什么要学习SpringMVC呢?

Spring MVC的特点：

  1. 轻量级，简单易学
  2. 高效 , 基于请求响应的MVC框架
  3. 与Spring兼容性好，无缝结合
  4. 约定优于配置
  5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
  6. 简洁灵活

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

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

正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等......所以我们要学习 .

最重要的一点还是用的人多 , 使用的公司多 .

2.2、中心控制器

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

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


SpringMVC的原理如下图所示：

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

2.3、SpringMVC执行原理


图为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. 最终视图呈现给用户。

3、第一个MVC程序

3.1 配置版

  1. 新建一个Module，maven的webapp，springmvc-02-hellomvc
  2. 确定是否导入依赖
  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>
  1. 编写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">
    <!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器: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>

</beans>
  1. 编写业务类HelloController，要么通过实现Controller接口，要么增加@Controller注解；需要返回一个ModelAndView，装数据，封视图。
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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;
    }
}
  1. 将HelloController注册到SpringIOC容器，在springmvc-servlet.xml注册bean
<bean id="/hello" class="com.gmt.controller.HelloController"/>
  1. 编写要跳转的jsp页面，显示ModelAndView存放的数据，以及我们正常的页面
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %><html><head>    <title>Title</title></head><body>${msg}</body></html>
  1. 配置Tomcat，启动测试。

3.2 注解版

  1. 新建一个Module，maven的webapp，springmvc-03-annotation
  2. 确定是否导入依赖
  3. 配置web.xml，注册DispatcherServlet
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" ><web-app>      <display-name>Archetype Created Web Application</display-name>      <!--注册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错。

  1. 添加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.gmt.controller"/>       <!--让Spring MVC不处理静态资源-->        <mvc:default-servlet-handler/>       <!--    支持mvc注解驱动        		在spring中一般采用@RequestMapping注解来完成映射关系        		要想使@RequestMapping注解生效        		必须向上下文中注册DefaultAnnotationHandlerMapping        		和一个AnnotationMethodHandlerAdapter实例        		这两个实例分别在类级别和方法级别处理        		而annotation-driven配置帮助我们自动完成上面两个实例的注入    -->        <mvc:annotation-driven/>       <!--视图解析器: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></beans>
  1. 创建Controller
import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class HelloController {            @RequestMapping("/hello")        public String hello(Model model){                // 封装数据                model.addAttribute("msg","Hello,SpringMVC Annotation");                return "hello";         // 会被视图解析器处理        }}
  • @Controller是为了让SpringIOC容器初始化时自动扫描到
  • @RequestMapping功能是确定映射请求路径
  • 方法中声明Model类型的参数是为了把Action中的数据带到视图中
  • 方法返回的结果是hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp
  1. 创建视图层

在WEB-INF/jsp目录中创建hello.jsp，视图可以直接取出并展示从Controller带回的消息

可以通过EL表示取出Model中存放的值，或者对象

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

3.3 静态资源过滤问题

<build>        <resources>                <resource>                       <directory>src/main/java</directory>             <includes>                          <include>**/*.properties</include>                         <include>**/*.xml</include>                     </includes>                       <filtering>false</filtering>               </resource>               <resource>                      <directory>src/main/resources</directory>                  <includes>                              <include>**/*.properties</include>                           <include>**/*.xml</include>                      </includes>                       <filtering>false</filtering>              </resource>        </resources></build>

3.4 关于页面中EL表达式依旧显示${xxx}，而不显示值的问题

解决方法：添加isELIgnored="false"

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false"%>

  • EL表达式

    • Expression Language表达式语言
    • 是一种在JSP页面获取数据的简单方式(只能获取数据，不能设置数据)
    • 在JSP2.0开始引入概念

  • 语法格式

    在JSP页面的任何静态部分均可通过：${expression}来获取到指定表达式的值

4、Controller

4.1、实现Controller接口

缺点：一个控制器中只能有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦

public class HelloController1 implements Controller {        @Override        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {             ModelAndView mv = new ModelAndView();            mv.addObject("msg","使用Controller接口实现");               mv.setViewName("hello");              return mv;      }}

4.2、使用注解@Controller

@Controllerpublic class HelloController {        @RequestMapping("h1")       public String hello (Model model){              model.addAttribute("msg","使用注解开发Springmvc1");               return "hello";        }       @RequestMapping("h2")      public String hello (Model model){            model.addAttribute("msg","使用注解开发Springmvc2");            return "hello";       }}

我们的两个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。

5、Restful风格

  • 概念

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

@Controllerpublic class RestFul {        // 传统风格：http://localhost:8080/add1?a=1&b=2       @RequestMapping("/add1")        public String test1(int a, int b, Model model){                int res = a + b;                model.addAttribute("msg","结果为"+res);                return "hello";        }        // RestFul风格：http://localhost:8080/add2/1/2       @RequestMapping("/add2/{a}/{b}")       public String test2(@PathVariable int a ,@PathVariable int b , Model model){               int res = a + b;              model.addAttribute("msg","结果为"+res);            return "hello";       }}

6、结果跳转方式

6.1、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 HelloController1 implements Controller {    @Override    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse                                      httpServletResponse) throws Exception {        ModelAndView mv = new ModelAndView();        mv.addObject("msg","使用Controller接口实现");        mv.setViewName("hello");        return mv;    }}

6.2、ServletAPI

通过设置ServletAPI，不需要视图解析器

  1. 通过HttpServletResponse进行输出
  2. 通过HttpServletResponse实现重定向
  3. 通过HttpServletResponse实现转发
@Controllerpublic class ResultGo {    //通过HttpServletResponse进行输出    @RequestMapping("/result/t1")    public void test1(HttpServletRequest request, HttpServletResponse response) throws IOException {        response.getWriter().print("Hello , Spring By Servlet APU");    }    //通过HttpServletResponse实现重定向    @RequestMapping("/result/t2")    public void test2(HttpServletRequest request,HttpServletResponse response) throws IOException {        response.sendRedirect("/index.jsp");    }    //通过HttpServletResponse实现转发    @RequestMapping("/result/t3")    public void test3(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {        request.setAttribute("msg","/result/t3");        request.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(request,response);    }}

6.3、SpringMVC

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

@Controllerpublic class ResultSpringMVC {    @RequestMapping("/rsm/t1")    public String test1(HttpServletRequest request, HttpServletResponse response) throws IOException {        //转发一        request.setAttribute("msg","test11111");        return "/WEB-INF/jsp/hello.jsp";    }    @RequestMapping("/rsm/t2")    public String test2(HttpServletRequest request, HttpServletResponse response) throws IOException {        //转发二        request.setAttribute("msg","test222222");        return "forward:/WEB-INF/jsp/hello.jsp";    }    @RequestMapping("/rsm/t3")    public String test3(HttpServletRequest request, HttpServletResponse response) throws IOException {        // 重定向        return "redirect:/index.jsp";    }}

6.4、转发和重定向

6.4.1、转发和重定向的区别

  1. request.getRequestDispatcher().forward()方法,只能将请求转发给同一个WEB应用中的组件

    response.sendRedirect() 方法不仅可以重定向到当前应用程序中的其他资源，还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。

    如果传递给response.sendRedirect()方法的相对URL以“/”开头，它是相对于整个WEB站点的根目录；

    如果创建request.getRequestDispatcher()对象时指定的相对URL以“/”开头，它是相对于当前WEB应用程序的根目录。

  2. 重定向访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；

    请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。

  3. HttpServletResponse.sendRedirect方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的访问请求。这个过程好比有个绰号叫“浏览器”的人写信找张三借钱，张三回信说没有钱，让“浏览器”去找李四借，并将李四现在的通信地址告诉给了“浏览器”。于是，“浏览器”又按张三提供通信地址给李四写信借钱，李四收到信后就把钱汇给了“浏览器”。

    由此可见，重定向的时候，“浏览器”一共发出了两封信和收到了两次回复，“浏览器”也知道他借到的钱出自李四之手。

    request.getRequestDispatcher().forward()方法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。这个过程好比绰号叫“浏览器”的人写信找张三借钱，张三没有钱，于是张三找李四借了一些钱，甚至还可以加上自己的一些钱，然后再将这些钱汇给了“浏览器”。

    由此可见，转发的时候，“浏览器”只发 出了一封信和收到了一次回复，他只知道从张三那里借到了钱，并不知道有一部分钱出自李四之手。

  4. request.getRequestDispatcher().forward()方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；

    而response.sendRedirect()方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。

    对于同一个WEB应用程序的内部资源之间的跳转，特别是跳转之前要对请求进行一些前期预处理，并要使用HttpServletRequest.setAttribute方法传递预处理结果，那就应该使用request.getRequestDispatcher().forward()方法。

    不同WEB应用程序之间的重定向，特别是要重定向到另外一个WEB站点上的资源的情况，都应该使用response.sendRedirect()方法。

6.4.2、转发和重定向的小结

转发 重定向
getRequestDispatcher() sendRedirect()
浏览器URL的地址栏不变 浏览器URL的地址栏改变
服务器行为 客户端行为
浏览器只做了一次访问请求 浏览器做了至少两次的访问请求
2次跳转之间传输的信息不会丢失 2次跳转之间传输的信息会丢失（request范围）

6.4.3、转发和重定向的选择

  1. 重定向的速度比较慢，因为浏览器还得发出一个新的请求，如果在使用转发和重定向皆可的时候，建议使用转发。
  2. 因为转发只能访问当前WEB的应用程序，所以不同WEB应用程序之间的访问，特别是要访问到另一个WEB站点上的资源的情况，这个时候只能使用重定向。

7、数据处理

7.1、处理提交数据

  1. 提交的域名称和处理方法的参数名一致

    提交数据：http://localhost:8080/hello?name=gmt

@RequestMapping("/hello")public String hello(String name){    System.out.println(name);    return "hello";}

  1. 提交的域名称和处理方法的参数名不一致

    提交数据:http://localhost:8080/hello1?username=hello

@RequestMapping("/hello1")public String hello1(@RequestParam("username") String name){    System.out.println(name);    return "hello";}

  1. 提交的是一个对象

    要求提交的表单的属性名和对象的属性名一致，参数使用对象即可

    1. 实体类
    public class User {    private int id;    private String name;    private int age;    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public String toString() {        return "User{" +                "id=" + id +                ", name='" + name + '\'' +                ", age=" + age +                '}';    }}
    1. 提交数据

    http://localhost:8080/hello2?name=gmt&id=123&age=21

    1. 处理方法
    @RequestMapping("/hello2")public String hello2(User user){    System.out.println(user);    return "hello";}
    1. 后台输出

    User{id=123, name='gmt', age=21}

    注意：如果使用对象的话，前端传递的参数名和对象名必须一致，否则在就是null

7.2、数据显示到前端

7.2.1、通过ModelAndView

public class HelloController1 implements Controller {    @Override    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {        ModelAndView mv = new ModelAndView();        mv.addObject("msg","使用Controller接口实现");        mv.setViewName("hello");        return mv;    }}

注意：需要在springmvc-servlet.xml配置中注册bean，url为localhost:8080/h2

<bean id="/h2" class="com.gmt.controller.HelloController1"/>

7.2.2、通过ModelMap

 @RequestMapping("/h3")public String hello(@RequestParam("username")  String name, ModelMap model){    model.addAttribute("msg",name);    System.out.println(name);    return "hello";}

提交数据：http://localhost:8080/h3?username=gmt

输出：gmt

7.2.3、通过Model

@RequestMapping("/h4")public String hello(@RequestParam("username") String name,Model model){    model.addAttribute("msg",name);    System.out.println(name);    return "hello";}

提交数据：http://localhost:8080/h4?username=gmt

8、JSON

8.1、什么是JSON

  • JSON（JavaScript Object Notation，JS对象标记）是一种轻量级的数据交换格式，目前使用特别广泛。
  • 采用完全独立于编程语言的文本格式来存储和表示数据。
  • 简洁和清晰的层次结构使得JSON成为理想的数据交换语言
  • 容易让人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在JavaScript语言中，一切都是对象。因此，任何JavaScript支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。

格式和语法：

  • 对象表示为键值对，数据由逗号分隔。
  • 花括号保存对象
  • 方括号保存数组

JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异，键值对组合中的键名写在前面并用“”包裹，使用冒号:分隔，然后紧接着值

两种格式：

  • 花括号存对象：
let json = {  name: "张三",  age: 12,  sex: "男"};
  • 方括号存数组
let test = [    {        name : "李四",        age : 12,        sex : "女"    },    {        name : "王五",        age : 14,        sex : "男"    }]

8.2、JSON和JavaScript对象互转

  1. JSON.stringify() 将JavaScript对象转换为JSON字符串
let obj1 = JSON.stringify({name:"张三",age:12,sex:"男"});console.log(obj1);// 输出：{"name":"张三","age":12,"sex":"男"}
  1. JSON.parse() 将Json字符串转换为JavaScript对象
let obj2 = JSON.parse('{"name":"hello","age":"12","sex":"男"}')console.log(obj2)// 输出：{age:"12",name: "hello",sex:"男"}

代码测试：

  1. 新建一个webapp的module，springmvc-05-json
  2. 在web目录下新建一个jsontest.html
<!DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8">    <title>Title</title>  <script type="text/javascript">    // JSON.stringify() 将JavaScript对象转换为JSON字符串    let obj1 = JSON.stringify({name:"张三",age:12,sex:"男"});    console.log(obj1);    // 输出：{"name":"张三","age":12,"sex":"男"}    // JSON.parse() 将Json字符串转换为JavaScript对象    let obj2 = JSON.parse('{"name":"hello","age":"12","sex":"男"}')    console.log(obj2)    // 输出：{age:"12",name: "hello",sex:"男"}  </script></head><body></body></html>
  1. 用浏览器打开并输入网址，localhost:8080/jsontest.html，在控制台查看输出

8.3、Jackson

  1. 导入Jackson的依赖，Jackson是目前比较好的json解析工具
<dependency>    <groupId>com.fasterxml.jackson.core</groupId>    <artifactId>jackson-databind</artifactId>    <version>2.12.3</version></dependency>
  1. 配置web.xml
<!DOCTYPE web-app PUBLIC        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"        "http://java.sun.com/dtd/web-app_2_3.dtd" ><web-app>      <display-name>Archetype Created Web Application</display-name>      <servlet>    <servlet-name>springmvc</servlet-name>    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    <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>      <servlet-mapping>    <servlet-name>springmvc</servlet-name>    <url-pattern>/</url-pattern>  </servlet-mapping>    </web-app
  1. 配置springmvc-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"       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">    <context:component-scan base-package="com.gmt"/>    <mvc:default-servlet-handler/>    <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>
  1. 编写实体类，需要导入Lombok依赖
package com.gmt.pojo;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;@Data@AllArgsConstructor@NoArgsConstructorpublic class User {    private String name;    private int age;    private String sex;}
  1. 编写测试类 Controller
package com.gmt.controller;import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.gmt.pojo.User;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;// @RestController 注解相当于是 @Controller + @ ResponseBody 结合起来的作用@Controllerpublic class UserController {    // application/json;charset=utf-8 设置编码格式为utf-8 ，防止出现中文乱码    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")    // @ResponseBody作用是将Java对象转为json格式的数据    @ResponseBody    public String test() throws JsonProcessingException {        // 创建一个jackson的对象映射器，用来解析数据        ObjectMapper mapper = new ObjectMapper();        // 创建一个对象        User user = new User("张三",12,"男");        // 将user对象解析为json格式        String str = mapper.writeValueAsString(user);        // 由于@ResponserBody注解，这里会将str转成json格式返回        return str;    }}

@Controller和@RestController的区别？

​ @RestController注解相当于@ResponseBody+@Controller合在一起的作用。

  1. 如果只用@RestController注解Controller类，则Controller类中的所有方法都无法返回jsp页面或者html页面，配置的视图解析器InternalResourceViewResolver不起作用，返回的内容就是return里的内容。

  2. 如果需要返回指定页面，则需要用@Controller配合视图解析器InternalResourceViewResolver才可以。

    如果需要返回JSON，XML到页面，则需要在对应的方法前加上@ResponseBody注解

8.4、乱码统一解决

在springmvc-servlet.xml文件中加入这段配置

<mvc:annotation-driven>   <mvc:message-converters register-defaults="true">       <bean class="org.springframework.http.converter.StringHttpMessageConverter">           <constructor-arg value="UTF-8"/>       </bean>       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">           <property name="objectMapper">               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">                   <property name="failOnEmptyBeans" value="false"/>               </bean>           </property>       </bean>   </mvc:message-converters></mvc:annotation-driven>

8.5、测试输出

8.5.1、测试集合输出

@Controllerpublic class UserController {        @RequestMapping(value = "/j2",produces = "application/json;charset=utf-8")    @ResponseBody    public String test1() throws JsonProcessingException {        ObjectMapper mapper = new ObjectMapper();        List<User> list = new ArrayList<>();        User user1 = new User("张三",12,"男");        User user2 = new User("李四",11,"男");        User user3 = new User("王五",13,"女");        User user4 = new User("赵六",14,"男");        list.add(user1);        list.add(user2);        list.add(user3);        list.add(user4);        String str = mapper.writeValueAsString(list);        return str;    }}

8.5.2、测试时间输出

@Controllerpublic class UserController {    // 输出时间对象    @RequestMapping("/j3")    @ResponseBody    public String test2() throws JsonProcessingException {        ObjectMapper mapper = new ObjectMapper();        // 不使用时间戳方式 ，Jackson默认是会把时间转成timestamps形式        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);        // 自定义日期格式对象        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        // 指定日期格式        mapper.setDateFormat(sdf);        // 创建一个时间对象        Date date = new Date();        // 将对象解析成为json格式        String str = mapper.writeValueAsString(date);        return str;    }}

8.5.3、抽取为工具类

package com.gmt.controller;import com.gmt.utils.JsonUtils;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import java.util.Date;@Controllerpublic class UserController {    @RequestMapping("/j4")    @ResponseBody    public String test3 (){        Date date = new Date();        String json = JsonUtils.getJson(date);        return json;    }}

package com.gmt.utils;import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;import java.text.SimpleDateFormat;public class JsonUtils {    public static String getJson(Object object){        return getJson(object,"yyyy-MM-dd HH:mm:ss");    }    public static String getJson(Object object,String dataFormat){        ObjectMapper mapper = new ObjectMapper();        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);        SimpleDateFormat sdf = new SimpleDateFormat(dataFormat);        mapper.setDateFormat(sdf);        try {            return mapper.writeValueAsString(object);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        return null;    }}

可复用，代码更加简单

8.6、FastJson

FastJson是阿里巴巴开发的一项专门用于Java开发的包，可以方便的实现json对象和JavaBean对象的转换，实现JavaBean对象和Json字符串的转换，实现Json对象和Json字符串的转换。

FastJson的pom依赖：

<dependency>    <groupId>com.alibaba</groupId>    <artifactId>fastjson</artifactId>    <version>1.2.76</version></dependency>

FastJson三个主要的类：

  • JSONObject 代表 json对象
    • JSONObject实现了Map<String,Object>接口。
    • JSONObject对应json对象
      • get()：获取json对象中的数据
      • size()：获取“键：值“对的个数
      • isEmpty()：判断是否为空
    • 本质是通过实现Map接口并调用接口中的方法完成的
  • JSONArray 代表json对象的数组
    • JSONArray实现了List接口
    • JSON代表JSONObject和JSONArray的转化
      • JSON.toJSONString(object)：Java对象转JSON字符串
      • JSON.parseObject(str,User.class)：JSON字符串转Java对象
      • JSON.tojavaObject(jsonObject,User.class)：JSON对象转Java对象
      • JSON.toJSON(user)：Java对象转JSON对象
      • package com.gmt.controller;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONObject;import com.gmt.pojo.User;import java.util.ArrayList;import java.util.List;public class FastJsonTest {    public static void main(String[] args) {        // 创建一个对象        User user1 = new User("张三",12,"男");        User user2 = new User("李四",13,"男");        User user3 = new User("王五",14,"男");        User user4 = new User("赵六",15,"男");        List<User> list = new ArrayList<>();        list.add(user1);        list.add(user2);        list.add(user3);        list.add(user4);        System.out.println("======= java对象 转 JSON字符串 =======");        String str1 = JSON.toJSONString(list);        System.out.println("JSON.toJSONString(list) ==> "+str1);        String str2 = JSON.toJSONString(user1);        System.out.println("JSON.toJSONString(user1) ==> "+str2);        System.out.println("======= JSON字符串 转 Java对象 =======");        User user = JSON.parseObject(str2, User.class);        System.out.println("JSON.parseObject(str2, User.class) ==> " + user);        System.out.println("======= Java对象 转 JSON对象 =======");        JSONObject jsonObject = (JSONObject) JSON.toJSON(user2);        System.out.println("(JSONObject) JSON.toJSON(user2) "+jsonObject);        System.out.println("======= JSON对象 转 Java对象 =======");        User user5 = JSON.toJavaObject(jsonObject, User.class);        System.out.println("JSON.toJavaObject(jsonObject, User.class) ==> "+user5);    }}

      输出：======= java对象 转 JSON字符串 =======JSON.toJSONString(list) ==> [{"age":12,"name":"张三","sex":"男"},{"age":13,"name":"李四","sex":"男"},{"age":14,"name":"王五","sex":"男"},{"age":15,"name":"赵六","sex":"男"}]JSON.toJSONString(user1) ==> {"age":12,"name":"张三","sex":"男"}======= JSON字符串 转 Java对象 =======JSON.parseObject(str2, User.class) ==> User(name=张三, age=12, sex=男)======= Java对象 转 JSON对象 =======(JSONObject) JSON.toJSON(user2) {"sex":"男","name":"李四","age":13}======= JSON对象 转 Java对象 =======JSON.toJavaObject(jsonObject, User.class) ==> User(name=李四, age=13, sex=男)
posted @ 2021-10-12 16:31  Cherish486  阅读(20)  评论(0)  编辑  收藏  举报