SpringMVC基础

SpringMVC

SpringMVC:是基于spring的一个框架，实际上就是spring的模块。专门是做web开发的，相当于Servlet的升级版

SpringMVC能够创建对象，放入容器中，springMVC容器中放入的是控制器对象。

使用@Contorller创建控制器对象，将对象放入springmvc容器中，把创建的对象作为控制器使用，这个控制器对象能接收用户的请求，

显示处理结果，就当作一个servlet使用。

1.中央调度器(DispatcherServlet):

• 负责接收用户的所有请求，用户把请求给了中央调度器，之后中央调度器把请求转给我们的Controller对象，最后是Controller对象处理请求。

2，springmvc的开发步骤：

开发步骤详解：

• 新建web maven工程。

• 加入依赖

  • spring-webmvc依赖，间接的把spring的依赖加入到项目中

  • jsp，servlet依赖

  • <?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.powernode</groupId>
      <artifactId>SpringMVC-01-helloSpringMVC</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
      </properties>
    
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
    <!--    servlet依赖-->
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
          <scope>provided</scope>
        </dependency>
    <!--    springmvc依赖-->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.5.RELEASE</version>
        </dependency>
      </dependencies>
    
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
              <source>1.8</source>
              <target>1.8</target>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </project>
    

• 在web.xml中注册springmvc框架的核心对象：DispatcherServlet,他的父类是集成HttpServlet

  • DispatcherServlet也叫做前端控制器，（font controller）：接收用户的请求，调用其他的控制器对象，并把请求的结果显示给用户。

  • <?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">
    
    <!--    注册springmvc的核心对象DispatcherServlet
            在tomcat服务器启动的时候，创建DispatcherServlet对象的实例。
            在DispatcherServlet在他的创建过程中，会同时创建springMVC对象，
            读取springmvc的配置文件，并且将配置文件中所有的对象都创建好，当用户发起请求时就可以直接使用对象了
        -->
        <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启动后创建对象的顺序，他的值为整数，数值越小，优先级越高    -->
            <load-on-startup>1</load-on-startup>
        </servlet>
    
        <servlet-mapping>
            <servlet-name>myWeb</servlet-name>
    <!--        使用框架的时候，url-pattern可以使用两个值
                1,使用扩展名的方式，语法： *.xxx,   xxx是自定义的扩展名，常用的方式是*.do    *.action   *.mvc等等
                        http://localhost:8080/oa/some.do
                2，  使用/.
        -->
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
    </web-app>
    

• 创建页面

• 创建控制器类

  • 在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中。

  • 在类中的方法上边加入@RequestMapping注解。

    • 请求映射，作用是将一个请求地址和一个方法绑定在一起，一个请求指定一个方法处理。

    • 属性：

      • value 是一个String ，表示请求的uri地址，value的值必须是唯一的，不能重复。在使用推荐以“/”

    • 位置：在方法的上边和在类的上边都可以。

    • 例子：

      • @RequestMapping
        // ModelAndView : Model ：数据，请求处理完成后，需要显示给用户的数据。
        //  			  View ： 视图，jsp等等。
        
        @RequestMapping(value = "/some.do")
        // value 属性为：一个字符串数组，可以让一个方法同时处理多个请求
        public ModelAndView doSome() {
            ModelAndView mv = new ModelAndView();
            // 添加数据，框架在请求的最后将数据放入到request作用域中
            mv.addObject("msg","欢迎使用springmvc做web开发");
            mv.addObject("fun","执行的是doSome方法");
            
            // 指定视图，要指定视图的完整路径
            // 框架对视图的操作相当于forward操作
            mv.setViewName("/show.jsp");
            
            return mv;
        }
        

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

