springMVC框架

springMVC框架

第一章 SpringMVC概述

1.1SpringMVC简介

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

​ 理解servlet的一个升级

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

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

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

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

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

web开发底层是servlet，springmvc中有一个对象是servlet：DispatherServlet

DispatherServlet：负责接收用户所有的请求，用户把请求给了DispatherServlet，之后DispatherServlet把请求转发给我们的Contorller对象，最后Contorller对象处理请求

1.2 SpringMVC优点

1.3 第一个注解的SpringMVC程序

spring-hello-springmvc:第一个springmvc项目
需求：用户在页面发起一个请求，请求交给springmvc的控制器对象
        并显示请求的处理结果（在结果页面显示一个欢迎语句）


实现步骤
1.新建web maven工程
2.加入依赖
    spring-webmvc依赖，简介把spring的依赖加入到项目
    jsp，servlet依赖

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

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

6.创建一个作为结果的jsp，显示请求的处理结果
7.创建springmvc的配置文件，和spring的配置文件一样
        声明组件扫描器，指定@Contorller注解所在的包名
        声明视图解析器，帮助处理视图的

1.4 SpringMVC的MVC组件

1.5 SpringMVC执行流程（理解）

springmvc的执行流程

​ 1.发起some.do

​ 2.tomcat（web.xml—url-pattern知道*.do的请求给DispatcherService）

​ 3.DispatcherService（根据springmvc.xml配置知道some.do--------dosome（））

​ 4.DispatcherService把some.do 转发给MyContorler,doSome（）方法

​ 5.框架执行doSome（）把得到的ModelAndView进行处理，转发到show.jsp

上面的过程简化的方式：

some.do------DispatcherService----MyContorler

springMVC执行过程源代码分析

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

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

​ DispatcherService它的父类是继承lHttpServlet的，它是一个servlet，在被创建时，执行了init（）方法

​ 在init（）方法中

​ //创建容器，读取配置文件

​ WebApplicationContext ctx=new ClassPathXmlApplicationContext(“springmvc.xml”);

​ //把容器对象放入到ServletContext中

​ getServletContext.setAttribute（key，ctx）;

​ 上面创建容器的作用：创建@Controller注解所在的类的对象，创建MyController对象，这个对象放入到springmvc容器中，容器是map，类似map.put(“Mycontorller”,Mycontorller对象);

2.请求的处理过程

​ 1）执行servlet的service（）方法

​

第二章 SpringMVC注解式开发

2.1 @RequestMappring定义请求规则

2.1.1 指定模块名

2.2.2 对请求提交方式的定义

/**
*@RequestMapping("/user") :

•   value:所有请求地址的公共部分，叫做模块名称
  

•   位置：方法类的上面
  

• */
  @Controller
  @RequestMapping("/user")

/**
* @RequestMapping 请求映射h
* 属性：method，表示请求的方式，它的值RequestMethod类枚举值
* 例如表示get请求方式，RequestMethod.GET
* post方式，RequestMethod.POST
* 不用get方式，错误是：405，不支持get请求方式
* */
@RequestMapping(value = “/some.do”,method = RequestMethod.GET)

<p><a href="user/some.do">发起some.do请求</a></p>

2.2 处理器方法的参数

参数的四类

HttpServletRequest

HttpServletResponse

HttpSession

请求中所携带的请求参数

2.2.1 逐个参数接收（参数较少，3.4个左右）

16

/**
  * 逐个接收请求参数：
  *          要求：处理器（控制器）方法的形参名和请求中参数名必须一致
  *          同名的请求参数赋值给同名的形参
  *框架接收请求参数
  *      1.使用request对象接收请求参数
  *          String  name=request.getParameter("name");
  *          String age=request.getParameter("age");
  *      2.Springmvc框架通过DispatcherService 调用MyController的doSome（）方法
  *          调用方法时，按名称对应，把接受的参数赋值给形参
  *          dosome（strName,Integer.valueof(strAge)）
  *          框架会提供类型转换的功能，能把string抓换为int,long,floot,double等类型。
  *  GET方式中文不会乱码，POST方式中文会乱码，解决如下：
  *  使用过滤器中解决乱码（可以自定义，可以使用框架中的过滤器）
  * */
 @RequestMapping(value = "/receive.do")
public ModelAndView dosome(String name,int age){
     //可以在方法中直接接收参数了
    //处理somg.do请求了。相当于service调用处理完成了
    ModelAndView mv=new ModelAndView();
    mv.addObject("myname",name);
    mv.addObject("myage",age);
     mv.setViewName("show");
    return mv;
}

<form action="receive.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age">
    <input type="submit" value="提交参数">
</form>

<h3>/WEB-INF/view/show.jsp项目中的show.jsp</h3>
<h3>myname:${myname}</h3><br>
<h3>myage:${myage}</h3>

2.2.2 请求参数中文乱码的问题

*  GET方式中文不会乱码，POST方式中文会乱码，解决如下：
*  使用过滤器中解决乱码（可以自定义，可以使用框架中的过滤器）
* */

<!--注册声明过滤器，解决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>

2.2.3 校正请求参数名@RequestParar

