[Java知识库] SpringMVC完整笔记

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> SpringMVC完整笔记 -> 正文阅读

[Java知识库]SpringMVC完整笔记

文章目录

1、回顾MVC

1.1、MVC概述

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。
MVC三层架构
- Model（模型)︰数据模型，提供要展示的数据，因此包含数据和行为。可以认为是领域模型或JavaBean组件(包含数据和行为)，不过现在一般都分离开来: Value object(数据Dao）和服务层(行为Service)。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
- View(视图)︰负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
- Controller(控制器)︰接收用户请求，委托给模型进行处理（状态改变)，处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。
最典型的MVC就是JSP + servlet + javabean的模式。

1.2、执行流程

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

1.3、职责分析

Controller：控制器
- 取得表单数据
- 调用业务逻辑
- 向指定的页面
Model：模型
- 业务逻辑
- 保存数据的状态
View：视图
- 显示页面

1.4、MVC框架做的事

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

1.5、说明

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF;
常见前端MVC框架：vue、angularjs、react、backbone;
由MVC演化出了另外一些模式如：MVP、MVVM（M；V；VM–ViewModel:双向绑定）等

2、回顾servlet

2.1、环境搭建

导入依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.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>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
</dependency>

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

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.获取前端参数
        String method = req.getParameter("method");
        if (method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //2.调用业务层

        //3.视图转发或者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

编写jsp页面test.jsp

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

配置文件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">

	<!--注册servlet-->    
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.ping.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

部署Tomcat测试

3、SpringMVC介绍

3.1、概述

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

3.2、特点

经量级，简单易学
高效，基于请求响应的MVC框架
与Spring兼容性好，无缝结合
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵活
最重要的一点还是用的人多，使用的公司多

3.3、中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
Spring MVC框架像许多其他MVC框架一样,以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet(它继承自HttpServlet 基类)。

3.4、执行原理

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

上图为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。
- Handler让具体的Controller执行。
- Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView
- HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
- DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
- 视图解析器将解析的逻辑视图名传给DispatcherServlet。
- DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
- 最终视图呈现给用户。

3.5、初步搭建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.注册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>

配置文件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"
       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"/>

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

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

</beans>

控制层：类HelloController

//注意：这里导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {

        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //封装对象，放在ModelAndVie中
        mv.addObject("msg","HelloSpringMVC");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");//：/WEB-INF/jsp/hello.jsp

        return mv;
    }
}

视图层：hello.jsp

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

部署Tomcat测试
可能遇到的问题:访问出现404，排查步骤:
- 查看控制台输出，看一下是不是缺少了什么jar包。
- 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖
- 重启Tomcat即可解决!

3.6、注意点

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

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

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

4、使用注解开发SpringMVC

4.1、环境搭建

配置文件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.注册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>

配置文件springmvc-servlet.xml

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

<?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
          http://www.springframework.org/schema/context/spring-context.xsd
          http://www.springframework.org/schema/mvc
          http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
    <context:component-scan base-package="com.ping.controller"/>
    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--
    支持mvc注解驱动
        在spring中一殷采川@RequestMapping注解来完成映射关系
        要想使@RequestMapping主解生效
        必须向上下文中注册DefaultAnnotationHandLerMapping
        和一个AnnotationMethodHandLerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven/>

    <!--视图解析器：DisapatcherServlet给它的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>

控制层HelloController

@Controller
@RequestMapping("/hello")
public class HelloController {
    //localhost:8080/hello/h1
    @RequestMapping("/h1")
    public String hello(Model model){
        //封装数据，向模型中添加属性msg与值，可以在jsp页面中取出并渲染
        model.addAttribute("msg","Hello,SpringMVCAnnotation");

        return "hello"; //会被视图解析器处理：/WEB-INF/jsp/hello.jsp
    }
}

视图层hello.jsp

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

4.2、实现步骤

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

4.3、控制器Controller

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

5、RestFul风格

5.1、概念

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

5.2、功能

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

5.3、传统方式操作资源

http://127.0.0.1/item/queryltem.action?id=1 查询,GET
http://127.0.0.1/item/saveltem.action 新增,POST
http://127.0.0.1/item/updateltem.action 更新,POST
http://127.0.0.1/item/deleteltem.action?id=1 删除,GET或POST

5.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.5、传统方式的示例

控制层：RestFulController类

@Controller
public class RestFulController {

    //传统的url：http://localhost:8080/add?a=1&b=2
    @RequestMapping("/add")
    public String test(int a, int b, Model model){
        int res = a+b;
        model.addAttribute("msg","结果为"+res);
        return "test";
    }
}

视图层：test.jsp

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

