SpringMVC

学习总结b站up“狂神说Java”的“SpringMVC”笔记，侵删

面试重点：

Spring：IOC 和 AOP*
SpringMVC：SpringMVC的执行流程*

SpringMVC：SSM框架整合

编码错误总结

404 ：很有可能是文件包中没有配置lib

其次是可能form表单中action的路径没有加具体模块module包名

MVC

模型（dao,service)视图（jsp)控制器(servlet)

dao

service

servlet：转发，重定向

jsp/html：

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

前端数据传输实体类

实体类：用户名，密码，生日，爱好，。。。20个

前端：用户名，密码

pojo：User

vo：UserVo 细分，去掉前端不需要的属性

dto（数据传输时的对象）：

最典型的就是JSP+servlet+javabean

JSP：本质就是一个Servlet

假设：你的项目的架构，是设计好的，还是演进的？

Alibaba PHP
随着用户量增大，转到Java
王坚去IOE MySQL
MySQL：MySQL-->AliSQL、Aliredis
All in one -->微服务

回顾Servlet

记得注册Servlet

MVC：

MVVM：M V VM ViewModel：双向绑定

SpringMVC

是Spring Framework的一部分，是给予Java实现的MVC的轻量型的Web框架

轻量级、简单易学
高效，基于请求响应的 MVC框架
与Spring兼容性好，无缝结合
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简介灵活
最重要的一点是使用的人多，使用的公司多

微信图片_20200901173428

中心控制器

以请求为驱动，围绕一个中心的Servlet

分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet（它继承自HttpServlet基类）

DispatcherServlet类中的doService方法是核心方法

遇到404问题有可能是

没写一个模块都要写一个lib

查看控制台输出，看一下是不是缺少什么jar包
如果jar包存在，显示无法输出，就在IDEA的项目中发布中，添加lib依赖！
重启Tomcat即可解决。
具体步骤，配置idea文件结构，创建lib目录，导入所有jar包。

简要执行流程（底层原理）

第一个SpringMVC程序

1、配置版

2、注解版

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

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

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

通常只需要配置视图解析器，而处理器映射器、处理器适配器由注解自动配置

Controller配置总结

@Component	组件
@Service	serviece
@Controller	controller
@Repository	dao

RequestMapping说明

配置访问servlet的路径

RestFul风格

localhost:8080/method?add=1&

localhost:8080/method/add=1/...

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

使用RTestFul风格操作资源：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询GET

http://127.0.0.1/item/ 新增POST

http://127.0.0.1/item/ 更新PUT

@Controller
public class RestFulController {
    //原来的的：localhost:8080/add?a=1&b=2
    //RestFull:localhost:8080/add/a/b
    
    

//    @RequestMapping("/add/{a}/{b}")
//    方式一：@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
//    方式二：@GetMapping("/add/{a}/{b}")
    @PostMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res=a+b;
        System.out.println("start");
        model.addAttribute("msg","结果1为"+res);
        return "hello";
    }
    //地址一样，请求的方法不一样
    @GetMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res=a+b;
        System.out.println("start");
        model.addAttribute("msg","结果2为"+res);
        return "hello";
    }

}

最大的优点：安全

转发和重定向

通过视图解析器

ModelAndView

前缀+viewname+后缀

ServletAPI

通过HTTPServletResponse进行输出
通过HTTPServletResponse实现重定向
通过HTTPServletResponse实现转发

Servlet（req,resp)-》doService(req,resp)

不需要试图解析器（注释掉试图解析器），能够转发/重定向

直接

// 转发
return "/WEB-INF/jsp/hello.jsp";

//重定向
return "redirect:/index.jsp"

配置了视图解析器

// 转发
return "hello";
//重定向
return "redirect:/index.jsp";

接收参数请求以及数据回显

和传来的参数名称一样
和传来的参数名称不一样

传来的是一个对象

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){
        // 1.接受前端参数
        System.out.println("接收到前端的参数为"+name);

        // 2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        return "hello";

    }
}

