一：SpringMVC

java开源框架，Spring Framework的一个独立模块。
MVC框架,在项目中开辟MVC层次架构
对控制器中的功能包装简化扩展践行工厂模式，功能架构在工厂之上

MVC : Model View Controller

模型视图控制器
模型：即业务模型，负责完成业务中的数据通信处理，对应项目中的 service和dao
视图：渲染数据，生成页面。对应项目中的Jsp
控制器：直接对接请求，控制MVC流程，调度模型，选择视图。对应项目中的Servlet

MVC是现下软件开发中的最流行的代码结构形态;
人们根据负责的不同逻辑，将项目中的代码分成 M V C 3个层次;
层次内部职责单一，层次之间耦合度低;
符合低耦合高内聚的设计理念。也实际有利于项目的长期维护。

二. 开发流程

2.1 废话不多说先导依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

2.2 配置核心(前端)控制器

作为一个MVC框架，首先要解决的是：如何能够收到请求！

所以MVC框架大都会设计一款前端控制器，选型在 Servlet 或 Filter两者之一,在框架最前沿率先工作，接收所有请求。

此控制器在接收到请求后，还会负责springMVC的核心的调度管理，所以既是前端又是核心。
**为了解决这个问题，我们需要在web.xml中添加一个servlet用来接受所有请求并交给Spring工厂进行操作**

<servlet>
    <servlet-name>mvc9</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <!-- 局部参数：声明配置文件位置 -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:mvc.xml</param-value>
    </init-param>
    <!-- Servlet启动时刻：可选 -->
    <load-on-startup>1</load-on-startup>
   
</servlet>
<servlet-mapping>
    <servlet-name>mvc9</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

名字可以随意不影响，这样，所有的请求我们就都可以接收到了

2.3 后端控制器

请求我们接受了，接下来我们就要进行处理请求，以前我们通过servlet进行处理，现在我们要写的等价于之前的servlet

下面是一个例子：

@Controller //声明这是一个控制器
@RequestMapping("/hello")  //访问路径 ，等价于url-pattern
public class HelloController {
    @RequestMapping("/test1")  //访问路径
    public String hello1(){
        System.out.println("hello world");
        return "index"; // 跳转:/index.jsp  
    }
    @RequestMapping("/test2") //访问路径
    public String hello2(){
        System.out.println("hello c9");
        return "views/users";//  跳转:/views/user.jsp
    }
}

2.4 配置文件

默认名称：核心控制器名-servet.xml 默认位置：WEB-INF
随意名称：mvc.xml 随意位置：resources 但需要配置在核心控制器中

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

    <!-- 告知springmvc  哪些包中 存在 被注解的类 -->
    <context:component-scan base-package="com.zhj.controller"></context:component-scan>
    <!-- 注册注解开发驱动 -->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!-- 视图解析器
         作用：1.捕获后端控制器的返回值="index"
              2.解析： 在返回值的前后 拼接 ==> "/index.jsp"
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

3. 接收请求参数

通过控制器中方法的形参接收请求参数
请求参数要和方法的形参同名

// id  name gender
// springMVC默认可以识别的日期字符串格式为： YYYY/MM/dd HH:mm:ss
// http://localhost:8989/xxx/../text1?id=1&name=zzz&gender=false&birth=2018-12-12 12:20:30
@RequestMapping("/test1")
public String testParam1(Integer id,
                         String name,
                         Boolean gender,
                         @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")Date birth){
    System.out.println("test param1");
    return "index";
}

3.2 实体收参(建议)

请求参数和实体的属性同名即可(会自动帮助我们封装成对象，超省事的)

public class User {
    private Integer id;
    private String name;
    @DateTimeFormat(pattern="yyyy-MM-dd")
    private Date birth;
    private Boolean gender;
    //set/get ...
}

//http://localhost:8989/.../test2?id=1&name=zzz&gender=false&birth=2018-12-12 12:20:30
@RequestMapping("/test2")
public String testParam2(User user){
    System.out.println("test param2");
    System.out.println("user:"+user);
    return "index";
}

3.5 中文乱码

