一.MVC

1.是什么

<1>M：model（模型）（dao,service）

指的是工程中的javabean，作用是处理数据；
javabean分为两类：
实体类bean：存储业务数据，如Student，User等
业务处理bean：处理业务逻辑和数据访问，指的是dao,service层对象

<2>V:view(视图)（jsp）

指的是工程中的jsp，html页面，作用是与用户交互，展示数据

<3>C：controller（控制器）（servlet）

指的是servlet，作用是接收请求和响应浏览器

<4>总结

MVC不是设计模式，是一种架构模式，最典型的就是JSP+Servlet+javabean的模式

2.补充

二.springMVC

1.是什么

springmvc是spirngframework的一部分  ，它是spring的一个子项目，也是目前作为javaee工程中三层架构中表现层的一个主流框架（表现层包括前台页面和后台servlet）

2.为什么用

<1>轻量级，简单易学，不用导入很多jar包

<2>基于原生的servlet，通过前端控制器dispatcherServlet，对请求和响应做出统一处理

通过封装servlet，浏览器发来的请求就不需要我们自己写servlet处理，有dispatcherServlet帮我们统一处理，；
封装的内容有很多，如获取请求参数，往域对象放置，页面跳转，重定向等操作，不再需要原生servlet的语法

<3>内部组件化程度高

我们需要什么功能，就在springmvc的核心配置文件中配置相应的组件即可，不再需要自己写类写功能

<4>与spring无缝斜街，可以把springmvc中用到的bean都注册到spring中交给spring管理

<5>约定大于配置

<6>功能多：支持Restful风格

4.怎么用

<1>快速入门（基于配置文件实现）

I.开发环境

    IDE
    构建工具：maven
    服务器：tomcat
    spring版本：5.x    

II.创建maven工程，导入依赖，javatoweb

<dependencies>
    <!--springmvc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.15</version>
    </dependency>
    <!--日志-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.10</version>
    </dependency>
    <!--spring5和thymeleaf整合包-->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring5</artifactId>
        <version>3.0.14.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.thymeleaf.extras</groupId>
        <artifactId>thymeleaf-extras-java8time</artifactId>
        <version>3.0.4.RELEASE</version>
    </dependency>
    <!--servlet-api-->
    <!--tomcat自带jsp和servlet两个jar包，所以servlet阶段不需要导入这两个-->
    <!--所以scope是provided，以为着打war包的时候servlet就不会在WEB-INF下的lib中，这个jar包由tomcat服务器提供-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>

