SpringMVC---初识、Restful风格、JSON

已于 2023-10-26 10:27:25 修改
阅读量637 收藏
点赞数 2
分类专栏： java 文章标签： java mvc spring json
于 2022-03-07 18:05:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47840823/article/details/123335395
版权

1.MVC

1.1MVC概念：

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

 
三层：

  • Model（模型）：数据模型，包含数据和行为，一般都分离开来即 Value Object（数据Dao）和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

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

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

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

 
发展：

  • 在web早期的开发中，通常采用的都是Model1，主要分为两层，视图层和模型层。
  • Model2把一个项目分成三部分，包括视图、控制、模型。过程如下：
    1. 用户发请求
    2. Servlet接收请求数据，并调用对应的业务逻辑方法
    3. 业务处理完毕，返回更新后的数据给servlet
    4. servlet转向到JSP，由JSP来渲染页面
    5. 响应给前端更新后的页面

拓展：

实体类：pojo    有20个字段
但是我们设置一个登录界面，只需要用户名和密码两个字段，因此封装一个新的实体类叫vo
控制层的叫dto

常见的服务器端MVC框架有：Struts、SpringMVC、ASP.NET MVC、Zend Framework、JSF
常见前端MVC框架：vue、angularjs、react、backbone
由MVC演化出了另外一些模式如：MVP、MVVM 等等

面试：你的项目结构是设计好的，还是演进的？（答：演进的）

 

1.2回顾servlet

  1. 新建一个Maven工程当做父工程，导入pom依赖！

    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.1</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

  2. 建立子项目， 添加Web app的支持

    在这里插入图片描述
    在这里插入图片描述

  3. 编写一个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.调用业务层
        //3.转发和重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

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

  4. 编写test.jsp，在WEB-INF目录（安全性高）下新建一个jsp的文件夹，新建jsp文件

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

  5. 在web.xml中注册Servlet

    <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>moli.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    <!--session超时时间-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
    <!--欢迎页-->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

  6. 配置Tomcat，并启动测试成功

在这里插入图片描述

 
 

2.springMVC

官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/web.html

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

Spring MVC的特点：

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

 

2.1mvc原理

在这里插入图片描述

  • Spring的web框架围绕DispatcherServlet（调度Servlet ）设计，又叫前置控制器，是整个SpringMVC的控制中心。DispatcherServlet的作用是将请求分发到不同的处理器。
  • Spring MVC 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

 

原理图：

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

  • http://localhost:8080服务器域名
  • SpringMVC是部署在服务器上的web站点
  • hello表示控制器

即url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

在这里插入图片描述

实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

执行流程:

  1. 用户发出请求，DispatcherServlet接收并拦截请求。
  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. 最终视图呈现给用户。

 

2.2第一个MVC程序

2.2.1配置版

真实开发并不会这么写，这么写是为了理解原理！

  1. 配置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>

  2. 编写SpringMVC 的 配置文件：springmvc-servlet.xml ------官方要求名字 [servletname]-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"/>
    <!--添加 视图解析器-->
    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

  3. 编写我们要操作业务Controller

    //注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //1.业务代码
        //封装对象，放在ModelAndView中
        mv.addObject("msg","HelloSpringMVC!");
        //2.视图跳转
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

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

    <bean id="/hello" class="moli.controller.HelloController"/>

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

    <body>
   ${msg}
</body>

  6. 配置Tomcat 启动测试

 

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

  1. 查看控制台输出，看一下是不是缺少了什么jar包。

  2. 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！

  3. 重启Tomcat 即可解决

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

 

2.1.2注解版

从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁。