首先，页面中字符集统一
JSP : <%@page pageEncoding="utf-8" %>
HTML : <meta charset="UTF-8">
其次，tomcat中字符集设置，对get请求中，中文参数乱码有效
Tomcat配置：URIEncoding=utf-8
最后，设置此filter，对post请求中，中文参数乱码有效

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

4. 跳转

跳转关键字 forward: redirect:

4.1 C-->V controller--->view

【C-->V】
@RequestMapping("/test1")
public String testJump1(){
    System.out.println("test jump1");
    //重定向跳转   /index.jsp
    //return "redirect:/index.jsp";
    //转发跳转  /views/users.jsp
    return "forward:/views/users.jsp";
}

4.2 C-->C

【C-->C】
@RequestMapping("/test2")
public String testJump2(){
    System.out.println("test jump2");
    //转发跳转到  /jump/test1
    //return "forward:/jump/test1";
    //跳转到当前类下的 路径为test1的方法中
    //return "forward:test1";
    //重定向到 /jump/test1
    return "redirect:test1";
}

4.3 跳转细节

1.在增删改之后，为了防止请求重复提交，重定向跳转
2.在查询之后，可以做转发跳转
3.C到C，一般是增删改后衔接一个查询
4.C到V，一般是查询后衔接一个视图

4.4 jsp需要注意的细节

1.不应该直接访问jsp，应该先过C，查到数据后，在转发jsp（jsp需要数据的支撑）
2.可以将所有jsp都放入 WEB-INF目录下，即可强制不接受外界直接访问，只能由C转发（只能转发，哪怕是重定向也无法访问该目录下的jsp文件）

五传值问题

在后端传值一般都存在request作用域中，如果需要长期保持用户登录信息等，可以存放在session中

六 SpringMVC中的Model ，ModelAndView 对象

Model对象的作用基本和request的作用一致
而ModelAndView对象即封装了数据，也封装也view

七 SpringMVC中的静态资源

静态资源指的是：html，js文件，css文件，图片等

静态文件没有url-pattern,所以默认是访问不到的，之所以可以访问，是因为，tomcat中有一个全局的servlet：org.apache.catalina.servlets.DefaultServlet，它的url-pattern是 "/",是全局默认的Servlet. (最后都不处理就轮到他了) 所以每个项目中不能匹配的静态资源的请求，有这个Servlet来处理即可。

但是在SpringMVC中的核心构件DispatcherServlet也采用了“/”来作为url-pattern，所以项目中的全局默认servlet就无法在进行使用，静态资源访问也就无法完成

7.1 解决方案1

DispathcerServlet采用其他的url-pattern
此时，所有访问handler的路径都要以 action结尾！！(action只是习惯，在这里可以随意填)

<url-pattern>*.action</url-pattern>

7.2 解决方案2

DispathcerServlet的url-pattern依然采用 "/",但追加配置

