SpringMVC 简介

2023-12-08 07:08:57

文章目录

1、回顾MVC
- 1.1 什么是MVC？
- 1.2 Model 1 时代
- 1.3 Model 2时代
- 1.4 MVC框架要做哪些事情
2、Spring MVC
- 2.1 概述
- 2.2 中心控制器
- 2.3 Spring MVC的执行原理
3、第一个MVC程序
- 3.1、注解版
- - - 1、新建一个Moudle，添加web支持！
    - 2、由于Maven可能存在资源过滤的问题，我们将配置完善
    - 3、在pom.xml文件引入相关的依赖
    - 4、配置web.xml
    - - 【注】启动级别 load-on-startup
      - / 和 /\* 的区别：
    - 5、编写Spring MVC配置文件springmvc-servlet.xml
    - 6、创建controller
    - 7、创建视图层
- 3.2、小结
4、RestFul和控制器
- 4.1、控制器（Controller层的）
- - - 1.1 实现Controller接口
    - 1.2 使用注解@Controller
- 4.2、RequestMapping
- 4.3、RestFul风格
- - 1、概念
  - 2、功能
  - 3、小结
5、数据处理及跳转(SpringMVC参数接收处理和结果跳转 )
- 1、结果跳转方式
- - 1、1 ModelAndView
  - 1、2 ServletAPI
  - 1、3 Spring MVC
- 2、数据处理
- - 2、1 处理提交数据
  - 2、2 数据显示到前端
6、JSON数据交换
- 6.1 什么是JSON
- 6.2 Json和js互转
- 6.3 Controller返回json数据类型
- - 1. 使用Jackson工具
  - 2. @ResponseBody知识点
  - 3. 利用Spring统一解决乱码（优化）
  - 4. 返回json字符串统一解决*
  - 5. 输出时间对象
资料来源：

1、回顾MVC

1.1 什么是MVC？

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

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

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

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

1.2 Model 1 时代

在web早期的开发中，通常采用的都是Model1。
Model1中，主要分为两层，视图层（jsp包含View和Controller）和模型层(model)。

Model1优点：架构简单，比较适合小型项目开发；
Model1缺点：JSP职责不单一，职责过重，不便于维护

1.3 Model 2时代

Model2把一个项目分成三部分，包括视图（JSP）、控制（Servlet）、模型（业务逻辑Service）。

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

职责分析：

Controller：控制器(Servlet)

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

Model：模型(Service：业务逻辑)

业务逻辑
保存数据的状态

View：视图（JSP）：显示页面

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

1.4 MVC框架要做哪些事情

将url映射到java类或java类的方法 .
封装用户提交的数据 .
处理请求–调用相关的业务处理–封装响应数据 .
将响应的数据进行渲染 . jsp / html 等表示层数据 .

说明：

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

2、Spring MVC

2.1 概述

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

2、我们为什么要学习SpringMVC呢?

Spring MVC的特点：

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

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 Spring MVC的执行原理

在这里插入图片描述

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。获取用户发出的请求。

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

如上url拆分成三部分：
- http://localhost:9096服务器域名
- SpringMVC部署在服务器上的web站点
- hello表示控制器
通过分析，如上url表示为：请求位于服务器localhost:9096上的SpringMVC站点的hello控制器。

简单来说：http://localhost:9096/表示Tomcat服务器，SpringMVC表示项目名称， hello表示控制器（Servlet程序）==》获取用户请求的参数
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

3、第一个MVC程序

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

查看控制台输出，看一下是不是缺少了什么jar包。
如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
重启Tomcat 即可解决！

3.1、注解版

1、新建一个Moudle，添加web支持！

创建一个maven项目，moudle
然后右键点击新建的moudle，选择添加框架支持（add framework support）
然后选择Web Application，即可创建一个带有web.xml的moudle

2、由于Maven可能存在资源过滤的问题，我们将配置完善

<build><resources><resource><directory>src/main/javadirectory><includes><include>**/*.propertiesinclude><include>**/*.xmlinclude>includes><filtering>falsefiltering>resource><resource><directory>src/main/resourcesdirectory><includes><include>**/*.propertiesinclude><include>**/*.xmlinclude>includes><filtering>falsefiltering>resource>resources>
build>

