SpringMVC（一）视图解析器

springMVC是一个基于spring的一个框架，实际上 就是spring的一个模块，专门做web开发。

是servlet的一个升级。

web开发的底层是servlet，框架是再servlet基础上面加入一些功能，让你做web开发。

springMVC就是一个spring。spring是容器，ioc能够管理对象，使用,@Component,@Repository,@Service,@Controller

SpringMVC能够创建对象 ，放入到容器中(SpringMVC容器)，springmvc容器中放的是控制器对象。

​ 我们要做的就是，使用@Controller对象，把对象放入到springmvc容器中 ，把创建的对象作为控制器使用，这个控制器对象能够接受用户的请求，显示处理结果，就当作是一个servlet使用 。

​ 使用@Controller这个注解创建的是一个普通类的对象，不是Servlet，springmvc赋予了控制器对象一些额外的功能。

web开发底层是servlet，springmvc中有一个对象Servlet : DispacherServlet（中央调度器）

DispatherServlet:负责接收用户的所有请求，用户把请求给了DisapcherServlet,之后DispacherServlet把请求转发给

​ 我们的Controller对象，最后是Controller对象处理请求。

web开发步骤：

index.jsp---------DispacherServlet(Servlet)---------转发，分配给-------Controller对象(@Controller注解所创建的对象)

main.jsp MainController

addUser.jsp UserController

第一个springmvc的项目

需求：用户再页面发起一个请求，请求交给springmvc的控制器对象，并显示请求的处理结果(在结果页面显示一个欢迎语句)

实现步骤：
1.新建web maven工程
2.加入依赖
spring-webmvc依赖，间接的把spring的依赖都加入项目。
jsp，servlet 依赖

 <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </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>
	    <scope>provided</scope>
	</dependency>
	 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>5.3.5</version>
	</dependency>

 <build>
    <plugins>
  	<plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
        <sorce>1.8</sorce>
        <target>1.8</target>
        </configuration>
      </plugin>
      
     <plugin>
     	<groupId>org.apache.maven.plugins</groupId>
   	    <artifactId>maven-compiler-plugin</artifactId>
    	<configuration>
     	<source>1.8</source> 
    	<target>1.8</target> 
    	</configuration>
	</plugin> 
</plugins>
  </build>

3.重点：在web.xml文件中注册springmvc框架的核心对象DispacherServlet
(1)DispacherServlet叫做中央调度器，是一个servlet。、他的父类是继承了HttpServlet
(2)DispatherServlet也叫做前端控制器(front controller)
(3)DispatherServlet负责接收用户提交的请求，调用其他的控制器对象，并请求的处理结果显示给对象。

声明，注册springmvc的核心对象DispatcherServlet
需要在tomcat服务器启动后，创建DispatcherServlet对象的实例

为什么要创建DispatcherServlet对象的实例呢？
因为DispatcherServlet在他的创建过程中，同时会创建springmvc容器对象，
读取springmvc的配置文件，把这个配置文件中的对象创建好，当用户发起请求时就 可以直接使用对象了。

servlet的初始化会执行init()方法，DispatcherServlet在init()中{

	//创建容器，读取配置文件
	WebApplicationContext ctx = new ClassPathApplicationContext("springmvc.xml");
	//把容器对象放入到ServletContext中 
	getServletContext().setAttribute(key,ctx);
}

启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml(/WEB-INF/myweb-servlet.xml)
springmvc创建容器对象时 ，读取的配置文件默认是/WEB-INF/-servlet.xml

<web-app>
  <servlet>
  	<servlet-name>myweb</servlet-name>
  	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  <!-- 自定义springmvc读取的配置文件的位置 -->
  <init-param>
  <!-- springmvc读取的配置文件的属性 -->
  	<param-name>contextConfigLocation</param-name>
  	<!-- 指定自定义文件的位置 -->
  	<param-value>classpath:springmvc.xml</param-value>
  </init-param>

  <!-- 在tomcat启动后，创建Servlet对象
  		land-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，
  		数值越小，tomcat创建对象的时间越早，大于等于0的整数。
   -->
  <load-on-startup>1</load-on-startup>
  </servlet>
	

<servlet-mapping>
	<servlet-name>myweb</servlet-name>
	<!-- 
		使用框架的时候，url-pattern可以使用两种值
		1.使用扩展名方式，语法 *.xxxx,xxxx是自定义的扩展名。常用的方式 *.do,*.action,*.mvc等等
		http://localhost:8080/myweb/some.do
		http://localhost:8080/myweb/other.do
		
		2.使用/
	 -->
	
	<url-pattern>*.do</url-pattern>
</servlet-mapping>