测试结果：地址栏输入传统的url：http://localhost:8080/add?a=1&b=2

结果为3

5.6、RestFul示例

控制层：RestFulController类

方式一：@RequestMapping("/add2/{a}/{b}")

//RestFul：http://localhost:8080/add2/1/2

@RequestMapping("/add2/{a}/{b}")
//@PathVariable 让方法参数的值对应绑定到一个URL模板变量
public String test1(@PathVariable int a,@PathVariable int b, Model model){
    int res = a+b;
    model.addAttribute("msg","结果为"+res);
    return "test";
}

方式二：使用method属性指定请求类型

@RequestMapping(value="/add2/{a}/{b}",method = RequestMethod.GET)

public String test2(@PathVariable int a,@PathVariable int b, Model model){
    int res = a+b;
    model.addAttribute("msg","结果为"+res);
    return "test";
}

方式三：使用组合注解@GetMapping

@GetMapping("/add2/{a}/{b}")

public String test3(@PathVariable int a,@PathVariable int b, Model model){
    int res = a+b;
    model.addAttribute("msg","结果为"+res);
    return "test";
}

视图层test.jsp同上
测试结果：地址栏输入RestFul风格的url：http://localhost:8080/add2/1/2

结果为3

5.7、总结

使用路径变量的好处
- 使路径变得更加简洁;
- 获得参数更加方便,框架会自动进行类型转换。
- 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/add/1/2，则路径与方法不匹配，而不会是参数转换失败。
使用method属性指定请求类型
- 用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET， POST, HEAD,OPTIONS,PUT,PATCH，DELETE，TRACE等
所有的地址栏请求默认都会是HTTP GET类型的
方法级别的注解变体有如下几个：组合注解
```
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
```
- @GetMapping是一个组合注解，它所扮演的是@RequestMapping(method =RequestMethod.GET)的一个快捷方式

6、重定向和转发

重定向是客户端行为，状态吗是307！转发是服务端行为，状态码是302！

6.1、ModelAndView

设置ModelAndView对象，根据view的名称，和视图解析器跳到指定的页面
- 页面：{视图解析器前缀}+viewName +{视图解析器后缀}
- 同上3.5

6.2、ServletAPI

通过设置ServletAPl，不需要视图解析器﹒
- 通过HttpServletResponse进行输出
- 通过HttpServletResponse实现重定向
- 通过HttpServletRequest实现转发

示例

@Controller
public class ModelTest1 {
    @RequestMapping( "/m1/t1")
    public String test1(HttpServletRequest req,HttpServletResponse resp){
        HttpSession session = req.getSession();
        session.setAttribute("msg","test1");
        return "test";
    }
    @RequestMapping( "/m1/t2")
    public void test2(HttpServletRequest req,HttpServletResponse resp) throws IOException {
        resp.getWriter().println("test2");
    }
    @RequestMapping( "/m1/t3")
    public void test3(HttpServletRequest req,HttpServletResponse resp) throws IOException {
        //重定向
        resp.sendRedirect("/index.jsp");
    }
    @RequestMapping( "/m1/t4")
    public void test4(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
        //转发
        req.setAttribute("msg","test4");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);

    }

}

6.3、SpringMVC

通过SpringMVC来实现转发和重定向

重定向，不需要视图解析器，本质就是重新请求一个新地方，所以注意路径问题.
可以重定向到另外—个请求实现

示例

@Controller
public class ModelTest2 {

    @RequestMapping("/m2/t1")
    public String test1(){
        //转发1：该情况会走视图解析器，报错：文.件[/WEB-INF/jsp/index.jsp.jsp] 未找到
        return "/index.jsp";
    }

    @RequestMapping("/m2/t2")
    public String test2(){
        //转发二：加forward:不走视图解析器，正常转发
        return "forward:/index.jsp";
    }

    @RequestMapping("/m2/t3")
    public String test3(){
        //重定向：加redirect:不走视图解析器，正常重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do 为另一个请求
    }
}

7、接收请求参数及数据回显

7.1、接收请求参数

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

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

处理方法︰

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端的参数为："+name);
        
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);

        //3.视图跳转
        return "test";
    }
}

后台输出: ping

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

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

处理方法∶

//@RequestParam("username"):username提交的域的名称

@GetMapping("/t2")
public String test2(@RequestParam("username") String name, Model model){
    System.out.println("接收到前端的参数为："+name);
    model.addAttribute("msg",name);
    return "test";
}

后台输出: ping

提交的是一个对象

要求提交的表单域和对象的属性名一致，参数使用对象即可
http://localhost:8080/user/t3?id=1&name=ping&age=20

实体类

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

处理方法

