学习Spring MVC

最新推荐文章于 2021-09-13 19:48:11 发布

Gitshile

最新推荐文章于 2021-09-13 19:48:11 发布

阅读量121

点赞数 2

文章标签： spring java

本文链接：https://blog.csdn.net/an760998254/article/details/114500534

版权

本文详细介绍了SpringMVC框架，包括其核心组件、执行原理、控制器实现、RESTful风格、数据处理、重定向、乱码问题解决及JSON数据返回。从配置版到注解版的SpringMVC程序示例，展示了如何创建和测试一个完整的SpringMVC应用，以及如何处理HTTP请求、数据绑定和视图解析。此外，还探讨了JSON数据的生成和处理，以及FastJSON库的使用。

摘要由CSDN通过智能技术生成

学习Spring MVC

一、什么是Spring MVC？

mvc是一种架构模式，不是设计模式。

Spring MVC是Spring Framework的一部分，是给予java实现mvc的轻量级web框架。

1.spring 组成？

model(模型)

数据模型，用于显示数据
实现业务逻辑

view(视图)：

显示页面

Controller(控制器)：

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

2.Spring特点？

轻量级，简单，高效
与Spring兼容性好
预定大于配置

注：Spring MVC的三大组件

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

3.Spring MVC执行原理

简要分析执行流程

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.1、使用Spring MVC步骤

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

3.2、第一个Spring MVC程序(配置版)

1.建立moudle,添加web支持！

2.导入相关依赖包

3.配置web.xml,注册DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    //注册DispatcherServlet
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        //关联一个Spring Mvc的配置文件springmvc-servlet.xml
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
//匹配请求
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

4.编写Spring MVC的配置文件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-3.0.xsd">
//添加 处理映射器
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
  //添加 处理器适配器  
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
// 添加 视图解析器
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    //将Hellocontroller提交spring容器
    <bean id="/hello" class="com.sun.controller.HelloController"/>

</beans>

5.编写操作业务Controller,实现Controller接口

public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg", "HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

6.编写jsp跳转页面，显示moudelandView存放的数据

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

7.启动tomcat测试

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

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

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5I9AP3qA-1615125817245)(C:\Users\拾忆\AppData\Roaming\Typora\typora-user-images\image-20210301111831133.png)]$
重启Tomcat 即可解决！

3.3、第二个pring MVC程序（使用注解）

1.建立moudle,添加web支持！

2.导入相关依赖包

3.配置web.xml,注册DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

4.编写Spring MVC的配置文件springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    https://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.sun.controller"/>
    <mvc:default-servlet-handler />
    <mvc:annotation-driven />

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

5.创建Controller

@Controller
public class HelloController {
    @RequestMapping("/h1")
    public String major(Model model){
        model.addAttribute("msg","hello,Study Spring Mvc annotation");
        return "hello";
    }
}

6.创建视图层

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

7.启动tomcat测试

二、Controller以及RestFul风格

2.1Controller接口实现

Controller是一个接口，在org.springframework.web.servlet.mvc包下
控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
控制器负责解析用户的请求并将其转换为一个模型。

案例测试：

注：在已经注册web.xml下的DispatcherServlet，和Spring MVC的配置文件springmvc-servlet.xml基础上进行

1.新建一个Controller**类

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

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

public class ControllerTest01 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg","测试trollertest01");
        modelAndView.setViewName("test");
       //返回的是模型视图对象
        return modelAndView;
    }
}

2.在Spring中注册bean，需要用name,和class属性，name对应请求的路径，class对应请求的类

<bean name="/t1" class="com.sun.controller.ControllerTest01"/>

3.编写前端jsp代码，对应视图解析器

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

4.启动tomcat

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

Controller接口实现的缺陷：

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

2.2 使用注解@Controller

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

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

1.新建一个ControllerTest02类

@Controller
public class ControllerTest02 {
    @RequestMapping("/t2")
    public String  test02(Model model){
    //Spring mvc自动生成Model对象向视图传值
        model.addAttribute("msg","测试Controller02");
       //返回视图位置
        return "test";
    }
}

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法,可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。例如：访问路径：http://localhost:8080 / 项目名 / h1

2.启动Tomcat

2.3 RestFul 风格

1.什么是Restful风格？

REST是英文representational state transfer(表象性状态转变)或者表述性状态转移;
Rest是web服务的一种架构风格;使用HTTP,URI,XML,JSON,HTML等广泛流行的标准和协议;
轻量级,跨平台,跨语言的架构设计，更易于实现缓存等机制;
它是一种设计风格,不是一种标准,是一种思想

2.Restful功能体现？

资源（Resources）

资源：就是网络上的一个实体，或者说是网络上的一个具体信息。例如：一张图片，一种服务，用一个URI（统一资源标识符）指向它，每种资源对应一个特定的URI。获取这个资源，访问它的URI就可以获得。

表现层（Representation）

表现层：“资源"具体呈现出来的形式，叫做它的"表现层”，例如：文本可以用txt格式表现，也可以用HTML格式等。

状态转化（State Transfer）

