springmvc项目所有接口不对外暴露 springmvc接口开发

1. 什么是SpringMVC

SpringMVC是一个Spring内置的MVC框架，采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性。

在没有使用SpringMVC之前我们都是使用Servlet在做Web开发。但是使用Servlet开发在接收请求参数，数据共享，页面跳转等操作相对比较复杂。servlet是java进行web开发的标准，SpringMVC底层就是Servlet，SpringMVC就是对Servlet进行深层次的封装。

SpringMVC解决WEB开发中常见的问题(参数接收、文件上传、表单验证、国际化等等)，而且使用简单，与Spring无缝集成。支持 RESTful风格的URL请求。

2. Springmvc开发步骤

下面通过实现接口Controller的方式来定义控制器，开发第一个SpringMVC 的程序

实现接口Controller定义控制器是较老的办法
缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；

1. 创建项目
   创建一个新的模块，不使用任何archetype项目模板
   
   
2. 导入依赖

<!--  依赖  -->
    <dependencies>
        <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.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>

点击项目模块，手动在WEB-INF文件夹下创建lib文件夹

选中当前的项目

然后把包全部导入进去

3. 在web/WEB-INF文件夹里面创建一个jsp文件夹，里面创建一个test.jsp视图

4. 配置web.xml 文件

在web.xm里面注册DispatcherServlet，DispatcherServlet是SpringMVC的核心，是请求分发器或者前端控制器，所有的请求都会经过他，在注册时 还需要给他绑定对应的配置文件，以及设置启动级别

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

<!--注册DispatcherServlet，是请求分发器或者前端控制器，所有的请求都会经过他-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- DispatcherServlet要绑定springmvc的配置文件  (配置文件一般放在resources文化夹下)     -->
        <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>