</web-app>

4.创建一个发起请求的页面
5.创建一个控制器类
1）在类的上面加入@Controller注解，创建对象并放入到springmvc容器中，
2）在类中的方法上面加入@RequestMapping注解

package com.sdyu.controller;


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/*
* @Controller：创建处理器对象，对象放在springmvc容器中。
* 位置：在类的上面
* 和spring中讲Service，@Conponent
*
* 能处理请求的都是控制器{处理器} ：MyContrller能处理请求，叫做后端控制器
*                            {back controller}
* */
@Controller
public class MyController {
    /*
    * 处理用户提交的请求，springmvc中使用方法来处理的
    * 方法是自定义的，可以有多种返回值，多种参数，方法名称自定义
    *
    * */

    /*
    * 准备使用doSome方法处理some.do请求
    * @RequestMapping 请求映射，作用是把一个请求地址和一个方法绑定在一起
    *                       一个请求指定一个方法处理
    *           属性：1.value 是一个String,表示请求的uri地址的:（some.do）
    *                   value的值必须是唯一的,不能重复。在使用时，推荐地址以“/”
    *           位置：1,在方法的上面
    *               2.在类的上面
    * 说明：使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
    * 使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet,doPost
    *
    * 返回值：ModelAndView
    *       Model:数据，请求处理完成后。要显示给用户的数据
    *       View：视图，比如jsp等等。
    * */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){  //doGet()--Service请求处理
    //处理some.do的请求了。相当于service调用处理完成了。
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域。
        //request.setAttribute("msg",“欢迎使用springmvc做web开发”)
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        System.out.println("========1");

        //指定视图 指定视图的完整路径
        //框架对视图执行的forward操作，request.getRequestDispather("/show.jsp").forward(...)
//        mv.setViewName("/WEB-INF/view/show.jsp");

        //配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
        //框架会使用视图解析器的前缀+逻辑名称+后缀 组成完成路径，这里就是字符连接操作
        //WEB-INF/view/ +show +.jsp
        mv.setViewName("show");

        //返回mv
        return mv;
    }


    @RequestMapping(value = "/other.do")
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","other");
        mv.addObject("fun","执行的是dother方法");

        mv.setViewName("other");

        return mv;
    }


    }

6.创建一个作为结果的jsp,显示请求的处理结果，

7.创建springmvc的配置文件(spring的配置文件一样)
1）声明组件扫描器，指定Controller注解所在的包名
2）声明视图解析器，帮助处理视图的。

	<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>show</title>
</head>
<body>
  <h3>WEB-INF-show.jsp从request作用域中获取数据</h3><br/>
  <h3>msg数据:${msg}</h3><br/>
  <h3>fun数据:${fun}</h3>
</body>
</html>

springmvc请求的处理流程

1.发起some.do

2.tomcat{web.xml—url-pattern知道 *.do的请求给DispatcherServlet}

3.DispatcherServlet(根据springmvc.xml配置知道 some.do—doSome() )

4.DispatcherServlet把some.do转发给MyController.doSome()方法

5.框架执行doSome()把得到ModelAndView进行处理，转发到show.jsp

上面这个过程简化的方式：

some.do—DispatcherSerlvet—MyController

==========================================================

springmvc执行过程源代码分析

1.tomcat启动，创建容器的过程

​ 通过load-on-start标签指定的1，创建DispatcehrServlet对象，

​ DispatcehrServlet他的父类是继承HttpServlet的，它是一个servlet，在被创建时，会执行 init()方法。

​ 在init() 方法中，

​ servlet的初始化会执行init()方法，DispatcherServlet在init()中{
​ //创建容器，读取配置文件
​ WebApplicationContext ctx = new ClassPathApplicationContext(“springmvc.xml”);
​ //把容器对象放入到ServletContext中
​ getServletContext().setAttribute(key,ctx);
​ }

上面创建容器作用:创建@controller注解所在的类的对象，创建MyController对象，

这个对象放入 springmvc的容器中，容器是 map，类似map.put(“Mycontroller”,MyController对象)

2.请求的处理过程

1.执行servlet的service

{protected void service(HttpServletRequest request, HttpServletResponse response)}

protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception

配置视图解析器

springmvc.xml：

<!--声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀：视图文件的路径-->
    <property name="prefix" value="/WEB-INF/View/"/>
    <!--后缀：视图文件的路径-->
    <property name="suffix" value=".jsp"/>
</bean>

MyController
//配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
//框架会使用视图解析器的前缀+逻辑名称+后缀 组成完成路径，这里就是字符连接操作
//WEB-INF/view/ +show +.jsp
mv.setViewName(“show”);