狂神SpringMVC教学视频学习笔记，包括回顾JavaWeb、SpringMVC原理、RestFul风格、JSON、整合SSM等内容

0 JAVAWEB回顾

首先回顾一下之前JavaWeb的学习笔记

一个网站的结构：

--webapps ：Tomcat服务器的web目录
	-ROOT
	-kuangstudy ：网站的目录名
		- WEB-INF
			-classes : java程序
			-lib：web应用所依赖的jar包
			-html文件夹  内含各种html页面
			-web.xml ：网站配置文件
		- index.html 默认的首页
		- static  各种静态资源
            -css
            -js
            -img
         -.....

HTTP（超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上。

Http请求：get 、post
Http响应：响应状态码
浏览器输入url后回车到页面展示，经历的过程？

Maven：项目架构管理工具

Tomcat服务器：是一个免费的开放源代码的Web 轻量级应用服务器

Servlet

Servlet：把实现了Servlet接口的Java程序叫做Servlet，HttpServlet接口。

1 编写一个普通类HelloServlet实现Servlet接口，这里我们直接继承HttpServlet
2 编写Servlet的映射，即在web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径
3 配置Tomcat，启动测试

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，会

ServletContext代表了当前的web应用，功能有：共享数据、获取初始化参数、请求转发、读取资源文件Properties，
HttpServletResponse响应，功能有输出消息、下载文件、验证码、重定向、登录重定向
HttpServletRequest请求，获得客户端的所有信息，获取参数、请求转发

Cookie通过在客户端记录信息确定用户身份

给客户端们颁发一个通行证吧，每人一个，无论谁访问都必须携带自己通行证。这样服务器就能从通行证上确认客户身份了。这就是Cookie的工作原理。Cookie实际上是一小段的文本信息，储存在浏览器中。服务器还可以根据需要修改Cookie的内容。

Session通过在服务器端记录信息确定用户身份

Session是服务器端使用的一种记录客户端状态的机制，使用上比Cookie简单一些，相应的也增加了服务器的存储压力。

Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。

cookie和session的区别

一个是IE启动到IE关闭.(浏览器页面一关 ,session就消失了)，一个是预先设置的生存周期，或永久的保存于本地的文件。(cookie)
cookie数据存放在客户的浏览器上，session数据放在服务器上.
session会比较占用你服务器的性能考虑到减轻服务器性能方面，应当使用cookie，考虑到安全应当使用session。
单个cookie保存的数据不能超过4K，很e多浏览器都限制一个站点最多保存20个cookie

JSP: Java Server Pages

JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！

JSP最终也会被转换成为一个Java类！JSP 本质上就是一个Servlet

JSP语法，JSP9大内置对象

- PageContext    存东西
- Request     存东西
- Response
- Session      存东西
- Application   【SerlvetContext】   存东西
- config    【SerlvetConfig】
- out
- page ，不用了解
- exception

作用域的区别：

request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看就没用的！

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据；

MVC三层架构

Model

业务处理：业务逻辑（Service）
数据持久层：CRUD （Dao）

View

展示数据
提供链接发起Servlet请求（a，form，img…）

Controller （Servlet）

接收用户的请求：（req：请求参数、Session信息….）
交给业务层处理对应的代码
控制视图的跳转

登录--->接收用户的登录请求--->处理用户的请求（获取用户登录的参数，username，password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）--->Dao层查询用户名和密码是否正确-->数据库

过滤器Filter、监听器

1 回顾Servlet

首先搭建基本环境：建一个Maven项目作为父项目，导入公用的依赖，建子Maven普通项目、并添加框架支持web-app.

Servlet开发的三个步骤如下：

1 编写一个普通类XXServlet实现Servlet接口，这里我们直接继承HttpServlet

2 修改欢迎界面index.jsp（即首页）做成表单的格式；编写视图界面hello.jsp

3 编写Servlet的映射，即在web.xml服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径

4 配置Tomcat，启动测试

1 编写一个Servlet类，重写doGet和doPost方法用来处理用户的请求
- 前端传过来的参数name为method111,存入字符method中

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 获取前端参数
        String method = req.getParameter("method111");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法。");
        }
        if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法。");
        }
        // 2. 调用业务层
        //3.视图转发 (或者重定向)
        req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