/*
    1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
    2.假设传递的是一个对象User，匹配User对象中的字段名:如果名字一致则OK，否则，匹配不到
    */
@GetMapping("/t3")
public String test3(User user){
    System.out.println(user);
    return "test";
}

7.2、数据回显到前端

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

8、过滤器解决乱码问题

以前乱码问题通过过滤器解决，而SpringMVC给我们提供了一个过滤器，可以在web.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>
    <url-pattern>/*</url-pattern>
</filter-mapping>

9、JSON讲解

9.1、什么是JSON

JSON(JavaScript Object Notation,JS对象标记)是一种轻量级的数据交换格式，目前使用特别广泛。
采用完全独立于编程语言的文本格式来存储和表示数据。
简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
在JavaScript语言中，一切都是对象。因此，任何JavaScript支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。看看它的要求和语法格式:
- 对象表示为键值对，数据由逗号分隔
- 花括号保存对象
- 方括号保存数组
JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异，建/值对组合中的键名写在前面并用双引号""包裹，使用冒号∶分隔，然后紧接着值

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

//这是一个对象，注意键名也是可以使用引号包裹的
var user ={
            name : "ping",
            age:3,
            sex:"男"
};
//这是一个JSON字符串，本质是一个字符串
var json = '{"name":"ping","age":3,"sex":"男"}'

9.2、JSON 和JavaScript对象互转

要实现从JavaScript对象转换为JSON字符串，使用JSON.stringify()方法:
```
var json = JSON.stringify(user);
```
要实现从JSON字符串转换为JavaScript对象，使用JSON.parse()方法:
```
var obj = JSON.parse(json);
```

完整js

<script type="text/javascript">
    //编写一个JavaScript对象
    var user ={
        name : "ping",
        age:3,
        sex:"男"
    };

    //将js对象转换为JSON字符串
    var json = JSON.stringify(user);
    console.log(json);

    //将JSON字符串转换为JavaScript对象
    var obj = JSON.parse(json);
    console.log(obj);

</script>

9.3、Controller返回JSON数据（Jackson）

Jackson应该是目前比较好的json解析工具；另外还有阿里巴巴的 fastjson等等。

使用Jackson，需要导入它的jar包

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.0</version>
</dependency>

代码测试

实体类User

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

UserController

@Controller//走视图解析器
public class UserController {

    @RequestMapping("/j1")
    @ResponseBody //配合@Controller使用，不会走视图解析器，会直接返回一个字符串
   
    public String json1() throws JsonProcessingException {
        //jackson, ObjectMapoper
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User("小明", 20, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

使用@RestController注解（相当于@Controller+ @ResponseBody）

@RestController //以下方法不走视图解析器，只会返回JSON字符串
public class UserController {
    
    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        //jackson, ObjectMapoper
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User("小明", 20, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

将上述代码中的公共部分提到工具类中

JsonUtils类

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();
        //使用ObjectMapper来格式化输出，不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);

        //自定义日期格式
        SimpleDateFormat sf = new SimpleDateFormat(dateFormat);

        mapper.setDateFormat(sf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        return null;
    }
}

测试

@RequestMapping("/j1")
public String json1() throws JsonProcessingException {
    User user = new User("小明", 20, "男");
    return JsonUtils.getJson(user);
}

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {

    List<User> userList = new ArrayList<User>();

    User user1 = new User("小明1", 20, "男");
    User user2 = new User("小明2", 20, "男");
    User user3 = new User("小明3", 20, "男");
    User user4 = new User("小明4", 20, "男");

    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);

    return JsonUtils.getJson(userList);
}

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {

    Date date = new Date();
    String json = JsonUtils.getJson(date);
    return json;
}

出现了乱码问题，需要设置一下它的编码格式为utf-8，以及它返回的类型;

方式一：通过@RequestMaping的produces属性来实现，修改下代码

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

方式二（推荐）：可以通过Spring配置统一指定，这样就不用每次都去处理了!
可以在springmvc的配置文件（springmvc-servlet.xml）上添加一段消息StringHttpMessageConverter转换配置

<!--JSON乱码问题配置-->
<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>

9.4、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字符串之间的相互转化。

代码示例

//fastjson
@RequestMapping("/j4")
public String json4(){

    User user = new User("小明", 20, "男");

    //Java对象 转 JSON字符串
    String s = JSON.toJSONString(user);

    //JSON字符串 转 Java对象
    User user1 = JSON.parseObject(s, User.class);

    //Java对象 转 JSON对象
    JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user);
    System.out.println(jsonObject1.getString("name"));

    //JSON对象 转 Java对象
    User user2 = JSON.toJavaObject(jsonObject1, User.class);

    return s;
}