状态转化：如果客户端想要操作服务器，必须通过某种手段，让服务器端发生"状态转化"（State Transfer）。而这种转化是建立在表现层之上的，所以就是"表现层状态转化"。

资源方式对比：

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

实现案例：

1.编写一个测试类RestFulController

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {
 @RequestMapping("/t3/{a}/{b}")
    public String test03(@PathVariable int a, @PathVariable int b, Model model){
        int sum = a + b;
        model.addAttribute("msg","结果为："+sum);
        return "test";
    }
}

@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。例如：@RequestMapping("/t3/{a}/{b}")

2.启动tomcat

在这里插入图片描述

使用method属性指定请求类型

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

案例：

1.新增一个方法类，指定method为post方式，

@Controller
public class ControllerTest04 {
    @RequestMapping(value = "/t4",method = {RequestMethod.GET})
    public String Test04(Model model){
        model.addAttribute("msg","hello model!");
        return "test";
    }

}

2.启动tomcat

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

出错原因：

使用浏览器地址栏进行访问默认是Get请求，会报错405，将POST修改为GET则正常了

@Controller
public class ControllerTest04 {
    @RequestMapping(value = "/t4",method = {RequestMethod.GET})
    public String Test04(Model model){
        model.addAttribute("msg","hello model!");
        return "test";
    }

}

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

总结：Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH，指定方法的注解如下：

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

三、数据处理以及重定向

转发和重定向本质就是根据路径请求新地址，最终将地址页面呈现个用户。

3.1、转发和重定向（一般实现）

需要导入视图解析器，通过设置ModelAndview对象，根据view的名称 , 视图解析器将跳转到指定的页面 .

<!--将Hellocontroller提交spring容器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

编写Controllel类

public class ControllerTest01 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg","测试trollertest01");
        modelAndView.setViewName("test");
        return modelAndView;
    }
}

//编写对应的Servlet类，实现页面的转发以及重定向
@Controller
public class ResultGo {
    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.getWriter().println("hello servlet!");
    }
    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.sendRedirect("/index.jsp");
    }
    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest request, HttpServletResponse response) throws Exception {

    request.setAttribute("msg","hello ServletTest03");
    request.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(request,response);
    }
}

3.2、转发和重定向（Spring MVC实现）

无需视图解析器，但是在测试前，需要注释视图解析器

@Controller
public class ResultSpringMVC {
@RequestMapping("/ServletTest01")
    public String test(Model model){
    model.addAttribute("msg","不需要通过forward属性实现页面转发");
        return "/WEB-INF/jsp/test.jsp";
    }
    @RequestMapping("/ServletTest02")
    public String test02(Model model){
    model.addAttribute("msg","通过forward属性实现页面转发");
    return "forward:/WEB-INF/jsp/test.jsp";
    }


    @RequestMapping("/ServletTest03")
    public String test03(){
        return "redirect:/index.jsp";
    }
}

重新加载tomcat

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

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

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

3.3 处理数据

需要重新导入视图解析器

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

提交数据请求网址：http://localhost:8080/USerTest01?name=date

编写方法：

@Controller
public class UserController {
    @RequestMapping("/USerTest01")
    public String UserTest(String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端参数为："+name);
        //2.将返回结果传递前端
        model.addAttribute("msg",name);
        return "test";
    }
}

在这里插入图片描述

2.提交的名称和出库请求的方法不一致（引入@RequestParam实现）

@Controller
public class UserController {
    @RequestMapping("/USerTest01")
    public String UserTest(@RequestParam("username") String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端参数为："+name);
        //2.将返回结果传递前端
        model.addAttribute("msg",name);
        return "test";
    }

3.提交的是对象

使用注解前需要导入Lombox依赖

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>

1.编写实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private String id;
    private int age;
}

2.实现类
@RequestMapping("/USerTest02")
public String UserTest02(User user,Model model){
    model.addAttribute("msg",user);
    System.out.println(user);
      return "test";
}

3.提交数据
在这里插入图片描述

3.4 将数据显示到前端

1、通过ModelAndView实现

//1.通过ModelAndView实现
@RequestMapping("/USerTest03")
public ModelAndView modelAndView(HttpServletRequest request, HttpServletResponse response){
        ModelAndView view = new ModelAndView();
        view.addObject("msg","通过ModelAndView返回结果");
        view.setViewName("test");
        return view;//返回一个模型对象
    }

2.通过ModelMap

@RequestMapping("/USerTest04")
public String UserTest03(@RequestParam("username") String name, ModelMap model){
    model.addAttribute("name",name);
    System.out.println(name);
    return "test";
}

3.通过Model

 @RequestMapping("/USerTest02")
public String UserTest02(User user,Model model){
    model.addAttribute("msg",user);
    System.out.println(user);
      return "test";
}

ModelMap、Model、ModelAndView 区别：

public class ModelMap extends LinkedHashMap

public interface Model

四、Spring MVC处理乱码问题

1、法一：在web.xml中配置过滤器

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

2.修改tomcat配置文件

在server.xml中配置

 <Connector executor="tomcatThreadPool"
           port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
		   URLEncoding="UTF-8"/>