2 修改欢迎界面index.jsp做成表单的格式；编写视图界面hello.jsp
- index.jsp首页界面默认存在，body部分洗一个表单提交参数 name设为method111,,传参方式为post
- 写Hello.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <form action="/hello" method="post">
      <input type="text" name="method111">
      <input type="submit">
    </form>
  </body>
</html>

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>wuKang</title>
</head>
<body>
    <%-- 获取setvlst中传递的msg?--%>
    ${msg}
</body>
</html>

3 在web.xml配置中编写Servlet的映射，用mapping指定url

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    <!-- 在web.xml中注册Servlet-->
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <!--超时，刷新-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

4 配置Tomcat，启动测试

2 初识Spring MVC

先用一个springMCV的demo入门，然后一究其原理。

2.1 第一个Spring MVC程序

1、新建一个Moudle ， springmvc-02-hello ，添加web的支持！

2、确定导入了SpringMVC 的依赖！

3、配置web.xml ，注册DispatcherServlet【写死的】

注册DispatcherServlet,并将其关联一个springmvc的配置文件:【servlet-name】-servlet.xml

设置DispatcherServlet，能匹配所有的请求

4、在resource目录下编写SpringMVC 的配置文件！名称：springmvc-servlet.xml : [servletname]-servlet.xml 说明，这里的名称要求是按照官方来的

添加处理映射器【写死的】

添加处理器适配器【写死的】

添加视图解析器【写死的】

5、编写我们要操作业务Controller ，要么实现Controller接口，要么增加注解；需要返回一个 ModelAndView，装数据，封视图；

6、将自己的类HelloController交给SpringIOC容器，注册bean

7、写要跳转的jsp页面hello.jsp，显示ModelandView存放的数据，以及我们的正常首页index.jsp；

8、配置tomcat,启动

3、配置web.xml ，注册DispatcherServlet【写死的】

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.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-->
        <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>

4、在resource目录下编写SpringMVC 的配置文件！名称：springmvc-servlet.xml 【三个写死的】

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

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

    <!--视图解析器:DispatcherServlet给他的ModelAndView
    1. 获取了ModelAndView的数据
    2. 解析ModelAndView的视图名字
    3. 拼接视图名字，找到对应的视图
    4. 将数据渲染到当前视图上-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


</beans>

5、编写我们要操作业务HelloController，要么实现Controller接口，要么增加注解

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC_wukang!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

6、在springmvc的配置文件springmvc-servlet.xml中注册了一下类HelloController

1 2	<!-- 在spring中注册我们的HelloController--> <bean id="/hello" class="com.kuang.controller.HelloController"/>

7、在WEB-INF包下建jsp包下写一个hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>wuKang</title>
</head>
<body>
    <%-- 获取setvlst中传递的msg?--%>
    ${msg}
</body>
</html>

8、配置Tomcat 并启动

可能遇到的问题：访问出现404，排查步骤： 1. 查看控制台输出，看一下是不是缺少了什么jar包。 2. 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！3. 重启Tomcat 即可解决！

总结

/hello没有在web.xml中配置也没有写Servlet，springmvc配置文件的处理映射器、处理器适配器等将去自动匹配可以处理这个/hello，url的Controller，然后对应的Controller返回一个ModelAndView，然后视图解析式帮我们拼接出来真正hello.jsp所在的位置，返回该页面。

也就是如果要有一个新的url： /hello2，，我们只需要在springmvc的配置文件中注册一下，然后再写一个具体的Controller类就好了。（不用再写Servlet了）

2.2 SprincgMVC执行原理

中心控制器DispatcherServlet

SpringMVC的执行过程是围绕着DispatcherServlet的调度来设计的，称为中心控制器。SpringMVC框架也是以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet实际上就是一个具体的Servlet (它继承自HttpServlet 基类)，也就是说DispatcherServlet就是SpringMVC框架的中心Servlet。

SprincgMVC的执行流程

我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

DispatcherServlet的作用是将请求分发到不同的处理器。不同的处理器处理并返回对应的结果给DispatcherServlet，最核心的三个大步骤如下：

1 2 3 4步调用处理器映射HandlerMapping 和解析控制器映射HandlerExecution
- 其主要作用是根据url查找控制器，上面url被查找控制器Hander 为：hello。
5 6 7 8步就是调用我们找到的控制器Hander 让他调用Controller,获得视图和Model
- HandlerAdapter表示处理器适配器，让具体的Controller执行
- Controller执行时调用dao层，获得具体的执行结果
9 10 11 12步可以说是视图渲染和呈现视图
- 视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名
- DispatcherServlett根据视图解析器解析的视图结果，调用具体的视图

