欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

SpringMVC学习日记总结

程序员文章站 2022-07-08 17:59:50
博主学习SpringMVC时做的笔记。...

SpringMVC

1、回顾MVC

1.1、什么是MVC?

  1. MVC是模型,视图,控制器的简写,是一种软件设计规范
  2. MVC主要作用是降低了视图与业务逻辑间的双向耦合
  3. MVC不是设计模式,是架构模式

1.2、MVC框架要做哪些事情?

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

1.3、MVC框架

  • Spring MVC是SpringFramework的一部分,是给予java实现MVC的轻量级Web框架,
  • 官网:https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web.html

1.4、我们为什么要学习SpringMVC?

  • Spring MVC的特点
    1. 轻量级。简单易学
    2. 高效,基于请求响应的MVC框架
    3. 与Spring兼容性好,无缝结合
      • Spring是个大杂烩,可以将SpringMVC中所有要用到的bean,注册到Spring中!
    4. 约定优于配置
    5. 功能强大:RESTful、数据验证、格式化、本地化、主题等
    6. 简介灵活

2、步骤

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.1</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
  • 导入servlet和jsp的jar依赖

    <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>
    
  1. 新建Moudle,添加web支持

  2. 确定导入了SpringMVC的依赖

  3. 配置web.xml注册DispatcherServlet(web.xml)

    <!--    注册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>contextClass</param-name>
                    <param-value>classpath:springmvc-servlet.xml</param-value>
                </init-param>
    <!--            启动级别-->
                <load-on-startup>1</load-on-startup>
            </servlet>
    
    <!--    / 匹配所有的请求:(不包括.jsp)-->
    <!--    /* 匹配所有的请求: (包括.jsp)-->
            <servlet-mapping>
                <servlet-name>springmvc</servlet-name>
                <url-pattern>/</url-pattern>
            </servlet-mapping>
    
  4. 编写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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    </beans>
    
  5. 添加处理器映射器

    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    
  6. 添加处理器适配器

    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    
  7. 添加视图解析器

    <!--    添加视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--        前缀-->
            <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--        后缀-->
            <property name="suffix" value=".jsp"/>
        </bean>
    
  8. 编写Conteroller,

    public class helloController implements Controller {
        public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception{
            // ModerLAndView 模型和视图
            ModelAndView mv = new ModelAndView();
    
            // 封装对象,放在ModelAndView中, Model
            mv.addObject("msg","HelloSpringMVC"!)
    
            mv.setView("hello");
            return mv;
        }
        public String value() {
            return null;
        }
    
        public Class<? extends Annotation> annotationType() {
            return null;
        }
    }
    
  9. 将自己的类交给Springioc容器,注册bean

    <bean id="/hello" class="com.bdqn.controller.helloController"/>
    
  10. 要跳转到的jsp页面

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

3、SpringMVC执行原理

官方图
SpringMVC学习日记总结

详情图
SpringMVC学习日记总结

实线表示MVC框架提供的技术,不需要开发者实现;虚线表示需要开发者实现

简单分析执行流程

  1. DispatcherServlet表示前置控制器,是整个SpringMVC的控制中心,用户发出请求 DispathcherServlet接受请求并拦截请求

    • 我们假设请求的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系那个具体的执行信息返回给HandlerAdpter,如ModeriAndView

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

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

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

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

  12. 最终视图呈现给用户

    执行原理

  1. 用户发送请求给前端控制器
  2. 前端控制器委托请求给页面控制器(也就是“配置文件”)
  3. 页面控制器通过HandlerMapping根据路径查找Handler映射给DispatchServlet
  1. DispatcherServlet通过映射回来的信息让处理器适配器(HandlerAdaper)执行Handler(Handler上有具体的Controller,意思其实是执行Controller)
  2. Controller把执行信息返回给处理器适配器(HandlerAdapter)
  3. 处理器适配器(HandlerAdapter)再返回给DispatcherServlet
  1. DispatcherServlet调用视图解析器来解析处理器适配器返回的信息
  2. 视图解析器将解析的视图名(前缀和后缀)返回给DispacthcherServlet。
  3. DispactherServlet将根据视图解析器解析出来的视图名将最终视图传递给用户!

4、注解版

  1. 新建一个Moudle,添加web支持!

  2. 由于Maven可能存在资源过滤问题, 我们将配置完善

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
    
  3. 配置web.xml

    <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>
    
    • < url-pattern > / </ url-pattern > 不会匹配到.jsp, 只针对我们编写的请求;即:.jsp 不会进入spring的 DispatcherServlet类 。
    • < url-pattern > /* </ url-pattern > 会匹配 *.jsp,会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类,导致找不到对应的controller所以报404错。
  4. 在resource目录下添加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">
    
    
        <!-- 自动扫描包,让指定包下的注解生效,由IOC容器统一管理 -->
        <context:component-scan base-package="com.bdqn.controller"/>
        <!-- 让Spring MVC不处理静态资源 -->
        <mvc:default-servlet-handler />
        <!--支持mvc注解驱动-->
        <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

    @org.springframework.stereotype.Controller
    public class Controller {
        @RequestMapping("/hello")
        public String hello(Model model){
            // 封装数据
            model.addAttribute("massage","Hello,SpringMVCAnnotation!");
            return "hello";     // 会被视图解析器处理
        }
    }
    
    • @Controller是为了让Spring IOC容器初始化时自动扫描到
    • @RequestMapping是为了映射请求路径,在类上写就表示父子关系
    • 参数Model 是为了把Action中的数据带到视图中;
    • return的是视图的名称hello,在视图配置中会给予武装(加上前后缀)
  6. 创建视图层

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    ${massage}
    </body>
    </html>
    
  7. 配置Tomcat运行

小结

  • 实现步骤

    1. 新建web项目
    2. 导入相关jar包
    3. 编写web.xml,(注册DispatchServlet)
    4. 编写springmvc配置文件
    5. 创建对应的控制类 Controller
    6. 完善前端视图和controller之间的对应
    7. 测试运行调试
  • SpringMVC必须配置的三大件:

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

    通常只需要手动配置视图解析器,

    ​ 处理器映射器和处理器适配器,只需要开启注解驱动即可,<mvc:annotation-driven />

5、Controller控制器

  • 提供访问应用程序的行为,定义方法:接口或注解
  • 控制器负责解析用户的请求,并将其转换为一个模型(Model)
  • 一个控制器类可以包含多个方法
  • Controller的配置有很多种
  1. 实现Controller接口(接口只有一个方法)

    //实现该接口的类就可以获得控制器的功能
    public class HelloController implements Controller {
    //    返回ModelAndView
        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("massage","Controller1");
            modelAndView.setViewName("hello");
            return modelAndView;
        }
    

    缺点:一个控制器只能写一个方法

  2. 使用注解@Controller

    @Controller // 代表这个类会被Spring接管 类下所有的方法如果返回值是String 并且有具体的页面可以跳转,就会被视图解析器解析
    public class HelloController2 {
    //    映射访问路径
        @RequestMapping("/t2")
        public String test1(Model model){
            model.addAttribute("mas","Controller2");
            return "hello";
        }
    }
    
  • 配置类

        <!--    扫描controller包-->
        <context:component-scan base-package="com.bdqn.controller"/>
    <!--    过滤静态资源-->
    <!--    <mvc:default-servlet-handler/>-->
    <!--    注解支持-->
    <!--    <mvc:annotation-driven/>-->
    <!--    视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="WEB-INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    <!--    <bean id="/tt" class="com.bdqn.controller.HelloController"/>-->
    

6、RestFul风格

6.1 概念

​ RestFul就是资源定位和资源操作的风格,不是标准也不是协议,只是风格。这个风格可以让软件更简洁,更有层次,更易于实现缓存等机制

6.2 路径

// 原来:http://localhost:8080/add?a=1&b=2
// RestFul:http://localhost:8080/add/a/b
  • @GetMapping:通过Get地址栏上写入
  • @PostMapping:通过表单的方式写入
  • @RequestMapping(value = “/add”,method = RequestMethod.GET)
  • @RequestMapping(value = “/add”,method = RequestMethod.POST)

6.3 代码

@GetMapping(value = "/{a}/{b}")
public String test3(@PathVariable Integer a,@PathVariable Integer b, Model model){
    Integer c = a + b;
    model.addAttribute("message",c);
    return "admin/text";
}

7、关于转发与重定向

可以脱离视图解析器【非人类】

  1. 把视图解析器注释掉

  2. 在Controller类中定义转发

    return "forward:/WEB-INF/jsp/admin/text.jsp";
    
  3. 在Controller类中定义重定向

    return "redirect:/index.jsp";
    

8、请求参数与数据回显

8.1 请求参数

  1. 参数为变量:
    • @RequestParam(“xxx”) 设置别名,表明决心!
  2. 参数为对象
    • 保证前端数据和对象名的字段名一致,即可赋值到实体类中
    • 提交方法:http://localhost:8080/user/t2?id=1&name=Aaron&age=10

8.2 数据回显

  1. 第一种:通过ModelAndView

    //    返回ModelAndView
        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("massage","Controller1");
            modelAndView.setViewName("hello");
            return modelAndView;
        }
    
  2. 第二种:通过Model

    @RequestMapping("/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int c = a + b;
        model.addAttribute("mas",c);
        return "hello";
    }
    
  3. 第三种:通过ModelMap

    • 与Model功能一样,Model是ModelMap的精简版
  4. 对比

    1. Model 只有寥寥几个方法只适合储存数据,简化了新手对Model对象的操作和理解
    2. ModelMap继承了LinkedMap,除了实现了自身的一些方法,同样的继承了LinkedMap的方法和特性;
    3. ModelAndView 可在存储数据的同时,进行设置返回的逻辑视图。进行控制显示的跳转。
  5. 鸡汤:请使用80%的时间打好基础,剩下18%的时间研究框架,2%的时间去学点英文,框架的官方文档永远是最好的教程。


9、乱码问题

测试步骤:

  1. 在首页编写一个提交的表单

    <form action="/e/t1" method="post">
      <input type="text" name="name">
      <input type="submit" value="Go">
    </form>
    
  2. 在Controller编写处理类

    @RequestMapping("/e/t1")
    public String test(String name, Model model) {
        System.out.println(name);
        model.addAttribute("massage",name);
        return "test";
    }
    
  3. 测试运行Tomcat

处理方法:

  1. 修改tomcat配置文件:设置编码!

    <Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    
  2. 修改web.xml文件(需要重新启动Tomcat)

    <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.bdqn.Encoding;
     
    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 {
     
        public void destroy() {
        }
     
        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);
        }
     
        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;
        }
    }
    
    <!--   终极 配置SpringMVC乱码过滤器-->
        <filter>
            <filter-name>encoding</filter-name>
            <filter-class>com.bdqn.Encoding.GenericEncodingFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>encoding</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    

10、JSON

10.1 什么是json

  • JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式
  • 采用文本格式来存储和表示数据

10.2 语法格式:

JSON键值对:

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

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

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

JSON 和 JavaScript 对象互转

  • JSON字符串转换为JavaScript 对象,使用 JSON.parse() 方法:

    var obj = JSON.parse('{"a": "Hello", "b": "World"}');
    //结果是 {a: 'Hello', b: 'World'}
    
  • JavaScript 对象转换为JSON字符串,使用 JSON.stringify() 方法:

    var json = JSON.stringify({a: 'Hello', b: 'World'});
    //结果是 '{"a": "Hello", "b": "World"}'
    

10.3 代码测试

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Aaron</title>
</head>
<body>
 
<script type="text/javascript">
    //编写一个js的对象
    var user = {
        name:"Aaron",
        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>
 
</body>
</html>

10.4 Jackson使用

  • 为了Controller返回JSON数据
  • JSON的解析工具
  1. 导入依赖

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.11.3</version>
    </dependency>
    
  2. 前端控制器(web,xml)

    <!--    配置DispatchServlet-->
        <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-jsons.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>
    
  3. Spring配置文件

    <?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
            https://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">
    
        <!--    扫描controller包-->
        <context:component-scan base-package="com.bdqn.controller"/>
        <!--    过滤静态资源-->
        <mvc:default-servlet-handler/>
        <!--    注解支持-->
        <mvc:annotation-driven/>
        <!--    视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>
    
  4. Controller

    @Controller
    public class jsonController {
        @RequestMapping("/j1")
        @ResponseBody // 不让它走视图解析器
        public String json1() throws JsonProcessingException {
            ObjectMapper mapper = new ObjectMapper();
            User user = new User(1,"陈赛飞",19);
            return mapper.writeValueAsString(user);
        }
    }
    
  5. 测试(添加lib)

乱码解析!(解决JSON的乱码问题)

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

json返回时间

  1. 原生态java【推荐】

    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        Date date = new Date();
        // 设置格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
        return mapper.writeValueAsString(simpleDateFormat.format(date));
    }
    
  2. 使用ObjectMapper

    @RequestMapping("/j4")
    public String json4() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        // 关闭时间戳
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        // 自定义时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
        // 注入
        mapper.setDateFormat(simpleDateFormat);
        Date date = new Date();
    
        return mapper.writeValueAsString(simpleDateFormat.format(date));
    }
    

创建json工具类

  • 采用方法重写,传递一个参数(对象或集合)转成json格式,传入两个参数(时间)转成json格式

  • 工具类

public class JsonUtils {

    public static String getJson(Object o) {
        return getJson(o,"yyyy-mm-dd HH:mm:ss");
    }

    public static String getJson(Object o,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        // 关闭时间戳
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        // 自定义时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
        // 注入
        mapper.setDateFormat(simpleDateFormat);
        try {
            return mapper.writeValueAsString(o);
        }catch (Exception ex){
            ex.printStackTrace();
        }
        return null;
    }
}
  1. 时间转换json格式时调用时

    // 使用ObjectMapper获取时间并返回
        @RequestMapping("/j4")
        public String json4() throws JsonProcessingException {
            Date date = new Date();
            return JsonUtils.getJson(date);
        }
    }
    
  2. 对象或集合转换json格式时

    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        User user = new User(1,"Aaron",19);
        return mapper.writeValueAsString(user);
    }
    

10.5 Fastjson使用

  • fastjson是阿里云开发的一款专门用java开发的包,可以方便json与javaBean对象的转换
  1. fastjson的pom的依赖!

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.60</version>
    </dependency>
    
  2. fastjsoon 三个主要的类

    1. 【JSONOnject代表json对象】
      • 内部是用Map接口实现的
    2. 【JSONArray代表json对象数据】
      • 内部是由List接口中的方法来完成操作的
    3. 【JSON代表JSONObject和JSONArray的转化】

代码测试

  1. 导入依赖

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.60</version>
    </dependency>
    
  2. 编写代码 返回值用JSON.toJSONString(list);

@RequestMapping("/j5")
public String json5() throws JsonProcessingException {
    User user1 = new User(1,"Aaron",19);
    User user2 = new User(2,"Aaron",19);
    User user3 = new User(3,"Aaron",19);
    User user4 = new User(4,"Aaron",19);
    User user5 = new User(5,"Aaron",19);
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);
    list.add(user5);
    String s = JSON.toJSONString(list);
    return s;
}

本文地址:https://blog.csdn.net/ThisAaron/article/details/109275364