接收参数

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){
//        1.接受前端参数
        System.out.println("接收到前端的参数为"+name);

//        2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        return "hello";

    }

//    前端接受的是一个对象： id,name,age
    @GetMapping("/t2")
    public String test2(User user) {

        System.out.println(user);
//        1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
//        2.假设传递的是一个对象User，匹配User对象中的字段名，如果名字一致则OK，否则就是null。

//        表单提交 http://localhost:8080/springMVC_04_controllerconfig_war_exploded/user/t2?id=1&name=qinjiang&age=3
        return "hello";
    }
}

传递参数

ModelMap

树形：

LinkedHashMap

ModelMap：继承了LinkedHashMap，所以它拥有LinkedHashMap的全部功能

Model：精简版的，大部分情况下使用Model

80%的时间大号基础，剩下18%的时间研究框架，2%的时间去学点儿英文，框架的官方文档永远是最好的教程。

乱码问题

@Controller
public class EncodingController {
    @PostMapping("/e/t1")
    public String test1(String name, Model model){
        System.out.println(name);
        model.addAttribute("msg",name);

        return "hello";
    }
}

过滤器

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() {

    }
}

使用Get方法（不用Post）

使用SpringMVC自带过滤器

<!--2.配置SpringMVC的乱码过滤器-->
<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>

修改Tomcat配置文件

/tomcat/conf/server.xml

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

自定义过滤器

package com.kuang.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;