<p>请求参数名和处理器方法的形参民不一样</p>
<form action="receiveparam.do" method="POST">
    姓名：<input type="text" name="rname"><br>
    年龄：<input type="text" name="rage"><br>
    <input type="submit" value="提交参数">
</form>

/**
  * 请求中参数名和处理器方法中的形参名不一样
  * @RequestParam 解决请求中参数名形参名不一样的问题
  *          属性：1.value 请求中的参数名称
  *                2.required 是一个boolean，默认是true
  *                      true：表示请求中必须包含此参数
  *          位置： 在处理器方法的形参定义的前面
  *
  * */
@RequestMapping(value = "/receiveparam.do")
 public ModelAndView receiveparam(@RequestParam(value = "rname",required = false) String name,
                                  @RequestParam(value = "rage",required = false) Integer age){

2.2.4 对象参数接收（参数较多时）

<p>使用java对象接受请求参数</p>
<form action="receiveobject.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交参数">
</form>

//保存请求参数值的一个普通类
public class Student {
    //属性名和请求参数名一样
    private String name;
    private Integer age;

 /**
     * 处理器方法形参是java对象，这个对象的属性名和请求中参数名一样的
     * 框架会创建形参的Java对象，给属性赋值，请求中的参数是name，框架会调用setName()
     *
     * */
    @RequestMapping(value = "/receiveobject.do")
    public ModelAndView receiveobject(Student student){
        //可以在方法中直接接收参数了
        //处理somg.do请求了。相当于service调用处理完成了
        ModelAndView mv=new ModelAndView();
        mv.addObject("myname",student.getName());
        mv.addObject("myage",student.getAge());
        mv.setViewName("show");
        return mv;
    }

2.3 处理器方法的返回值

2.3.1 返回ModelAndView

​ 若处理器方法处理完后，需要跳转到其他资源，且又要在跳转资源中传递数据，此时处理器方法返回ModelAndView比较好

​ 在使用时，若处理器方法只是进行跳转而不进行传递数据，或只是传递数据而不像任何资源跳转，此时返回ModelAndView，则总是有一部分多余，要么Model多余，要么View多余

2.3.2 返回String

String代表视图部分（View）可以是一个逻辑名称，也可以是一个完整路径

（1）逻辑名称

<p>处理器方法返回String表示视图名称</p>
<form action="return-view.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交参数">
</form>

 /*
    * 处理器方法返回值String--表示逻辑视图名称，需要配合视图解析器
    * */
    @RequestMapping(value = "/return-view.do")
   public String dosome(HttpServletRequest request, String name,Integer age){
        //想要获取数据的方式
        request.setAttribute("myname",name);
        request.setAttribute("myage",age);
        //show：逻辑视图名称，项目中配置了视图解析器
        //框架对视图执行forward转发操作
       return "show";
   }
   
   <!-- 声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!-- 后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

（2）完整路径，项目中不能配置视图解析器

<p>处理器方法返回String表示视图完整路径</p>
<form action="return-view1.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交参数">
</form>

/*
 * 处理器方法返回值String--表示逻辑视图完整路径，此时不需要配合视图解析器
 *
 * */
@RequestMapping(value = "/return-view1.do")
public String dosome1(HttpServletRequest request, String name,Integer age){
    //想要获取数据的方式
    request.setAttribute("myname",name);
    request.setAttribute("myage",age);
    //show：完整路径，项目中不能配置视图解析器
    //框架对视图执行forward转发操作
    return "/WEB-INF/view/show.jsp";
}

2.3.3 返回void 24

2.3.4 返回对象Object

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

​ 返回对象，需要使用@ResposeBody注解，将转换的JSON数据放入到响应体中

(1)返回值是Student的json格式

/**
 * 处理器方法返回一个Student，通过框架转为json，响应ajax
 * @ResponseBody
 *     作用：把处理器方法返回对象转为json，通过HttpServletResponse输出给浏览器
 *     位置：方法的定义上面，和其他注解没有顺序的关系。
 *返回对象框架的处理流程：
 * 1.框架会把返回Studnet类型，调用框架中的ArrayList<HttpMessageConverter>中每个类的canWrite()方法
 *      检查那个HttpMessageConverter接口的实现类能处理Student类型的数据MappingJackson2HttpMessageConverter
 * 2.框架会调用实现类的write（），MappingJackson2HttpMessageConverter的write（）方法
 *      把李四同学的student对象转换为json，调用jackson的ObjectMapper实现转换为json
 *
 * 3.框架会调用@ResponseBody把2中的结果输出到浏览器，ajax请求处理完成
 *
 * */
@RequestMapping(value = "/returnStudentJson.do")
@ResponseBody
public Student doStudentJsonObject(String name,Integer age) {
    Student student=new Student();
    student.setName("李四同学");
    student.setAge(20);
    return student;//会被框架转换为json
}

$(function () {
            $("button").click(function () {
                //alert("button click");
                $.ajax({
                   // url:"returnVoid-ajax.do",
                    //代表的是请求的地址
                    url:"returnStudentJson.do",
                    data:{
                        name:"zhangsan",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp) {
                        //resp从服务器段返回的是json格式的字符串{“name”："zhangsan"，“age”：20}
                        //jquery会把字符串转为json对象，赋值给resp形参
                        alert(resp.name+"   "+resp.age);
                    }
                })
            })
        })
    </script>

（2）返回值list是JsonArray

/**
 * 处理器方法返回List<Student>
 *返回对象框架的处理流程：
 * 1.框架会把返回List<Student>类型，调用框架中的ArrayList<HttpMessageConverter>中每个类的canWrite()方法
 *      检查那个HttpMessageConverter接口的实现类能处理Student类型的数据MappingJackson2HttpMessageConverter
 * 2.框架会调用实现类的write（），MappingJackson2HttpMessageConverter的write（）方法
 *      把李四同学的student对象转换为json，调用jackson的ObjectMapper实现转换为json
 *
 * 3.框架会调用@ResponseBody把2中的结果输出到浏览器，ajax请求处理完成
 * */
@RequestMapping(value = "/returnStudentArray.do")
@ResponseBody
public List<Student> doStudentJsonObjectArray(String name, Integer age) {
    List<Student> list=new ArrayList<>();

    Student student=new Student();
    student.setName("李四同学");
    student.setAge(20);
    list.add(student);

    student=new Student();
    student.setName("张三同学");
    student.setAge(18);
    list.add(student);

    return list;//会被框架转换为json
}

<script type="text/javascript">
        $(function () {
            $("button").click(function () {
                //alert("button click");
                $.ajax({
                   // url:"returnVoid-ajax.do",
                    //代表的是请求的地址
                    //url:"returnStudentJson.do",
                    url:"returnStudentArray.do",
                    data:{
                        name:"zhangsan",
                        age:20
                    },
                    type:"post",
                    dataType:"json",
                    success:function (resp) {
                        //resp从服务器段返回的是json格式的字符串{“name”："zhangsan"，“age”：20}
                        //jquery会把字符串转为json对象，赋值给resp形参
                        //alert(resp.name+"   "+resp.age);
                        //输出数组的形式
                        $.each(resp,function (i,n) {
                            alert(n.name+"  "+n.age)
                        })
                    }
                })
            })
        })
    </script>

（3）

2.4 解读

2.4.1 第一种处理静态资源的处理方式

第一种处理静态资源的方式
        需要在springmvc配置文件中加入<mvc:default-servlet-handler/>
        原理是：加入这个标签后，框架会创建控制器对象DefaultServletHttpRequestHandler(类似于我们自己创建的MyContorler)
        DefaultServletHttpRequestHandler这个对象可以把接收到的请求转发给tomcat的dafault这个servlet
-->
    <mvc:default-servlet-handler/>
 解决冲突的方法  
<!--default-servlet-handler和@RequestMapping注解有冲突，需要加入注解驱动类解决这个矛盾-->

2.4.2 第二种处理静态资源的处理方式（用的多）

<!--第二种处理静态资源的方式
     <mvc:resources>加入后框架会创建ResourcesHttpRequestHandler这个处理器对象
     让这个对象处理静态资源的访问不依赖tomcat服务器
     mapping：访问静态资源的url地址，使用通配符 **
     location：静态资源在你的项目中的目录的位置
     images/**:表示images下面的所有文件
-->
   <mvc:resources mapping="images/**" location=""/>  

2.4.3 一条配置处理所有的静态资源文件

将所有的文件写在同一个目录下面

2.4.4 路径的问题

1.绝对路径：带有协议名称的都是绝对路径，访问地址变为http://localhost:8080/ch05_url_pattern/some.do

​ 访问的是：http://localhost:8080/ch05_url_pattern/some.do

​ 路径：http://localhost:8080/ch05_url_pattern/

​ 资源：some.do

2.相对地址：没有协议开头的，例如：usesr/some.do, /usesr/some.do

3.参考地址

​ 1）在你的页面中，访问地址不加 “/”

​ 2）在你的页面中访问地址加 “/”

2.4.5 解决路径访问的问题

​ 1. 如果你的资源不能访问，加入${pageContext.request.contextPath}

2. ​ 使用base地址

第三章 SSM整合开发（42）

3.1 搭建SSM开发环境

ch07-ssm:SSM整合开发
SSM：SpringMVC+Mybatis+Spring

SpringMVC：视图层，界面层，负责请求接收，显示处理结果的
Spring：业务层，管理service，dao，工具类对象的
Mybatis:持久层，访问数据库的

用户发起请求--SpringMVC接收--Spring中的Service对象--MyBatis处理数据

SSM整合也叫SSI（IBatis也是mybatis的前身），整合中有容器
1.第一个容器SpringMVC容器，管理Controller控制器对象的
2.第二个容器Spring容器，管理service，dao，工具类对象的
我们要做的把使用的对象交给合适的容器创建，管理，把controller还有web开发的相关对象
交给spring容器，这些web用的对象写在springmvc配置文件中

service dao对象定义在spring配置文件中，让spring管理这些对象

springmvc和spring是有关系的，关系已经确定好的
springmvc容器是spring容器的子容器，类似java中的继承，子可以访问父的类容
在子容器中的controller可以访问父容器中的service对象，就可以实现contorller使用service对象

实现步骤
0.使用springdb的mysql数据库
1.新建maven web项目
2.加入依赖
      springmvc依赖，spring依赖，mybatis三个框架的依赖，jackson依赖，mysql驱动，druid连接池
      jsp，servlet依赖
3.写web.xml
    1）注册DispatcherServlet，目的：1.创建springmvc容器对象，才能创建Contorller类对象
                                   2.创建的是Servlet，才能接受用户的请求
    2）注册spring监听器，ContextLoaderListenner，目的：创建spring的容器对象，才能创建servlt，dao对象
    3）注册字符集过滤器，解决post请求乱码问题
4.创建包，Controller包，service，dao，实体类包名创建好
5.写springmvc，spring，mybatis的配置文件
    1) springmvc配置文件
    2)spring配置文件
    3)mybatis主配置文件
    4)数据库的属性配置文件
6.写代码，dao接口和mapper文件，service和实现类，controller，实体类
7.写jsp页面

3.1.1 maven pom.xml

3.1.2 配置web.xml

(1) 注册ContextLoaderListene

<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

(2) 注册字符集过滤器

<!--注册声明过滤器，解决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>

(3) 配置中央调度器

<!-- 注册中央调度器-->
<servlet>
  <servlet-name>springmvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--在tomcat启动后，创建servlet对象
  load-on-startup：表示tomcat启动后创建对象的顺序，它的值是整数，数值越小
                   tomcat创建对象的时间越早，大于等于0的整数
  -->
  <!--自定义springmvc读取的配置文件的位置-->
  <init-param>
    <!-- springmvc配置文件的属性-->
    <param-name>contextConfigLocation</param-name>
    <!-- 指定自定义文件的位子-->
    <param-value>classpath:conf/dispatcherServlet.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

3.2 SSM整合注解开发

3.2.1 新建student

3.2.2 新建web工程

3.2.3 maven依赖

3.2.4 定义包，组织程序的结构

3.2.5 编写配置文件

<!--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="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
<!--SqlSessionFactoryBean 创建 SqlSessionFactory   -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:conf/mybatis.xml"/>
    </bean>
<!--    声明mybatis的扫描器，创建dao对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.jike.dao"/>
    </bean>
<!--    声明service的注解@Service所在的包名位置-->
    <context:component-scan base-package="com.jike.service"/>
<!--    事务配置，注解配置或aspecj配置-->
</beans>

<!--    springmvc配置文件，声明controller和其他web相关的对象-->
<!--    组件扫码器-->
    <context:component-scan base-package="com.jike.controller"/>
<!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
<!--    注解驱动-->
    <mvc:annotation-driven>
<!--
1.相应ajax请求，返回json
2.解决静态资源访问
-->
    </mvc:annotation-driven>
</beans>

jdbc.url=jdbc:mysql://localhost:3306/ssmdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

<configuration>
    <!--settings：控制mybatis的全局行为-->
<!--    <settings>-->
<!--        &lt;!&ndash;设置mybatis输出日志&ndash;&gt;-->
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!--    </settings>-->
    <!--环境配置：数据库的连接信息
        default:必须和和某个environment的id值一样
        告诉mybatis使用哪个数据库的连接信息，也就是访问哪个数据库

    -->

    <!--    设置别名-->
    <typeAliases>
<!-- name是实体类的包名-->
        <package name="com.jike.domain"/>
    </typeAliases>
 <!--
        sql mapper（sql映射23文件的位置）
-->
    <mappers>
        <!--
       一个mapper标签指定一个文件的位置
       从类路径开始的路径信息，target/class（类路径）
       name:包名，这个包中所有mapper.xml文件能一次加载
       使用package的要求：
             1.mapper文件名称和dao接口名必须完全一样，包括大小写
             2.mapper文件和dao接口必须在同一目录
        -->
<!--        <mapper resource="com/jike/dao/StudentDao.xml"/>-->
        <package name="com.jike.dao"/>
    </mappers>
</configuration>

3.2.6 定义web.xml

3.2.7 实体类Student

public class Student {
    private Integer id;
    private String name;
    private Integer age;

3.2.8 dao接口和sql映射文件

public interface StudentDao {
    int insertStudent(Student student);
    List<Student> selectStudent();
}

<mapper namespace="com.jike.dao.StudentDao">
<select id="selectStudent" resultType="Student">
    select id,name,age from student order by id desc
</select>
<insert id="insertStudent" >
    insert into student(name,age) values(#{name},#{age})
</insert>
</mapper>

3.2.9 service接口和实现类

public interface StudentService {
    int addStudent(Student student);
    List<Student> findStudents();
}

@Service
public class StudentServiceImpl implements StudentService {
    //引用类型自动注入@Autowired，@Resource
    @Resource
    private StudentDao studentDao;
    @Override
    public int addStudent(Student student) {
        int nums=studentDao.insertStudent(student);
        return nums;
    }

    @Override
    public List<Student> findStudents() {

        return studentDao.selectStudent();
    }
}

3.2.10 处理器定义

@Controller
@RequestMapping("/student")
public class StudentController {

    @Resource
    private StudentService service;
    //注册学生
    @RequestMapping("/addStudent.do")
    public ModelAndView addStudent(Student student){
        ModelAndView mv=new ModelAndView();
        String tips="注册失败";
        //调用service处理student
        int nums = service.addStudent(student);
        if (nums>0){
            //注册成功
            tips="学生["+student.getName()+"]注册成功";
        }
        //添加数据
        mv.addObject("tips",tips);
        //指定结果界面
        mv.setViewName("result");
        return mv;
    }
    //处理查询，相应ajax
    @RequestMapping("/queryStudent.do")
    @ResponseBody
    public List<Student> queryStudent(){
        //参数检查，简单数据处理
        List<Student> students=service.findStudents();
        return students;
        //
    }

3.2.11 定义视图-首页文件--------index.jsp

<%
    String basepath= request.getScheme() + "://"+
            request.getServerName()+":"+request.getServerPort()+
            request.getContextPath()+"/";
%>
<base href="<%=basepath%>">
<div align="center">
<p>SSM整合</p>
    <table>
        <tr>
            <td><a href="addStudent.jsp">注册学生</a></td>
        </tr>
        <tr>
            <td><a href="listStudent.jsp">浏览学生</a></td>
        </tr>
    </table>
</div>

3.2.12 注册学生页面-----addStudent.jsp 50

<%
String basepath= request.getScheme() + "://"+
                request.getServerName()+":"+request.getServerPort()+
                request.getContextPath()+"/";
%>
 <base href="<%=basepath%>">
<div align="center">
    <form action="student/addStudent.do" method="post">
        <table>
            <tr>
                <td>
                    姓名:
                </td>
                <td>
                    <input type="text" name="name">
                </td>
            </tr>
            <tr>
                <td>
                    年龄：
                </td>
                <td>
                    <input type="text" name="age">
                </td>
            </tr>
            <tr>
                <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
                <td><input type="submit" value="注册"></td>
            </tr>

        </table>
    </form>
</div>

3.2.13 浏览学生页面------listStudent.jsp

<%
    String base= request.getScheme() + "://"+
            request.getServerName()+":"+request.getServerPort()+
            request.getContextPath()+"/";
%>
<base href="<%=base%>">
    <script type="text/javascript" src="js/jquery.min.js"></script>
    <script type="text/javascript">
 //入口函数
        $(function () {
            //在前面页面dom对象加载后，执行loadStudentData();
            loadStudentData();
            //指定按钮
            $("#btnLoader").click(function () {
                loadStudentData();
            })
        })
        function loadStudentData() {
            //ajax的调用
            $.ajax({
                //请求地址
                url:"student/queryStudent.do",
                //请求方式
                type:"get",
                //指定数据格式
                dataType:"json",
                //指定成功的函数
                success:function (data) {
                    //清除旧的数据
                    $("#info").html("");
                    //data就是数据库中的数据，会被jquery转换成json对象
                    //alert("data"+data);
                    //循环处理数组函数
                    $.each(data,function (i,n) {
                        $("#info").append("<tr>")
                            .append("td"+n.id+"<td>")
                            .append("td"+n.name+"<td>")
                            .append("td"+n.age+"<td>")
                            .append("</tr>")
                    })
                }

            })
        }
    </script>
</head>
<body>
<div align="center">
    <table>
        <thead>
        <tr>
            <td>学号</td>
            <td>姓名</td>
            <td>年龄</td>
        </tr>
        </thead>
        <tbody id="info">

        </tbody>
    </table>
    <input type="button" id="btnLoader" value="数据查询">
</div>

3.2.14 注册成功页面------success.jsp

3.2.15 注册失败页面------fail.jsp

第四章 SpringMVC核心技术 52

SpringMVC框架把原来Servlet中请求转发和重定向操作进行封装

​ forward：表示转发，实现request.getRequestDispatcher(“xxx.jsp”).forward

​ redirect：表示重定向，实现reponse.sendRedirect(“xxx.jsp”)

4.1 请求重定向和转发

4.1.1 请求转发

<p>当出来方法返回值ModelAndView实现forward</p>
<form action="dofarword.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交请求">
</form>

/**
 *@RequestMapping("/user") :
 *       value:所有请求地址的公共部分，叫做模块名称
 *       位置：方法类的上面
 * */
@Controller

public class MyContorler {
 /**
  * 处理器方法返回值ModelAndView，实现fforward
  * 语法：setViewName("forward：视图文件的完整路径")
  * forward特点：不和视图解析器一同使用，就当项目中没有视图解析器
  * 可以转发到其他任意目录下的文件
  * */
    @RequestMapping(value = "/dofarword.do")
   public ModelAndView dofarword(String name,Integer age){
        ModelAndView mv=new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("forward:/WEB-INF/view/show.jsp");
       return mv;
   }

<!--声明组件扫描器-->
    <context:component-scan base-package="com.jike.contorller"/>
<!-- 声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!-- 后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>
<!--default-servlet-handler和@RequestMapping注解有冲突，需要加入注解驱动类解决这个矛盾-->
    <mvc:annotation-driven/>
<!-- 第一种处理静态资源的方式
        需要在springmvc配置文件中加入<mvc:default-servlet-handler/>
        原理是：加入这个标签后，框架会创建控制器对象DefaultServletHttpRequestHandler(类似于我们自己创建的MyContorler)
        DefaultServletHttpRequestHandler这个对象可以把接收到的请求转发给tomcat的dafault这个servlet
-->
    <mvc:default-servlet-handler/>
<!--第二种处理静态资源的方式
     <mvc:resources>加入后框架会创建ResourcesHttpRequestHandler这个处理器对象
     让这个对象处理静态资源的访问不依赖tomcat服务器
     mapping：访问静态资源的url地址，使用通配符 **
     location：静态资源在你的项目中的目录的位置
     images/**:表示images下面的所有文件
-->
<!--    <mvc:resources mapping="images/**" location=""/>  -->

4.1.2 转发

<p>当出来方法返回值ModelAndView实现redirect</p>
<form action="doredirect.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交请求">

</form>

/**
 * 处理器方法返回值ModelAndView，实现redirect
 * 语法：setViewName("redirect：视图文件的完整路径")
 * redirect特点：不和视图解析器一同使用，就当项目中没有视图解析器
 *
 * 框架对重定向的操作：
 * 1.框架会把Model中的简单类型的数据，转为string使用，作为hello.jsp的get请求参数使用
 *   目的是在doredirect.do和hello.jsp两次请求之间传递数据
 * 2.在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
 *   ${param.myname}
 *
 *3.重定向不能访问/WEB-INF/下资源
 * */
 @RequestMapping(value = "/doredirect.do")
 public ModelAndView doredirect(String name,Integer age){
     ModelAndView mv=new ModelAndView();
     mv.addObject("myname",name);
     mv.addObject("myage",age);
     mv.setViewName("redirect:/hello.jsp");
     return mv;
 }

4.2 异常处理 56

异常处理：

​ springmvc框架采用的是统一，全局的异常处理

把controler中的所有异常处理都集中在一个地方，采用的是aop的思想，把业务逻辑和异常处理代码分开，解耦合

使用两个注解

1.@ExceptionHandler

2.@ControllerAdvice

ch09-exception-handler：异常处理

异常处理步骤：
1.新建maven web项目
2.加入依赖
2.新建一个自定义异常类，MyUserException，在定义他的子类NameException，AgeException
4.在conroller抛出NameException，AgeException
5.创建一个普通类，作用全局异常处理类
    1）在类的上面加入@ControllerAdvice
    2）在类中定义方法，方法的上面加入@ExceptionHandler
6.创建处理异常的视图页面
7.创建springmvc的配置文件
    1）组件扫描器，扫描@Controller
    2）组件扫描器，扫描@ControllerAdvice所在的包名
    3）声明注解驱动

public class MyUserException extends Exception {
    public MyUserException() {
    }

    public MyUserException(String message) {
        super(message);
    }
}

//表示当用户的姓名有异常时，抛出NameException
public class NameException extends MyUserException {
    //重写方法的快捷键      ctrl+o
    public NameException() {
        super();
    }

    public NameException(String message) {
        super(message);
    }
}

//当年龄有异常时，抛出异常
public class AgeException extends MyUserException {
    public AgeException() {
        super();
    }

    public AgeException(String message) {
        super(message);
    }
}

@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age) throws MyUserException {
    ModelAndView mv=new ModelAndView();
    //根据请求参数抛出异常
    if (!"zs".equals(name)){
        throw new NameException("姓名不正确！！！！");
    }
    if (age==null || age>80){
        throw new AgeException("年龄比较大！！！！");
    }
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    mv.setViewName("show");
    return mv;
}

/**
 * @ControllerAdvice 控制器增强（也就是说给控制器类增加功能---异常处理）
 *          位置：在类的上面
 *   特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器
 *   指定@ControllerAdvice所在的包名
 *
 * */
@ControllerAdvice
public class GlobaException {
    //定义方法，处理发生的异常
    /**
     * 处理异常的方法和控制器方法的定义一样，可以有多个参数，可以有ModelAndView，
     * string，void，对象类型的返回值
     *
     * 形参：Exception表示controller的异常
     * 通过形参可以获得发生的异常信息
     *
     * 还需要@ExceptionHandler（异常的class）:表示异常的类型，
     * 当发生此类型异常时，由当前方法处理
     * */

    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception ex){
        //处理NameException的异常
        /**
         * 异常发生处理逻辑
         *      1.需要把异常记录下来，记录到数据库，日志文件
         *          记录日志发生的时间，哪个方法发生的，异常错误内容
         *      2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员
         *      3.给用户友好提示
         *
         * */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","姓名必须是zs，其他用户不能访问");
        mv.addObject("ex",ex);
        mv.setViewName("nameError");
        return mv;
    }

    //处理AgeException
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception ex){
        //处理NameException的异常
        /**
         * 异常发生处理逻辑
         *      1.需要把异常记录下来，记录到数据库，日志文件
         *          记录日志发生的时间，哪个方法发生的，异常错误内容
         *      2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员
         *      3.给用户友好提示
         *
         * */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","年龄不得大于80");
        mv.addObject("ex",ex);
        mv.setViewName("ageError");
        return mv;
    }
    //处理其他异常，不知类型的异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception ex){
        //处理NameException的异常
        /**
         * 异常发生处理逻辑
         *      1.需要把异常记录下来，记录到数据库，日志文件
         *          记录日志发生的时间，哪个方法发生的，异常错误内容
         *      2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员
         *      3.给用户友好提示
         *
         * */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","年龄不得大于80");
        mv.addObject("ex",ex);
        mv.setViewName("defaultError");
        return mv;
    }