1.web.xml

  • 注意web.xml版本问题，要最新版！
  • 注册DispatcherServlet
  • 关联SpringMVC的配置文件
  • 启动级别为1
  • 映射路径为 / （不要用/*，会404）
<?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>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:mvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

2.mvc-servlet

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

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="moli.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--在spring中一般采用@RequestMapping注解来完成映射关系，
        HandlerMapping和HandlerAdapter由annotation-driven配置帮助我们自动完成上述两个实例的注入。-->
    <mvc:annotation-driven />
    
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

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

  • 让IOC的注解生效
  • 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 …
  • MVC的注解驱动
  • 配置视图解析器

3.controller

@Controller
public class helloController {
    @RequestMapping("/hello")//既可以写在方法上，也可以写在类上
    public String hello(Model model){
        model.addAttribute("msg","lkjhg");
        return "hello";
    }
}

4.hello.jsp

<body>
  ${msg}
</body>

 

小结：

实现步骤：

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

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

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

  • 通常，我们只需要手动配置视图解析器

  • 处理器映射器和处理器适配器只需要开启注解驱动即可

 

2.3RestFul风格

2.3.1概念

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

  • 更简洁，更有层次

  • 更易于实现缓存等机制

  • 可以通过不同的请求方式来实现不同的效果，请求地址一样，但是功能可以不同

  • 原始的路径请求：http://localhost:8080/r?a=1&b=1

    @Controller
public class restful {
    @RequestMapping("/r")
    public String test(int a, int b, Model model){
        int result = a+b;
        model.addAttribute("msg","test结果为："+result);
        return "test";
    }
}

  • restful的路径请求：http://localhost:8080/r/1/2

 

2.3.2@PathVariable

1.常规写法：

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

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

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

@Controller
public class restful {
    @RequestMapping(value = "/r/{a}/{b}",method = RequestMethod.POST)
    public String test(@PathVariable int a, @PathVariable int b, Model model){
        int result = a+b;
        model.addAttribute("msg","test结果为："+result);
        return "test";
    }
}

我们使用浏览器地址栏进行访问默认是Get请求，会报错405。
在这里插入图片描述

3.使用注解指定请求类型：

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@Controller
public class restful {
    @RequestMapping(value = "/r/{a}/{b}")
    @GetMapping
    public String test(@PathVariable int a, @PathVariable int b, Model model){
        int result = a+b;
        model.addAttribute("msg","test结果为："+result);
        return "test";
    }
}

 

2.4转发和重定向

1.ServletAPI：

不需要视图解析器，而是通过HttpServletResponse进行输出、实现重定向，HttpServletRequest实现转发。

@Controller
public class servletAPI {
    @RequestMapping("/a")
    public void api(HttpServletRequest req,HttpServletResponse resp) throws IOException {
        resp.getWriter().print("sdc");
    }
    @RequestMapping("/a1")
    public void api1(HttpServletRequest req,HttpServletResponse resp) throws IOException {
        //重定向：路径会改变
        resp.sendRedirect("/index.jsp");
    }
    @RequestMapping("/a2")
    public void api2(HttpServletRequest req,HttpServletResponse resp) throws IOException, ServletException {
        //转发
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }
}

2.通过SpringMVC来实现转发和重定向，无需视图解析器。

@Controller
public class sendRedirect {
    @RequestMapping("/s")
    public String s(){
        //转发
        //return "/index.jsp";
        return "forward:/index.jsp";
    }
    @RequestMapping("/s1")
    public String s1(){
        //重定向
        return "redirect:/index.jsp";
    }
}

默认的是转发，所以转发可以不注明。

 

2.5数据处理

  • 接收前端用户传递的参数，判断方法参数的名字，假如名字直接在方法上，可以直接使用；提交名称和处理方法的参数名不一致使用@RequestParam

  • 假设传递的是一个对象，匹配User对象中的字段名，如果名字一致即可，不一致匹配为null

@Controller
public class userController {
    //http://localhost:8080/u?username="xiao"
    @RequestMapping("/u")
    public String user(@RequestParam("username") String name, Model model){
        //接受前端的参数
        System.out.println("前端的参数为："+name);
        //将传递的结果，返回给前端
        model.addAttribute("msg",name);
        //视图跳转
        return "test";
    }
    
    //前端接受的是一个对象 name age id
    //http://localhost:8080/u1?name="xiao"&id=2&age=1
    @RequestMapping("u1")
    public String user1(User user){
        System.out.println(user);
        return "test";
    }
}

区别：

  • Model 继承了ModelMap ，是其简化，只有几个方法适合用于储存数据；

  • ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

  • ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

 

2.6乱码问题

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

@Controller
public class EncodingController {
    //注意表单的提交方式是post，所以这里我们用post的注解
    @PostMapping("/e")
    public String e(String name, Model model){
        System.out.println(name);
        model.addAttribute("msg",name);
        return "test";
    }
}

通过表单提交个中文名字：乱码在这里插入图片描述

 

2.6.1过滤器

以前乱码问题通过过滤器解决 ，但是psot提交的乱码没有解决

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

注册：

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>moli.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <!--过滤所有的请求-->
    <url-pattern>/</url-pattern>
</filter-mapping>

 

2.6.2mvc配置过滤器

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

 

2.6.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, FilterChainchain) 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;
  }
}

另外：

  • 修改tomcat配置文件 ：server.xml设置编码！
<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />
  • 乱码问题，需要平时多注意，在尽可能能设置编码的地方（浏览器后台，清理一下后台），都设置为统一编码 UTF-8！

 
 

3.JSON

3.1JS和JSON

在这里插入图片描述

  • JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
  • 采用完全独立于编程语言的文本格式来存储和表示数据。
  • 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
  • JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。
  • JSON 和 JavaScript 对象的写法大同小异，键值对中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔。

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

  • 对象表示为键值对，数据由逗号分隔，最后一个不加逗号
  • 花括号保存对象
  • 方括号保存数组
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!--script标签必须是两个，不能自闭合-->
    <script type="text/javascript">
      //编写一个JavaScript的对象
        var user={
            name:"小明",
            age:"11",
            sex:"男"
        };
        //js转json
        var obj= JSON.stringify(user)
        console.log(obj);
        console.log("=======================")
        //json转js
        var json = JSON.parse(obj)
        console.log(json);
    </script>
</head>

控制台结果：在这里插入图片描述

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

 

3.2Controller返回JSON数据

Jackson应该是目前比较好的json解析工具了（另外还有阿里巴巴的 fastjson）

3.2.1jar包

首先需要导入它的jar包：

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

然后配置web.xml、springmvc-servlet.xml，再写一个User实体类。

 

3.2.2UserController

@Controller
//@RestController使用了这个注解，就不走视图解析器，而是直接返回一个字符串
public class UserController {
    //produces解决·json乱码问题
    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    @ResponseBody//使用了这个注解，就不走视图解析器，而是直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器
        ObjectMapper mapper = new ObjectMapper();
        User user = new User("小明", 2, "男");
        //将我们的对象解析成为json格式
        String s = mapper.writeValueAsString(user);
        return s;
    }
    
    @RequestMapping(value = "/j2")
    @ResponseBody
    public String json2() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        ArrayList<Object> list = new ArrayList<>();
        User user = new User("小删除", 2, "男");
        User user1 = new User("小元", 4, "男");
        User user2 = new User("小发", 5, "男");
        User user3 = new User("小的风", 66, "女");
        list.add(user);
        list.add(user1);
        list.add(user2);
        list.add(user3);
        String s = mapper.writeValueAsString(list);
        return s;
    }
    
    @RequestMapping(value = "/j3")
    @ResponseBody
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        Date date = new Date();
        //自定义时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //传统的将时间格式化：simpleDateFormat.format(date)
        //用ObjectMapper将时间格式化，不使用时间戳
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        mapper.setDateFormat(simpleDateFormat);
        String s = mapper.writeValueAsString(date);
        return s;
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

 

3.2.3抽取公共类

public class JsonUtils {
    public static String getJson(Object object) throws JsonProcessingException {
        return Json(object,"yyyy-MM-dd hh:mm:ss");
    }
    public static String Json(Object obj, String dateFormat) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        //自定义时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
        //用ObjectMapper将时间格式化，不使用时间戳
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        mapper.setDateFormat(simpleDateFormat);
        return mapper.writeValueAsString(obj);
    }
}

 

3.2.4乱码

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

 

3.3FastJson

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

@ResponseBody
@RequestMapping("/j4")
public String json4(){
    ArrayList<Object> list = new ArrayList<>();
    User user = new User("小删除", 2, "男");
    User user1 = new User("小元", 4, "男");
    User user2 = new User("小发", 5, "男");
    User user3 = new User("小的风", 66, "女");
    list.add(user);
    list.add(user1);
    list.add(user2);
    list.add(user3);
    //Java对象 转 JSON字符串
    return JSON.toJSONString(list);
}
容辞
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC-RESTful-Json
05-30
SpringMVC-RESTful-Json
java spring MVC之RESTful快速开发
weixin_45966674的博客
05-14 1360
这里 触发 get 因为后面的id是路径参数 需要保留 其他 如果你想直接用user这个名字 就不需要加这个RequestMapping的value来声明路径了。首先 来做第一个简化 大家会发现 他们路径都是user 那么 简化最需要简的就是 重复部分 我们先改成这样。写在类上面 每个方法就不需要单独加了 这个就表示 这个类下所有的方法都使用ResponseBody。然后 我们发现 每一个方法都有一个 RequestMethod.请求方式 这个也可以写简单一点。
Spring MVC实现RESTful API，打造高效便捷的Web服务
BXA
05-14 1345
REST（Representational State Transfer）是一种架构风格一种设计风格而非标准。它并不是新技术是用于Web服务端的一种设计风格。通过设计好的URI和HTTP方法可以实现对资源的操作。RESTful API是符合REST风格的API，具有良好的可读性、可扩展性、可维护性、可测试性和可移植性。 Spring MVC是Spring Framework的一个模块，它为Web应用程序提供了一种模型-视图-控制器（MVC）架构。通过分离模型
SpringMVC 06 -RESTFul风格接口设计
yinying293的博客
04-17 356
等价System . out . println("查询所有user" + "...." + pageNum + "..." + limit);i < 10;i ++) {userList . add(new User("张三" + i , "123" , "1234" + i , 30 + i));} return new DataResult(200 , "查询成功" , userList);
【SpringMVC+RestFul】springMVC Restful风格API接口开发
南方有乔木的博客
05-20 1368
【SpringMVC+RestFul】SpringMVC+RestFul知识点 ResponseEntity https://blog.csdn.net/u010900754/article/details/105329256 https://blog.csdn.net/neweastsun/article/details/81142870 produces = MediaType https://blog.csdn.net/jaryle/article/details/72965885 ..
基于Spring的RESTful API开发：让Web应用更加开放和灵活
BXA
05-16 1116
Spring框架是一套开源的企业级应用程序开发框架，通过IoC（Inversion of Control）和AOP（Aspect Oriented Programming）技术，帮助开发者实现松耦合的、模块化的可重用代码。SpringMVC是Spring框架中的一个模块是一个基于MVC模式的Web框架，通过它可以方便地构建Web应用程序。摘要认证是一种在HTTP请求和响应过程中对消息进行摘要计算的认证方式。
springmvc-base-quick.rar
12-21
springmvc-base-quick.rar
springmvc-json-lib.rar
11-16
springmvc-json-lib.rar springmvc-json-lib.rar
springMVC-ppt.rar
12-07
springMVC-ppt.rar
springmvc-base-restful-04.rar
最新发布
01-24
springmvc-base-restful-04.rar
SpringMVC的Restfull风格接口开发
weixin_44914784的博客
04-15 907
版权声明：本文为博主原创文章，未经博主允许不得转载 什么是Restfull风格? 简单点说就是访问后台时的请求路径与请求的方式有所不同. 传统的请求路径如:http://127.0.0.1:8080/user/getUser.do?id=1 Restfull风格的请求路径为:http://127.0.0.1:8080/user/1 操作步骤 将web.xml中 Controller中的写法 //...
SpringMVC如何实现restful接口
datouniao1的博客
08-02 3931
 今天看一个SpringMVC的项目，然后编写接口，并通过前台的ajax调用来访问接口，当然这所有的一切好像都没有什么问题，你看下面是我们的ajax， function sendMessage() { var curPath=window.document.location.href; var pathName=window.document.loc...
SpringMVC实现REST的PUT和DELETE请求
qq_45174642的博客
08-11 709
1、什么是REST？ REST：Representational State Transfer，表现层资源状态转移。 1、资源 资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的...
SpringMVC框架基础详解(四) （RESTFul使用案例）
weixin_45139640的博客
04-05 303
文章目录**功能清单一、准备工作1.1、项目目录1.2、实体类Employee1.3、控制层EmployeeController1.3、dao层 EmployeeDao1.4、springMVC.xml1.5、 web.xml二、功能1： 访问首页2.1、templates目录下创建index.html2.2 、springMVC中配置视图控制器方便访问首页2.3、首页三、功能2：查询所有员工信息3.1、控制器方法3.2创建employee_list.html四、功能3：删除3.1、创建处理delete请求
SpringSecurity学习总结-2 第三章 使用SpringMVC开发Restful API
Mr_XiMu的博客
02-13 529
SpringSecurity学习总结-2 第三章 使用SpringMVC开发Restful API
使用springmvc编写restful接口
tianquanlei的博客
02-17 480
HttpURLConnection通过post请求方式发送xml数据类型到spring创建的restful接口
SpringMVC---RESTful风格简化开发
weixin_65237252的博客
03-26 104
SpringMVC---RESTful风格简化开发
ajax modelmap,spring mvc+ajax处理JSON返回前台的方法
weixin_42460182的博客
08-05 307
在 Spring mvc3中，响应、接受 JSON都十分方便。使用注解@ResponseBody可以将结果(一个包含字符串和JavaBean的Map)，转换成JSON。使用 @RequestBody 注解前台只需要向 Controller 提交一段符合格式的 JSON，Spring 会自动将其拼装成 bean。Spring这个转换是靠org.codehaus.jackson这个组件来实现的，所有需...
Restful风格API接口开发springMVC篇
weixin_30897079的博客
09-12 4672
Restful风格的API是一种软件架构风格，设计风格而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。 在Restful风格中，用户请求的url使用同一个url而用请求方式：get，post，delete，put...等方式对请求的处理方法进行区分，这样可以在前后台分离式的开发中使得前...
springmvc-config.xml文件
08-16
springmvc-config.xml文件是用于配置Spring MVC框架的文件。它包含了一些重要的配置，如控制器的映射、处理器适配器、视图解析器等。在配置文件中，可以定义控制器的映射路径和对应的处理器，通过配置处理器适配器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值