SpringMVC

霍志杰

已于 2022-10-10 17:07:41 修改

阅读量6.4k

点赞数 1

分类专栏： java 文章标签： servlet java spring

于 2022-08-27 11:35:47 首次发布

本文链接：https://blog.csdn.net/weixin_51444308/article/details/126481520

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

SpringMVC

一、MVC

MVC模式（Model–view–controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。MVC模式的目的是实现一种动态的程式设计，使后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。

*模型（Model） - 程序员编写程序应有的功能（实现算法等等）、数据库专家进行数据管理和数据库设计(可以实现具体的功能)。
*视图（View） - 界面设计人员进行图形界面设计。
*控制器（Controller）- 负责转发请求，对请求进行处理。
在这里插入图片描述

二、servlet

*1.新建空工程，新建模块的时候，添加web框架支持。
*2.添加pom依赖
spring-webmvc
servlet-api
jsp-api
jstl

<!-- org.springframework/spring-webmvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.22</version>
    </dependency>
    <!-- artifact/jakarta.servlet/jakarta.servlet-api -->
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>5.0.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- artifact/jakarta.servlet.jsp/jakarta.servlet.jsp-api -->
    <dependency>
      <groupId>jakarta.servlet.jsp</groupId>
      <artifactId>jakarta.servlet.jsp-api</artifactId>
      <version>3.0.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- artifact/jakarta.servlet.jsp.jstl/jakarta.servlet.jsp.jstl-api -->
    <dependency>
      <groupId>jakarta.servlet.jsp.jstl</groupId>
      <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
      <version>3.0.0</version>
    </dependency>

*3.新建一个类去继承HttpServlet

@WebServlet("/tests")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取前段参数
        String method = request.getParameter("method");
        if (method.equals("add")) {
            request.getSession().setAttribute("msg","执行了add方法");
        }
        if (method.equals("delete")) {
            request.getSession().setAttribute("msg","执行了delete方法");
        }
        //2.调用业务层
        //3.视图转发或重定向
        request.getRequestDispatcher("/test.jsp").forward(request,response);
    }
}

*4.index页面提交表单数据

<html>
  <head>
    <title>index</title>
  </head>
  <body>
  <form action="/springmvc_01_servlet/tests" method="post">
    <input type="text" name="method">
    <input type="submit" value="tijaio">
  </form>
  </body>
</html>

*5.数据展示

<html>
<head>
    <title>Title</title>
</head>
<body>
	${msg}
</body>
</html>

三、SpringMVC

Spring MVC是一个基于Java的、实现了MVC设计模式的、请求驱动类型的—轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，高效开发。
Spring MVC 与许多其他 Web 框架一样，是围绕前端控制器模式设计的，该模型非常灵活，支持多种工作流程。（DispatcherServlet）

1.代码实现

- xml方式

*1.pom添加依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.22</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jsp-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
  </dependencies>

*2.web.xml中配置DispatchServlet（前端控制器）

	<servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--DispatcherServlet绑定spring的配置文件-->
<!--通过初始化参数指定SpringMVC配置文件的位置来进行关联-->
        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