<!-- 处理异常需要的两步-->
    <context:component-scan base-package="com.jike.handler"/>
    <mvc:annotation-driven/>

nameError.jsp<br>
提示信息:${msg}<br>
系统异常信息:${ex.message}
</body>

4.3 拦截器 60

拦截器

​ 1）拦截器是springmvc中的一种，需要实现是HanderlerInterceptor接口

​ 2）拦截器和过滤器类似，功能方向侧重点不同，过滤器是用来过滤请求参数，设置编码字符集等工作

​ 拦截器是拦截用户的请求，做请求做判断处理的

​ 3）拦截器是全局的，可以对多个Contorller做拦截

​ 一个项目中可以有0个或多个拦截器，他们在一起拦截用户的请求

​ 拦截器常用在：用户登录处理，权限检查，记录日志

拦截器的使用步骤：

​ 1.定义类，实现HanderlerInterceptor接口

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

拦截器的执行时间

​ 1）在请求处理之前，也就是Contorller类中的方法执行之前先被拦截

​ 2）在控制器方法执行之后也会执行拦截器

​ 3）在请求处理完成之后也会执行拦截器

4.3.1 一个拦截器的执行

ch10-inteerceptor：拦截器

异常处理步骤：
1.新建maven web项目
2.加入依赖
3.创建Contorller类
4.创建普通类，作为拦截器使用
    实现handerInterceptor接口
    实现接口中的三个方法