• 创建springmvc的配置文件(springmvc.xml)（和spring的配置文件一样）

  • 声明组件扫描器，指定@Controller注解所在的包名。

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

  • 声明视图的解析器，帮助处理视图。

    • 为了防止用户直接访问结果页面，我们将jsp页面放在/webapp/WEB—INF/下

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

    • 配置了视图解析器之后，可以使用逻辑名称(文件名称)，指定名称

      • // 框架会使用视图解析器中的前缀+文件名+后缀组成路径。
        mv.setViewName("show");
        

3,@RequestMapping的使用及其属性：

处理请求路径相同部分

• @RequestMapping放在类的上边，

  • 属性：value表示所有请求的公共部分，叫做模块的名称

    • 例子：

      • @RequestMapping(value = "/text")
        public class MyController {
        	// 原来的请求路径为： /test/some.do    和  /test/orther.do 
            // 将@RequestMapping 放在类上边，可以变成下边这种形式
            @RequestMapping(value = {"/some.do","/first.do")
            public ModelAndView doSome() {}
            @RequestMapping(value = {"/orther.do","/seconde.do"})
         	public ModelAndView doOrther() {}
            
        }
        

指定请求方式Method属性：

• @RequestMapping：请求映射

  • 属性：method ：表示请求的方式，它的值为RequestMethod类的枚举值。

    • 例子： 表示get请求方式：RequestMethod.GET

    • @RequestMapping(value="/some.do",method = RequestMethod.GET)
      public ModelAndView doSome() {}
      

4，接收参数

处理器方法的形参

• 例子：

  • // 在处理器方法的形参位置添加
     
    @RequestMapping(value="some.do",method=RequestMethod.GET) 
    public ModelAndView doSome(HttpServkletRequest request,
                               HttpServletResponse response,
                               HttpSession session) {
        // 使用request接收参数
        String param = request.getParameter("name");
    }
    

接收用户提交的数据：

• 逐个接收：

  • 要求：处理器方法的形参名和请求中的形参名必须一致。同名的请求参数赋值给同名的形参。

  • 例子：如果用户提交的是name和age，则处理器方法中的形参列表为

    • @RequestMapping(value="some.do")
      // 只需要方法中的参数名字一致，类型可以自定义
      public ModelAndView doSome(String name,int age) {
          //使用
          ModelAndView mv = new ModelAndView();
          
          mv.addObject("myName",name);
          mv.addObject("myAge",age);
          // 展示数据
          mv.setViewName("show");
          return mv;
      }
      

  • 在提交请求参数的时候，get请求方式中中文不出现乱码

  • 使用post请求，会出现中文乱码，使用过滤器处理乱码的问题：

    • 过滤器可以自定义，也可以使用框架中的过滤器CharacterEncodingFilter

      • 在web.xml文件中声明一个过滤器

        • <!--    声明过滤器，解决乱码问题-->
              <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>
          

  • 请求的参数名和处理器方法的参数名不相同：

    • @RequestParam ： 解决我们请求中参数名和方法名不一致的问题(只适用于逐个接收参数)

      • 属性：

        • value ：请求中的参数名称
        • required : 是一个boolean，默认为true
          • true ：表示请求中必须包含此参数
          • false ： 表示请求中不必包含此参数

      • 位置：在处理器方法形参定义的前面

      • 例子：

        • @RequestMapping(value = "/some.do")
          public ModelAndView doSome(@RequestParam(value="rname",required = false) String name,
                                     @RequestParam(value="rage",required = false) Integer age) {
              
          }
          

• 对象接收：

  • 处理器方法形参是java对象，这个对象的属性名和请求中的参数名一样的。

    • 框架会自动创建形参的java对象，给属性赋值，请求中的参数为name，框架会调用setName()

    • 例子：

      • @RequestMapping(value = "/some.do")
        public ModelAndView doSome(Student stu) {
         	
            ModelAndeView mv = new ModelAndView();
            mv.addObject("myName",stu.getName());
            mv.addObject("myAge",stu.getAge());
            // 对象也可以放进去
            mv.addObject("student",stu);
            return mv;
        }
        

处理器方法的返回值类型

返回值String表示视图：

• 处理器方法的返回值表示请求的处理结果

  • ModelAndView : 有数据和视图，对视图进行执行forward。

  • String ：表示视图，可以是逻辑名称，也可以是完整视图路径。

    • 先配置视图解析器，在springmvc.xml文件中

    • 例子：

      • @RequestMapping(value = "/some.do")
        public String doSome(String name,Integer age) {  
            
        	System.out.println("name = " + name + ": age =" + age );
        
         	// show ： 逻辑视图名称，项目中配置了视图解析器
            // 框架对视图执行了forward转发操作
                    return "show";
            
            
            // 当使用完整的视图路径的时候，不能配置视图解析器 
            // 例子：return "/WEB-INF/view/show.jsp";
        
        }
        

返回值void响应ajax：

• 不能表示数据和视图

• 在处理ajax的时候使用void的返回值

  • 通过HttpServletResponse输出数据，响应ajax请求，ajax请求服务端返回的就是数据，和视图无关。

    • pom文件导入json依赖：

    • <!--    jackson依赖-->
          <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
          </dependency>
          <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
          </dependency>
      

返回值为Object：

• 处理器方法也可以返回Object对象，这个Object可以是Integer,String,自定义对象，Map，List等等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面中显示的数据出现的。

• 返回对象，需要使用@ResponseBody注解，将转换后的json数据放入到响应体当中。可以使用对象表示的数据，响应ajax请求。

• 步骤：

  • 导入处理json的工具库的依赖，springmvc默认使用的jackson。

  • 在springmvc.xml配置文件中加入mvc:annotation-driven 注解驱动

    • 注解驱动处理的东西：

      • // 使用jackson中的ObjectMapper转为json字符串
        json = om.writeValueAsString(student);
        

    • 注解驱动加载到springmvc.xml配置文件后，会自动创建HttpMessageConverter接口的7个实现类对象

      • StringHttpMessageConverter：负责读取字符串格式的数据和写出字符串格式的数据
      • MappingJackson2HttpMessageConverter ：负责读取和写入json格式的数据。利用jackson的ObjectMapping读写json数据，操作Object类型的数据，可读取application/json，响应媒体类型为：application/json

  • 在处理器方法上边加入注解：@ResponseBody

    • 通过HttpServletresponse输出数据，响应ajax请求的。把处理器方法返回的对象转为json后，通过HttpResponse输出给浏览器

    • 注解处理的东西：

      response.setContentType("application/json;charset=utf-8");
      PrintWrite pw = response.getWrite();
      pw.println(json);
      pw.flush();
      pw.close();
      

• 返回值为对象框架的处理流程：

  • 框架会把返回Student类型，调用框架中的ArryList中的canWrite()方法来检查哪个消息处理器接口实现类能处理Student类型的数据-------MappingJackson2HttpMessageConverter
  • 框架会调用这个实现类的write()，MappingJackson2HttpMessageConverter的write()方法，把数据的Student对象转换为Json，调用Jackson的ObjectMapping转为json
  • 框架会调用@ResponseBody把上一步的结果数据输出到浏览器，完成ajax请求的处理。

返回值List是jsonArray：

• 处理器方法返回的是一个List集合，例如：List
• 框架会把返回Student类型，调用框架中的ArryList中的canWrite()方法来检查哪个消息处理器接口实现类能处理Student类型的数据-------MappingJackson2HttpMessageConverter
• 框架会调用这个实现类的write()，MappingJackson2HttpMessageConverter的write()方法，把数据的Student对象转换为Json，调用Jackson的ObjectMapping转为json array:json数组
• 框架会调用@ResponseBody把上一步的结果数据输出到浏览器，完成ajax请求的处理。

返回值为字符串对象：

• 处理器方法返回的是String，String是表示数据的，不是视图。
  • 区分返回值Sting是视图还是数据：看该方法是否有@ResponseBody注解。有就是数据
  • 处理中文乱码问题：
    • @RequestMapping(value=“/returnStringData.do”,produces = “text/plain;charset=utf-8”)

访问静态资源：

第一种方式：

• 在web.xml文件中：

  • <!--当在项目中使用了“/”，它会替代tomcat的defaultServlet
    	导致所有的静态资源都给DispacherServlet处理，默认情况下中央调度器没有处理静态资源的能力，
    	没有控制器对象能处理静态资源的访问：  所以静态资源会出现404
    -->
    <servlet-mapping>
    	<servlet-name>myweb</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    

• 处理静态资源无法访问的问题：在springmvc.xml文件中配置：

  • <mvc:default-servlet-handler/>
    <!--原理是： 加入这个标签以后，框架会创建一个控制器对象DefaultServletHttpRequestHandler
    			类似于我们自己创建的myController
    		DefaultServletHttpRequestHandler这个对象会把接收的请求转发给tomcat的default这个servlet。
    -->
    

  • 注意：

    • <mvc:default-servlet-handler/> 
      <!--该标签和@RequestMapping注解有冲突
      	需要加入注解驱动标签：
      	<mvc:annotation-driven />	
      -->
      

第二种方式(在项目中使用较多)：

• 在springmvc.xml文件中配置：

  • <!--
    	该标签加入后，框架会自动创建ResourceHttpRequestHandler这个对象
    		该对象去处理静态资源的访问，不依赖tomcat服务器。
    		
    		mapping ：访问静态资源的uri地址。使用通配符：**
    		location ：静态资源在项目中的目录位置。
    
    		/images/** : 表示images/p1.jpg  ,images/p2.png    ** :表示任意
    		
    	注意：该标签和@RequestMapping有冲突，需要添加注解驱动
    	<mvc:annotation-driven />
    -->
    
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/html/**" location="/html/" />
    <mvc:resources mapping="/js/**" location="/js/" />
    <mvc:resources mapping="/images/**" location="/images/" />
    

• 一般都是将所有的静态资源放在一个包中,使用一个标签实现对静态资源的访问。

  • <mvc:resources mapping="/static/**" location="/static/">
    

解决jsp页面的路径问题：

是否使用" / ":

• 在jsp，html中使用的地址，都是在前端页面中的地址，都是相对地址。

• 地址的分类：

  • 绝对地址：
    • 带有协议的名称的，例子：http://www.bai.com;
  • 相对地址：
    • 没有协议开头的，例如：/user/some.do , user/some.do
    • 相对地址不能独立使用，必须有一个参考地址。通过参考地址+相对地址本身才能指定资源。

• 加 “/”:

  • 参考地址应该是：http://localhost:8080 + 请求时候的路径

  • 例子：

    • http://localhost:8080/oa/user/some.do
    • 路径: http://localhost:8080/oa/user/
    • 资源：some.do

    注意：当再一次发送请求的时候，浏览器会将路径+user/some.do当作新的请求路径，会发生错误。

• 不加"/"

  • 参考地址为：http://localhost:8080/oa/ + 请求时候的路径

解决方式：

• 加入base标签：(没有加"/")

  • 是html语言的标签，表示当前页面中访问地址的基地址。页面中所有的没有以"/"开头的地址，都是以base标签中的地址为参考地址。

  • <!--
    	base标签是在<head></head>内部使用的标签
    -->
    
    <base href="http://localhost:8080/oa/" />
    

  • 获取项目的路径：

    • <%
      String basePath = request.getScheme() + "://" + request.getServerName() + ":" + 
          				request.getServerPort() + request.getContextPath() + "/"; 
      %>
      
      <base href="<%=basePath%>"/>
      

• 使用el表达式：

  • <a href="${pageContext.request.contextPath}/user/some.do">发送请求</a>
    

SSM整合开发：

搭建SSM开发环境：

• springmvc+spring+mybatis
  • springmvc：视图层，界面层，负责接收请求，显示处理结果
    • 管理Controller控制器对象的
  • spring：业务层，管理Service，dao，工具类对象的。
    • 管理service，dao，工具类的。
  • mybatis：持久层，访问数据库
• springmvc容器是spring容器的子容器，类似于java中的继承。在子容器中的controller可以访问父容器中的service对象

整合步骤：

• 新建maven web项目
• 在pom文件中加入依赖
  • springmvc，spring，mybatis三大框架的依赖，jackson依赖，mysql驱动，druid连接池，jsp，servlet依赖
• 写web.xml文件：
  • 注册DispatcherServlet，目的：创建springmvc 对象。创建servlet，接收用户的请求。
  • 注册spring的监听器：ContextLoaderListener。目的：创建spring容器对象，才能创建service吗，dao等对象。
  • 注册字符集过滤器，解决post请求乱码的问题。
• 创建，controller包，service，dao，实体类包名都创建好
• 写spring，springmvc，mybatis的配置文件
  • springmvc的配置文件
  • spring的配置文件
  • mybatis的配置文件
  • 数据库的属性配置文件
• 写dao接口和mapper文件，service和实现类，controller，实体类。

实现整合：

maven依赖：

<?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.springmvc</groupId>
  <artifactId>SSM-together</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
<!--    Servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
<!--  springmvc依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
<!--    事务依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
<!--    jdbc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
<!--    jackson-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
<!--    spring和mybatis整合-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
<!--    mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.2</version>
    </dependency>
<!--    mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.26</version>
    </dependency>
<!--    druid-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
  </dependencies>

  <build>
    <!--        目的是将src/main/java目录中的xml文件包含到输出结果中，输出到classes目录中-->
    <resources>
      <resource>
        <!--                文件所在的目录-->
        <directory>src/main/java</directory>
        <includes>
          <!--                    目录下的.properties.xml文件都会被扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <!--指定jdk的版本-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

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>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:conf/dispatcherServlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

<!--   注册spring的监听器 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:conf/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

<!--    字符集过滤器-->
    <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>
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true </param-value>
        </init-param>
        <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>
</web-app>

创建目录：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lOovQlda-1691557512313)(C:\Users\李润鑫\AppData\Roaming\Typora\typora-user-images\image-20221018220029080.png)]

springmvc的配置文件：

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

<!--    springmvc配置文件，声明controller和其他web相关的对象-->

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

<!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp"/>
    </bean>

<!--  注解驱动   : 响应ajax返回json需要用到
                  解决静态资源的访问问题-->
    <mvc:annotation-driven/>
</beans>

spring的配置文件：

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--spring的配置文件：声明service和dao，工具类的对象-->

    <context:property-placeholder location="classpath:conf/jdbc.properties"/>

<!--    声明数据源,连接数据库-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
            <!-- 连接数据库的属性  -->
        <property name="username" value="${jdbc.username}"/>
        
        <property name="password" value="${jdbc.password}"/>
        
        <property name="url" value="${jdbc.url}"/>
    </bean>


<!--    声明SqlSessionFactoryBean : 创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:conf/mybatis-config.xml"/>
    </bean>

<!--    声明mybatis的扫描器，创建mapper对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.springmvc.mapper"/>
    </bean>

<!--    声明service的注解@Service所在的包名的位置-->
    <context:component-scan base-package="com.springmvc.service"/>

<!--    事务的配置-->

</beans>

mybatis的配置文件：

<?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.springmvc.pojo"/>
    </typeAliases>

<!--    mapper文件的所在位置-->
    <mappers>
        <package name="com.springmvc.mapper"/>
    </mappers>
</configuration>

转发和重定向：

springMVC框架

• forward:表示转发，实现了request.getRequestDispacher(“xxx.jsp”).forward;

  • 方法返回ModelAndView实现forward

  • 语法：

    • setViewName("forward:视图的完整路径");
      

  • forward特点：

    • 不和视图解析器一起使用。

    • @RequestMapping(value="/student.do")
      public ModelAndView doSome() {
          ModelAndView mv = new ModelAndView();
          
          // 显示转发 ： 用的视图没有在视图解析器下的时候使用
          mv.setViewName("forward:/WEB-INF/view/show.jsp");
          return mv;
      }
      

• redirect:表示重定向，实现response.sendRedirect(“xx.jsp”);

  • 处理器方法返回的ModelAndView，实现重定向redirect

  • 语法：setViewName(“redirect:视图的完整路径”);

  • @RequestMapping(value="/doRedirect.jsp")
    public ModelAndView doSome() {
        ModelAndView mv = new ModelAndView();
        /*
        	数据处理：放在request作用域
        */
       
        // 重定向
        mv.setViewName("redirect:/hello.jsp");
        return mv;
    }
    

  • 框架对重定向的操作：

    • 框架会将Model中的简单类型的数据，转为字符串使用，作为hello.jsp的get请求的参数使用。目的是在doRedirect.do和

      hello.jsp两次请求之间传递数据。

    • 在hello.jsp中使用参数集合对象${param}获取请求参数值

      • ${param.myName}
        

  • 重定向不能访问/WEB-INF下的资源