具体的执行过程（贴过来吧）：上图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。我们假设请求的url为 : http://localhost:8080/SpringMVC/hello，上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping。HandlerMapping根据请求url查找Handler。

HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello

HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

Handler让具体的Controller执行Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

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

视图解析器将解析的逻辑视图名传给DispatcherServlet。

DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

最终视图呈现给用户。

2.3 注解版的Spring MVC程序

环境搭建好之后，只需要编写具体的Controller类（使用注解），编写视图页面hello.jsp，

1 新建一个Moudle，springmvc-03-hello-annotation 。添加web支持！

2 在pom.xml文件引入相关的依赖：主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了！此时加一个<build></build>避免资源过滤问题【写死的】

3 配置web.xml，注册DispatcherServlet 关联SpringMVC的配置文件启动级别为1 映射路径为 / 【写死的】

4 添加Spring MVC配置文件springmvc-servlet.xml【写死的】

自动扫描包，让指定包下的注解生效,由IOC容器统一管理

让Spring MVC不处理静态资源

支持mvc注解驱动

视图解析器

5 编写一个Java控制类：HelloController

@Controller是为了让Spring IOC容器初始化时自动扫描到；

@RequestMapping是为了映射请求路径

方法中声明Model类型的参数是为了把Action中的数据带到视图中

方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

6 在WEB-INF/ jsp目录中创建hello.jsp，视图可以直接取出并展示从Controller带回的信息；可以通过EL表示取出Model中存放的值，或者对象

7 配置Tomcat ，开启服务器，访问对应的请求路径！

2 在pom.xml文件引入相关的依赖

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

3 配置web.xml，注册DispatcherServlet 关联SpringMVC的配置文件启动级别为1 映射路径为 /

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">

    <!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <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>

    <!--所有请求都会被springmvc拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

4 在resource下添加Spring MVC配置文件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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/mvc 
       https://www.springframework.org/schema/mvc/spring-mvc.xsd 
       http://www.springframework.org/schema/context 
       https://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.kuang.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>

5 编写一个Java控制类：HelloController

@Controller
@RequestMapping("/HelloController")  //localhost:8080/HelloController/h1
public class HelloController {
    @RequestMapping("/h1")
    public String hello(Model model){
        //封装数据 向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg","Hello,SpringMVCAnnotation");
        return "hello"; // 会被视图解析器处理 web-inf/jsp/hello.jsp
    }
}

6 在WEB-INF/ jsp目录中创建hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>wuKang222</title>
</head>
<body>
    <%-- 获取setvlst中传递的msg?--%>
    ${msg}
</body>
</html>

7 配置Tomcat ，开启服务器，访问对应的请求路径！

如果还是访问出现404就在IDEA的项目发布中，添加lib依赖！然后重启Tomcat！

2.4 注解介绍和RestFul风格

@Controller和@RequestMapping

@Controller是为了让Spring IOC容器初始化时自动扫描到控制类；Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。

1 2	<!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 --> <context:component-scan base-package="nuc.ss.controller"/>

@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/h1；

RestFul 风格

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

举一个传参的栗子：@RequestMapping("/add/{p1}/{p2}")

需要使用 @PathVariable 注解，让方法参数的值对应绑定到一个URL模板变量上。

@Controller
public class RestFulController {

   //映射访问路径
   @RequestMapping("/add/{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";
  }
}

使用RestFul，访问 localhost:8080/add/1/2 ，返回的界面为“结果为：3”
如果不使用的话，以前的访问路径是 localhost:8080/add/a=1&b=2

栗子2：使用method属性指定请求类型

几个类似的组合注解，用于指定请求的方式。比如：@GetMapping 是一个组合注解它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

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

http://127.0.0.1/item/1 查询,GET
http://127.0.0.1/item/1 删除,DELETE
http://127.0.0.1/item 新增,POST
http://127.0.0.1/item 更新,PUT

比如查询和删除的url一样、新增和更新的url也一样，但指定的请求方式不一样，会走不同的方法。一般来说所有的地址栏请求默认都会是GET 类型的。