/**
* 解决get和post请求 全部乱码的过滤器
*/
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

   @Override
   public void doFilter(ServletRequest request, ServletResponseresponse, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse)response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest)request;
       // 对request包装增强
       HttpServletRequest myrequest = newMyRequest(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中/和/*的区别

在用SpringMVC进行web开发的时候，如果将DispathcerServlet对外访问的虚拟路径配置成/时，需要在Spring的配置文件中配置mvc:default-servlet-handler/这一项，那么为什么需要配置这一项呢？如果对外访问虚拟路径配置成/*可以吗？接下来本文将带着这样的两个疑问，从Tomcat中的conf/web.xml文件着手，深入浅出的分析这两种配置的真正区别。

1. 一个注意点：why?拦截why?匹配 在描述一个Servlet对应的url-patten标签时，很多人会用“拦截”一词来描述这种关系，其实“拦截”一词用在这是很不贴切的。在日常生活中，“拦截”一词顾名思义就是拦下来，不给它通行权。那么用在Servlet中应该就是把请求给拦下来，不给浏览器响应。实际上，这显然不是我们要的结果。那么该用什么词来更为妥当的描述这种关系呢？

è¿éåå¾çæè¿°

上图是截自Tomact中conf/web.xml中的org.apache.jasper.servlet.JspServlet（第113行）说明，从中可以看到是用map一词来描述这种关系的。map译为“映射”，但”映射”过于专业化，对于初学者来说不易理解，因此使用意思贴近的”匹配”可以更好的描述这种关系，更为平易近人。因此只有请求匹配到了相应的Servelt，服务器才会给出响应，否则对不起，给出404.

2. 一点说明：所有的请求资源都需要经过Servlet处理 所有的请求资源都需要经过Servlet处理，包括但不限于静态资源（.html、.css、jpg等文件）、.jsp请求和Servlet请求。初学web时，在地址栏直接访问静态资源（localhost:8080/index.html）的时候，给我们的感觉是不需要经过Servlet处理的，服务器会直接给我们做出响应。其实不然，在Tomcat中的conf/web.xml有如下说明（第38行），这段说明是关于org.apache.catalina.servlets.DefaultServlet的。

è¿éåå¾çæè¿°

从中可以看到DefaultServlet主要处理的是静态资源，这个Servlet处理规则是其它Servlet不能匹配的请求将由它进行处理。而在Tomcat中的DefalutServlet(默认Servlet、缺省Servlet)的路径配置恰巧是/。

è¿éåå¾çæè¿°

如果在自己写的web应用中，同样配置一个路径/，则会覆盖Tomcat中的conf/web.xml中的缺省Servlet,为此在自己写的web.xml中配置如下：

  <servlet>



    <servlet-name>DefaultServlet</servlet-name>



    <servlet-class>cn.tedu.test.DefaultServlet</servlet-class>



  </servlet>



 



  <servlet-mapping>



    <servlet-name>DefaultServlet</servlet-name>



    <url-pattern>/</url-pattern>



  </servlet-mapping>



 



  <welcome-file-list>



    <welcome-file>index.html</welcome-file>



  </welcome-file-list>

在自己写的DefaultServlet中有如下代码：

 //告诉浏览器响应的是文本信息



        response.setContentType("text/html;charset=utf-8");



        //获得index.html的真实路径



        String path = this.getServletContext().getRealPath("index.html");



        //获得输入输出流,并将文件内容响应给浏览器



        FileInputStream fis = new FileInputStream(path);



        OutputStream out = response.getOutputStream();



        int i = -1;



        while((i = fis.read()) != -1){



            out.write(i);



        }

准备一个简单的html静态资源放在webRoot目录下：

<!DOCTYPE html>



    <html>



      <head>



        <title>index.html</title>



        <meta charset="UTF-8">



      </head>



 



      <body>



        This is my HTML page. <br>



      </body>



    </html>

这个时候在浏览器输入相应的地址，浏览器会有”This is my HTML page.”显示，表明此时可以正确访问静态资源index.html。当将自己的DefalutServlet中的java代码给注释掉后，再从浏览器访问index.html静态资源，会发现浏览器不会做出任何响应。从这个结果中可以看到静态资源是由Servlet以流的形式响应给页面的，在这个Servlet中有一个重要的设置response.setContentType(“text/html;charset=utf-8”)。这个设置是告诉浏览器服务器将发送的是text/html信息，浏览器将会按照这种格式去解析浏览器所发送的内容（ig.发送的是png格式的图片则为image/png）。从上我们可以看到当在自己的Servlet中配置/的时候会覆盖Tomcat中config/web.xml中的/配置，这时如果我们不对静态资源进行相应的处理的时候，将导致静态资源无法访问。可见，Tomcat中的config/web.xml中的缺省Servlet主要处理的就是静态资源的访问。这也是为什么平常我们在自己的web应用中没有处理配置处理静态资源ervlet的时候，静态资源仍然可以正常访问和显示的原因。因此当我们在springMVC中将DispatcherServlet配置成/时，我们一定要在spring的配置文件中加上如下配置的原因。

<!-- 处理静态资源被"/"所拦截的问题 -->



    <mvc:default-servlet-handler/>

3. /和/*区别 其实/和/*都可以匹配所有的请求资源，但其匹配的优先顺序是不同的。/在所有的匹配路径中，优先级最低，即当别的路径都无法匹配时，/所匹配的缺省Servlet才会进行相应的请求资源处理。而 /星号匹配的优先级是高于/路径和星号.后缀的路径的（如星号.action,星号.jsp等路径）。为了更好的说明这个问题我们以一个例子来说明。相关文件如下（注意导入springMVC的jar包）： è¿éåå¾çæè¿°

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>



  </servlet>



 



  <servlet-mapping>



    <servlet-name>springmvc</servlet-name>



    <url-pattern>/</url-pattern>



  </servlet-mapping>



 



  <welcome-file-list>



    <welcome-file>index.jsp</welcome-file>



  </welcome-file-list>！

springmvc-servlet.xml配置如下：

 <!-- 处理静态资源被"/"所拦截的问题 -->



    <mvc:default-servlet-handler/>

index.jsp文件如下：

 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>



<!DOCTYPE >



<html>



  <head>



    <title>My JSP 'index.jsp' starting page</title>



  </head>



 



  <body>



    This is my JSP page. <br>



    <img alt="图片" src="1.jpg" border="1px" width="400px" height="200px">



  </body>



</html>

在浏览器地址栏输入localhost:8080/hello，我们发现页面文字和图片内容都可以正常显示。

è¿éåå¾çæè¿°

当将springmvc-servlet.xml中关于静态资源访问的配置给注释掉后，再次访问结果如下：

è¿éåå¾çæè¿°

这时静态的图片资源无法访问，这正如一开始论述的结论一样。这时我们再次打开springmvc-servlet.xml中关于静态资源的配置，并将web.xml中对外访问的虚拟路径配置成/*这样的形式。再次访问会抛出一个404的错误。而将地址栏改为localhost:8080/hello/index.jsp强行访问该资源的时候，会出现以下结果： è¿éåå¾çæè¿°

即将jsp内容以文本的形式显示出来了。接着我们继续将springmvc-servlet.xml中关于静态资源的访问配置给注释掉，继续访问localhost:8080/hello/index.jsp资源，这时会抛出一个404错误，也就是说在上一次访问的时候，服务器把index.jsp当成了静态资源响应给了浏览器，所有我们才会看到这样的文本页面。那么为什么在配置成/*后index.jsp就不能正常访问了？原来在Tomcat中conf/web.xml中配置了org.apache.jasper.servlet.JspServlet用来处理.jsp这样的资源了（第113行）。 è¿éåå¾çæè¿°

这段话的意思是说JspServlet是jsp页面的编译和执行的Servlet.也就是说JspServlet可以将.jsp页面转换成.java文件，最终编译成.class文件并执行。至此，对/和/的配置有一个这样的总结：两者都可以匹配任何资源，只不过两者的匹配的优先级是不一样的;当请求资源与其它Servlet都无法匹配的时候，/所配置的Servlet才会匹配。在Tomcat中conf/web.xml中有关于/和.jsp页面处理的Servlet,当自己所配的web.xml文件中配置/时，会使Tomcat中的DefaultServlet无法访问，导致静态资源无法访问，因此在SpingMVC配置文件中要开启处理静态资源的开关。实际上，当将对外访问的虚拟路径配置成.action等类似路径的时候，就可以很好的避免上述问题了。

4. 引申一：Servlet对外访问虚拟路径匹配顺序简介 Servlet对外访问的虚拟路径的匹配顺序大致如下：

1.含有全部或部分对外访问的具体路径配置，如/LoginServlet，/servlet/*(优先匹配更为具体的路径); 2./的配置; 3.形如.action这样后缀形式的配置，如index.jsp,login.action（即使是具体的路径，优先级也会低于1和2的配置）; 4.其它配置无法匹配的时候，匹配/所配置的Servlet。

注意：/servlet/*.action这样的配置是错误的，即不应该存在这样的配置。

5. 引申二：过滤器对外访问虚拟路径可以配置成/吗? 答案是否定的。在Servlet中，请求资源必须要有相应的Servlet进行处理，否则会抛出404错误。但在过滤器中则不一样，请求资源有时候并不需要经过过滤器的处理，因此当配置成/时，过滤器将不会生效。这与/配置的结论是相符的，即/只会匹配其它请求资源无法处理的请求，而在过滤器中对请求资源并不要求一定要处理。

JSON

前后端分离时代：

后端独立部署，提供接口，提供数据：

json是一种数据交换的格式

前端独立部署，负责渲染后端的数据：

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

	<%--    script不能单闭合--%>
    <script type="text/javascript">

        var user={
            name:"name",
            age:3,
            sex:"男"
        };


        // 将js对象转换成json对象
        var json=JSON.stringify(user);
        console.log(json);


        console.log("===============");
        // 将json对象转换成js对象
        var obj=JSON.parse(json)
        console.log(obj);
    </script>
</head>
<body>

</body>
</html>

Jackson

@Controller
public class UserController {
    @ResponseBody// 他就不会走视图解析器，会直接返回一个字符串
    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    public String json1() throws JsonProcessingException {

//        jackson,ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();


        User user=new User("秦将",3,"nan");
        String s = objectMapper.writeValueAsString(user);

//        String s="00";

        return s;
    }
}

<mvc:annotation-driven>
   <mvc:message-convertersregister-defaults="true">
       <beanclass="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-argvalue="UTF-8"/>
       </bean>
       <beanclass="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <propertyname="objectMapper">
               <beanclass="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <propertyname="failOnEmptyBeans"value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

RestController注解

//标注下面所有方法都只会返回json字符串
@RestController
public class UserController {
    @RequestMapping(value = "/j1")
    public String json1() throws JsonProcessingException {

//        jackson,ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();


        User user=new User("秦将",3,"nan");
        String s = objectMapper.writeValueAsString(user);

//        String s="00";

        return s;
    }
}

返回list类型的json

@RequestMapping(value = "/j2")
    public String json2() throws JsonProcessingException {

//        jackson,ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();
        List<User> userList = new ArrayList<User>();
        User user1=new User("秦将1",3,"nan");
        User user2=new User("秦将2",3,"nan");
        User user3=new User("秦将3",3,"nan");
        User user4=new User("秦将4",3,"nan");


        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        

        String s = objectMapper.writeValueAsString(userList);
        return s;// new ObjectMapper().writeValueAsString(userList);
    }

日期输出

纯java

@RequestMapping(value = "/j3")
public String json3() throws JsonProcessingException {
    Date date = new Date();
    //ObjectMapper 解析Date的默认格式为 Timestamp时间戳

    SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


    return new ObjectMapper().writeValueAsString(simpleDateFormat.format(date));
}

objectMapper方式

 @RequestMapping(value = "/j3")
    public String json3() throws JsonProcessingException {

        //ObjectMapper 解析Date的默认格式为 Timestamp时间戳
        //使用ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        objectMapper.setDateFormat(simpleDateFormat);

        Date date = new Date();
        System.out.println(date);
        return objectMapper.writeValueAsString(date);
    }

编写Json工具类

public class Json {

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

    public static String getJson(Object object,String dateformat){
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateformat);
        objectMapper.setDateFormat(simpleDateFormat);
        String s = null;
        try {
            s = objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return s;
    }
}

FastJson

package com.kuang.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kuang.pojo.User;

import java.util.ArrayList;
import java.util.List;

public class FastJsonDemo {
   public static void main(String[] args) {
       //创建一个对象
       User user1 = new User("秦疆1号", 3, "男");
       User user2 = new User("秦疆2号", 3, "男");
       User user3 = new User("秦疆3号", 3, "男");
       User user4 = new User("秦疆4号", 3, "男");
       List<User> list = new ArrayList<User>();
       list.add(user1);
       list.add(user2);
       list.add(user3);
       list.add(user4);

       System.out.println("*******Java对象 转 JSON字符串*******");
       String str1 = JSON.toJSONString(list);
       System.out.println("JSON.toJSONString(list)==>"+str1);
       String str2 = JSON.toJSONString(user1);
       System.out.println("JSON.toJSONString(user1)==>"+str2);

       System.out.println("\n****** JSON字符串 转 Java对象*******");
       User jp_user1=JSON.parseObject(str2,User.class);
       System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

       System.out.println("\n****** Java对象 转 JSON对象 ******");
       JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
       System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

       System.out.println("\n****** JSON对象 转 Java对象 ******");
       User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
       System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
  }
}

Ajax

jQuery就是JavaScript的一个库，有js的大量函数

HTML+CSS：略懂+js（超级熟练）

js：

函数：闭包（）（）
Dom

id，name，tag

增删改
Bom

window

document

ES6：规范

import，require

拦截器

是AOP思想的具体应用

应该创建一个引用HandlerInterceptor接口的类

笔记-Java-SpringMVC

SpringMVC

编码错误总结

MVC

回顾Servlet

SpringMVC

中心控制器

简要执行流程（底层原理）

第一个SpringMVC程序

1、配置版

2、注解版

Controller配置总结

RequestMapping说明

RestFul风格

转发和重定向

通过视图解析器

ServletAPI

接收参数请求以及数据回显

接收参数

传递参数

乱码问题

过滤器

使用Get方法（不用Post）

使用SpringMVC自带过滤器

修改Tomcat配置文件

自定义过滤器

web.xml中/和/*的区别

JSON

Jackson

RestController注解

日期输出

纯java

objectMapper方式

编写Json工具类

Ajax

拦截器