异常处理：

springmvc:

• springmvc采用的是统一的，全局的异常处理。

• 将controller中的所有的异常都集中到一个地方，来处理项目中的异常。将业务逻辑和异常处理代码分开。

• 两个注解：

  • @ExceptionHandler
  • @ControllerAdvice

• 异常的处理步骤：

  • 新建一个maven项目

  • 加入依赖

  • 创建一个自定义异常类，再定义它的子类

  • 在controller抛出子类的异常

  • 创建一个普通类，作为全局异常处理类

    • 在类的上边加入@ControllerAdvice

      • 位置：在类的上边
      • 特点：必须让框架知道这个注解所在的包名，需要在springmvc中声明组件扫描器。

    • 在类中去定义方法，在方法的上边加入ExceptionHandler

      • 处理异常的方法和controller中的方法定义是一样的

      • // @ExceptionHandler(异常的class) ：表示异常的类型，当发生此类异常时，由当前的方法来处理
        @ExceptionHandler(value = nameException.class)
        public ModelAndView doNameException(Exception e) {
            // 形参表示controller中抛出的异常对象。通过形参可以获得发生的异常的信息
        }
        

    • 异常的处理逻辑：

      • 将异常的信息记录下来，记录到数据库，日志文件。包括异常发生的事件，哪个方法发生的，异常错误的内容
      • 发送通知，将异常的信息发送给相关人员。
      • 给用户友好的提示。

    • 处理其他的异常，不知类型的异常

      • @ExceptionHandle   // 不加value ，当发生我们没有写的异常时，执行该方法
        public ModelAndView doOtherException(Exception e) {
            
        }
        

  • 创建处理异常的视图页面。

  • 创建springmvc的配置文件：

    • 组件扫描器，扫描的是：@Controller注解

    • 组件扫描器，扫描@ControllerAdvice所在的包名

    • 声明注解驱动

    • <!--    处理异常所需要的配置-->
          <context:component-scan base-package="com.springmvc.handler"/>
      
          <mvc:annotation-driven/>
      

