SpringMVC学习笔记

最新推荐文章于 2024-01-04 21:18:27 发布

Forever-0928

最新推荐文章于 2024-01-04 21:18:27 发布

阅读量679

点赞数

分类专栏： Spring 文章标签： springmvc

本文链接：https://blog.csdn.net/RenBoQing_1314/article/details/119864154

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringMVC

1.回顾MVC

1.什么是MVC

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

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

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

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

Model**（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或

JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层

（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。**

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

Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型

数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-exB9Ul6G-1629686073466)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710154733525.png)]

2.Mode1时代

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OcHgUbAX-1629686073468)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710154816604.png)]

3.Model2时代

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kToAmddE-1629686073470)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710154859110.png)]

职责分析

Controller**：控制器**

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

Model**：模型**

业务逻辑
保存数据的状态

View**：视图**

显示页面

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

4.Servlet回顾

1.新建maven工程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ufGXBJij-1629686073472)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710160457668.png)]

2.导入项目公共依赖

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1MeI7Z3K-1629686073474)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710160902239.png)]

4.导入servlet 和 jsp 的 jar 依赖

 <!--     导入子项目本身的依赖-->
    <dependencies>
        <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>
    </dependencies>

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

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.提交到Service层

//        3.转发或重定向页面
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
}

6.编写test.jsp

%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>显示页</title>
</head>
<body>
<%--打印对应的数据--%>
${msg}
</body>
</html

6.web.xml编写

 <servlet>
<!--        这里的servlet-name随便  但是建议本身的Servlet名称开头字母小写-->
        <servlet-name>helloServlet</servlet-name>
<!--        全类名的配置-->
        <servlet-class>com.study.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
<!--        这里的servlet-name和上面的一样-->
        <servlet-name>helloServlet</servlet-name>
<!--        访问路径 但是建议本身的Servlet名称开头字母小写-->
        <url-pattern>/helloServlet</url-pattern>
    </servlet-mapping>

7.配置Tomcat，启动测试

localhost:8080/SpringMVC_01_servlet/helloServlet?method=add

5.MVC框架职责

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

6.说明

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见

前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM

等等

2.SpringMVC

1.概念

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Hu3w7iu-1629686073475)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710162223442.png)]

2.SpringMVC特点

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

Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。
DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的
用户可以采用基于注解形式进行开发，十分简洁；
正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于
配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦
截器 等等......所以我们要学习

3.中心控制器

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NOjwYex7-1629686073476)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710165150431.png)]

SpringMVC的原理如下图所示：

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制

器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图

渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vRQGQpqJ-1629686073477)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710165214378.png)]

4.SpringMVC执行原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mK3cnIvF-1629686073478)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710165251091.png)]

1.简要分析执行流程

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

DispatcherServlet接收请求并拦截请求。

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

如上url拆分成三部分：

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

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

hello表示控制器

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

2.HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据

请求url查找Handler。

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

为：hello。

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

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

6.Handler让具体的Controller执行。

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

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

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

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

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

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

在这里先听一遍原理，不理解没有关系，我们马上来写一个对应的代码实现大家就明白了，如果不明

白，那就写10遍，没有笨人，只有懒人

5.HelloSpringMVC

1.新建maven项目，导入依赖，添加框架支持

2.配置web.xml(DispatcherServlet)

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

3.编写SpringMVC 的配置文件(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"> </beans>

4.添加处理映射器与适配器

    <!--    1.添加 处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--    2.添加 处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter "/>

5.添加视图解析器

<!--    3.配置视图解释器-->
    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"             id="InternalResourceViewResolver">
        <!--前缀   这里前缀的value是从web层的目录开始算起的-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀 表示以什么样的文件后缀结束-->
        <property name="suffix" value=".jsp"/>
    </bean>

6.编写我们要操作业务Controller ，要么实现Controller接口返回对应的vew

public class HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        //封装对象，放在ModelAndView中。  Model  前面的参数是变量 后面的是对应的值
    mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中 这里的setViewName直接些对应的jsp文件名称就可以啦
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
         return mv;
    }
}

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

<!--Handler  这里的id就在地址栏里面访问的id  后面是对应的controller的类 这里的id一般和实现类的setViewName（）中的名称相同-->
    <bean id="/hello" class="com.study.controller.HelloController"/>

8.编写接受数据的页面（jsp）

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

9.测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z5YE6mTq-1629686073479)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210710195119326.png)]

6.使用注解开发

1.新建maven项目，导入依赖，添加框架支持，添加jar包

2.编写web.xml配置文件