2.5、处理提交数据

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

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

处理方法 :

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

后台输出 : kuangshen

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

提交数据 : http://localhost:8080/hello?username=kuangshen

处理方法 :

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

后台输出 : kuangshen

3、提交的是一个对象

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

实体类

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

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

处理方法 :

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

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

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

2.6、数据显示到前端

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

ModelMap

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

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

对比

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

1
2
3

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

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

2.7 处理乱码问题

处理办法，直接使用SpringMVC内置一个过滤器，直接在web.xml中注册即可：

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

举一个例子：

在WEB-INF文件下面写一个form表单页面form.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>form_wukang</title>
</head>
<body>
    <form action="/hello/h3" method="post">
        <input type="text" name="nameForm">
        <input type="submit">
    </form>
</body>
</html>

HelloController中写一个获取表单数据，并再传给前端页面hello.jsp的方法

//处理提交的数据并显示到前端
@PostMapping("/hello/h3")
public String test02(String nameForm,Model model){
    //获取表单提交的nameForm值 再传给前端
    model.addAttribute("msg_wk",nameForm);
    return "hello";
}

hello.jsp前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title_wukang</title>
</head>
<body>
    <%-- 获取setvlst中传递的msg?--%>
    获取的参数为：${msg_wk}
</body>
</html>

要注意的是form表单的action要和test02方法的路径一致，form表单的name要和test02的参数名一致；还有后台通过model传值给前端的msg_wk变量名也是要保证一致的。

没有设置过滤器和设置了过滤器之后的结结果对比

3 JSON

3.1 JSON介绍

前后端分离时代：

后端部署后端：提供接口、提供数据

==JOSN就是用来在前后端之间传递数据的一种格式==
前端独立部署：拿到数据后，负责渲染后端的数据

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，采用完全独立于编程语言的文本格式来存储和表示数据。

JS对象和JSON的格式

1
2

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

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。
任何JavaScript 支持的类型都可以很简单的通过 JSON 来表示，转换十分方便

JS对象和JSON的转换

JSON字符串转JavaScript 对象，使用 JSON.parse() 方法：

1 2	var obj = JSON.parse('{"a": "Hello", "b": "World"}'); //结果是 {a: 'Hello', b: 'World'}

JavaScript 对象转JSON字符串，使用 JSON.stringify() 方法：

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

3.2 Controller类返回JSON对象

JSON一般存键值对比如复杂对象，所以建一个User实体类表示对象。然后还需要用到一个新注解@ResponseBody和一个新的对象ObjectMapper ，并且一般要防止乱码问题（工具类？）。

可以使用的解析工具有Jackson、fastjson（阿里）等。这里使用Jackson。需要先导入Jackson的依赖

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

操作步骤如下所示

1 搭建基础环境：导入依赖、配置web.xml，配置springmvc-servlet.xml

2 建一个实体类 User （这里用lombok依赖会很方便），编写我们的测试Controller

3 springmvc的配置指定StringHttpMessageConverter转换配置,防止JSON乱码

4 启动Tomcat 测试

2建实体类User，编写我们的 JSONController

先引入lombok依赖

<!--lombok依赖-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

建实体类

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

编写 JsonController

@Controller
public class JsonController {

    @RequestMapping("/json/j1")
    @ResponseBody
    private String json01() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        User user01 = new User("风清扬", 18, "man");
        //将我们的对象解析成为json格式
        String sJson = mapper.writeValueAsString(user01);
        return sJson;
    }
}

3 springmvc-servlet.xml配置文件中指定StringHttpMessageConverter转换配置,防止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>

配置Tomcat 启动，未引入过滤器和引入过滤器的结果对比：

同样的，我们增加一个方法，测试将集合对象转换为JSON:

1 添加json02()方法

2 启动Tomcat测试

添加json02()方法，转换对象为List集合

@RequestMapping("/json/j2")
@ResponseBody
private String json02() throws JsonProcessingException {
    //创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    //构造list对象集合
    User user01 = new User("风清扬1", 18, "man");
    User user02 = new User("风清扬2", 19, "woman");
    User user03 = new User("风清扬3", 20, "man");
    List<User> list  = new ArrayList<>();
    list.add(user01); list.add(user02);list.add(user03);
    //将我们的list集合对象解析成为json格式
    String sJson = mapper.writeValueAsString(list);
    return sJson;
}