3、在pom.xml文件引入相关的依赖

主要有Spring框架核心库、Spring MVC、servlet , JSTL等。

<dependencies><dependency><groupId>junitgroupId><artifactId>junitartifactId><version>4.12version>dependency><dependency><groupId>org.springframeworkgroupId><artifactId>spring-webmvcartifactId><version>5.1.9.RELEASEversion>dependency><dependency><groupId>javax.servletgroupId><artifactId>servlet-apiartifactId><version>2.5version>dependency><dependency><groupId>javax.servlet.jspgroupId><artifactId>jsp-apiartifactId><version>2.2version>dependency><dependency><groupId>javax.servletgroupId><artifactId>jstlartifactId><version>1.2version>dependency>
dependencies>

4、配置web.xml

注意点：



<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"><servlet><servlet-name>SpringMVCservlet-name><servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class><init-param><param-name>contextConfigLocationparam-name><param-value>classpath:springmvc-servlet.xmlparam-value>init-param><load-on-startup>1load-on-startup>servlet><servlet-mapping><servlet-name>SpringMVCservlet-name><url-pattern>/url-pattern>servlet-mapping>
web-app>

【注】启动级别 load-on-startup

load-on-startup元素标记容器是否在启动的时候就加载这个servlet(实例化并调用其init()方法)。
它的值必须是一个整数，表示servlet应该被载入的顺序
当值为0或者大于0时，表示容器在应用启动时就加载并初始化这个servlet；
当值小于0或者没有指定时，则表示容器在该servlet被选择时才会去加载。
正数的值越小，该servlet的优先级越高，应用启动时就越先加载。
当值相同时，容器就会自己选择顺序来加载。

所以，x，中x的取值1，2，3，4，5代表的是优先级，而非启动延迟时间。

通常大多数Servlet是在用户第一次请求的时候由应用服务器创建并初始化，但n 可以用来改变这种状况，根据自己需要改变加载的优先级！