<!--  在Springmvc中
  / :只会匹配所有的请求，不会匹配jsp页面
  /*:会匹配所有的请求，包括jsp页面 （不用）
  假如用户在地址栏直接访问了test.jsp页面，后面适配器又会对地址进行拼接，再套上一个前缀和后缀，无限循环
  -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

5. 编写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">

<!--添加 处理映射器-->
<!--除了BeanNameUrlHandlerMapping以外 还有很多种处理映射器   -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

<!--添加 处理器适配器 SimpleControllerHandlerAdapter  -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--添加 视图解析器 InternalResourceViewResolver  这个类以后可以变化的，用模板引擎进行替代  -->

    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀  用/结尾，表示下级目录     -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 后缀      -->
        <property name="suffix" value=".jsp"/>
    </bean>

<!-- BeanNameUrlHandlerMapping 匹配对应的bean   -->
    <bean id="/hello" class="com.tcgroup.controller.HelloController"/>

</beans>

6. controller代码测试

public class HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //业务代码写这里
        String result ="hello SPRINGMVC 假装自己是调用service的返回值";
        
        //封装对象，放在ModelAndView中。键值对的形式 且值可以为空
        mv.addObject("msg",result);

        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("test"); //: /WEB-INF/jsp/test.jsp
        
        return mv;
    }
}

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

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

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

重启Tomcat 即可解决！

3. SpringMVC 执行原理

简要分析执行流程

2. DispatcherServlet表示前端控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。



3. 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
   如上url拆分成三部分：
   http://localhost:8080服务器域名SpringMVC部署在服务器上的web站点
   hello表示控制器
   通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
4. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
6. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello，对应的是HelloController。



7. 注意：1，2，3走完，前端控制器已经知道去找那个controller执行了
8. HandlerExecution将解析后的信息（比如控制器映射）传递给DispatcherServlet

5.调用 HandlerAdapter（处理器适配器）识别所有实现了 Controller 接口的 Handler 控制器

（处理器适配器） 它支持所有实现了 Controller 接口的 Handler 控制器，如果开发中编写了实现 Controller 接口的控制器，则 SimpleControllerHandlerAdapter 适配器就会去执行 Controller 的具体方法。

6. Handler让具体的Controller（也就是Hello Controller）执行。
7. Controller回去调用对应的业务，获取数据对象，如ModelAndView，并且将具体的执行信息返回给HandlerAdapter,

8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
   此时DispatcherServlet前端控制器已经拿到了对应的数据模型，也知道要找哪个视图了
9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递过来的的逻辑视图名。
11. 视图解析器根据配置信息进行解析，解析出来的是完整的视图地址，并传回给DispatcherServlet。



12. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
    此时数据有了，视图也有了,最终呈现给用户。

4. 使用注解来定义Controller进行开发

1. @Controller注解类型用于声明Spring类的实例是一个控制器
2. Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类（这个功能类似于上面的 HandlerAdapter处理器适配器），为了保证Spring能找到你的控制器，需要在springmvc的配置文件中声明组件扫描。并且告诉springmvc我要用注解了

<!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.tcgroup.controller"/>
    <!-- <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->-->
    <mvc:annotation-driven />

3. 增加一个Controller类，使用注解实现；

//@Controller注解的类会自动添加到Spring上下文中
@Controller
//如果这里也加了RequestMapping注解且给了值， 下面的h1 要通过http://localhost:8080/ddd/h1访问
@RequestMapping("/ddd")
public class HelloController {

//映射访问路径
//  这里写了h1 就可以http://localhost:8080/h1访问  没写：404
    @RequestMapping("/h1")
    public String sayHello(Model model){

        //业务代码写这里
        String result ="hello SPRINGMVC 假装自己是调用service的返回值";

		//Spring MVC会自动实例化一个Model对象用于向视图中传值
        //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg", result);

        //视图解析器会根据这里返回的hello进行拼接解析 到 web-inf/jsp/hello.jsp
        return "hello";
    }
}

4. @RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

• 只注解在方法上面

@Controller
public class TestController {
   @RequestMapping("/h1")
   public String test(){
       return "test";
  }
}

访问路径：http://localhost:8080 / 项目名 / h1

• 同时注解类与方法

@Controller
@RequestMapping("/admin")
public class TestController {
   @RequestMapping("/h1")
   public String test(){
       return "test";
  }
}

访问路径：http://localhost:8080 / 项目名/ admin /h1 , 需要先指定类的路径再指定方法的路径；

4.1 实现Controller 接口的控制器和注解定义的控制器在代码上有哪些不同

1. springmvc配置文件：保留了视图解析器，去掉了映射处理器，处理器适配器，以及handler，增加了自动扫描包，注解驱动，和静态资源过滤
2. controller

4.2 SpringMVC注解开发小结

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

5. RestFul 风格

5.1 概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

5.2 功能

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

分别对应 添加、 删除、修改、查询。

传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

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

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

http://127.0.0.1/item 新增,POST

http://127.0.0.1/item 更新,PUT

http://127.0.0.1/item/1 删除,DELETE

5.3 @PathVariable 注解

在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

@Controller
public class RestFulController {

   //映射访问路径
   @RequestMapping("/commit/{p1}/{p2}")
   public String index(@PathVariable int p1, @PathVariable int p2, Model model){
       
       int result = p1+p2;
       //Spring MVC会自动实例化一个Model对象用于向视图中传值
       model.addAttribute("msg", "结果："+result);
       //返回视图位置
       return "test";   
  }
}

5.4测试代码

@Controller
public class RestFulController {

//  原来给ab传参的方式  http://localhost:8080/springmvc_05_controller_war_exploded/add?a=1&b=2
    @RequestMapping ("/add")
    public String test1(int a, int b, Model model){

        int result=a+b;

        model.addAttribute("msg","a+b结果为："+result);


        return "test";
    }
// restful 风格的传参  http://localhost:8080/springmvc_05_controller_war_exploded/add2/1/2
    @RequestMapping (value = "/add2/{a}/{b}",method = RequestMethod.GET)
    public String test2(@PathVariable  int a, @PathVariable int b, Model model){

        int result=a+b;

        model.addAttribute("msg","a+b结果为："+result);


        return "test";
    }


//  http://localhost:8080/springmvc_05_controller_war_exploded/add3/1/2
//  我们可以通过@GetMapping，@PostMapping，@DeleteMapping等注解来根据用户请求方式的不同， 让用户进入到不同的方法里面
//  上一个方法通过method的这种方式来指定也可以实现 @RequestMapping (value = "/add2/{a}/{b}",method = RequestMethod.GET)

    @GetMapping("/add3/{a}/{b}")
    public String test3(@PathVariable  int a, @PathVariable int b, Model model){

        int result=a+b;

        model.addAttribute("msg","a+b结果Get为："+result);

        return "test";
    }

    @PostMapping("/add3/{a}/{b}")
    public String test4(@PathVariable  int a, @PathVariable int b, Model model){

        int result=a+b;

        model.addAttribute("msg","a+b结果Post为："+result);

        return "test";
    }




}

5.5 使用路径变量的好处？

使路径变得更加简洁；

获得参数更加方便，框架会自动进行类型转换。

通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。

6. 结果跳转 （转发和重定向）

6.1 ServletAPI（不常用）

因为Springmvc 底层还是servlet，所以我们可以获取到HttpServletRequest req, HttpServletResponse rsp使用， 直接进行转发和重定向，且不需要视图解析器

@Controller
public class ResultGo {

   @RequestMapping("/result/t1")
   public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.getWriter().println("Hello,Spring BY servlet API");
  }

   @RequestMapping("/result/t2")
   public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.sendRedirect("/index.jsp");
  }

   @RequestMapping("/result/t3")
   public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
       //转发
       req.setAttribute("msg","/result/t3");
       req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
  }

}

6.2 SpringMVC

通过SpringMVC来实现转发和重定向有两个种方式 -
第一种：无需视图解析器（需要将视图解析器注释掉）；
第二种：有视图解析器

第一种 无需视图解析器；（不常用 不能有视图解析器）

//    通过Springmvc来实现重定向和转发(需要注释掉springmvc配置文件里面的视图解析器)
    @RequestMapping("/m1/t3")
    public String  test3(Model model){
        model.addAttribute("msg","ModelTest1.test3");
        //转发(下面两种方式都可以)
//        return "forword:/WEB-INF/jsp/test.jsp";
//        return "/WEB-INF/jsp/test.jsp";
//        重定向
        return "redirect:/index.jsp";
    }

第二种：有视图解析器 (常用)

@RequestMapping("/m1/t1")
    public String test1(Model model){
        model.addAttribute("msg","ModelTest1.test1");

        //转发： 下面两种方式都可以
//        return "test";
//        return "forword:test";
//        重定向
        return "redirect:/index.jsp";

    }

7. 数据处理

7.1 处理用户前端提交的数据

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

提交数据 : http://localhost:8080/hello?name=tcgroup

处理方法 :直接通过参数获取

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

后台输出 : tcgroup

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

提交数据 : http://localhost:8080/hello?username=tcgroup
处理方法 :通过@RequestParam注解指定参数对应的是前端传过来的哪个参数

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

后台输出 :tcgroup

3. 提交的是一个对象

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

• 实体类

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

2、提交数据 : http://localhost:8080/mvc04/user?name=tcgroup&id=1&age=15

3、处理方法 :直接用USER类去接受 会自己去匹配名字一样的属性

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

后台输出 : User { id=1, name=‘tcgroup’, age=15 }

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。如果不一致可以通过上面第二种方法 一个参数一个参数接收

7.2 数据显示到前端

第一种 : 通过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;
  }
}

第二种 : 通过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";
}

第三种 : 通过Model

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

就对于新手而言简单来说使用区别就是：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

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

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

当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

7.3 乱码问题

以前乱码问题通过过滤器解决 , 而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>

如果有些极端情况下.这个过滤器对get的支持不好 .
处理方法 :

1. 修改tomcat安装地址下conf文件夹server.xml配置文件 ：设置编码！

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

2. 自定义过滤器 然后 web.xml中配置 (一般 Spring 的就好，极端情况换成这个)

/**
* 解决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;
  }

7.4 Json

7.4.1 什么是Json

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛，采用完全独立于编程语言的文本格式来存储和表示数据，简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言，易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

• 对象表示为键值对，数据由逗号分隔
• 花括号保存对象
• 方括号保存数组
  JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

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

可以这么理解：
JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

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

JSON 和 JavaScript 对象互转
在 JavaScript中，要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

ar 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"}'

7.4.2 Controller返回JSON数据

1. 导入依赖

目前比较好的json解析工具有Jackson，阿里巴巴的 fastjson 等等
我们这里使用Jackson，使用它需要导入它的jar包；

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

2. 编写一个User的实体类

package com.kuang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

   private String name;
   private int age;
   private String sex;
   
}

3. 编写一个Controller；

@ResponseBody注解，在方法上使用， 让这个方法返回对应的值，而不走视图解析器
ObjectMapper：jackson的对象映射器

@RequestMapping("/json1")
    @ResponseBody
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("小熊1厘米", 3, "男");
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }

执行这段代码的时候有可能出现乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型
有两种设置方法：

1. 通过@RequestMaping的produces属性来实现，修改下代码

//produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

项目中有许多请求则每一个都要添加

2. 乱码统一解决
   我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！

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

7.4.3 输出时间对象

增加一个新的方法

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

   ObjectMapper mapper = new ObjectMapper();

   //创建时间一个对象，java.util.Date
   Date date = new Date();
   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(date);
   return str;
}

运行结果 :

默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！

Jackson 默认是会把时间转成timestamps形式

解决方案：取消timestamps形式 ， 自定义时间格式

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {

   ObjectMapper mapper = new ObjectMapper();

   //不使用时间戳的方式
   mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
   //自定义日期格式对象
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   //指定日期格式
   mapper.setDateFormat(sdf);

   Date date = new Date();
   String str = mapper.writeValueAsString(date);

   return str;
}

如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

//创建一个工具类
public class JsonUtils {
//    提供一个方法  传入任意一个date对象和时间格式，返回对应格式的JSON字符串
    public static String getJson (Object object ,String dateFormat){
        ObjectMapper mapper =new ObjectMapper();
        // 默认的是使用时间戳， 关闭即是不使用时间戳
        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;
    }

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

抽取后代码更加简洁了

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

7.4.4 fastjson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

fastjson 的 pom依赖！

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

fastjson 三个主要的类：

• JSONObject 代表 json 对象

JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。

JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

• JSONArray 代表 json 对象数组

内部是有List接口中的方法来完成操作的。

• JSON代表 JSONObject和JSONArray的转化

JSON类源码分析与使用

仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

@RequestMapping("/j4")
    public String json4() {
        //创建一个对象
        List<User> userList =new ArrayList<>();

        User user1 =new User("小熊1厘米",3,"男");
        User user2 =new User("小熊2厘米",3,"男");
        User user3 =new User("小熊3厘米",3,"男");
        User user4 =new User("小熊4厘米",3,"男");
        User user5 =new User("小熊5厘米",3,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        userList.add(user5);

        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(userList);
        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);

        return JSON.toJSONString(userList);
    }

8. 拦截器

8.1 什么是拦截器

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

过滤器与拦截器的区别：
拦截器是AOP思想的具体应用。

• 过滤器

servlet规范中的一部分，任何java web工程都可以使用

在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

• 拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

8.2 自定义拦截器

那如何实现拦截器呢？

1. 想要自定义拦截器，必须实现 HandlerInterceptor 接口。

public class MyInterceptor implements HandlerInterceptor {

   //在请求处理的方法之前执行
   //如果返回true执行下一个拦截器
   //如果返回false就不执行下一个拦截器
   public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
       System.out.println("------------处理前------------");
       return true;
  }

   //在请求处理方法执行之后执行
   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
       System.out.println("------------处理后------------");
  }

   //在dispatcherServlet处理后执行,做清理工作.
   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
       System.out.println("------------清理------------");
  }
}

2. 在springmvc的配置文件中配置拦截器

<mvc:interceptors>
        <mvc:interceptor>
            <!--/** 包括路径及其子路径-->
            <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
            <!--/admin/** 拦截的是/admin/下的所有-->
            <mvc:mapping path="/**"/>
            <!--bean配置的就是拦截器-->
            <bean class="com.tcgroup.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

在程序中的运行效果