<!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet
        </servlet-class> 
        <!--2.通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--3. 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

3.编写springmvc—servlet.xml

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

4.编写Controller ，使用注解

@Controller  //相当于实现了接口
public class HelloController {
//    http://localhost:8080/springmvc_04_annotation/hello(就是对应的后面的访问名)
    @RequestMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("msg", "hello Spring MVC 使用注解开发 ");
//        需要返回的对应的jsp页面    Spring会自动寻找对应问价下的jsp文件
        return "hello";
    }
}

5.接受数据jsp页面编写

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

6.测试

7.Controller接口实现

Controller**(控制器)**

1.控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。

2.控制器负责解析用户的请求并将其转换为一个模型。

3.在Spring MVC中一个控制器类可以包含多个方法

4.在Spring MVC中，对于Controller的配置方式有很多种

1.新建一个Moudle，springmvc-04-controller ，mvc的配置文件只留下视图解析器！

2.Controller类的编写，ControllerTest

public class ControllerTest implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest,                       HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "Controller简介");
        mv.setViewName("test");
        return mv;
    }
}

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

     <!--    使用Controller配置bean-->
    <bean id="/test1" class="com.study.controller.ControllerTest"/>

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title> 数据接受页面</title>
</head>
<body>
${msg}
</body>
</html>

5.配置tomocat运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tDUM6grC-1629686073480)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711193608586.png)]

6.说明

实现接口Controller定义控制器是较老的办法

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

较麻烦；

8.使用Controller注解

1.@Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注

解）；

Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的

2.控制器，需要在配置文件中声明组件扫描。

1.在springmvc—servlet.xml添加包结构扫描

    <!-- 1.自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.study.controller"/>
    <!-- 2.让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler/>
    <!-- 3.支持mvc注解驱动 在spring中一般采用@RequestMapping注解来完成映射关系
    要想使@RequestMapping注解生效 必须向上下文中注册DefaultAnnotationHandlerMapping
    和一个AnnotationMethodHandlerAdapter实例 这两个实例分别在类级别和方法级别处理。
    而annotation-driven配置帮助我们自动完成上述两个实例的注入。 -->
    <mvc:annotation-driven/>

2.新建实现类（使用注解）

//使用Controller注解开发
    @Controller
public class ControllerTest1 {
//    使用RequestMapping来映射访问路径
    @RequestMapping("/test")
    public String index(Model model){
         model.addAttribute("msg","这个是使用注解进行开发的RequestMapping");
        return "test";
    }

}

3.运行Toco测试

9.RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。

用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

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

1.只注解在方法上面

@RequestMapping("/test")
    public String index(Model model){
         model.addAttribute("msg","这个是使用注解进行开发的RequestMapping");
        return "test";
    }

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

2.同时注解类与方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XuRAHMWT-1629686073481)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711201353184.png)]

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

10.RestFul 风格

1.概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设

计的软件可以更简洁，更有层次，更易于实现缓存等机制。

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.学习测试

1.新建RestFulController类

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

上

@Controller  //使用注解开发
public class RestFulController {
    @RequestMapping("/commit/{p1}/{p2}")//设置访问的路径{p1}{p2}为参数的格式
    public String index(@PathVariable int p1,@PathVariable int p2, Model model){
        //这样是@PathVariable设置参数的个数以及参数的类型
       int result=p1+p2;
       model.addAttribute("msg","结果为"+result);
        return "test";
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T5LTkIAZ-1629686073481)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711203646850.png)]

2.优点

使路径变得更加简洁；

获得参数更加方便，框架会自动进行类型转换。

通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这

里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XNkVqhFp-1629686073482)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711204516514.png)]

3.修改参数类型

@Controller
public class RestFulController {
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable String p2, Model model) {
        String result = p1 + p2;
        model.addAttribute("msg", "结果为" + result);
        return "test";
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kWmEGOva-1629686073483)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711204722473.png)]

4.使用method属性指定请求类型

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

PATCH, DELETE, TRACE等

我们来测试一下：

1.新增加方法

//    修改提交的方式
    @RequestMapping(value = "/commit/{p1}/{p2}",method = RequestMethod.POST)
    public String method(@PathVariable int p1, @PathVariable int p2,Model model){
        int result = p1 + p2;
        model.addAttribute("msg", "结果是"+result);
        return "test";
    }
}

2.修改请求方式

 @RequestMapping(value = "/commit/{p1}/{p2}",method = RequestMethod.POST)

3.测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kpUJaiXW-1629686073484)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711210430434.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CDYghRqR-1629686073484)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711210448185.png)]