5.创建show页面
6.创建springmvc的配置文件
    1）组件扫描器，扫描@Controller
    2）组件扫描器，并指定拦截器的请求uri地址

/**
 *@RequestMapping("/user") :
 *       value:所有请求地址的公共部分，叫做模块名称
 *       位置：方法类的上面
 * */
@Controller

public class MyContorler {

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age){
        ModelAndView mv=new ModelAndView();

        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

public class MyInterceptor implements HandlerInterceptor {
    private long btime=0;
    /**
     * preHandle叫做预处理方法。
     * 很重要，是整个项目的入口，门户。当preHandle返回true，请求可以被处理
     *                               当preHandle返回false，请求到此方法就截止l
     * 参数：
     * Object handler：被拦截的控制器对象
     * 返回值boolean
     *      true：请求时通过了验证，可以执行处理其方法
     *      拦截器的MyInterceptor的preHandle（）
     *      =========执行了MyContorler中的dosome（）方法
     *      拦截器的MyInterceptor的postHandle
     *      拦截器的MyInterceptor的afterCompletion
     *      false：请求没有通过拦截器的验证，请求到达拦截器就截止了。请求没有被处理
     *           拦截器的MyInterceptor的preHandle
     * 特点：
     *      1.方法在控制器方法（MyController的dosome）之前执行的
     *          用户的请求首先到达此方法
     *      2.在这个方法中可以获得请求的信息，验证请求是否符合要求
     *          可以验证用户是否登录，验证用户是否有权限访问某链接地址（url）
     *          如果验证失败，可以截断请求，请求不能被处理
     *          如果验证成功，可以放行请求，此时控制器方法才能执行
     *
     * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime=System.currentTimeMillis();//当前的系统时间
        System.out.println("拦截器MyInterceptor的preHandle（）");
        //返回值时false时，给浏览器一个返回结果
        //request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    /**
     * postHandle：后处理方法
     * 参数
     * Object handler：被拦截的处理器对象MyInterceptor
     * ModelAndView mv：处理方法的返回值
     *
     * 特点：
     *      1.在处理器方法之后执行的(MyContorler.dosome())
     *      2.能够获取到方法的返回值ModelAndView，可以修正ModelAndView中的
     *      数据和视图，可以影响到最后的执行结果
     *      3.主要是对原来的执行结果进行二次修正
     * */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) throws Exception {
        System.out.println("拦截器MyInterceptor的postHandle（）");
        //对原来的dosome执行结果，需要调整
        if (mv!=null){
            //修改数据
            mv.addObject("mydata",new Date());
            //修改视图
            mv.setViewName("other");
        }
    }

    /**
     * afterCompletion：最后执行的方法
     * 参数
     *      Object handler：被拦截器的处理对象
     *      Exception ex：程序中发生的异常
     *      特点：
     *          1.在请求处理完成后执行的，框架中规定的是当你的视图处理完成后，对视图执行了forward。就认为请求处理完成
     *          2.一般做资源回收工作的，程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收
     * */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("拦截器MyInterceptor的afterCompletion（）");
        long etime=System.currentTimeMillis();
        System.out.println("计算从开始到结束所用的系统时间"+(etime-btime));
    }

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

