springMVC

最新推荐文章于 2023-12-22 10:52:49 发布

杨小花的博客

最新推荐文章于 2023-12-22 10:52:49 发布

阅读量338

点赞数

分类专栏： springmvc 文章标签： mvc spring java

本文链接：https://blog.csdn.net/qq_40690208/article/details/120191059

版权

springmvc 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、SpringMVC

1.1、什么是MVC:

MVC 是模型(model)，视图(view),控制器(Controller)的简写，是一种软件的设计的规范
将业务逻辑，数据，显示分离的方法来组织代码
MVC主要是降低了视图与业务逻辑之间的双向的耦合
MVC不是一种设计的模式，而是一种架构模式，不同的MVC存在着很大的差异

**Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是JavaBean组件（包含数据和行为），Value Object（数据Dao）和服务层（行为Service）也就是模型提供了模型数据的查询和模型数据状态的更新的功能，包括数据和业务

**view(视图)：**负责要展示的部分，一般就是我们见到的用户的界面，客户想要看到的东西。

**Controller(控制器)：**接收用户的请求，委托给模型进行处理，处理完毕之后将返回的模型的数据返回给视图，由视图负责展示

1.2、MVC要做的事情

将url映射到java类或者java类的方法
封装用户提交的数据
处理请求调用相关的业务进行处理，封装响应数据
将响应的数据进行处理

1.3、springMVC的特点

轻量级
高效，基于请求和响应
与spring兼容性好，spring是一个大杂烩，可以将springMVC用到的bean注册到spring中
约定优于配置
功能强大，restful、数据验证，格式化，本地化，主题
简洁灵活
使用的人多

1.4、中央控制器

spring的web框架围绕着dispatcherServlet设计，DispatcherServlet作用是将请求分发到不同的处理器
springMVC 框架像许多的其他的MVC框架一样，以请求为驱动，围绕着一个中心的Servlet分派请求提供其他的功能，DispatcherServlet实际上就是一个servlet
当发起请求的时候被前端的控制器进行拦截到请求，根据请求参数生成代理请求，找到请求对应的实际的控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器。控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，然后在将结果返回给请求者

在这里插入图片描述

1.5、springMVC的执行的流程

DispatcherServlet表示的是前端控制器，是整个springMVC的控制的中心，用户发起请求，DispatcherServlet接受到请求并且进行拦截请求
handlerMapping为处理器映射器，DispatcherServlet调用
handlerExecution表示的是具体的控制器，其主要的作用是根据url查找控制器
HandlerExetion将解析后的信息传递给DispatcherServlet，如解析控制器映射
HandlerAdapter表示为处理器适配器，按照特定的规则去执行Handler
handler让具体的Controller执行
Controller将具体的执行的信息返回给HandlerAdapter
handlerAdapter将视图逻辑名或者是模型传递给了DispatcherServlet
DispatcherServlet调用视图解析器去解析逻辑视图名
视图解析器将解析的逻辑视图名传递给DispatcherServlet
DispatcherServlet将根据视图解析器解析视图结果
呈现给用户

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5QKUBczF-1631113514600)(C:\Users\17451\Desktop\学习笔记\springMVC\springMVC(1)].assets\image-20210809153313296.png)$

通俗理解：

首先客户端发起请求，浏览器解析请求，调用前端控制器，然后通过处理器映射器handlerMapping，调用处理器适配器，找到对应的controller，创建一个modelandView，交给视图解析器进行渲染，然后再返回给前端控制器进行展示

1.6、控制器Controller

坐标