拦截器：

拦截器的基本介绍：

• 拦截器是springmvc的一种，需要实现HandlerInterceptor接口。
  • 和过滤器类似，但是功能的侧重点不同。过滤器是来过滤请求参数，设置编码字符集等工作。拦截器是拦截用户发送的请求，做请求判断的处理。
  • 特点：拦截器是全局的，可以对多个controller做拦截，一个项目可以有多个拦截器，他们在一起拦截用户的请求。
  • 拦截器常用在：用户的登录处理，权限检查，记录日志。

拦截器的使用：

• 定义类实现HandlerInterceptor接口

• 在springmvc的配置文件中声明拦截器，让框架知道框架的存在。

  • <!--声明拦截器：拦截器可以有一个或者多个-->
    <mvc:interceptors>
    	<!--声明第一个拦截器-->
        <mvc:interceptor>
        	<!--指定拦截器的请求uri地址 path：就是uri地址，可以使用通配符  
    			** 表示任意的文件或者路径
    			/user/** : 拦截以user开头的所有请求
    			/** ：表示拦截所有的请求
    			-->
            <mvc:mapping path="/user/**"/>
            
        <!--声明拦截器对象-->
            <bean class="com,lirunxin.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
    
    

• 执行时间：

  • 在请求处理之前，在controller类中的方法执行之前先被拦截。
  • 在控制器方法执行之后，也会执行拦截器。
  • 在请求处理完成后也会执行拦截器

• 拦截器的三个方法：

  • preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

    • 预处理方法：

      • 参数：

      • Object handler : 被拦截的控制器对象

      • 返回值：

        • true：
        • false：

      • 特点：
        1，方法在控制器方法之前先执行的，用户的请求先到达此方法。

        ​ 2，在这个方法中可以获取请求的信息，验证是否符合要求。可以用户是否登录，验证用户是否有权限去访问某个 地址 。验证失败，截断请求，请求不能被处理。验证成功，可以放行请求，此控制器方法才能执行。

  • postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
    

    • Object handler ：被拦截的处理对象MyController
    • ModelAndView modelAndView ：处理器方法的返回值
    • 特点：
      • 在处理器方法之后执行的
      • 能够获取到处理器方法的返回值ModelAndView，可以修改ModelAndView中的数据和视图，可以影响到最后的执行结果。
      • 主要是对原来的结果做二次的修正

  • afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
    

    • Object handler：被拦截器处理的处理器对象
    • Exception ex ：程序中发生的异常。
    • 特点：
      • 在请求处理完成后执行的。框架中规定当你的视图处理完成后，对视图进行了forward，就完成了请求处理。
      • 一般是做资源回收的作用。程序请求的过程中创建了一些对象，在这里可以删除，把占用的内存回收。

多个拦截器的执行顺序：

• 多个拦截器会按照在配置文件中的配置的先后执行
• 在框架中保存多个拦截器是ArrayList，先声明的先进入到集合中去

SpringMVC执行流程：

springmvc内部请求的处理流程（重点）：

• 用户发起请求some.do

• DispatcherServlet接收请求some.do,把请求转交给处理器的映射器

  • 处理器映射器：springmvc框架中的一种对象，框架把实现了HandlerMapping接口的类都叫做映射器（多个）
  • 处理器映射器作用：根据请求，从springmvc容器对象中获取处理器对象（mycontroller对象相 = getBean的操作）

• 框架会将找到的处理器对象放到执行链(HandlerExcutionChain)的类中保存

  • HandlerExcutionChain : 类中保存的是处理器对象(MyCOntroller) ,以及项目中所有的拦截器

• 以DispatcherServlet把HandlerExcutionChain中的处理器对象交给了处理器适配器对象(适配器可以有多个)

  • 处理器适配器：是springmvc框架中的一个接口，实现的是HandlerAdapter接口
  • 处理器适配器的作用：执行处理器的方法（调用myController中的doSome()方法，得到返回值ModelAndView）

• DispatcherServlet会将处理器适配器得到的ModelAndView交给视图解析器

  • 视图解析器：springmvc中的对象，需要实现的是ViewResoler接口，可以有多个

    • 作用：组成视图的完整路径，使用前缀，后缀，并且创建View对象。

      view是一个接口，表示视图的，在框架中的jsp，html不是String表示的，而是使用View和它的实现类表示视图的

    • InternalResourceView：视图类，表示jsp文件，视图解析器会创建InternalResourceView类对象。

      • 这个对象里边，有一个属性url=/WEB-INF/view/show.jsp找到静态资源

• DispatcherServlet把创建的View对象获取到，调用View类自己的方法，把Model的数据放到request作用域，执行对象视图的forward，请求结束。