<!--声明拦截器：拦截器可以有0个或多个-->
    <mvc:interceptors>
    <!-- 声明第一个拦截器-->
        <mvc:interceptor>
            <!-- 指定拦截器的请求uri地址
            path：就是uri地址，可以使用通配符 **
                ** ：表示任意的字符，文件或者多级目录和目录中的文件

            -->
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.jike.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

<p>一个拦截器</p>
<form action="some.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交请求">
</form>
<br>

4.3.2 多个拦截器的执行

/**
 *@RequestMapping("/user") :
 *       value:所有请求地址的公共部分，叫做模块名称
 *       位置：方法类的上面
 * */
@Controller

public class MyContorler {

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age){
        ModelAndView mv=new ModelAndView();

        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

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

<!--声明拦截器：拦截器可以有0个或多个
多个拦截器是一个ArrayList集合
按照声明的先后顺序放入到ArrayList
-->
    <mvc:interceptors>
    <!-- 声明第一个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.jike.handler.MyInterceptor"/>
        </mvc:interceptor>
        <!-- 声明第二个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.jike.handler.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

public class MyInterceptor implements HandlerInterceptor {

public class MyInterceptor2 implements HandlerInterceptor {

4.3.3权限拦截器举例

拦截器和过滤器的区别

1.过滤器是servlet中的对象，拦截器是框架中的对象

2.过滤器实现Filter接口的对象，拦截器是实现HandlerInterceptor

3.过滤器是用来设置request，response的参数，属性的，侧重对数据进行过滤的

​ 拦截器是用来验证请求的，能截断请求

4.过滤器是在拦截器之前执行的

5.过滤器是tomcat服务器创建的对象

​ 拦截器是springmvc容器中创建的对象

6.过滤器是一个执行时间点

​ 拦截器有三个执行时间点

7.过滤器可以处理jsp，js，html等等

​ 拦截器是侧重拦截对contoriller的对象，如果你的请求不能被DispatcherServlet接收，这个请求不会执行拦截器的内容

8.拦截器拦截普通类方法执行，过滤器过滤servlet请求响应

ch12-interceptor - permission：使用拦截器检验登录用户是不是能访问系统

实现步骤：
1.新建maven
2.修改web.xml注册中央调度器
3.新建index.jsp发起请求
4.创建MyController处理请求
5.创建结果show.jsp
6.创建一个login.jsp模拟登录（把用户的信息放入到session）；
    创建一个jsp，logout.jsp模拟退出系统（从session中删除数据）
7.创建按拦截器，从session中获取用户的登录数据，验证能否访问系统
8.创建一个验证的jsp，如果衍生视图，给出提示
9.创建springmvc配置组件
    生命组件扫描器
    声明拦截器

<p>一个拦截器</p>
<form action="some.do" method="POST">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交请求">
</form>
<br>

/**
 *@RequestMapping("/user") :
 *       value:所有请求地址的公共部分，叫做模块名称
 *       位置：方法类的上面
 * */
@Controller

public class MyContorler {

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age){
        ModelAndView mv=new ModelAndView();

        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        /**
         * 验证登录的用户信息，正确true，其他false
         * 从session中获取name值
         * */
        String loginName="";
        Object attr=request.getSession().getAttribute("name");
        if (attr !=null){
            loginName=(String)attr;
        }
        //判断用户登录的账户，是否符合要求
        if (!"zs".equals(loginName)){
            //不能访问系统
            //给用户提示
            request.getRequestDispatcher("/tips.jsp").forward(request,response);
        }
        //zs登录
        return true;
    }

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

<!--声明拦截器：拦截器可以有0个或多个
多个拦截器是一个ArrayList集合
按照声明的先后顺序放入到ArrayList
-->
    <mvc:interceptors>
    <!-- 声明第一个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.jike.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

模拟登陆
<%
session.setAttribute("name","zs");
%>

退出系统，从session中删除数据
<%
session.removeAttribute("name");
%>

4.3.4 springmvc映射器

ApplicationContext ctx=new ClassPathXmlApplication(“beans.xml”);

StudentSercice serivice =(StudentService)ctx.getBean(“service”);

springmvc内部请求的处理流程：也就是springmvc请求接收，到处理完成的过程

​ 1.用户发起请求some.do

​ 2.DispatcherService接收请求some.do，把请求交给处理器映射器

​ 处理器映射器：springmvc中的一种对象，框架把实现了HandlerMappring接口的类都叫映射器

​ 处理器的作用：根据请求，从springmvc容器中获取处理器对象（MyContorler contorller=ctx.getBean(“some.do”)）

​ HandlerExecutionChain：类中保存着1.处理器对象（MyContorler）；2.项目中的所有拦截器在List

​ 3.DispatcherService把2中的HandlerExecutionChain中的处理器对象交给了处理器适配器对象（多个）

​ 处理器适配器：springmvc框架中的对象，需要实现HandlerAdapter接口

​ 处理器适配器作用：执行处理器方法（调用MyContorller.doSone()）得到返回值ModeAndView

​ 4.DispatcherService把3中获取的ModeAndView交给了视图解析器对象

​ 视图解析器：springmvc中的对象，需要实现了ModeAndView接口（可以有多个）

​ 视图解析器作用：组成视图完成路径，使用前缀，后缀，并创建View对象

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

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

这个对象里面，有一个属性url=/WEB-INF/view/show.jsp

5.DispatcherService把4步骤中的创建的view对象获取到，调用view类自己的方法，把Model数据放入到request作用域，执行对象视图的forward，请求结束