<!--        单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
<!--        spring所使用到的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</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.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">
<!--配置dispatcherServlet,springMvc的核心；请求分发器，又叫做前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--        DispatcherServlet要绑定spring的配置文件-->
        <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>
    <!--
    "/"和"/*"的区别
    /： 只匹配所有的请求，不会去匹配jsp的页面
    /* : 匹配所有的请求，包括jsp页面

    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

实现controller的接口：

package com.hema.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
//只要实现了Controller接口的类，就是一个控制器了
public class ControllerTest1 implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
      ModelAndView mv = new ModelAndView();
      mv.addObject("msg","2233");
      mv.setViewName("test");
        return mv;
    }
}

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:aop="http://www.springframework.org/schema/aop" 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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <!--    使用注解需要导入context约束-->
        <context:annotation-config/>
    <!--    指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.hema.controller"/>
<!--让springmvc不再处理静态的资源；-->
<mvc:default-servlet-handler/>
<!--
        支持MVC注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系，如果想要完成映射关系
        必须要上下文中注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter实例
        并且annotation-driver配置帮助我们完成以上的两个实例的注册
-->
    <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>
    <bean id="/hello" class="com.hema.controller.ControllerTest1"/>
</beans>

@Component 		组件
@Service		service
@Controller  	controller
@Repository		dao
@RestController  返回的直接是一个字符串，不会被视图解析器进行解析，用于接收json数据

使用注解进行开发：

controller:

package com.hema.controller;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller//代表着这个类会被spring进行接管，被这个注解的类中所有的方法，如果返回值是string并且具体的页面可以跳转的话，
// 那么就会被视图解析器进行解析
public class ControllerTest2 {
    @RequestMapping("/hello")
    public String test1(Model model) {//model和ModelAndView是一样的，是简化版的，用于向前端传递数据的对象
        model.addAttribute("msg","5464516");
        return "test";//
    }
}

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:aop="http://www.springframework.org/schema/aop" 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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <!--    使用注解需要导入context约束-->
        <context:annotation-config/>
    <!--    指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.hema.controller"/>
<!--让springmvc不再处理静态的资源；-->
<mvc:default-servlet-handler/>
<!--
        支持MVC注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系，如果想要完成映射关系
        必须要上下文中注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter实例
        并且annotation-driver配置帮助我们完成以上的两个实例的注册
-->
    <mvc:annotation-driven/>
    <!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--    前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--    后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

web.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">
<!--配置dispatcherServlet,springMvc的核心；请求分发器，又叫做前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--        DispatcherServlet要绑定spring的配置文件-->
        <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>
    <!--
    "/"和"/*"的区别
    /： 只匹配所有的请求，不会去匹配jsp的页面
    /* : 匹配所有的请求，包括jsp页面

    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

2、restFul风格

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

资源：互联网上的所有的事物都可以称为资源
资源操作：使用post、delete、put、get 来进行不同方式获取资源进行操作
分别对应，添加、删除、修改、查询

package com.hema.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ControllerRestful {
    @RequestMapping("/add")//原来的可以直接在路径上面进行拼接，变量名要和路径中的变量的命名一致对应才能找到
    public String add(int a, int b, Model model) {
        model.addAttribute("msg",(a+b)+"");
        return "hello";
    }
}

使用@PathVariable注解声明到变量上面，让对应的参数的值绑定到url路径上面

package com.hema.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {
//    原来的操作：http://localhost:8080/add?a=1&b=2
//    使用restful：http://localhost:8080/add/a/b
    /*
    使用@PathVariable注解，让对应的参数的值绑定到url路径上面

     */
    @RequestMapping(name="/add/{a}/{b}",method= RequestMethod.DELETE)
    public String test1(@PathVariable int a, @PathVariable int b, Model model) {//传递的值要跟定义的类型一致，不然无法进行接收
        int res =a + b;
    model.addAttribute("msg","结果为"+res);
        return "test";
    }
}

指定请求的类型

package com.hema.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class ControllerRestful {
    @RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
//    @GetMapping  可以使用RequestMapping来指定请求的类型是post还是get，路径使用value指定，请求的类型使用get进行指定
    public String add(@PathVariable int a, @PathVariable int b, Model model) {
        model.addAttribute("msg",(a+b)+"");
        return "hello";
    }
}

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

//WEB-INF目录下的页面和资源是不能通过浏览器进行直接访问的，但是后台可以通过转发或者重定向进行访问，视图解析器默认使用转发，重定向不走视图解析器，重定向不能访问WEB-INF下的内容，

package com.hema.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Controller
public class ModelTest1 {
    @RequestMapping("/t")
    public String test(Model model) {
       model.addAttribute("msg","7777777");
//       直接进行转发，无需视图解析器
//        return "/WEB-INF/jsp/hello.jsp";
//        转发
//        return "forward:/WEB-INF/jsp/hello.jsp";
        
//        重定向
        return "redirect:/index.jsp";
    }
}