<!--            这个东西有个高大上的名字---------》静态资源扫描器
  额外的增加一个handler，且其requestMapping:  "/**" 可以匹配所有请求，但是优先级最低
  所以如果其他所有的handler都匹配不上，请求会转向 "/**" ,恰好，这个handler就是处理静态资源的
  处理方式：将请求转会到tomcat中名为default的Servlet

  request-mapping: /*  /a  /b   /c   /ssss
                 : /**   /a   /b   /c    /a/b/c/df/d/f/fe/fefef/d
  -->
<mvc:default-servlet-handler/>

8. JSON处理（重重重重重重重重重重点）

JSON是前后端进行数据交互的一种重要手段，而在SpringMVC中采用的默认JSON解决方案是JackSon，只需要导入Jackson的依赖，就可以使用

8.1 导入依赖

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>
<!-- FastJson 我是中国人，还是喜欢fastjson一点，嘿嘿嘿-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.54</version>
</dependency>

8.2 使用@ResponseBody（将handler的返回值，转换成json并将json响应给客户端。）

简单举例一下：

@RequestMapping("/test1")
@ResponseBody //将handler的返回值，转换成json(jackson),并将json响应给客户端。
public User hello1(){
    System.out.println("hello world");
    User user = new User();
    return user;
}
//@ResponseBody还可以用在handler的返回值上
@RequestMapping("/test2")
public @ResponseBody List<User> hello2(){
    System.out.println("hello world");
    List<User> users = Arrays.asList(new User(),new User());
    return users;
}

8.3 jackson的日期格式化

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
作用：将前端传过来的json串中的日期转换为指定的格式

public class User implements Serializable{
    private Integer id;
    private String name;
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date birth;
    ....

8.4 FastJson(又到最喜欢的FastJson环节啦~~~)

因为SpringMVC中默认使用的是jackson所以如果我们想要使用FastJson还需要在工厂中安装FastJson

8.4.1 FastJson的安装(废话不多说，上代码)

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <!-- 声明转换类型:json -->
            <property name="supportedMediaTypes">
                <list>
                    <value>application/json</value>
                </list>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

至于使用方式，和jackson基本没差别

8.4.3 日期格式化

@JSONField(format="yyyy/MM/dd")

public class User implements Serializable{
    private Integer id;
    private String name;
    @JSONField(format="yyyy/MM/dd")
    private Date birth;
    ...

8.5 @RestController

等价于在本类的所有Handler中都添加了@ResponseBody

@RestController // 等价于在本类的所有Handler中都添加了@ResponseBody
@RequestMapping("/json")
public class MyController {

    @RequestMapping("/test1")
    public User queryOneUser(Integer id){
        ....
    }
}

8.6 使用@RequestBody

@RequestBody, 接收Json参数并将其自动转换为java对象

@RequestMapping("/users")
public String addUser(@RequestBody User user){//@RequestBody将请求体中的json数据转换为java对象
    System.out.println("cap2");
    System.out.println("Post user :"+user);
    return "index";
}

9. 异常解析器

项目中会面临各种异常。
1. 运行时异常，大多会在开发测试阶段解决掉。
2. 非运行时异常，是必须要处理的。
3. 业务异常，是根据业务要求，在出现非法情况时，人为抛出的。

9.1 异常处理方案

DAO,Service的所有异常，必须无条件上抛，全部集中到C
C中处理所有异常，将不同的异常转发到不同的错误处理结果中

C中的每个Handler不再自己处理异常，而是直接上抛所有异常。
定义一个“异常解析器” 集中捕获处理所有异常

public class MyExResolver implements HandlerExceptionResolver{
    /**
     * 异常解析器：主体逻辑
     * 执行时刻：当handler中抛出异常时，会执行：捕获异常，并可以跳到错误页面
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex) {
        ex.printStackTrace();//打印异常栈
        //创建一个ModelAndView
        ModelAndView mv = new ModelAndView();
        //识别异常
        if (ex instanceof Exception1) {
            mv.setViewName("redirect:/dispatch/login/page");
        }else if(ex instanceof Exception2){
            mv.setViewName("redirect:/dispatch/error1/page");
        }else{
            mv.setViewName("redirect:/dispatch/error");
        }
        return mv;
    }
}

<!-- 声明异常解析器 -->    
<bean class="com.baizhi.exception.resolver.MyExResolver"></bean>

10. 拦截器(类似于过滤器？？？？？)

作用：抽取c中的冗余功能

public class MyInter1 implements HandlerInterceptor{
    //主要逻辑：在handler之前执行：抽取handler中的冗余代码
    @Override
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {
        System.out.println("pre~~~");
        if(1==2){
            response.sendRedirect("/springMVC_day2/index.jsp");//响应
            return false;//中断请求
        }
        return true;//放行，后续的拦截器或handler就会执行
    }
    //在handler之后执行:进一步的响应定制
    @Override
    public void postHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        System.out.println("post~~");
    }
    //在页面渲染完毕之后，执行：资源回收
    @Override
    public void afterCompletion(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println("after~~");
    }
}

10.2 配置拦截路径

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/inter/test1"/>
        <mvc:mapping path="/inter/test2"/>
        <mvc:mapping path="/inter/test*"/>  /inter/testaa  /inter/test22  /inter/testssssss
        <mvc:mapping path="/inter/**"/> /inter/a/b/c/d   /inter/cc/ss/dfd
        <mvc:exclude-mapping path="/inter/a/**"/> 不拦截此路径
        <bean class="com.baizhi.interceptor.MyInter1"></bean> 拦截器类
    </mvc:interceptor>
</mvc:interceptors>

多个拦截器，拦截相同的位置： A-->B -->Handler --> B--> A

11. spring整合

11.1 整合思路

此时项目中有两个工厂

DispatcherServlet 启动的springMVC工厂==负责生产C及springMVC自己的系统
组件
ContextLoaderListener 启动的spring工厂==负责生产其他所有组件
springMVC的工厂会被设置为spring工厂的子工厂，可以随意获取spring工厂中
的组件
整合过程，就是累加：代码+依赖+配置。然后将service注入给controller即可

11.2 整合技巧

两个工厂不能有彼此侵入，即，生产的组件不能有重合。

<!-- 告知SpringMVC  哪些包中 存在 被注解的类
    use-default-filters=true 凡是被 @Controller @Service  @Repository注解的类，都会被扫描
    use-default-filters=false 默认不扫描包内的任何类, 只扫描include-filter中指定的类
    只扫描被@Controller注解的类
-->
<context:component-scan base-package="com.zhj" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!-- 告知Spring
     唯独不扫描@Controller注解的类 -->
<context:component-scan base-package="com.zhj" use-default-filters="true">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

总结：学代码就是一个不断学新的，不断整合，不断推翻的过程，环环相扣，要不想
被狠狠拍在沙滩上，还是要好好学习啊！

Spring——SpringMVC整合

Spring——SpringMVC整合

一：SpringMVC

MVC : Model View Controller

二. 开发流程

2.1 废话不多说先导依赖

2.2 配置核心(前端)控制器

2.3 后端控制器

2.4 配置文件

3. 接收请求参数

3.2 实体收参(建议)

3.5 中文乱码

4. 跳转

跳转关键字 `forward:` `redirect:`

4.1 C-->V controller--->view

4.2 C-->C

4.3 跳转细节

4.4 jsp需要注意的细节

五传值问题

六 SpringMVC中的Model ，ModelAndView 对象

七 SpringMVC中的静态资源

7.1 解决方案1

7.2 解决方案2

8. JSON处理（重重重重重重重重重重点）

8.1 导入依赖

8.2 使用@ResponseBody（将handler的返回值，转换成json并将json响应给客户端。）

8.4 FastJson(又到最喜欢的FastJson环节啦~~~)

8.4.1 FastJson的安装(废话不多说，上代码)

8.4.3 日期格式化

8.5 @RestController

8.6 使用@RequestBody

9. 异常解析器

9.1 异常处理方案

10. 拦截器(类似于过滤器？？？？？)

10.2 配置拦截路径

11. spring整合

11.1 整合思路

11.2 整合技巧

推荐阅读更多精彩内容

Spring——SpringMVC整合

一：SpringMVC

MVC : Model View Controller

二. 开发流程

2.1 废话不多说先导依赖

2.2 配置核心(前端)控制器

2.3 后端控制器

2.4 配置文件

3. 接收请求参数

3.2 实体收参(建议)

3.5 中文乱码

4. 跳转

跳转关键字 forward: redirect:

4.1 C-->V controller--->view

4.2 C-->C

4.3 跳转细节

4.4 jsp需要注意的细节

五 传值问题

六 SpringMVC中的Model ，ModelAndView 对象

七 SpringMVC中的静态资源

7.1 解决方案1

7.2 解决方案2

8. JSON处理（重重重重重重重重重重点）

8.1 导入依赖

8.2 使用@ResponseBody（将handler的返回值，转换成json并将json响应给客户端。）

8.4 FastJson(又到最喜欢的FastJson环节啦~~~)

8.4.1 FastJson的安装(废话不多说，上代码)

8.4.3 日期格式化

8.5 @RestController

8.6 使用@RequestBody

9. 异常解析器

9.1 异常处理方案

10. 拦截器(类似于过滤器？？？？？)

10.2 配置拦截路径

11. spring整合

11.1 整合思路

11.2 整合技巧

推荐阅读更多精彩内容

跳转关键字 `forward:` `redirect:`

五传值问题