III.配置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">

   <!--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-->
      <!--因为servlet的生命周期是服务器启动就存在，所以启动级别设置为1-->
      <load-on-startup>1</load-on-startup>
   </servlet>
   <!--/ 匹配所有的请求;(不包括.jsp)--> 
   <!--/* 匹配所有的请求;(包括.jsp)-->
   <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
   </servlet-mapping>

</web-app>

IV.创建springmvc的配置文件

<?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">
    <!--处理映射器、处理器适配器、视图解析器是springmvc核心三要素-->
    <!--添加 处理映射器-->
    <!--这个处理映射器之后不会用，原理部分便于理解，它需要找到bean来查询url映射地址-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />
    <!--添加 处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter "/>
    <!--添加 视图解析器-->
    <!--这是spring自带的视图解析器，后面会学模板引擎thymleaf，freemarker-->
    <!--视图解析器: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>

V.创建请求控制器Controller

i.实现Controller接口方式（真实开发不这么写，但原理是这样 ）

功能：在controller中存值并跳转到hello页面       

//注意:这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    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;
    }
}

ii.写@Controller注解

参考注解方式开发springmvc

VI.springmvc配置文件中注册bean

<!--Handler-->
<!--注册bean-->
<!--上面的映射器和适配器就是为了输入url时，spring找到可以处理的Controller-->
<bean id="/hello" class="com.itheima.controller.HelloController"/>

VII.返回给页面的数据

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

VIII.配置tomcat并测试

<2>快速入门（注解开发springmvc）

I.创建maven工程，导入依赖，javatoweb

<dependencies>
    <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.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

II.配置web.xml

用最新版，2.x或3.x代码跑不起来
参考原始方式（配置文件实现）的web.xml配置

III.配置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.itheima.controller"/>
    <!-- 让Spring MVC不处理静态资源 --> 
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
    在spring中一般采用@RequestMapping注解来完成映射关系
    要想使@RequestMapping注解生效
    必须向上下文中注册DefaultAnnotationHandlerMapping 和一个AnnotationMethodHandlerAdapter实例
    这两个实例分别在类级别和方法级别处理。
    而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>

IV.创建对应的资源包

V.编写controller（handler）

//相当于注解方式的springmvc-servlet中的<bean id..>
@Controller
//@RestController,这个注解表示这个类不会被视图解析器解析，只返回json格式的字符串
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","hellomvc");
        //返回的结果被视图解析器处理，进行字符串的拼接然后找资源路径
        return "hello";
    }
}

VI.返回给页面的数据

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

VII.部署tomcat并测试

<3>报错解决

I.pom文件导入依赖，项目没有导入成功

5.@RequestMapping()解析

<1>只有一个参数

name可以不写

<2>多个参数

I.指定请求形式

i.源码分析

ii.代码实现

//映射访问路径,必须是POST请求
@RequestMapping(value = "/hello",method = {RequestMethod.GET}) public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "hello";
}

iii.简化请求方式

@GetMapping("hello")
public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "hello";
}

6.springmvc实现重定向和请求转发

<1>通过SpringMVC来实现转发和重定向 - 不配置视图解析器

@Controller
public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发
        return "/index.jsp";
    }
    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发二
        return "forward:/index.jsp";
    }
    @RequestMapping("/rsm/t3")
    public String test3(){ //重定向
        return "redirect:/index.jsp";
    }
}

<2>通过SpringMVC来实现转发和重定向 - 有视图解析器

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        //转发
        return "test";
    }
    @RequestMapping("/rsm2/t2")
        public String test2(){
            //重定向
            return "redirect:/index.jsp";
            //return "redirect:hello.do"; //hello.do为另一个请求
    } 
}

7.数据处理

<1>处理前端提交的数据

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

i.提交数据

http://localhost:8080/hello?name=alex

ii.处理方法

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

iii.后台输出

alex

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

i.提交数据

http://localhost:8080/hello?username=alex

ii.处理方法

//@RequestParam("username") : username提交的域的名称 
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

iii.后台输出

alex

I.提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

i. 实体类

public class User {
    private int id;
    private String name; 
    private int age; 
    //构造
    //get/set 
    //tostring()
}

ii.提交数据

http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15 

iii.处理方法

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

iv.后台输出

User { id=1, name='kuangshen', age=15 } 
说明:如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

<2>数据显示到前端

I.通过ModelAndView

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView(); 
        mv.addObject("msg","ControllerTest1"); 
        mv.setViewName("test");
        return mv;
    }
}

II.通过ModelMap ——ModelMap对象

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

III.通过Model——model对象

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

<3>对比

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

<4>乱码问题

I.主页面编写一个表单

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

II.后台编写对应的处理类

@Controller
public class Encoding {
    @PostMapping("/e/t")
    public String encoding(String name, Model model){
        model.addAttribute("msg",name);
        return "test";
    }
}

III.输入中文测试，发现乱码

IV.springmvc的乱码解决

spring阶段的乱码问题用过滤器解决 , SpringMVC提供了一个过滤器 , 在web.xml中配置（修改了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>

V.自定义过滤器

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

三.springmvc执行原理

1.DispatcherServlet类

<1>图解继承体系

<2>分析继承体系

由继承体系可知，DispatcherServlet底层也是servlet，所以也会用到doGet(),doPost()方法处理请求以及响应

<3>分析DispatcherServlet类源码

核心方法：doService(),这个方法会处理请求和响应两个对象

2.springmvc执行原理

<1>图解

<2>springmvc的组件分析

DispatcherServlet：前置控制器，是springmvc的控制中心，用户发出的请求都由他接收并拦截
HandlerMapping:DispatcherServlet调用HandlerMapping，HandlerMapping根据url查找handler
HandlerExecution：表示具体的Handler，根据url查找控制器，并将解析后的信息传递给DispatcherServlet（如解析控制器映射）
HandlerAdapter：处理器适配器，执行Handler
Handler（Controller）：Handler将具体的执行信息返回给HandlerAdapter（ModelAndView）
ViewResolver：DispatcherServlet调用视图解析器（ViewResolver）来解析HandlerAdapter传递的逻辑视图名
view：DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图，并展示给用户

<3>代码流程

3.总结

springmvc需要配置的三大组件
处理器映射器
处理器适配器
视图解析器
原生方式，都需要手动配置；注解方式，开启注解驱动即可自动配置处理器映射器和处理器适配器，只需要手动配置视图解析器

四.JSON

1.是什么

json是一种数据交换格式，它可以把js对象用字符串表示

2.用来干什么

json键值可以用来保存js对象；
花括号用来保存对象，方括号用来保存数组

3.怎么用（以jackson为例）

<1>前端方式实现js对象和json之间的转换

I.json字符串转换为js对象

JSON.parse()

II.js对象转换为json字符串

JSON.stringify()

III.纯前端方式实现js对象与json之间的转换

<2>java方式实现

I.工具

第三方：jackson，fastjson（阿里）
自己写：本质就是把一个字符串返回给前端

II.将一个User对象转化为字符串输出给前端

i.依赖

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

ii.实体类

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

iii.配置web.xml和springmvc-servlet.xml

iv.通过tostring（）方式把User对象返回给前端并部署测试

@Controller
public class ControllerToString {
    @RequestMapping("/toString")
    @ResponseBody//表示不走视图解析器，直接给前端返回字符串
    public String json(){
        User user = new User("alex",22,"男");
        return user.toString();
    }
}

v.使用jackson的ObjectMapper对象，把User对象返回给前端

@RequestMapping("/json")
@ResponseBody//表示不走视图解析器，直接给前端返回字符串
public String json() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    User user = new User("alex",22,"男");
    String string = mapper.writeValueAsString(user);
    return string;
}

III.解决乱码问题

i.原生方式

@Controller
public class JsonController {
    @RequestMapping(value = "/json",produces = "application/json;charset=utf-8")
    @ResponseBody//表示不走视图解析器，直接给前端返回字符串
    public String json() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        User user = new User("alex",22,"男");
        String string = mapper.writeValueAsString(user);
        return string;
    }
}

ii.springmvc方式解决

在springmvc的配置文件中添加配置

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

IV.返回给前端日期对象

i.编写接口

@RequestMapping("/time")
public String json2() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    //默认会返回时间戳的格式，设置false，即不适用时间戳格式
    mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
    //自定义日期的格式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    mapper.setDateFormat(sdf);
    Date date = new Date();

    return mapper.writeValueAsString(date);
}

ii.部署并测试

<3>将ObjectMapper抽取出来作为工具类

I.返回日期对象优化

i.初级写法——编写controller接口与工具类(源码思想)

@RequestMapping("/time2")
public String json3(){
    Date date = new Date();
    return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
}

public class JsonUtils {
    public static String getJson(Object object,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        //默认会返回时间戳的格式，设置false，即不适用时间戳格式
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
        //自定义日期的格式
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

ii.重载方式升级

@RequestMapping("/time3")
public String json4(){
    Date date = new Date();
    return JsonUtils.getJson(date);
}

public class JsonUtils {
    public static String getJson(Object object){
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }
    public static String getJson(Object object,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        //默认会返回时间戳的格式，设置false，即不适用时间戳格式
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
        //自定义日期的格式
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

iii.部署并测试

4.FastJson使用

<1>是什么

fastjon.jar是阿里开发用于java的包，方便实现json对象和javaBean对象之间的转换

<2>为什么用

<3>怎么用

I.依赖

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

II.fastjson主要的三个类

i.JsonObject——代表json对象

ii.JsonArray——代表json对象数组

iii.Json——代表JsonObject与jsonArray之间的转化

III.接口实现

@RequestMapping("/fastjson")
public String json6(){
    ArrayList<Object> userList = new ArrayList<>();
    User user = new User("roin", 23, "男");
    userList.add(user);
    System.out.println("java对象转json字符串");
    String str1 = JSON.toJSONString(userList);
    String str2 = JSON.toJSONString(user);
    System.out.println(str1);

    System.out.println("json字符串转java对象");
    User jp_user1 = JSON.parseObject(str2,User.class);
    System.out.println(jp_user1);

    System.out.println("java对象转json对象");
    JSONObject jsonObject = (JSONObject) JSON.toJSON(user);
    System.out.println(jsonObject);

    System.out.println("json对象转java对象");
    User to_java_user = JSON.toJavaObject(jsonObject,User.class);
    System.out.println(to_java_user);

    return "Hello";
}

五.springmvc功能实现

1.支持简单的junit测试

2.支持restful风格

3.异常处理

4.本地化

5.国际化

6.数据验证

7.类型转换

8.拦截器