2、接受请求参数以及数据的回显

提交的域名称和处理方法中的参数名称是一致的

package com.hema.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(String name, Model model) {
//        1.接受请求中的参数,因为如果变量名和请求参数中的名称一致的时候，可以直接进行赋值
        System.out.println("前端接收到的参数为"+name);
//        2.将返回的结果传递给前端,一般情况下使用model进行传值
        model.addAttribute("msg",name);
//        进行视图跳转
        return "/WEB-INF/jsp/hello.jsp";
        //默认使用的是转发，使用rediect可以进行重定向
         return "rediect:/book/allBook";
    }
}

提交的域名称和处理的方法的参数名称不一致,使用requestParam进行指定配对

package com.hema.controller;

        import org.springframework.stereotype.Controller;
        import org.springframework.ui.Model;
        import org.springframework.web.bind.annotation.GetMapping;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model) {
//        1.接受请求中的参数,因为如果变量名和请求参数中的名称一致的时候，可以直接进行赋值
        System.out.println("前端接收到的参数为"+name);
//        2.将返回的结果传递给前端,一般情况下使用model进行传值
        model.addAttribute("msg",name);
//        进行视图跳转
        return "/WEB-INF/jsp/hello.jsp";
    }
}

提交的是一个对象,直接使用对象进行接收

 @RequestMapping("/t2")
    public String test2(User user, Model model) {
//        接收前端的参数直接进行封装成一个对象，传递的参数必须要跟对象的属性名一致，如果不一致，就会返回一个null
        System.out.println(user);
        model.addAttribute("msg",user);
        return "/WEB-INF/jsp/hello.jsp";
    }

LinkedHashMap,ModelMap,ModelAndView的区别

Model: 只有很少的方法适合于存储数据，简化了新手对Model对象的操作和理解
ModelMap: 继承了LinkedMap 除了自身的方法外，同样继承了LinkedMap的方法和特性
ModelAndView：可以在存储数据的同时，可以进行设置返回的逻辑视图，进行控制层的跳转

3、解决乱码问题

之前解决中文乱码问题，写一个过滤器，然后注册到web.xml中

package com.hema.filter;

import javax.servlet.*;
import java.io.IOException;