4.总结

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

及 PATCH。

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

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

@GetMapping
@PostMapping
@PutMapping 
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解

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

平时使用的会比较多！

5.小黄鸭调试法

场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时

候就在我们解释的过程中自己却想到了问题的解决方案，然后对方却一脸茫然。

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

留下一脸茫然的你。

其实上面两种场景现象就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它

是我们软件工程中最常使用调试方法之一。

11.结果跳转方式

1.ModelAndView

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

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

1.视图解析器

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

2.对应的类

@Controller
public class RestFulController {
    //Rest风格
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable String p2, Model model) {
        String result = p1 + p2;
        model.addAttribute("msg", "结果为" + result);
        return "test";
    }

2.ServletAPI

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

1.通过HttpServletResponse进行输出

2.通过HttpServletResponse实现重定向

3.通过HttpServletResponse实现转发

@Controller
public class ModelTest {
    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().println("hello Spring By Servlet API");

    }
    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.sendRedirect("/springmvc_05_controller/index.jsp");
    }
    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        req.setAttribute("msg","result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req, resp);
    }

}

4.测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T007CEN2-1629686073485)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711225751920.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TOgKHcXV-1629686073486)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711225802375.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1GfhRcee-1629686073488)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210711225817063.png)]

3.使用SpringMVC实现重定向和转发

1.无需视图解释器

@Controller
//这个不需要视图解释器  都会挑转到对应的
public class ResultSpringMVC {
    @RequestMapping("res/t1")
    public String test(){
//        转发
        return "/index.jsp";
        //会访问web下的index.jsp 但是地址栏不会发生改变
    }
    @RequestMapping("res/t2")
    public String temp(){
        //转发二
        return "forward:/index.jsp";
         //会访问web下的index.jsp  但是地址栏不会发生改变
    }
    @RequestMapping("res/t3")
    public String test2(){
//        重定向
        return "redirect:/index.jsp";
        //会访问web下的index.jsp  但是地址栏会发生改变
    }
}

2.需视图解释器(建议使用)

 <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 ResultSpringMVC2 {
    //    1.转发
    @RequestMapping(value = "/def/t1")
    public String test1() {
        //转发 return "test";
        return "test";
    }

    //       2.重定向
    @RequestMapping(value = "/def/t2")
    public String test2() {
        return "redirect:/index.jsp";
    }
}

12.数据处理

1.处理提交数据

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

提交域名：http://localhost:8080/springmvc_05_controller/user/u1?name=renboiqng

 @RequestMapping("/user/u1")
//    当地址栏输入的参数和处理方法的参数相同时
    public String test1(String name){
        System.out.println(name);
        return "test";
    }

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

提交域名：http://localhost:8080/springmvc_05_controller/user/u2?username=renboiqng

  @RequestMapping("/user/u2")
//    当地址栏输入的参数和处理方法的参数不相同时
// 建议：无论参数名称与方法名称是否相同 都加上@RequestParam（）注解
    public String test2(@RequestParam("username") String name){
        System.out.println(name);
        return "test";
    }
}

3.提交的是一个对象

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

提交域名：http://localhost:8080/springmvc_05_controller/user/u3?name=renboqing&age=22&id=21

 @RequestMapping("/user/u3")
    public String test3(User user){
        System.out.println(user.toString());
        return "test";
    }

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

2.数据显示到前端

1.使用ModelView

@Controller
public class RestFulController {
    //Rest风格
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable String p2, Model model) {
        String result = p1 + p2;
        model.addAttribute("msg", "结果为" + result);
        return "test";
    }
//    修改提交的方式
    @RequestMapping(value = "/commit/{p1}/{p2}",method = RequestMethod.POST)
    public String method(@PathVariable int p1, @PathVariable int p2,Model model){
        int result = p1 + p2;
        model.addAttribute("msg", "结果是"+result);
        return "test";
    }
}

2.使用ModelMap

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

3.使用ModelAndView(不建议使用)

public class ControllerTest implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "Controller简介");
        mv.setViewName("test");
        return mv;
    }
}

4.对比

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

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

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档**

永远是最好的教程。

13.乱码问题

1.表单提交

<html>
<head>
    <title>表单页面</title>
</head>
<body>
<%--这里需要注意，这里面需要对应的项目路径 如果直接使用的话  是对应的localhost8080：后面（需要打带上对应的项目名称）--%>
<form action="${pageContext.request.contextPath}/e/t" method="post">
    <input type="text" name="name">
    <input type="submit">

</form>
</body>
</html>

2.Controller编写

