SpringMVC

哔哩哔哩狂神说Java学习网址
文章只为分享学习经验和自己复习用，学习还是该去查看正规视频网站和官方文档才更有效

文章目录

SpringMVC
- 1、回顾 MVC
- - 1.1、什么是 MVC
  - 1.2、Model1 时代
  - 1.3、Model2 时代
  - 1.4、回顾 Servlet
- 2、什么是SpringMVC
- - 2.1、概述
  - 2.2、中心控制器
  - 2.3、SpringMVC执行原理
- 3、编写程序
- - 3.1、配置版
  - 3.2、注解版
- 4、RestFul和控制器
- - 4.1、控制器Controller
  - - 1、实现Controller接口
    - 2、使用注解@Controller
  - 4.2、RequestMapping
  - 4.3、RestFul 风格
- 5、结果跳转方式
- - 5.1、ModelAndView
  - 5.2、ServletAPI
  - 5.3、SpringMVC
- 6、SpringMVC数据处理
- - 6.1、处理提交数据
  - 6.2、数据显示到前端
  - 6.3、对比
- 7、乱码问题
- 8、Json交互处理
- - 8.1、什么是JSON？
  - 8.2、JSON 和 JavaScript 对象互转
  - 8.3、Controller返回JSON数据
  - 8.4、代码优化-乱码
  - 8.5、测试集合输出
  - 8.6、输出时间对象
  - 8.7、FastJson

ssm：mybatis + Spring + SpringMVC MVC三层架构

Java的三大类JavaSE和JavaWeb，学习基础多看视频，多跟着老师学习，比较容易入门。

但是SSM框架，更多的需要自学，老师只能教你一些，大部分都是通过研究官方文档和开发项目中去学习的

JavaSE：认真学习，老师带，入门快
JavaWeb：认真学习，老师带，入门快
SSM框架：研究官方文档，锻炼自学能力，锻炼笔记能力，锻炼项目能力

SpringMVC以后还要学习 Vue + SpringBoot + SpringCloud + Linux

SSM 就等于 JavaWeb做项目，只是简化了一些方法，增加了注解

Spring ：IOC 和 AOP 是重点

SpringMVC ：SpringMVC的执行流程是重点

SpringMVC ：SSM框架的集合

1、回顾 MVC

1.1、什么是 MVC

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

dao层数据库一 service层调dao层执行业务处理一 servlet层接收前段数据（转发，重定向）一 jsp/html 前段

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

扩展：

如果业务分成：前段数据库实体类

实体类内有：用户名、密码、生日、爱好…20多条

但是实际前段登录只需要：用户名、密码

这样如果只创建一个对象，就会有很多null数据出现，浪费资源

所以实际开发中就会将创建出不同的对象，

比如：

实体类 pojo：User

视图对象 vo：UserVo

数据传输对象 dto：UserDto

等等

但是对整体编程没有影响，只是一种细化方式

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

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

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

1.2、Model1 时代

在web早期的开发中，通常采用的都是Model1，直接在JSP中处理。
Model1中，主要分为两层，视图层和模型层。

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

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

JSP：本质就是一个Servlet

1.3、Model2 时代

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

扩展：

假设：你去面试，面试官问你：你的项目的架构，是设计好的，还是演进的？

答案是演进，因为所有的程序或者架构都是根据自己的需求，从小开始，逐步变大。

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

职责分析：

Controller：控制器

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

Model：模型

业务逻辑
保存数据的状态

View：视图

显示页面

更重要的是适合团队性开发

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

1.4、回顾 Servlet

新建一个Maven工程当做父工程！pom依赖！

<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>

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

导入Web需要的依赖 servlet 和 jsp

<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>

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

想要编程Servlet类就需要继承HttpServlet实现方法

//实现Servlet接口
public class HelloServlet extends HttpServlet {@Overrideprotected 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方法");}//业务逻辑//视图转发或重定向//.forward(req,resp);转发并且携带参数req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doGet(req,resp);}
}

编写Hello.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp

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

在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"><servlet><servlet-name>HelloServlet</servlet-name><servlet-class>com.kuang.servlet.HelloServlet</servlet-class></servlet><servlet-mapping><servlet-name>HelloServlet</servlet-name><url-pattern>/user</url-pattern></servlet-mapping><!-- 超时时间<session-config><session-timeout>15</session-timeout></session-config> --><!-- 欢迎页面<welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list> --></web-app>