/ 和 /* 的区别：

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

注意web.xml版本问题
注册DispatcherServlet
关联SpringMVC的配置文件
启动级别为1
映射路径为 / 【不要用/*，会404】

5、编写Spring MVC配置文件springmvc-servlet.xml

在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：


<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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvchttps://www.springframework.org/schema/mvc/spring-mvc.xsd"><context:component-scan base-package="com.kuang.controller"/><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>

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

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

6、创建controller

编写一个Java控制类：com.kuang.controller.HelloController , 注意编码规范
编写我们要操作业务Controller ，要么实现Controller接口，要么增加注解(RequestMapping(""))；需要返回一个ModelAndView，装数据，封视图

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;@Controller
@RequestMapping("/HelloController")
public class HelloController {
//URL：http://localhost:9096/项目名/HelloController/hello@RequestMapping("/hello")public String sayHello(Model model){//向模型中添加属性msg与值，可以在JSP页面中取出并渲染model.addAttribute("msg","hello,SpringMVC");//WEB-INF/jsp/hello.jspreturn "hello";}
}

@Controller是为了让Spring IOC容器初始化时自动扫描到；
@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
方法中声明Model类型的参数是为了把Action中的数据带到视图中；
方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

7、创建视图层

在WEB-INF/ jsp目录中创建hello.jsp ，视图可以直接取出并展示从Controller带回的信息；可以通过EL表示取出Model中存放的值，或者对象；

8、访问结果如下：
在这里插入图片描述
如果在类上，将RequestMapping("/")的值变为 / ，则在访问的时候直接加上控制器的名称即可

@Controller
@RequestMapping("/") 
public class HelloController {//URL：http://localhost:9096/项目名/hello@RequestMapping("/hello")public String sayHello(Model model){//向模型中添加属性与值，使得在JSP页面中可以通过属性获取到值model.addAttribute("msg", "Hello, Annotation_SpringMVC!!!");// WEB-INF/jsp/hello.jspreturn "hello";//方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。}
}
//访问的URL与返回的字符串没有任何关系，只与类和方法上的@RequestMapping中的值有关

与上图对比：
在这里插入图片描述

3.2、小结

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

新建一个maven项目，然后添加web框架
导入相关jar包
编写web.xml , 注册DispatcherServlet
编写springmvc配置文件
接下来就是去创建对应的控制类 , controller
最后完善前端视图和controller之间的对应
测试运行调试.

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

处理器映射器 HandlerMapping
处理器适配器 HandlerAdapter
视图解析器 ViewResolver

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

4、RestFul和控制器

4.1、控制器（Controller层的）

控制器负责提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
控制器负责解析用户的请求并将其转换为一个模型。
在Spring MVC中一个控制器类可以包含多个方法
在Spring MVC中，对于Controller的配置方式有很多种

1.1 实现Controller接口

Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法；

//实现该接口的类获得控制器功能
public interface Controller {//处理请求且返回一个模型与视图对象ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

说明：

实现接口Controller定义控制器是较老的办法
缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；

1.2 使用注解@Controller

@Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解）；
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。


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

增加一个ControllerTest2类，使用注解实现；

//@Controller注解的类会自动添加到Spring上下文中
@Controller
public class ControllerTest2{//映射访问路径@RequestMapping("/t2")public String index(Model model){//Spring MVC会自动实例化一个Model对象用于向视图中传值model.addAttribute("msg", "ControllerTest2");//返回视图位置   test.jspreturn "test";}
}

4.2、RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
为了测试结论更加准确，我们可以加上一个项目名测试 myweb
只注解在方法上面

@Controller
public class TestController {@RequestMapping("/h1")public String test(){return "test";}
}
//此时的访问路径为：http://localhost:9096 / 项目名 / h1

同时注解类与方法

@Controller
@RequestMapping("/admin")
public class TestController {@RequestMapping("/h1")public String test(){return "test";}
}
//访问路径：http://localhost:8080 / 项目名/ admin /h1  , 需要先指定类的路径再指定方法的路径；

4.3、RestFul风格

1、概念

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

2、功能

1、资源：互联网所有的事物都可以被抽象为资源。

2、资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。分别对应添加、删除、修改、查询。

3、传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET
http://127.0.0.1/item/saveItem.action 新增,POST
http://127.0.0.1/item/updateItem.action 更新,POST
http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

4、 使用RESTful操作资源 ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询,GET
http://127.0.0.1/item 新增,POST
http://127.0.0.1/item 更新,PUT
http://127.0.0.1/item/1 删除,DELETE

5、 学习测试

在新建一个类 RestFulController

@Controller
public class RestFulController {}

在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

@Controller
public class RestFulController {//映射访问路径@RequestMapping("/commit/{p1}/{p2}")public String index(@PathVariable int p1, @PathVariable int p2, Model model){int result = p1+p2;//Spring MVC会自动实例化一个Model对象用于向视图中传值model.addAttribute("msg", "结果："+result);//返回视图位置return "test";  }
}

思考：使用路径变量的好处？
- 使路径变得更加简洁；
- 获得参数更加方便，框架会自动进行类型转换。
- 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。

可以使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等。

//映射访问路径,必须是POST请求
@RequestMapping(value = "/hello",method = {RequestMethod.POST})
public String index2(Model model){model.addAttribute("msg", "hello!");return "test";
}//映射访问路径,必须是Get请求
@RequestMapping(value = "/hello",method ={RequestMethod.GET})
public String index2(Model model){model.addAttribute("msg", "hello!");return "test";
}

3、小结

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

public enum RequestMethod {GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
}
//RequestMethod是一个枚举类型，包括八种请求方式

5、数据处理及跳转(SpringMVC参数接收处理和结果跳转 )

1、结果跳转方式

1、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 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;}
}

1、2 ServletAPI

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

1、通过HttpServletResponse进行输出
2、通过HttpServletResponse实现重定向
3、通过HttpServletResponse实现转发

@Controller
public class ResultGo {@RequestMapping("/result/t1")public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {rsp.getWriter().println("Hello,Spring BY servlet API");}//当输入URL:http://ip:port/project_name/result/test01时页面内就会输出括号里的字符串@RequestMapping("/result/t2")public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {rsp.sendRedirect("/index.jsp");}
//当输入URL时就会自动重定向到 http://ip:port/projrct_name/index.jsp页面@RequestMapping("/result/t3")public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {req.setAttribute("msg","/result/t3");req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);}//转发  }

1、3 Spring MVC

通过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为另一个请求/}
}

2、数据处理

2、1 处理提交数据

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

提交数据 : http://localhost:9096/hello?name=kuasheng

处理方法 :

@RequestMapping("/hello")
public String hello(String name){System.out.println(name);  //后台输出：kuashengreturn "hello";
}

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

提交数据 : http://localhost:9096/hello?username=kuangshen

处理方法 :

//@RequestParam("username") : username提交的域的名称 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){System.out.println(name); //输出：kuangshenreturn "hello";
}

3、提交的是一个对象

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

1、实体类

public class User {private int id;private String name;private int age;//构造//get/set//tostring()
}

2、提交数据 : http://localhost:9096/mvc04/user?name=kuangshen&id=1&age=1

3、处理方法 :

@RequestMapping("/user")
public String user(User user){System.out.println(user); //输出：User{ id=1, name='kuangshen', age=15 }return "hello";
}
//说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

2、2 数据显示到前端

第一种 : 通过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;}
}

6、JSON数据交换

6.1 什么是JSON

概念和作用

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

语法格式

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

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

注意事项

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

{"name":"小明"}  //键和值都必须使用 “ ”

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

6.2 Json和js互转

1、Json转换为js对象，使用JSON.parse()方法

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

2、js对象转换为Json字符串，使用JSON.stringify()方法

var json = JSON.stringify({a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'

3、测试

DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Json测试title>
head>
<body><script type="text/javascript">//编写一个js对象var user = {name:"秦时明月",type:"动漫",count:6};//将js对象转换为一个json对象var json = JSON.stringify(user);console.log(json);  //在网页控制台打印相关信息，比使用alert好，alert会阻断js程序的运行//将json字符串转换为js对象var user2 = JSON.parse(json);console.log(user2.name, user2.type, user2.count);script>
body>
html>

6.3 Controller返回json数据类型

1. 使用Jackson工具

导入依赖（jar包）
配置springmvc需要的配置。web.xml和springmvc-servlet.xml
编写一个实体类进行测试

<dependency><groupId>com.fasterxml.jackson.coregroupId><artifactId>jackson-databindartifactId><version>2.11.3version>
dependency>

配置web.xml文件


<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"><servlet><servlet-name>springmvcservlet-name><servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class><init-param><param-name>contextConfigLocationparam-name><param-value>classpath:springmvc-servlet.xmlparam-value>init-param><load-on-startup> 1 load-on-startup>servlet><servlet-mapping><servlet-name>springmvcservlet-name><url-pattern>/url-pattern>servlet-mapping><filter><filter-name>encodingFilterfilter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class><init-param><param-name>encodingparam-name><param-value>utf-8param-value>init-param>filter><filter-mapping><filter-name>encodingFilterfilter-name><url-pattern>/url-pattern>filter-mapping>
web-app>

配置springmvc-servlet.xml


<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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvchttps://www.springframework.org/schema/mvc/spring-mvc.xsd"><context:component-scan base-package="com.wei.controller"/><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>

编写一个实体类
编写Controller进行测试

@Controller
public class UserController {//@RequestMapping("/jsonData")//解决乱码的注解@RequestMapping(value="/jsonData",produces = "application/json;charset=utf-8")@ResponseBodypublic String jsonData(Model model) throws JsonProcessingException {//创建一个Jackson的对象映射器，用来解析jsonObjectMapper mapper = new ObjectMapper();//创建一个对象User user = new User("天明",14,"男");//将我们的对象解析成json格式String str = mapper.writeValueAsString(user);//由于@ResponseBody，会将str自动转换为json格式返回return str;}
}

2. @ResponseBody知识点

1、作用

将方法的返回值，以特定的格式写入到response的body区域，进而将数据返回给客户端。
当方法上面没有写ResponseBody，底层会将方法的返回值封装为ModelAndView对象。
如果返回值是字符串，那么直接将字符串写到客户端；如果是一个对象，会将对象转化为json串，然后写到客户端。

2、转换为json格式的字符串的原理：

通过HttpMessageConverter中的方法实现的，它本是一个接口，在其实现类完成转换。如果是bean对象，会调用对象的getXXX（）方法获取属性值并且以键值对的形式进行封装，进而转化为json串。如果是map集合，采用get(key)方式获取value值，然后进行封装。

3、注意事项

如果返回对象,按utf-8编码。
如果返回String，默认按iso8859-1编码，页面可能出现乱码。

因此在注解中我们可以手动修改编码格式，

//例如：前面是请求的路径，后面是编码格式 
@RequestMapping(value="/cat/query",produces="text/html;charset=utf-8")

3. 利用Spring统一解决乱码（优化）

上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！

我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！


<mvc:annotation-driven><mvc:message-converters><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>

4. 返回json字符串统一解决*

	在类上直接使用 **@RestController** ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！

@RestController
public class UserController2 {@RequestMapping(value = "/jsonData2")public String jsonData2() throws JsonProcessingException {//1、创建一个Jackson的对象的映射器，用来解析数据ObjectMapper mapper = new ObjectMapper();//2、创建一个对象User user = new User("少羽", 16, "男");//3、将我们的对象解析为Json格式String str = mapper.writeValueAsString(user);return str;}
}

5. 输出时间对象

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 getJsonTime(Object object) {return getJsonTime(object,"yyyy-MM-dd HH:mm:ss");}public static String getJsonTime(Object object,String dateFormat) {ObjectMapper mapper = new ObjectMapper();//不使用时间差的方式mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);//自定义日期格式对象SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);//指定日期格式mapper.setDateFormat(sdf);try {return mapper.writeValueAsString(object);} catch (JsonProcessingException e) {e.printStackTrace();}return null;}
}

资料来源：

https://www.bilibili.com/video/BV1aE41167Tu?from=search&seid=14819380356113406739

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！

标签：技术

上一篇 > MySQL---7.Memory引擎
下一篇 > MySQL---6.补充

Duilib中list控件支持ctrl和shif多行选中的实现

[ICML2015]Batch Normalization:Accelerating Deep Network Training by Reducing Internal Covariate Shif

win10系统微软输入法于eclipse ctrl+shif+f冲突间接处理办法

Codeforces Round #259 (Div. 2) B. Little Pony and Sort by Shif

读LDD3，内存映射与DMA--PAGE_SHIF…

VMware虚拟机安装XP【要先分区，再设置BOOT 启动CD，shif+上移】

更换iBus五笔的左与右Shif

sublime ctrl+shif+f 没用解决办法

idea 对 ctrl + z 的撤销是 ctrl + shif + z

计算机最早的设计师应用于,计算机应用基础选择题doc.doc

win10自带截图神器：Win+Shift+S

Python基础之文件目录操作

python简述目录_Python基础之文件目录操作(示例代码)

tp5 如何做数据采集

任务2-7(服务器字体+阿里巴巴矢量库)

html标签（1)：h1~h6,p,br,pre,hr

TI 电量计介绍与芯片选型指南

几款TI电源芯片简介

TI DSP芯片C2000系列读取FLASH数据

德州仪器(Ti)平台嵌入式开发基础

TI三相电机智能栅极驱动芯片特点分类

省选模拟（12.08） T3 圈圈圈圈圈圈圈圈

Hadoop生态圈技术栈（上）

大数据开发基础入门与项目实战（三）Hadoop核心及生态圈技术栈之6.Impala交互式查询

小猿圈之Linux下Mysql 操作命令

大数据Hadoop生态圈常用面试题

大数据开发基础入门与项目实战（三）Hadoop核心及生态圈技术栈之4.Hive DDL、DQL和数据操作

备战Noip2018模拟赛11（B组）T3 Monogatari 物语

【智能优化算法-圆圈搜索算法】基于圆圈搜索算法Circle Search Algorithm求解单目标优化问题附matlab代码

NYOJ 78 圈水池

递归问题跑道汽车绕圈问题 Python实现

Hadoop生态圈（三）：MapReduce