public class EncodingFliter implements Filter {
//    继承一个Filter接口，实现其中的方法，写完之后，还需要去在web.xml中进行配置
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
//       在此处设置处理乱码的问题
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
//        过滤完成之后需要对其进行放行操作
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

在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">
    <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>
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.hema.filter.EncodingFliter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <!--
            /只是过滤根目录下的web应用，不包括jsp /*过滤根目录下的子目录以及所有的web应用，get请求不会乱码,tomcat已经帮我们解决

-->
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

配置SpringMVC的乱码过滤器

<!-- 配置中文乱码过滤器 -->
  <filter>
    <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
    <!-- 拦截所有请求 -->
              <!--
            /只是过滤根目录下的web应用，不包括jsp /*过滤根目录下的子目录以及所有的web应用，get请求不会乱码,tomcat已经帮我们解决

-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

3、JSON（前后端分离时代）

前后端分离时代：
- 前端独立部署，负责渲染后端的数据
- 后端部署后端提供接口，提供接口，提供数据

1.什么是JSON

JSON是一种轻量级的是数据交换格式，使用的非常广泛
采用完全独立于编程语言的文本格式来存储和表示数据
易于人的阅读，同时也易于机器的解析和生成，并且有效的提高了网络的传输效率

在JavaScript中，一切皆对象，任何JavaScript支持的类型都可以通过JSON来表示，如字符串，数字，对象和数组，以下是要求和语法：

对象表示为键值对，数据由逗号进行分隔
花括号保存对象
方括号保存数组

JSON键值对是用来保存JavaScript对象的一种方式，和javaScript对象的写法大同小异，键值对使用""分别包裹，使用:进行分隔

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

Json是JavaScript对象字符串的表示方法，他使用文本表示一个js对象的信息，本质上就是一个字符串

2、JSON和javaScript对象的相互转换

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
<!--  script不是单闭合的标签  -->
    <script>
<!--        编写javaScript对象-->
        var user={
            name:"lala",
            age:"23",
            sex:"男"
        };
console.log(user);
        //将js对象转换成json对象
        var json = JSON.stringify(user);
console.log(json);
        //将json对象转换成js对象
       var s = JSON.parse(json);
console.log(s);
    </script>
</head>
<body>

</body>
</html>

3、Controller返回JSON数据

Jackson是当前比较好用的json解析工具了，以下是该工具的使用说明

package com.hema.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.hema.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Controller
public class UserController {
    @RequestMapping("/j")
    @ResponseBody//添加该注解表示返回值不会被视图解析器进行解析，会直接返回一个字符串
    public String json() throws JsonProcessingException {
        User user = new User("zhangsan",52,"男");
        User user2 = new User("zhangsan",52,"男");
        User user3 = new User("zhangsan",52,"男");
        User user4 = new User("zhangsan",52,"男");
        User user5 = new User("zhangsan",52,"男");
        List<User> list = new ArrayList<>();
        list.add(user);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);
        用json来返回对象,jackson
//        ObjectMapper mapper = new ObjectMapper();
//        mapper.writeValueAsString(user);
        ObjectMapper mapper = new ObjectMapper();
//        将集合转换成json对象进行输出
        String s = mapper.writeValueAsString(list);

        return s ;
    }

//    json返回时间对象
    @RequestMapping("/j2")
    @ResponseBody
    public String json2() throws JsonProcessingException {
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String m = format.format(date);
        ObjectMapper mapper = new ObjectMapper();
        String s = mapper.writeValueAsString(m);
        return s;

    }

}

在配置文件springmvc-servlet.xml中进行配置,解决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>

FastJson是阿里开发的一款专门用于java的开发工具包，可以方便的实现json对象和javaBean对象的转换，实现json和json字符串的转换，实现JavaBean和json的转换，

1.导入坐标
```

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>
```
2.fastjson三个主要的类
- JSONObject代表了json对象
- JSONArray代表了数组对象
- JSON代表了JSONObject和JSONArray的转化

4、SpringMVC整合SSM

数据库环境创建：

USE ssmbuild;
CREATE TABLE `books`(
`bookID` INT NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` VARCHAR(100) NOT NULL COMMENT '书名',
`bookCounts` INT NOT NULL COMMENT '数量',
`detail` VARCHAR(200) NOT NULL COMMENT '描述',
KEY `bookID`(`bookID`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

pom文件信息：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hema</groupId>
    <artifactId>ssmbulid</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
<!--    依赖：
              junit,数据库驱动，连接池，servlet,jsp,mybatis,mybatis-spring,spring
-->
    <dependencies>
<!--        单元测试-->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
<!--数据库的驱动-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
<!--        数据库的连接池-->
        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

<!--    静态资源过滤问题-->


        <build>
            <resources>
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>true</filtering>
                </resource>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>true</filtering>
                </resource>
            </resources>
        </build>
    <!--    过滤字符串的问题-->
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
</project>

com.hema.dao

package com.hema.dao;

import com.hema.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BookMapper {
//    增加一本书
    int addBook(Books book);
//    删除一本书
    int deleteBookById(@Param("bookId") int id);
//    更新一本书
    int updateBook(Books book);
//    查询所有的书
    List<Books> findAll();
}

com.hema.service

package com.hema.service;

import com.hema.dao.BookMapper;
import com.hema.pojo.Books;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Service;

import java.util.List;

public interface BookService {

    //    增加一本书
    int addBook(Books book);
    //    删除一本书
    int deleteBookById(@Param("bookId") int id);
    //    更新一本书
    int updateBook(Books book);
    //    查询所有的书
    List<Books> findAll();
}

com.hema.serviceImpl

package com.hema.service;

import com.hema.dao.BookMapper;
import com.hema.pojo.Books;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class BookServiceImpl implements BookService {

    private BookMapper bookMapper;

    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    @Override
    public int addBook(Books book) {
        int i = bookMapper.addBook(book);
        return i;
    }

    @Override
    public int deleteBookById(int id) {
        return 0;
    }

    @Override
    public int updateBook(Books book) {
        return 0;
    }

    @Override
    public List<Books> findAll() {
        List<Books> list = bookMapper.findAll();
        return list;
    }
}

com.hema.controller

package com.hema.controller;

import com.hema.pojo.Books;
import com.hema.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/book")
public class BookController {

    @Qualifier("BookServiceImpl")
    @Autowired
    private BookService bookService;
//查询全部的书籍
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.findAll();
        model.addAttribute("list" ,list);

        return "allBook";
    }
//    跳转到增加书籍页面
    @RequestMapping("/toAddBook")
    public String toAddPaper() {
        return "addBook";
    }
    @RequestMapping("/addBook")
    public String addBook(Books books) {
        System.out.println("addbook=>"+books);
        int i = bookService.addBook(books);
        if (i !=0) {
            System.out.println("添加才成功");
        }
//        重定向到
        return "redirect:/book/allBook";
    }

}

**配置文件：**将文件进行拆分成三层，dao整合mybatis、数据库连接池、sqlSessionFactory注入和dao层mapper接口的注入，service层、加载注解驱动和扫描、配置spring的事务,controller配置视图解析、导入视图解析器的约束、以及静态资源的过滤，这最后applicationContext进行将所有文件进行整合

dao对应的xml的sql配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hema.dao.BookMapper">
    <insert id="addBook" parameterType="Books">
        insert into books (bookName,bookCounts,detail)
        values (#{bookName},#{bookCounts},#{detail})
    </insert>
    <delete id="deleteBookById" parameterType="int">
        delete from books where bookId = #{id}
    </delete>
    <update id="updateBook" parameterType="Books">
        update books
        set bookName=#{bookName},bookCounts=#{bookCounts},detail=#{detail}
        where bookId = #{bookId}
    </update>
    <select id="findAll" resultType="Books">
        select *from books
    </select>
</mapper>

applicationContext.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:aop="http://www.springframework.org/schema/aop" 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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <import resource="spring-mvc.xml"/>
    <import resource="spring-service.xml"/>
    <import resource="spring-dao.xml"/>



</beans>

spring-dao.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    主要整合·Mybatis以及数据库的连接-->
<!--        1.关联数据库配置文件，一定要加classpath前缀，不然会报错，找不到jdbc这个文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

<!--    2.连接池出来
        dbcp: 半自动化操作
        c3p0： 自动化操作，自动加载配置文件，可以自动设置到对象中去
        druid
        hikari
-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

    </bean>

<!--    3.sqlSessionFactory-->

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        绑定mybatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
<!--    配置接口扫描包，动态的实现了Dao接口可以注入到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--        注入sqlsessionfactory，sqlSessionFactoryBeanName是string类型的，因此，是使用的value进行赋值操作
            根据name=""，进而判断使用value还是ref进行引用
-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--        扫描Mapper接口的，并且给spring进行代理-->
        <property name="basePackage" value="com.hema.dao"/>
    </bean>
</beans>

spring-service.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
        <!--    使用注解需要导入context约束-->
        <context:annotation-config/>
    <!--   1. 指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.hema.service"/>
<!--        2.将所有的业务类注入到Spring中去，通过配置或者注解进行实现-->
        <bean id="BookServiceImpl" class="com.hema.service.BookServiceImpl">
            <property name="bookMapper" ref="bookMapper"/>
        </bean>
<!--    3.声明式事务的配置-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        注入事务源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--   4.AOP 注入事务支持-->



</beans>

spring-mvc.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:aop="http://www.springframework.org/schema/aop" 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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--  1.  使用注解需要导入mvc约束-->
    <mvc:annotation-driven/>
    <!--  2.  指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.hema.controller"/>
    <!--  3.  静态资源的过滤-->
    <mvc:default-servlet-handler/>
    <!--    视图解析器-->
    <bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

mybatis核心配置文件，很大部分已经和spring进行整合，作用有点小:

<?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE configuration
                PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

<!--    起别名,就不用使用包的路径-->
<typeAliases>
    <package name="com/hema/pojo"/>
</typeAliases>
<mappers>
    <mapper resource="com/hema/dao/bookMapper.xml"/>
</mappers>
</configuration>

jdbc.properties:

#一定要加前缀jdbc,不然无法进行识别，SQLSTATE[HY000] [1045] Access denied for user 'root'@'localhost' (using password: YES)
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=FALSE&userUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
jdbc.username=root
jdbc.password=123456