配置Tomcat，并启动测试

localhost:8080/user?method=add
localhost:8080/user?method=delete

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、什么是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

老版本文档：https://docs.spring.io/spring/docs/4.3.24.RELEASE/spring-framework-reference/html/

我们为什么要学习SpringMVC呢?

Spring MVC的特点：

轻量级，简单易学
高效 , 基于请求响应的MVC框架
与Spring兼容性好，无缝结合

Spring:大杂烩，我们可以将SpringMVC中所有要用到的bean，注册到Spring中
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵活

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

中间的调度可以简单的理解为 DispatcherServlet

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框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
- 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
- 如上url拆分成三部分：
  - http://localhost:8080 ------> 服务器域名
  - SpringMVC ------> 部署在服务器上的web站点
  - hello ------> 表示控制器
- 通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler。
HandlerExecution表示具体的Handler，其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。（实现了Controller接口的都会被适配一下）
Handler让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

3、编写程序

3.1、配置版

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

确定导入了SpringMVC 的依赖！

配置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><!--org.springframework.web.servlet.DispatcherServlet 是固定的--><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml--><init-param><!-- 设置参数； classpath就是去所有包内寻找--><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>

配置DispatcherServlet：这个是SpringMVC的核心；请求分发器，前端控制器
DispatcherServlet 要绑定Spring的配置文件
SpringMVC / 和 /* 的区别：
- /不会匹配到.jsp，只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类。
- /*会匹配 *.jsp，会出现返回jsp视图时再次进入spring的DispatcherServlet类，导致找不到对应的controller所以报404错。

编写 SpringMVC 的配置文件！

名称：springmvc-servlet.xml : [servletname]-servlet.xml

resources

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

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 视图解析器：DispatcherServlet 给他的ModelAndView1. 获取了 ModelAndview 的数据2. 解析 ModelAndView 的视图名字3. 拼接视图名字，找到对应的视图 /WEB-INF/jsp/hello.jsp4. 将数据渲染到这个视图上
--></beans>

添加处理映射器（可省略）

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

BeanNameUrlHandlerMapping 处理映射器需要添加一个bean，找到hello的位置
<bean id="/hello class="com.kuang.controller.HelloController/>"

添加处理器适配器（可省略）

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

添加视图解析器

其他视图解析器，如：模板引擎 Thymeleaf ；Freemarker …等

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

以上三条就是SpringMVC的核心三要素，要完成工作的必要条件，使用注解可以简单配置

编写我们要操作业务HelloController

要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图

package com.kuang.controller;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.mvc.Controller;
//注意：这里我们先导入Controller接口
public class HelloController implements Controller {public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {//ModelAndView 模型和视图ModelAndView mv = new ModelAndView();//上下是固定的，中间只需要写业务代码和视图跳转//业务代码//封装对象，放在ModelAndView中String result = "HelloSpringMVC!"mv.addObject("msg",result);//视图跳转//封装要跳转的视图，放在ModelAndView中mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jspreturn mv;}
}

只要有返回值，上来就创建这个返回值，并返回这个值，固定方法

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

<!--Handler-->
<bean id="/hello" class="nuc.ss.controller.HelloController"/>

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

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

配置Tomcat 启动测试！

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

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

IDEA缺少lib依赖解决办法，创建lib文件，将jar全部导入进入。

3.2、注解版

比配置版更加简单

新建一个Moudle

springmvc-03-hello-annotation 。添加web支持！

在pom.xml文件引入相关的依赖：主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了！

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

<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>

配置web.xml

注意点：

注意 web.xml 版本问题，要最新版，必须最新版
注册DispatcherServlet
关联SpringMVC的配置问题
启动级别为1
映射路径/【不要用/*，会出现404报错】
IDEA添加lib目录导包

<?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>

添加Spring MVC配置文件

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

<?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/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"><!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理，生效包的地址 --><context:component-scan base-package="com.kuang.controller"/><!-- 让Spring MVC资源过滤，不处理静态资源，不然.css.js.html等处理太多没用的类会浪费资源 --><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>

注解自动扫描包 context:component-scan
Spring MVC资源过滤 mvc:default-servlet-handler（固定）
mvc:annotation-driven 配置实例（固定）
视图解析器（固定）

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

创建Controller

编写一个Java控制类：com.kuang.controller.HelloController , 注意编码规范

package nuc.ss.controller;
package com.kuang.controller;import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;//添加注解后被context:component-scan扫描到
@Controller
public class HelloController {@RequestMapping("/hello")public String hello(Model model){//封装数据model.addAttribute("msg","hello,springmvcAnnotation");return "hello";}
}

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

现在添加多个映射请求，只需要添加方法来实现

创建视图层

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

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

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

配置Tomcat运行

配置Tomcat ，开启服务器，访问对应的请求路径！

OK，运行成功！

小结

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

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

使用springMVC必须配置的三大件

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

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

4、RestFul和控制器

4.1、控制器Controller

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

1、实现Controller接口

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

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

测试

1、新建一个Moudle，springmvc-04-controller！

mvc的配置文件只留下视图解析器！

2、编写一个Controller类，ControllerTest1

只要实现了 Controller 接口的类，说明这就是一个控制器了

//定义控制器
//注意点：不要导错包，实现Controller接口，重写方法；
public class ControllerTest1 implements Controller {public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {//返回一个模型视图对象ModelAndView mv = new ModelAndView();mv.addObject("msg","Test1Controller");mv.setViewName("test");return mv;}
}

3、编写完毕后，去Spring配置文件只中注册请求的bean；name对应请求路径，class对应处理请求的类

<?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/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><bean name="/t1" class="nuc.ss.controller.ControllerTest1"/></beans>

这个方法可以不使用：映射器，过滤器，配置器

4、编写前端test.jsp，注意在WEB-INF/jsp目录下编写，对应我们的视图解析器

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

5、配置Tomcat运行测试，我这里没有项目发布名配置的就是一个 / ，所以请求不用加项目名

说明：

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

2、使用注解@Controller

@Controller注解类型用于声明Spring类的实例是一个控制器

四个组件，功能一样，只是区分使用地方

@Component 组件
@Service service
@Controller controller
@Repository dao

Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。

<!-- 注解扫描 -->
<context:component-scan base-package="nuc.ss.controller"/>

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

//@Controller 代表这个类会被Spring接管
//被这个注解的类，中的所有方法，返回值是String，并且有具体页面可以跳转的，那么就会被视图解析器解析
@Controller
public class ControllerTest2{//映射访问路径@RequestMapping("/t2")public String index(Model model){//Spring MVC会自动实例化一个Model对象用于向视图中传值model.addAttribute("msg", "ControllerTest2");//返回视图位置return "test";}
}

@Controller 代表这个类会被Spring接管
被这个注解的类，中的所有方法，且返回值是String，并且有具体页面可以跳转的，那么就会被视图解析器解析

视图跳转的位置

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

注解方式是平时使用的最多的方式，除了这两种之外还有其他的方法。

4.2、RequestMapping

@RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

为了测试结论更加准确，我们可以加上一个项目名测试 myweb

只注解在方法上面

@Controllerpublic class TestController {@RequestMapping("/h1")public String test(){return "test";}
}

访问路径：http://localhost:8080 / 项目名 / h1

同时注解类与方法

@Controller
@RequestMapping("/admin")
public class TestController {@RequestMapping("/h1")public String test(){return "test";}
}

访问路径：http://localhost:8080 / 项目名/ admin /h1 , 需要先指定类的路径再指定

建议是在子类上写死，这样在拥有大量数据调试时，更容易看懂

4.3、RestFul 风格

概念

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

安全、高效、简洁

功能

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应添加、删除、修改、查询。

传统方式操作资源：通过不同的参数来实现不同的效果！方法单一，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

使用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

学习测试

在新建一个类 RestFulController

原来的方法

@Controllerpublic class RestFulController{@RequestMapping("/add")public String test1(int a,int b,Model model){int res = a + b;model.addAttribute("msg","结果为"+res);return "test";}
}

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


package com.kuang.controller;import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;@Controller
public class RestFulController {@GetMapping("/add/{a}/{b}")public String test1(@PathVariable int a,@PathVariable String b, Model model){String res=a+b;model.addAttribute("msg","结果为:"+res);return "test";}@PostMapping("/add/{a}/{b}")public String test2(@PathVariable int a,@PathVariable int b, Model model){int res=a+b;model.addAttribute("msg","结果为:"+res);return "test";}}}

我们来测试请求查看下

方法直接获取了/a/b的值

同时如果同样运行：http://localhost:8080/add/1/2

当请求方式为Get方法时，就会执行 @GetMapping("/add/{a}/{b}") test1方法
当请求方式为Post方法时，就会执行 @PostMapping("/add/{a}/{b}") test2方法

这就是他的，可以通过不同的请求方式来实现不同的效果

思考：使用路径变量的好处？

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

我们来修改下对应的参数类型，再次测试

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

使用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请求，会报错405：

如果将POST修改为GET则正常了；

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

@RequestMapping( 这里使用value，或者path，name会出错

小结：

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

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

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

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

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

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

扩展：小黄鸭调试法

场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时候就在我们解释的过程中自己却想到了问题的解决方案，然后对方却一脸茫然。

场景二：你的同行跑来问你一个问题，但是当他自己把问题说完，或说到一半的时候就想出答案走了，留下一脸茫然的你。

其实上面两种场景现象就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它是我们软件工程中最常使用调试方法之一。

此概念据说来自《程序员修炼之道》书中的一个故事，传说程序大师随身携带一只小黄鸭，在调试代码的时候会在桌上放上这只小黄鸭，然后详细地向鸭子解释每行代码，然后很快就将问题定位修复了。

平时应该多读代码，特别是自己写得，要有自己的思维，并且自己向自己解释一遍，这行代码做了什么！

5、结果跳转方式

5.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;}
}

5.2、ServletAPI

ServletAPI

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

通过HttpServletResponse进行输出
通过HttpServletResponse实现重定向
通过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");}@RequestMapping("/result/t2")public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {//重定向rsp.sendRedirect("/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);}}

不建议使用，会出现未知错误

5.3、SpringMVC

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

默认为forward转发（也可以加上）

redirect转发需特别加

@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来实现转发和重定向 - 有视图解析器；

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

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

默认为forward转发（不可以加上）

redirect转发需特别加

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

6、SpringMVC数据处理

6.1、处理提交数据

创建一个实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {private int id;private String name;private int age;
}

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

提交数据 : http://localhost:8080/test?name=kuangshen

处理方法 :

@Controller
@RequestMapping("/user")
public class UserContriller{//localhost:8080/user/t1@GetMapping("/t1")public String test1(String name,Model model){//1.接收前段参数System.out.println("接收前段的参数为："+name);//2.将返回的结果传输给前段 ，Modelmodel.addAttribute("msg",name);//3.视图跳转return "test";}
}

后台输出 : kuangshen

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

提交数据 : http://localhost:8080/test?username=kuangshen

处理方法 :使用@RequestParam("username")

//@RequestParam("username") : username提交的域的名称 .
@Controller
@RequestMapping("/user")
public class UserContriller{//localhost:8080/user/t1@GetMapping("/t1")public String test1(@RequestParam("username") String name,Model model){//1.接收前段参数System.out.println("接收前段的参数为："+name);//2.将返回的结果传输给前段 ，Modelmodel.addAttribute("msg",name);//3.视图跳转return "test";}
}

后台输出 : kuangshen

最好不管参数名一不一样最好都加上@RequestParam("")，这样可以明了的看出这个方法是要和前段配对

提交的是一个对象

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

提交数据 : http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15

处理方法 :

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

后台输出 : User { id=1, name=‘kuangshen’, age=15 }

内部步骤：

接收前段用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
假设传递的是一个对象User，匹配User对象中的字段名；如果名字一致则OK，否则，匹配不到
前端传递的参数名和对象名必须一致，否则就是null

6.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;}
}

第二种 : 通过ModelMap

ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap modelMap){//封装要显示到视图中的数据//相当于req.setAttribute("name",name);modelMap.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";
}

LinkedHashMap

ModelMap：继承了LinkedHashMap，所以它拥有了LinkedHashMap的全部功能！

Model：ModelMap的精简版（大部分情况下，我们都直接使用Model）

6.3、对比

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

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。

7、乱码问题

测试步骤：

1、我们可以在首页编写一个提交的表单

<form action="/e/t" method="post"><input type="text" name="name"><input type="submit">
</form>

2、后台编写对应的处理类

@Controller
public class EncodingController{@PostMapping("/e/t")public String test1(String name, Model model){model.addAttribute("msg",name);return "test";}
}

3、输入中文测试，出现乱码

使用过滤器解决乱码问题

创建过滤器

public class EncodingFilter implements Filter{public void init(FilterConfig filterConfig) throws ServletException{}public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException{request.setCharacterEncoding("utf-8");response.setCharacterEncoding("utf-8");chain.doFilter(request,response);}public void destroy(){}}

维护web.xml，配置过滤器

<filter><filter-name>encoding</filter-name><filter-class>com.kuang.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping><filter-name>encoding</filter-name><url-pattern>/</url-pattern>
</filter-mapping>

Post请求失败，还是乱码，但是Get请求可以正常显示

通过SpringMVC的过滤器解决乱码问题

通过SpringMVC给我们提供了一个过滤器，可以在wev.xml中配置，修改xml文件需要重启服务器

<!-- 配置SpringMVC的乱码过来 -->
<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><filter-class>/*</filter-class>
</filter-mapping>

注意/*和/的问题

但是发现，有些极端情况下，这个过滤器对get的支持不好

极端情况，还是无法处理的时候的终极大招

处理方法

1、修改tomcat配置文件：设置编码

位置：根目录→conf→server.xml

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443" />

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 {@Overridepublic void destroy() {}@Overridepublic 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);}@Overridepublic 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;}// 对需要增强方法 进行覆盖@Overridepublic 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();}//取一个值@Overridepublic String getParameter(String name) {Map<String, String[]> parameterMap = getParameterMap();String[] values = parameterMap.get(name);if (values == null) {return null;}return values[0]; // 取回参数的第一个值}//取所有值@Overridepublic String[] getParameterValues(String name) {Map<String, String[]> parameterMap = getParameterMap();String[] values = parameterMap.get(name);return values;}
}

这个是网上找的一些大神写的，一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了

3、维护自定义过滤器web.xml

<filter><filter-name>encoding</filter-name><filter-class>com.kuang.filter.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping><filter-name>encoding</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>

8、Json交互处理

8.1、什么是JSON？

前后端分离时代：

后端部署后端，提供接口，提供数据

中间连接部分，JSON

前段独立部署，负责渲染后端的数据（layui）

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

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

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

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

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：

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

var obj = {a: ‘Hello’, b: ‘World’}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = ‘{“a”: “Hello”, “b”: “World”}’; //这是一个 JSON 字符串，本质是一个字符串

8.2、JSON 和 JavaScript 对象互转

要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

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

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify()方法：

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

代码测试

新建一个module ，springmvc-05-json ，添加web的支持

在web目录下新建一个 json-1.html ，编写测试内容

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title><script type="text/javascript">//编写一个JavaScript对象var user={name:"秦疆"，age:3,sex:男}//输出console.log(user);//将 js 对象转换为 json 对象var json = JSON.stringify(user);console.log(json);//将 json 对象转换为 JavaScript 对象var obj = JSON.parse(json);console.log(obj);</script>
</head>
<body></body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>JSON_秦疆</title>
</head>
<body><script type="text/javascript">//编写一个js的对象var user = {name:"秦疆",age:3,sex:"男"};//将js对象转换成json字符串var str = JSON.stringify(user);console.log(str);//将json字符串转换为js对象var user2 = JSON.parse(str);console.log(user2.age,user2.name,user2.sex);</script></body>
</html>

在IDEA中使用浏览器打开，查看控制台输出！

8.3、Controller返回JSON数据

Jackson应该是目前比较好的json解析工具了
当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。
我们这里使用Jackson，使用它需要导入它的jar包；

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.10.0</version>
</dependency>

配置SpringMVC需要的配置

（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><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></web-app>

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/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"><!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 --><context:component-scan base-package="com.kuang.controller"/><!-- 视图解析器 --><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="internalResourceViewResolver"><!-- 前缀 --><property name="prefix" value="/WEB-INF/jsp/" /><!-- 后缀 --><property name="suffix" value=".jsp" /></bean></beans>

我们随便编写一个User的实体类，然后我们去编写我们的测试Controller；

    @Data@AllArgsConstructor@NoArgsConstructorpublic class User {private int age;private String name;private String sex;}

这里我们需要两个新东西，一个是@ResponseBody，一个是ObjectMapper对象，我们看下具体的用法

编写一个Controller；

@ResponseBody他就不会走视图解析器，会直接返回一个字符串（平时前后端分离的时候都不会走视图解析器）
ObjectMapper 对象中的writeValueAsString方法可以将一个值，变成一个字符串

    @Controllerpublic class UserController {@RequestMapping("/j1")@ResponseBody//他就不会走视图解析器，会直接返回一个 字符串public String json1() throws JsonProcessingException {//jackson,ObjectMapperObjectMapper mapper = new ObjectMapper();//创建一个对象User user = new User(1, "秦疆一号", 12);//return user.toString();简单法的返回字符串String str = mapper.writeValueAsString(user);return str;}

通过toString也可以返回字符串，但是需要调整格式才和JSON一样

此时输入中文会产生乱码

    //produces:指定响应体返回类型和编码@RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")

配置Tomcat ，启动测试一下http://localhost:8080/j1

【注意：使用json记得处理乱码问题】

8.4、代码优化-乱码

乱码统一解决

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

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

<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>

@ResponseBody（加到方法上）

@ResponseBody解决（每个方法都得加，不建议使用）

它是配合@Controller一起使用的，如果使用@RestController就没必要使用它了

@Controller
public class UserController {//produces:指定响应体返回类型和编码@RequestMapping(value = "/json1")@ResponseBodypublic String json1() throws JsonProcessingException {//创建一个jackson的对象映射器，用来解析数据ObjectMapper mapper = new ObjectMapper();//创建一个对象User user = new User(1, "秦疆一号", 12);//将我们的对象解析成为json格式String str = mapper.writeValueAsString(user);//由于@ResponseBody注解，这里会将str转成json格式返回；十分方便return str;}
}

@RestController（加到类上）

加上该注解，就只会返回字符串，不走视图解析

//@Controller  它会走视图解析器
@RestController
public class UserController {@RequestMapping(value = "/j1")public String json1() throws JsonProcessingException {//创建一个jackson的对象映射器，用来解析数据ObjectMapper mapper = new ObjectMapper();//创建一个对象User user = new User(1, "秦疆一号", 12);//将我们的对象解析成为json格式String str = mapper.writeValueAsString(user);return str;}}

8.5、测试集合输出

增加一个新的方法，多个对象，并把它们放到集合中

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {//创建一个jackson的对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user1 = new User(1, "秦疆1号", 12);
User user2 = new User(2, "秦疆2号", 12);
User user3 = new User(3, "秦疆3号", 12);
User user4 = new User(4, "秦疆4号", 12);
User user5 = new User(5, "秦疆5号", 12);
List<User> list = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
list.add(user5);//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(list);
return str;//new ObjectMapper().writeValueAsString(list);
}

运行结果 : 十分完美，没有任何问题！

8.6、输出时间对象

增加一个新的方法

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {ObjectMapper mapper = new ObjectMapper();//创建时间一个对象，java.util.Date//ObjectMapper 时间解析后的默认格式为：Timestamp，时间戳Date date = new Date();//将我们的对象解析成为json格式String str = mapper.writeValueAsString(date);return str;
}

运行结果 : 默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！

Jackson 默认是会把时间转成timestamps形式

解决方案：

1、取消timestamps形式， SimpleDateFormat自定义时间格式

2、使用ObjectMapper来格式化输出，configure()方法关闭默认的时间戳，setDateFormat()设置新的格式，然后再获取时间

@RequestMapping("/j3")
public String json4() throws JsonProcessingException {ObjectMapper mapper = new ObjectMapper();//不使用时间戳的方式，将默认时间戳方式关闭mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);//1.自定义日期格式对象SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//指定日期格式mapper.setDateFormat(sdf);//获得时间，并将时间重新格式化Date date = new Date();String str = mapper.writeValueAsString(date);return str;
}

运行结果 : 成功的输出了时间！

优化方法，抽取相同的部分，创建为工具类

如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

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 dateFormat) {ObjectMapper mapper = new ObjectMapper();//java自定义日期格式SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);//sdf.format(date)// 使用ObjectMapper 来格式化输出，关闭默认时间戳mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);mapper.setDateFormat(sdf);try {//ObjectMapper,时间解析后的默认格式为：TImestamp.时间戳return mapper.writeValueAsString(object);} catch (JsonProcessingException e) {e.printStackTrace();}return null;
}
}

方法重载：重载第二条的方法，并且输入默认值方便直接使用，也不妨碍客户输入自己想要的格式执行第二条。

这样我们使用工具类，代码就更加简洁了！

@RequestMapping("/j3")public String json3(){//只需要获取时间Date date = new Date();//工具类赋值时间和格式return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");//方法重载后，因为有默认值也可以直接使用 return JsonUtils.getJson(date);
}
}

使用工具类，重写集合方法

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {User user1 = new User(1, "秦疆1号", 12);
User user2 = new User(2, "秦疆2号", 12);
User user3 = new User(3, "秦疆3号", 12);
User user4 = new User(4, "秦疆4号", 12);
User user5 = new User(5, "秦疆5号", 12);
List<User> userlist = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
list.add(user5);return JsonUtils.getJson(userList);
}

重新梳理顺序

导入jackson包依赖
配置中文乱码问题
是否需要通过视图解析，@Controller，@RestController

8.7、FastJson

fastjson .jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换，实现json的转换方法很多，最好的实现结果都是一样的

fastjson 的 pom 依赖

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

fastjson 三个主要的类：

JSONObject 代表 json 对象
- JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的
JSONArray 代表 json 对象数组
- 内部是有List接口中的方法来完成操作的
JSON 代表JSONObject和JSONArray的转化
- JSON类源码分析与使用
- 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

代码测试，我们新建一个FastJsonDemo 类

@RequestMapping("/j4")//@ResponseBody//他就不会走视图解析器，会直接返回一个 字符串public String json4(){User user1 = new User(1, "秦疆1号", 12);User user2 = new User(2, "秦疆2号", 12);User user3 = new User(3, "秦疆3号", 12);User user4 = new User(4, "秦疆4号", 12);User user5 = new User(5, "秦疆5号", 12);List<User> list = new ArrayList<User>();list.add(user1);list.add(user2);list.add(user3);list.add(user4);list.add(user5);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("\n****** JSON字符串 转 Java对象*******");User jp_user1=JSON.parseObject(str2,User.class);System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);System.out.println("\n****** Java对象 转 JSON对象 ******");JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));System.out.println("\n****** JSON对象 转 Java对象 ******");User to_java_user = JSON.toJavaObject(jsonObject1, User.class);System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);return JSON.toJSONString(list);
}

这种工具类，我们只需要掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样，拿来用就好了！

SpringMVC---狂神说Java学习笔记相关推荐

狂神说Java学习笔记 Java基础
目录机器语言第二代语言(汇编语言) 第三代语言高级语言 Java特性和优势 JDK(Java Development Kit) JRE(Java Runtime Enviroment) JVM( ...
Git最新教程通俗易懂----狂神说Java -- ---学习笔记
[狂神说Java]Git最新教程通俗易懂 https://www.bilibili.com/video/BV1FE411P7B3 P1.前言之版本控制 06:12 P2.Git和SVN的区别 07:3 ...
java注解和反射——狂神说java学习笔记三
原文链接:公众号狂神说视频教程[狂神说B站]: https://www.bilibili.com/video/BV12J41137hu 如有侵权,联系立删什么是注解 Annotation是从JDK ...
Java学习笔记——流程控制
Java学习笔记--流程控制 Day05 一.用户交互Scanner 1.Scanner对象我们通过Java工具包java.util.Scanner中的Scanner类来获取用户的输入基本语法:S ...
Docker基础03--Dockerfile详解与镜像发布--(狂神说docker学习笔记)
文章目录 1. Dockerfile介绍 2. Dockerfile指令说明 3. 制作Centos镜像 3.1 编写Dockerfile的文件 3.2 通过这个文件构建镜像(注意最后加个点!!!) ...
JAVA学习笔记(1)【基础知识】
JAVA学习笔记DAY_1 提示:关于java系列的内容只是本人在老师的指导下和自学过程中的一些学习笔记,如果存在错误敬请批评指正! 文章目录 JAVA学习笔记DAY_1 前言一.Java语言未来的 ...
java学习笔记11--Annotation
java学习笔记11--Annotation Annotation:在JDK1.5之后增加的一个新特性,这种特性被称为元数据特性,在JDK1.5之后称为注释,即:使用注释的方式加入一些程序的信息. j ...
java学习笔记13--反射机制与动态代理
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note13.html,转载请注明源地址. Java的反射机制在Java运行时环境中,对于任意 ...
准备写java学习笔记
准备写java学习笔记 java int 转载于:https://blog.51cto.com/cryingcloud/1975267

SpringMVC---狂神说Java学习笔记