配置Tomcat 启动，结果如下

总结：

引入Jackson的依赖，使用Jackson包对转换JSON数据格式的支持
springmvc-servlet.xml配置文件中指定StringHttpMessageConverter转换配置,防止JSON乱码
ObjectMapper()对象的writeValueAsString()方法可以用来将java对象转换为JSON字符串
@ResponseBody注解会将String转成json格式返回；所以我们直接return一个字符串即可，十分方便
@RestController = @ResponseBody + @Controller

3.3 输出时间对象

这里就先不看了，思路就是写工具类，直接调用。

4 整合SSM

终于到了结束SSM框架的时刻了，从1月份就开始想整框架、结果一直到6月底才搞完这最基础的框架、前路漫漫啊！整合SSM需要的基本知识

MySQL数据库基本操作、建表，增删改查
Mybatis的使用，mybatis的配置实现接口，用来写sql语句
Spring的使用，利用Spring容器来创建和管理对象
SpringMVC的使用，利用注解传参、获取界面、渲染界面
简单的前端知识JavaScript，html， ccs

整体流程如下：

基本框架的搭建

1、数据库建表，创建一个存放书籍数据的数据库表

2、创建maven项目，添加web支持，导入相关的依赖pom.xml，并设置资源过滤<build>

3、建各层的包pojo实体类、dao持久层、service业务层、controller控制层

4、resource下建mybatis的配置文件mybatis-config.xml，，spring的配置文件applicationContext.xml

mybatis框架部分的编写

1、数据库配置文件 database.properties（其实也可以直接写在mybatis-config.xml里面）

2、IDEA关联数据库开启

3、编写MyBatis的核心配置文件mybatis-config.xml：

4、编写实体类com.kuang.pojo.Books

5、编写Dao层的XXMapper接口，里面是各种增删改查的抽象方法

==6、编写接口对应的 XXMapper.xml 文件。(需要导入MyBatis的包namespace为接口类)==

7、编写Service层的接口XXService和实现类XXServiceImpl，实现类需要用set方法注入XXMapper

Spring框架部分的编写

1、编写Spring整合Mybatis的相关的配置文件： spring-dao.xml，dao.xml中绑定mybatis-config.xml

2、Spring整合service层,写一个spring-service.xml的配置文件：即将Service注入为bean，注入连接池、配置事务管理器等

SpringMVC框架部分的编写

1、编写web应用的配置文件web.xml，里面加载spring的总配置文件，设置乱码过滤器等

2、编写springMVC的配置文件spring-mvc.xml：开启注解支持、设置视图解析器等

3、sping真正的配置文件applicationContext.xml，import导入其他的配置文件

配置搞定之后，编写Controller和视图层jsp

1、一个BookController类，下面有：查询全部书籍、添加书籍、修改书籍、删除书籍四个方法

2、对应的需要写：书籍列表页面 allbook.jsp、添加书籍页面addBook.jsp、修改书籍页面 updateBook.jsp、还有主页index.jsp页面

最后配置Tomcat，进行运行！

落风的风

SpringMVC_笔记（狂神）

0 JAVAWEB回顾

Servlet

JSP: Java Server Pages

MVC三层架构

1 回顾Servlet

2 初识Spring MVC

2.1 第一个Spring MVC程序

2.2 SprincgMVC执行原理

2.3 注解版的Spring MVC程序

2.4 注解介绍和RestFul风格

RestFul 风格

2.5、处理提交数据

2.6、数据显示到前端

2.7 处理乱码问题

3 JSON

3.1 JSON介绍

3.2 Controller类返回JSON对象

3.3 输出时间对象

4 整合SSM

5 Ajax

6 拦截器

7 文件上传下载

0 JAVAWEB回顾

Servlet

Cookie、Session

JSP: Java Server Pages

MVC三层架构

1 回顾Servlet

2 初识Spring MVC

2.1 第一个Spring MVC程序

2.2 SprincgMVC执行原理

2.3 注解版的Spring MVC程序

2.4 注解介绍和RestFul风格

RestFul 风格

2.5、处理提交数据

2.6、数据显示到前端

2.7 处理乱码问题

3 JSON

3.1 JSON介绍

3.2 Controller类返回JSON对象

3.3 输出时间对象

4 整合SSM

5 Ajax

6 拦截器

7 文件上传下载