3.自定义过滤器

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 {

   @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;
  }

   // 对需要增强方法 进行覆盖
   @Override
   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;
  }
}

五、Spring MVC返回JSON数据

1.什么是JSON？

JSON 是一种轻量级的数据交换格式
采用文本格式来存储和表示数据。

2.json语法规则

JSON 语法是 JavaScript 对象表示法语法的子集。

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

3.json与javascript关系？

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

var obj = {a: 'Hello', b: 'World'}; //这是一个JavaScript对象
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

4、JSON 和 JavaScript 对象互转

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

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

结果：

 {a: 'Hello', b: 'World'}

2.JavaScript 对象转换为JSON字符串，使用 ==JSON.stringify()==方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});

结果：

 '{"a": "Hello", "b": "World"}'

案例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<title>Title</title>
<meta charset="UTF-8">
<title>JSON使用</title>
</head>
<body>

<script type="text/javascript">
    var student = {
        name:"张三",
       major:"computer",
    };
    var str = JSON.stringify(student);
    console.log(str);
    var student1 = JSON.parse(str);
    console.log(student1.name,student1.major);

</script>

</body>
</html>

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

5、常见的json技术类型

json-lib：在早使用的json解析工具，缺点就是依赖很多的第三方包，此外，对于复杂类型的转换有一定的缺陷，例如：json-lib对于json转换成Bean有缺陷。
Jackson：开源的Jackson是Spring MVC内置的JSON转换工具，相比json-lib框架，jackson所依赖的jar包更少。简单且性能高。但是Jackson对于json转换成Bean也有缺陷，从Bean转换到JSON,转换的json格式不是标准的json格式。
Gson：Gson是当前功能最全的json解析器，最初是由Google研发的。
FastJson：FastJson是一个用java语言编写的高性能的json处理器，由阿里巴巴开发，特点是无依赖，不需要额外的jar文件，能够直接在jdk运行。

5.Controller返回JSON数据

以引入jackson为例

导入依赖包

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

配置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">
    - 注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个Spring Mvc的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--匹配请求-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <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/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    https://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.sun.controller"/>
    <mvc:default-servlet-handler />
    <mvc:annotation-driven />

    <!--将Hellocontroller提交spring容器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

1，编写实体类User

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private  String  name;
    private String major;
    private String emil;
}

2.编写Controller进行测试

方法一：导入**@RestController**，将对象转换成json格式并返回,（==注意：==需同时导入@Controller和@RestController）
方法二：在类上直接使用 @RestController，此时里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody 。

@Controller
@ResponseBody
public class UserController {
    @RequestMapping("/jsonTest")
    public String userTest() throws JsonProcessingException {
        //创建json对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        // 创建对象
        User user = new User("Gitshile","软件工程","523434@qq.com");
        //将对象解析成json格式
        String jsonUser = mapper.writeValueAsString(user);
        return jsonUser;
    }
}

3.启动tomcat,出现乱码

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

4.解决乱码

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

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

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

5.上述乱码解决方法有局限性，需要为每一个方法前设置编码格式，因此，可以在Spring MVC配置文件上统一解决

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

使用List测试

@RequestMapping(value = "/jsonTest02")
public String userTest02() throws JsonProcessingException {
    //创建json对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    // 创建对象
    List<User> user = new ArrayList<User>();
    User user1 = new User("Gitshile01","软件工程","523434@qq.com");
    User user2 = new User("Gitshile02","软件工程","523434@qq.com");
    User user3 = new User("Gitshile03","软件工程","523434@qq.com");
    User user4 = new User("Gitshile04","软件工程","523434@qq.com");
    user.add(user1);
    user.add(user2);
    user.add(user3);
    user.add(user4);

    //将对象解析成json格式
    String jsonUser = mapper.writeValueAsString(user);
    return jsonUser;
}

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

输出时间对象

//时间戳形式体现
@RequestMapping(value = "/jsonTest03")
public String userTest03() throws JsonProcessingException {

    //创建json对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
  //创建时间对象
    Date date = new Date();
    //将时间对象解析层json格式,并返回
    String datejson = mapper.writeValueAsString(date);
    return datejson;
}
//自定义时间格式
@RequestMapping(value = "/jsonTest04")
public String userTest04() throws JsonProcessingException {
    //创建json对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    //创建时间对象
    mapper.configure(SerializationFeature.CLOSE_CLOSEABLE,false);
    //定义时间格式
    SimpleDateFormat timeZone = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    mapper.setDateFormat(timeZone);
    Date date = new Date();
    String datejson = mapper.writeValueAsString(date);
    return datejson;
}

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

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

6.FastJSON使用

fastjson用于将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。

导入依赖

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

将 Java 对象转换换为 JSON 对象: JSON.toJSON（)
Java 对象转换为 JSON字符串:JSON.toJSONString()
JSON字符串转换为java对象:JSON.parseObject()
将JSON 对象转换换为 java 对象：JSON.toJavaObject()

JSONField与JSONType注解的使用

fastjson提供了JSONField对序列化与反序列化进行定制，比如可以指定字段的名称，序列化的顺序。JSONField用于属性，方法方法参数上。

Gitshile

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