<!--    /和/*的区别：
           /  只会匹配不包括jsp页面
           /* 匹配所有请求 包括jsp页面-->

所有请求过来先去DispatchServlet，通过DispatchServlet绑定的spring配置文件去找处理器映射器接着往下走。

*3.resource中新建spring的配置文件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"/>
<!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
<!--    BeanNameUrlHandlerMapping:bean-->
    <bean id="/hello" class="com.hdat.HelloController"/>
</beans>

配置处理器映射器，匹配地址为/hello的请求,通过处理器适配器映射到控制器，在控制器中得到视图名和请求数据，经视图解析器将视图名拼接为完整路径。

*4.控制器配置HelloController.java

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        //业务代码
        String result = "HelloSpringMVC";
        modelAndView.addObject("msg",result);
        //视图跳转
        modelAndView.setViewName("test");
        return modelAndView;
    }
}

*5.数据展示页面test.jsp

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

请求http://localhost:8088/springmvc_02_hellomvc/hello，经过处理，最终跳转到数据展示页面。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
注意点：
1.Tomcat现在还需要使用9版本
2.如果404，就去看看out里面是否有lib,如果没有，Project Structrue->Artifacts中手动加一下
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
原理图：
在这里插入图片描述

- 注解方式

**1.pom添加依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.22</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jsp-api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
  </dependencies>
  -------------------------------------------------------------------
	<resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>

**2.web.xml中配置DispatchServlet（前端控制器）

<servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--DispatcherServlet绑定spring的配置文件-->
<!--通过初始化参数指定SpringMVC配置文件的位置来进行关联-->
        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
<!--    /和/*的区别：
           /  只会匹配不包括jsp页面
           /* 匹配所有请求 包括jsp页面-->

所有请求过来先去DispatchServlet，通过DispatchServlet绑定的spring配置文件去找处理器映射器接着往下走。

**3.resource中新建spring的配置文件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.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.hdat.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

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

*自动扫描包，让指定包下的注解生效,由IOC容器统一管理
*让Spring MVC不处理静态资源 .css .js .mp4
*支持mvc注解驱动。在Spring中一般采用@RequestMapping注解来完成映射关系;要想使@RequestMapping注解生效，必须向上下文中注册DefaultAnnotationHandlerMapping和一个AnnotationMethodHandlerAdapter实例；这两个实例分别在类级别和方法级别处理。而annotation-driven配置帮助我们自动完成上述两个实例的注入。
*放到WEB-INF下面，外面不可以直接访问

**4.控制器配置HelloController.java

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model modle){
        modle.addAttribute("msg","hellospringmvc");
        return "jsp/test";//视图名
    }
    @RequestMapping("/hello2")
    public String hello2(Model modle){
        modle.addAttribute(
                "msg","hellospringmvc2");
        return "jsp/test2";
    }
}

*@Controller代表这个类会被spring接管，这个类中的所有方法，如果返回值是String，并且有具体页面可以跳转，就会被视图解析器解析
*jsp就是WEB-INF下面建的子文件夹，这样写，只要拖动文件，return的值就会跟着改变，不需要手动更改，jsp前面的/放到前缀中去，稳妥一点

**5.数据展示页面1-test.jsp

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

**6.数据展示页面2-test2.jsp

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

2.关于@RequestMapping注解

用于映射URL到控制器类或是特定方法。用于类和方法上。
*注解在方法上

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model modle){
        modle.addAttribute("msg","hellospringmvc");
        return "jsp/test";//视图名
    }
 }

访问路径：http://localhost:8088/springmvc_03_annotation/hello

*注解在方法和类上

@Controller
@RequestMapping("/admin")
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model modle){
        modle.addAttribute("msg","hellospringmvc");
        return "jsp/test";//视图名
    }
 }

访问路径：http://localhost:8088/springmvc_03_annotation/admin/hello

3.关于RESTful风格

RESTful(表现层状态转换)是一种万维网软件架构风格，目的是便于不同软件/程序在网络（例如互联网）中互相传递信息。需要注意的是，REST是风格而不是标准。REST模式与复杂的SOAP和XML-RPC相比更加简洁，越来越多的Web服务开始采用REST风格设计和实现. 特点:简洁高效安全

普通的写法

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

访问路径:http://localhost:8088/springmvc_03_annotation/add?a=1&b=2

REST

@RequestMapping("/add/{a}/{b}")
    public String test2(@PathVariable int a,@PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg",res);
        return "jsp/test";
    }

访问路径:http://localhost:8088/springmvc_03_annotation/add/1/2
使用@PathVariable 注解，可以让参数的值绑定到一个URI变量上。这样外面看不到参数名是什么，比较安全。

请求方法不同，访问的方法体就不同。可以通过method方法约束请求类型

@RequestMapping(value = "/add/{a}/{b}",method = {RequestMethod.GET})
    public String test3(@PathVariable int a,@PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg",res);
        return "jsp/test";
    }

或者使用注解

@GetMapping("/add/{a}/{b}")
    public String test4(@PathVariable int a,@PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg",res);
        return "jsp/test";
    }

如果两个同路径同类型的方法同时出现，就会报500错误。方法混淆，不知道访问哪个方法了。

4.关于重定向和转发

传统转发

@RequestMapping("/addsss")
    public void test8(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        request.setAttribute("msg","hello");
        request.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(request,response);
    }

转发可以访问WEB-INF下面的资源，因为转发是服务器内部跳转的。

传统重定向

@RequestMapping("/addss")
    public void test7(HttpServletRequest request, HttpServletResponse response) throws IOException {
        HttpSession session = request.getSession();
        session.setAttribute("msg","hello");
        response.sendRedirect(request.getContextPath()+"/index.jsp");
    }

重定向不能访问WEB-INF下面的资源，因为重定向相当于客户端访问，无法访问安全目录。

@RequestMapping(value = "/add/{a}/{b}",method = {RequestMethod.GET})
    public String test3(@PathVariable int a,@PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg",res);
        return "jsp/test";
    }

携带着数据，默认用的就是转发，如果使用视图解析器的话，只需要返回视图名即可

@RequestMapping(value = "/add/{a}/{b}",method = {RequestMethod.GET})
    public String test3(@PathVariable int a,@PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg",res);
        return "forward:/WEB-INF/jsp/test.jsp";
    }

如果不使用视图解析器，那就需要返回完整地址，forward只能在这个时候出现，有视图解析器的时候不能出现，否则会被拼接进去。

重定向

@RequestMapping("/adds")
    public String test6(Model model){
        return "redirect:index.jsp";
    }

使用重定向的话就要加上redirect:了，不论使用或不使用视图解析器。因为即便是使用视图解析器，也不会过视图解析器，redirect:也不会被拼接进去。

使用重定向访问WEB-INF安全目录下资源

@RequestMapping("/adds")
    public String test6(Model model){
        return "redirect:/tiao";
    }
@RequestMapping("/tiao")
    public String test9(Model model){
        return "/jsp/test";//存在视图解析器
    }

先重定向再转发

5.关于数据接收与响应

接收

@RequestMapping("/testmsg")
    public String test(@RequestParam("name") String name, Model model){
        System.out.println("从前端接收到的参数是:"+name);
        model.addAttribute("msg",name);
        return "/jsp/test";
    }

@RequestParam("name")可以写也可以不写，最好写上，可读性好。这是接收一个参数的情况。

@RequestMapping("/testmsg2")
    public String test2(User user, Model model){
        System.out.println(user);
        return "/jsp/test";
    }

如果接收的是一个对象，前端传的参数名要和实体类中属性名一致，否则返回null
现在请求http://localhost:8088/springmvc_03_annotation/testmsg2?id=1&name=hzj&age=21
打印:User(id=1, name=hzj, age=21)

响应

1.使用ModelAndView

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        //业务代码
        String result = "HelloSpringMVC";
        modelAndView.addObject("msg",result);
        //视图跳转
        modelAndView.setViewName("test");
        return modelAndView;
    }
}

2.使用Model

@Controller
public class UserController {
    @RequestMapping("/testmsg")
    public String test(@RequestParam("name") String name, Model model){
        System.out.println("从前端接收到的参数是:"+name);
        model.addAttribute("msg",name);
        return "/jsp/test";
    }
}

参数只要名字对应，可以自动获取

3.使用Mapping

@RequestMapping("/testmsg3")
    public String test3(@RequestParam("name") String name, Model model){
        System.out.println("从前端接收到的参数是:"+name);
        model.addAttribute("msg",name);
        return "/jsp/test";
    }

ModelMap 继承了LinkedMap,在实现自身一些方法的同时，也继承了LinkedMap的方法。

6.关于乱码问题

1.首先看一下tomcat里conf的servlet.xml是否配置了编码

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

2.使用SpringMVC的乱码过滤器
在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>

3.实在解决不了，尝试使用这个过滤器

package com.hdat.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * @ClassName: GenericEncodingFilter
 * @Author:
 * @Create: 2022/8/26 0026 18:54 Created with IntelliJ IDEA
 * @Description:解决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;
    }
}

web.xml

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

7.关于json的问题

- JavaScript中json的格式转换

<script type="text/javascript">
    //JavaScript对象
    var user = {
        name : "坏蛋阿土",
        age : 21,
        sex : "哈哈"
    };
    //转换为json对象
    var jsonstr = JSON.stringify(user);
    console.log(jsonstr);
    //转换为JavaScript对象
    var user2 = JSON.parse(jsonstr);
    console.log(user2);
</script>

JavaScript对象转换为json对象: JSON.stringify();
json对象转换为JavaScript对象: JSON.parse();

- Java中json的格式转换

jackson
添加pom依赖

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

@Controller

@RequestMapping("/router")
    @ResponseBody //就不走视图解析器了，只返回字符串
    public String json() throws JsonProcessingException {
        //jackson
        ObjectMapper objectMapper = new ObjectMapper();
        User user = new User("坏蛋阿土",21 );
        String s = objectMapper.writeValueAsString(user);
        return s;
    }

此时返回的json还会乱码

解决
方式一：每个controller都加编码

@RequestMapping(value = "/router",produces = "application/json;charset=utf-8")
    @ResponseBody //就不走视图解析器了，只返回字符串
    public String json() throws JsonProcessingException {
        //jackson
        ObjectMapper objectMapper = new ObjectMapper();
        User user = new User("坏蛋阿土",21 );
        String s = objectMapper.writeValueAsString(user);
        return s;
    }

produces = "application/json;charset=utf-8" 这样麻烦一点

方式二：在springmvc-servlet.xml中进行配置

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

统一解决

在类上面配置@RestController注解，类下面的方法就只会返回json字符串

@RestController
public class UserController {
    @RequestMapping("/router")
    public String json() throws JsonProcessingException {
        //jackson
        ObjectMapper objectMapper = new ObjectMapper();
        User user = new User("坏蛋阿土",21 );
        String s = objectMapper.writeValueAsString(user);
        return s;
    }
}

前后端分离，不需要视图解析器，就使用@RestController进行注解；@Controller会走视图解析器，@RestController不会走视图解析器，直接返回字符串

返回json集合

@RequestMapping("/router2")
    public String json2() throws JsonProcessingException {
        //jackson
        ObjectMapper objectMapper = new ObjectMapper();
        List<User> userList = new ArrayList<User>();
        User user = new User("坏蛋阿土",21 );
        User user2 = new User("坏蛋阿土2",22 );
        userList.add(user);
        userList.add(user2);
        String s = objectMapper.writeValueAsString(userList);
        return s;
    }

[{"id":0,"name":"坏蛋阿土","age":21},{"id":0,"name":"坏蛋阿土2","age":22}]

封装工具类JsonUtils

public class JsonUtils {
    public static String getJson(Object object){
        return JsonUtils.getJson(object,"yyyy-MM-dd HH:mm:ss");
    }
    public static String getJson(Object object,String dateFormat){
        ObjectMapper objectMapper = new ObjectMapper();
        //不使用时间戳
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        objectMapper.setDateFormat(sdf);
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
}

直接调用工具类即可

	@RequestMapping("/router3")
    public String json3() throws JsonProcessingException {
        Date date = new Date();
        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }
    @RequestMapping("/router4")
    public String json4() throws JsonProcessingException {
        User user = new User("坏蛋阿土",21 );
        return JsonUtils.getJson(user);
    }

fastjson
添加pom依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.12</version>
</dependency>

	    User user = new User("坏蛋阿土",21 );
        User user2 = new User("坏蛋阿土2",22 );
        //java对象->json字符串
        String s = JSON.toJSONString(user);
        System.out.println(s);
        //json字符串->java对象
        User jsonObject = JSON.parseObject(s,User.class);
        System.out.println(jsonObject.toString());
        //java对象->json对象
        JSONObject jso = (JSONObject)JSON.toJSON(user2);
        System.out.println(jso.toString());
        //json对象->java对象
        User jo = JSON.toJavaObject(jso,User.class);
        System.out.println(jo);

java对象->json字符串----JSON.toJSONString()
json字符串->java对象----JSON.parseObject()
java对象->json对象------JSON.toJSON()
json对象->java对象------JSON.toJavaObject()

最后感谢未曾相识的师父狂神说-秦疆！致敬

霍志杰

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringMVC

（Model–view–controller）是软件工程中的是实现一种，使后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。*- 程序员编写程序应有的功能（实现算法等等）、数据库专家进行数据管理和数据库设计(可以实现具体的功能)。*- 界面设计人员进行图形界面设计。*- 负责转发请求，对请求进行处理。.........
复制链接

扫一扫