2021.7.23

今天学习的是springmvc

创建项目的步骤

需求：用户在页面发起一个请求，请求交给springmvc的控制器对象
并显示请求的处理结果（在结果页面显示一个欢迎语句）
实现步骤：

新建web maven工程
加入依赖
spring-webmvc依赖，间接的把spring的依赖都加入到了项目
jsp，servlet依赖
重点：在web.xml中注册springmvc的核心对象DispatcherServlet
1.DispatcherServlet叫做中央调度器，是一个servlet，它的父类是继承HttpServlet
2，DispatcherServlet也叫作前段控制器（front controller）
3，DispatcherServlet负责接收用户提交的数据，调用其他控制器对象，并把请求的处理结果显示给用户
创建一个发起请求的页面 index.jsp
创建控制器
1. 在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2. 在类中的方法上面加入@RequestMapping注解
创建一个作为结果的jsp，显示处理结果
创建springmvc配置文件（与spring的配置文件一样）
1. 声明组件扫描器，指定@Controller注解所在的包名
2. 声明试图解析器，帮助处理视图的

** 在提交请求的过程中，post方式乱码，get方式没有乱码，可以使用过滤器解决**

pom.xml

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>

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

controller

/**
 * @Controller创建处理器对象，对象放在springmvc容器中
 * 位置：在类的上面
 *
 * 能处理请求的都是控制器（处理器）:MyController能处理请求，叫做后端控制器（back controller）
 */
@Controller
@RequestMapping("/test")
public class MyController {
    /*
    * 逐个接收请求参数：
    *   要求：控制器方法的形参名和请求参数名必须一致
    *       同名的请求参数赋值给同名的形参
    * 框架接收请求参数
    *   1，使用request对象接收请求参数
    *       String strName=request.getParameter("name");
    *   2，springmvc框架通过DispatcherServlet调用myController的doSome（）方法
    *       调用方法时，按名称对应。把接收的参数赋值给形参
    *   框架提供类型转换功能，把string转为其他基本类型
    * */
    @RequestMapping(value = {"/some.do", "/first.do"})
    //当你不确定年龄值有没有的时候，可以换成Integer
    public ModelAndView doSome(String name,Integer age){
        //现在就可以在方法中直接使用name和age了
        ModelAndView mv=new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

    @RequestMapping({"/other.do", "/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }
}

springmvc.xml

<!--声明组件扫描器-->
    <context:component-scan base-package="com.myweb.controller"/>

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

web.xml

<!--声明注册springmvc核心对象
        需要在TomCat服务器启动后创建DispatcherServlet对象的实例
        为什么要创建这个对象的实例呢？
        因为DispatcherServlet在它的创建过程中，会同时创建springmvc容器对象，
        读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起请求时就可以直接使用对象了

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

    <!--springmvc创建容器对象时，默认读取的是这个文件  （/WEB-INF/<servlet-name>-servlet.xml）-->
    <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>

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

    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            使用框架的时候， <url-pattern>可以使用两种方式
            1，扩展名，自定义扩展名，常用：*.do,*.action,*.mvc等
            2，使用斜杠"/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

    <!--注册声明过滤器，解决post乱码问题-->
    <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>
        <!--强制请求对象(HttpServletRequest)使用很encoding编码的值-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--强制应答对象(HttpServletResponse)使用很encoding编码的值-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <!-- /*表示强制所有的请求先通过过滤器-->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

笔记

SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门是做web开发的。
理解是servlet的一个升级

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

SpringMVC就是一个Spring。 Spring是容器，ioc能够管理对象，使用<bean>,* @Component, @Repository, @Service, @Controller*
SpringMVC能够创建对象，放入到容器中（SpringMVC容器）， springmvc容器中放的是控制器对象，</bean>

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

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

web开发底层是servlet， springmvc中有一个对象是Servlet ： DispatherServlet(中央调度器)
DispatherServlet: 负责接收用户的所有请求，用户把请求给了DispatherServlet，之后DispatherServlet把请求转发给
我们的Controller对象，最后是Controller对象处理请求。

index.jsp-----DispatherServlet(Servlet)----转发，分配给---Controller对象（@Controller注解创建的对象）
main.jsp MainController
addUser.jsp UserController

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

springmvc执行过程源代码分析

tomcat启动，创建容器的过程
通过load-on-start标签指定的1，创建DisaptcherServlet对象，
DisaptcherServlet它的父类是继承HttpServlet的，它是一个serlvet，在被创建时，会执行init（）方法。
在init（）方法中
//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("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 void doService(HttpServletRequest request, HttpServletResponse response)


      DispatcherServlet.doDispatch(request, response){

          调用MyController的.doSome()方法
      }

doDispatch：springmvc中DispatcherServlet的核心方法，所有的请求都在这个方法中完成的

一起学java 文章被收录于专栏

分享平时学习心得及见解，还有学习笔记