public class EncodingController {
//      这个方法发 前面是视图，后面是对应的参数
    @RequestMapping("/e/t")
    public String encodingString(Model model,String name){
        System.out.println(name);
        model.addAttribute("msg",name);
        return "test";
    }

3.配置tomocat测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPUhLsC7-1629686073489)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712143431980.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-89plSEqu-1629686073489)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712143444474.png)]

4.配置SpringMVC的过滤器(web.xml)

<!--    4.配置过滤器-->
    <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>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GDCmjy5v-1629686073490)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712144809569.png)]

5.修改tomcat配置文件

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

6.自定义过滤器

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

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

**解决了！**然后在web.xml中配置这个过滤器即可！****乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

14.JSON

1.概念

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广

泛。

采用完全独立于编程语言的文本格式来存储和表示数据。

简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。

易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率

2.语法格式

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例

如字符串、数字、对象、数组等。看看他的要求和语法格式：

1.对象表示为键值对，数据由逗号分隔

2.花括号保存对象

3.方括号保存数组

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

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

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

串。

   <script type="text/javascript">
            var user = {
                name: " 任柏庆",
                age: 20,
                sex: "男"
            };
         var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个 字符串
        </script>

1.将js对象转化为json对象

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

2.将json对象转为js对象

          //将json转化为javaScript对象
            var obj=JSON.parse(json);

3.测试

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yy6LrXWS-1629686073491)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712154942081.png)]

3.Controller返回JSON数据

1.新建模块，导入项目依赖，添加web框架支持

2.导入Jackson的项目依赖

  <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson- core -->
        <!--        jackson 的项目依赖-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>

3.配置web.xml

<!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <!--2.通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--3. 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--    4.配置过滤器-->
    <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>

4.配置springmvc-servlet.xml

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

5.实体类

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

6.Controller类

1.直接返回对象

@Controller
public class UserController {
    //     使用这个注解以后 不会走视图解析器
//    方式一
    @ResponseBody
    @RequestMapping("/j1")
    public String json1() {
        User user = new User("大数据", 20, "男");
        String s = user.toString();
        return s;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LlRR4STc-1629686073492)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712180322624.png)]

2.使用jackson返回

 @ResponseBody
    @RequestMapping("/j2")
//    使用jackson将Java对象转化为json
    public String json2() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        User user = new User("大数据", 20, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p3JAzlRX-1629686073492)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712190631328.png)]

3.乱码问题

1.使用@RequestMapping注解开发

@RequestMapping(value = "/j2",produces = "application/json;charset=utf-8")

2.乱码统一解决

在springmvc-servlet.xml配置

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

3.返回json字符串统一解决

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

4.输出集合对象

//    返回的值为集合的形式
    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        String str = mapper.writeValueAsString(list);
        return str;
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ahLw4Jzl-1629686073493)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712193919925.png)]

5.输出时间对象

1.使用时间戳的方式

 //    返回时间类型
    @RequestMapping("/j4")
    public String json4() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        //创建时间一个对象，java.util.Date
        Date date = new Date();
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(date);
        return str;
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U8fRrUrH-1629686073494)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712204153774.png)]

2.不使用时间戳

    @RequestMapping("/j5")
    public String json5() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
//        不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式对象
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//         指定日期的格式
        mapper.setDateFormat(df);
        Date date = new Date();
        String str = mapper.writeValueAsString(date);
        return str;
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p0ZbpMhk-1629686073494)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712204935401.png)]

3.封装工具类

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();
        //不使用时间差的方式
        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;

    }
}

@RequestMapping("/j4")
    public String json4() throws JsonProcessingException {
        Date date = new Date();
//        直接使用工具类
        return JsonUtils.getJson(date);

    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ajxe4690-1629686073495)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712205825181.png)]

6.使用FastJson返回

项目依赖

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zkv9QyJ8-1629686073496)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210712212614824.png)]

public String json6() {
        //创建一个对象 
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>" + str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>" + str2);
        System.out.println("\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 "";

<version>1.2.60</version>
    </dependency>


[外链图片转存中...(img-zkv9QyJ8-1629686073496)]

`````java
public String json6() {
        //创建一个对象 
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>" + str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>" + str2);
        System.out.println("\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 "";

Forever-0928

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC学习笔记

SpringMVC1.回顾MVC1.什么是MVCMVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。是将业务逻辑、数据、显示分离的方法来组织代码。MVC主要作用是降低了视图与业务逻辑间的双向偶合。MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。Model**（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或 JavaBean组件（包含数据和行为），不过现在一般都分离开来：Val
复制链接

扫一扫