首页 思维导图 详情

Spring-MVC

2021-07-26 10:31:41 43 举报
AI智能生成
SpringMVC学习过程
spring mvc
springMVC
作者其他创作
大纲/内容
小知识点
关于400状态码
1、关于400报错：肯定是和传递参数有关 比如：底层是个整数，传递一个字符串
 HTTP Status 400 – 错误的请求
Type Status Report
描述 由于被认为是客户端对错误（例如：畸形的请求语法、
无效的请求信息帧或者虚拟的请求路由）
服务器无法或不会处理当前请求。
什么时候需要配置注解驱动
1、将 Object 数据转化为 JSON 数据，就是做Ajax的第二步，使用注解驱动完成om.writeValueAsString();
   【原因】
               将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转 换器的
开启，需要由mvc:annotation-driven/来完成。
   【解决方案】
               1).加入jackson的依赖，springmvc框架默认是用jackson工具库，处理java对象到json的转换
               2).在springmvc配置文件加入注解驱动mvc:annotaion-driven
               3).在处理器方法的上面加入@ResponseBody【响应到前端】
2、解决静态资源和动态资源的冲突。在配置了DispatcherServlet中央调度器的url-pattern以后，如果是设置
了"  /  "就会拦截所有的请求，包括静态资源
             1、和注解<mvc:default-servlet-handler>的冲突
                  <!--default-servlet-handler和RequestMapping有冲突，导致动态资源不能访问-->
                  处理静态资源方式：<!--处理静态资源， 把静态资源的请求交给tomcat的default这个servlet-->

             2、和注解<mvc:resources/>的冲突
                   <!--resources和RequestMapping有冲突，导致动态资源不能访问-->
                  处理方式：<!--处理静态资源，有框架自己的处理器对象ResourceHttpRequestHandler处理
                                  mapping:访问静态资源的url地址， 使用统配符“**” ， 表示任意的目录和资源
                                  location:静态资源在web应用中的目录，不建议使用/WEB-INF。
                                 目录不要使用/WEB-INF/及其子目录。-->

           【解决方法】：加入<mvc:annotation-driven>注解
3、关于异常处理中的冲突，【原因】当自己不配注解驱动的情况，系统会默认扫描到自己所定义的异常类。
     加入注解驱动
1springmvc-简介
SprintMVC就是基于spring的一个模块。是专门用来做web开发的，SpringMVC也是一个容器
也可以创建对象，使用组件扫描器扫描包查找注解，创建对象，spring使用@Repository，@
Controller，@Service，@Component老创建对象并放到spring容器中去，SpringMVC能够
创建对象，并且放到S平ringMVC容器中去，使用的是@Controller注解创建对象
SpringMVC创建的对象就是控制器对象，将这个创建的对象放到SpringMVC容器中，实际上
这个对象就是一个普通的java对象，他没有实现HttpServlet，他本身不是一个Servlet，只是
SpringMVC框架赋予了它一些特殊的功能
重要的类：SpringMVC底层使用DispatcherServlet这个类来创建调度器对象，并创建SpringMVC容器
2、SpringMVC-WEB开发步骤
1、加入依赖
spring-webmvc依赖，这个依赖会间接的把spring需要的依赖导入
jsp，servlet的依赖
2、创建调度器对象，并创建springmvc容器
1）DispatcherServlet【中央调度器】是一个servlet，父类就是HttpServlet
2）DispatcherServlet【前端控制器-front controller】
3）DispatcherServlet：负责接受用户的请求，调度其他控制对象
并且吧请求的处理结果返回给用户
3、关于DispatcherServlet创建的规则
1、他是一个servlet，需要在web.xml文件中声明
2、创建springmvc容器对象需要跟spring一样指定那个配置文件位置
3、通知tomcat在服务器启动阶段创建这个对象。
4、声明
<servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>DispatcherServlet</servlet-class>
      <init-param>
              <init-name>contextConfigLocation</init-name>
              <init-value>classpatch:springmvc.xml</init-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>*.do</url-pattern>//拦截的请求
<servlet-mapping>
注意URL-parrern的设置
4、中央调度器的执行规则
浏览器发送请求---->中央调度器（DispatcherServlet）进行拦截 -------> 扫描创建的controller，找到对应的请求
-------> 对应的请求进行处理，处理以后返回结果给中央调度器
5、视图解析器创建
 1、关于数据的安全。
- 有些时候，某些数据不允许用户访问到，
比如我们发起某个请求以后通过转发的形式跳转到某个show.jsp.
但是用户如果猜到了这个show.jsp就可以直接通过地址栏访问，是不安全的
- 解决方法：
将需要保护的数据放在WEB-INF下，用户是没有访问权限的是安全的，比如web.xml配置文件
我们可以在web-info下新建文件夹存放资源文件
2、那么这个安全的数据怎么才能通过转发访问呢？
- 需要使用视图解析器
- 视图解析器需要在springMVC配置文件中声明，他是一个类通过bean标签声明
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
</bean>
1、@Controller注解：创建控制器对象，接受请求，处理请求。
6、重点注解
2、@RequestMapping注解：请求映射，和一个请求方法进行绑定，让这个方法去处理请求
1、value：请求的url地址，唯一值
2、method：请求的方式，使用的是RequestMethod类中的枚举值，比如：RequestMethod.GET
3、使用在方法上表示请求路径
4、使用在类上表示这个类中的处理器方法的url都需要加上这个模块名
3、关于请求参数的获取
1、使用HttpServletRequest，HttpServletResponse，HttpSession，这个三个参数可以直接出现在方法参数上，由框架进行自动赋值
2、使用逐个接收的形式接收参数，就是浏览器请求的参数出现在方法的形参列表中，但是名字必须相同
3、关于过滤器解决请求乱码的问题，框架提供了一个过滤器：characterencodingfilter
需要配置三个初始化参数
1、encoding：UTF-8
2、forceRequestEncoding：true
3、forceResponseEncoding：true
4、如果请求中参数名称和方法参数名称不一致，使用@RequestParam()注解进行重新命名
@RequestParam(value = "name",required = false) String cname,
@RequestParam(value = "age",required = false) Integer cage
5、使用对象来进行参数的获取，要求是请求参数名和属性名必须一致
 - 使用的包：vo:Value Object 值对象，也是ViewObject表现层对象
一个WEB页面的一堆数据参数对应一个VO
- 使用对象需要先创建页面参数对应的类，这个类就是一普通类需要set，get方法

- 作为参数出现在方法参数上
这个参数作为对象，属性会自动赋值，他会根据名称找到对应的属性值，使用set方法进行赋值
6【扩展】，Map，List，集合等都可以作为参数传进来，但是需要前端对数据进行处理
如果以后用到，百度查看使用方法
4、关于返回值类型
1、ModelAndView
1、返回数据和视图
2、使用方法是处理器方法的返回值是ModelAndView
3、需要创建对象，ModelAndView，使用add方法加入数据，使用setViewName方法设置请求路径
关于视图解析器
1、视图解析器的目的是简化请求转发的地址
2、就是使用请求的逻辑路径
3、配置方法：在springmvc配置文件中，声明bean标签，这个标签是
 <!--声明ModelAndView中的转发的视图的名称，就是【视图解析器】-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
</bean>
4、使用方法是直接返回名称比如:mv.setName("show")
4、如果一次处理中需要转发视图并且需要处理数据，可以使用ModelAndView
2、String
1、这个指的是返回视图文件的逻辑名称比如：return "show";
2、这个出现在一次请求中只需要返回视图不须要返回数据的情况下
 public String doView(){

return "视图的逻辑路径或者完整路径";
}
【注意】：如果设置了视图解析器就不能使用完整路径
3、void
1、这个void就是指只有数据信息，没有视图信息
2、常用在Ajax请求中，只需要处理数据，不需要返回视图信息
处理Ajax需要引入一个新的依赖就是处理json数据格式的jack-son依赖
3、使用void做AJax请求，需要自己手动将请求发给前端浏览器
4、Object：【是对象，是数据，不是视图，在框架中就是指ajax请求】
1、使用springmvc做Ajax的步骤
1、加入处理json数据格式的依赖
使用的springmvc默认的jack-son依赖

2、在springmvc配置文件中声明，<mvc:annotation-driven>注解驱动
目的是完成这一步
String json = om.writeValueAsString(student);

3、使用注解@ResponseBody注解
完成的是
response.setContextType("application/json;charset=urf-8");
PrintWrite out = response.getWrite();
out.print(json);
2、底层实现原理
1、springmvc处理方法返回Object，可以转换为json数据，响应ajax请求
2、<mvc : annotation-driven> 注解驱动
这个注解驱动实现的功能是：
完成java对象到json，xml，text，html，二进制等数据格式的转换
这个功能底层使用了一个接口
HttpMessageConverter接口：【消息转换器】
功能：定义了数据转换的方法。

- 就是说在程序启动的时候，tomcat会自动创建HttpMessageConverter接口的实现类
这个接口实现类自带的是4个实现类，他会创建这是个实现类对象

- 但是这个四个实现类不能满足需求，就是我们的对象转换为json格式的需求
因此需要加入依赖：就是处理json数据的jack-son依赖，然后在springmvc的
配置文件中加入<mvc : annotation-driven> 注解驱动，那么在服务器启动阶段
他会创建7个实现类，就是新增了导入依赖创建的3个实现类，【不同版本数量不一样】

- 作用就是将对应数据转换为对应的数据格式
5、关于使用springmvc做AJax的注意
1、返回List集合的json数据
2、返回Map集合的json数据
3、返回就是一个普通的字符串，他不是json数据
1、必须使用@ResponseBody注解，不然会被当做视图处理
2、 出现乱码，查看编码格式：Content-Type: text/html;charset=ISO-8859-1
       解决乱码的方式：
        @RequestMapping(value = "/doStringAjax.do",produces = "text/plain;charset=UTF-8")
5、关于中央调度器【DisapatcherServlet】url-pattern的设置
1、使用*.do
1、将所有的以.do结尾的请求交给DispatcherServlet处理
2、其他的请求交给web服务器默认的defaultServlet进行处理
3、优点是不会拦截静态资源，之会拦截指定的url-pattern设置的资源
2、使用 "/"
1、会拦截所有静态资源文件，全都交给DispatcherServlet进行拦截处理
2、解决静态资源无法访问的方法
1、使用配置文件<mvc:default-servlet-handler />
1、使用默认的servlet转发，配置springmvc
<mvc:default-servlet-driven>
目的是，拦截静态资源的请求访问，并转发给默认的那个defaultServlet进行处理
原理：给程序内存中增加一个对象：DefaultHttpRequestHandler,这个对象处理静态资源的访问
2、这个配置会和@RequestMapping发生冲突
解决办法就是配置注解驱动
<mvc:annotation-driven />
2、使用配置文件<mvc: resources/>
1、<mvc:resources mapping="/html/**" location="/html/"/>
第二种方式读取静态资源文件
mapping：就是你的资源文件比如：html/user.html
可以简写是 /html/** - > 含义：html目录下的所有静态资源文件
location： 就是静态资源的根目录
2、<mvc:resources mapping="/static/**" location="/static/"/>
第三种方式，简略，提取到父包
7、关于路径
1、什么是相对路径？什么是绝对路径
1、比如说：http://localhost:8080/myweb/userlogin.html
                   这个就是绝对路径
2、在项目中使用表单
            <form action="/login.html">
            </form>
             或者
             action="login.html"
都属于相对路径
2、请求的url使用 / -- 也就是action="/login.html"
1、他的参考地址就是项目的根路径
2、比如：http://localhost:8080/springmvc_day03/doListAjax.do
      参考地址：http://localhost:8080/springmvc_day03
      资源地址：/doListAjax.do
3、请求的url不适用 /  也就是action="login.html" 
1、他的参考地址就是当前页面的根
2、比如：http://localhost:8080/springmvc_day03/user/doListAjax.do
      参考地址：http://localhost:8080/springmvc_day03/user/
      资源路径：doListAjax.do
4、在jsp中可以使用EL表达式将项目名前缀替代
第一种方式配置：action="${pageContext.request.contextPath }/student/doview.do"
第二种方式配置
1、
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
2、
指定 base 标签
<head>
<base href="<%=basePath%>">
<title>title</title>
</head>
3、SSM整合开发
1、什么是SSM整合开发
SSM = Spring + SpringMVC + MyBatis
SSM整合也叫做SSI整合（MyBatis的前身是IBatis）。
整合中有个概念就是容器，
第一个容器：SpringMVC容器。存放的是controller对象以及web开发相关的对象
第二个容器：Spring容器。存放的是service，dao，工具类等业务处理的对象
我们开发人员需要做的就是把对象放到合适的容器中进行管理。
难点：这是两个容器，是两个盒子，如何让这两个盒子创建连接是重点
其实Spring和SpringMVC的关系以及确定好了。
SpringMVC是Spring的子容器。类似于java中的继承关系，但是他不是一个确切的继承。
在子容器中，controller对象可以调用父容器的service方法处理业务逻辑
2、SSM整合的开发步骤
1、编写pom.xml文件
1、加入依赖
1、SpringMVC的依赖
 <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
2、Spring的依赖
加入SpringMVC的依赖会自动导入Spring依赖
3、Mybatis的依赖
    <dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.1</version>
</dependency>
4、Mysql驱动依赖
    <dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
5、阿里数据库Druid的依赖
 <dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>
6、servlet的依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
7、jsp的依赖
  <dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2.1-b03</version>
<scope>provided</scope>
</dependency>
8、处理json数据的依赖
  <dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
9、Spring处理事务的依赖
   <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
 <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
2、配置resource，资源的位置
 <resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.txt</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.txt</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
3、配置编译工具版本
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
2、编写web.xml文件
1、创建第一个容器：SpringMVC容器
声明中央调度去对象，并创建S平ringMVC容器
DispatcherServlet对象

 <servlet>
<servlet-name>dispatcherServlet</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>
声明对象创建的时机，在tomcat服务器启动以后自动创建第一个创建
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
2、创建第二个容器：Spring容器
声明监听器对象，这个监听器是框架提供的，目的是创建spring容器
使用对象：ContextLoaderListener
<!-- 定义配置文件位置-->
<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>
3、设置字符集编码格式
使用过滤器对象，这个过滤器是框架提供的
characterEncodingFilter
  <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>
设置参数为true
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
设置参数为true
<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、创建业务的基本包
1、controllerer：控制器对象
2、dao：数据库访问对象
3、service：业务处理对象
4、domain：实体类对象
5、vo：对应前端表单提交参数的对象
6、util：工具包
7、exception:异常处理包
8、handler：全局处理包
9、aspect：功能增强包：aop
4、编写配置文件
1、jdbc.properties配置文件数据库信息
jdbc_url=jdbc:mysql://localhost:3306/mybatis
jdbc_user=root
jdbc_pwd=ht520520
jdbc_max=20
2、编写spring配置文件
1、引入properties资源文件，目的是读取jdbc信息
<context:property-placeholder location="classpath:jdbc.properties"/>
placeholder:占位符
2、编写数据库连接池，使用的是阿里公司的Druid
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" >
      <property name="url" value="${jdbc_url}"/>
      <property name="username" value="${jdbc_user}"/>
      <property name="password" value="${jdbc_pwd}"/>
      <property name="maxActive" value="${jdbc_max}"/>
</bean>
3、声明SqlSessionFactoryBean：目的是创建sqlSessionFactory
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactpryBean">
        <property name="dataSource" ref="dataSource"/>
        这里是声明mybatis的配置文件的，上面是数据库资源文件的
        <property name="configLocation" value="classpath:conf/mybatis.xml"/>
</bean>
4、给所有的dao类创建动态代理，就是类似于sqlSession.getMapper().这里是一次性全部生成
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
            <property name="basePackage" value="com.javase.dao"/>
</bean>
5、使用组件扫描器扫描注解创建对象
<context:component-scan base-package="com.javase.service"/>
3、编写mybatis配置文件
1、设置日志信息settings
 <settings>
设置显示日志信息
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
2、设置sql映射文件中查询结果的简单写法
<typeAliases>
<package name="com.javase.domain"/>
</typeAliases>
3、指定sql映射文件地址，就是mapper
<mappers>
<package name="com.javase.dao"/>
</mappers>
4、编写springMVC配置文件
1、创建组件扫描器，扫描对应包，创建对应的控制器对象
 <context:component-scan base-package="com.javase.controller"/>
2、创建视图解析器，访问WEB-INF下的资源，并且以后的返回视图直接使用逻辑名称
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            设置前缀
            <property name="prefix" value="/WEB-INF/jsp/"/>
            设置后缀
            <property name="suffix" value=".jsp"/>
</bean> 
3、声明注解驱动：< mvc: annotation driven/>
1、如果使用springmvc做AJAX请求，必须加入这个注解
2、如果是设置静态资源的访问，<mvc:defalut-servlet driven>   
这个会和@RequestMapping发生冲突，导致controller不会执行。因此加入注解驱动
3、如果设置另一个静态资源的访问办法，就是<mvc:resources />，也会和第2个一样发生冲突，因此必须设置注解驱动
5、关于转发和重定向
1、转发：forward
1、就是servlet中的request.getRequstDispatchet("show.jsp").forward(req,res);
2、默认视图返回就是一个转发操作，携带数据
1、未设置视图解析器：return "/WEB-INF/view/show.jsp";
2、设置了视图解析器：return "show";
3、即使设置了视图解析器，也可以使用forward转发
1、语法规则：setViewName("forward:/WEB-INF/jsp/show.jsp");
2、解决了：在设置了视图解析器以后的
非WEB-INF目录下资源访问的问题
 ModelAndView mv = new ModelAndView();
mv.addObject("msg","转发操作");
mv.setViewName("forward:/jsp/queryUser.jsp");
return mv;
2、重定向：redirect
1、就是之前的servlet中的response.sendRedirect("/html/show.jsp");
2、语法规则：setViewName("redirect:资源的完成路径")
3、- 重定向操作
     - 重定向时在两次请求中传递数据
4、框架实现了两次请求的数据传递
- 在第一次请求时将数据存储到mv中
会将这个数据当做第二次请求的参数也就是get请求的参数
使用EL表达式的param.name的形式读取
5、【注意】重定向无法访问WEB-INF目录下的资源，没有访问权限
6、关于框架中的统一异常处理方案
1、什么是异常的统一处理方案？
1、sprinmvc框架提供了一种统一的，全局的异常处理的方法，目的是让业务处理和异常处理分开，程序员专注于业务处理
就是解耦合
2、我的理解就是：所有出现的异常都往上抛出，有一个类专门去处理了这些抛出的异常，
就是说我这个方法调用了所有的方法，只要有异常出现，我就给处理掉，业务逻辑或者其他地方就不需要使用try...catch捕获
2、使用什么完成异常处理？
1、@ExceptionHandler
这个是做异常处理的
2、@ControllerAdvice
这个是做处理通知的
3、关于全局异常处理的实现步骤
1、 创建全局异常处理类：在handler包下创建：GlobalExceptionHandler
2、在这个类上添加注解@ControllerAdvice
1、添加这个注解需要在springmvc配置文件中声明组件扫描器，扫描此注解创建对象
2、一旦controller出现异常就会找到异常处理类
3、使用在类上，表示这是一个异常处理类
controllerAdvice：控制器增强（控制器通知），也就是给控制器增加功能的，这里增加的是异常
处理的功能。
3、添加注解
 <!-- 设置组件扫描器，创建异常处理对象（全局异常处理）-->
<context:component-scan base-package="com.javase.handler"/>
4、添加异常处理对象
<!-- 设置注解驱动--> <mvc:annotation-driven /> <!-- 设置组件扫描器，创建异常处理对象（全局异常处理）--> <context:component-scan base-package="com.javase.handler"/>
5、关于连个注解的使用规则
1、ControllerAdvice
2、@ExceptionHandler
1、默认的异常处理
1、默认的异常处理
2、也是返回一个视图和数据的modelandview
3、这个就是默认的异常处理机制，除了自己定义的异常以外的其他异常都会在这个全局
的处理方法中进行异常的处理
4、需要声明注解@ExceptionHandler
参数：value：指定异常类，如果使用的是Exception.class就是所有异常
5、有一个参数就是异常参数
 @ExceptionHandler(value = Exception.class)
public ModelAndView defaultException(Exception e){
ModelAndView mv = new ModelAndView();
mv.addObject("e",e);
mv.addObject("error","系统错误");
mv.setViewName("forward:/error/username_error.jsp");
return mv;
}
2、自定义的异常处理
@ExceptionHandler(value = UserNameException.class)
public ModelAndView nameError(Exception e){
ModelAndView mv = new ModelAndView();
mv.addObject("e",e);
mv.addObject("error","用户名错误");
mv.setViewName("forward:/error/username_error.jsp");
return mv;
}
7、关于拦截器
1、关于springMVC中的拦截器，需要实现HandlerInterceptor接口
功能解释：
1、拦截器的功能和过滤器类似
2、过滤器是过滤请求参数，设置字符集编码等工作
3、拦截器是拦截用户请求，对请求做判断处理的
4、拦截器是全局的，可以对多个controller进行拦截
 5、一个项目中可以有0个或者多个拦截器，他们在一起拦截用户的请求
      拦截器常用在登录处理，权限处理，日志记录等方面
拦截器的实现步骤
1、创建普通类实现HandlerInterceptor接口
2、实现三个方法：preHandle，postHandle，afterCompletion
3、在springmvc文件中声明拦截器
<mvc:interceptors>
<!--声明第一个拦截器MyHandlerInterceptor1-->
<mvc:interceptor>
<!-- 声明拦截的请求，可以使用通配符
1、**，就是指所有请求
2、比如拦截：http://localhost:8080/user/dosome.do
http://localhost:8080/user/other.do
-->
<mvc:mapping path="/user/**"/>
<!-- 声明使用哪个拦截器进行拦截-->
<bean class="com.javase.handler.MyHandlerInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
4、关于同时使用两个拦截器
原理：springmvc框架会创建一个ArrayList集合存放拦截器
先创建的拦截器先放进去
就是按照声明的拦截器的顺序出现在集合中。
8、拦截器和过滤器的部分区别
1、过滤器是Tomcat服务器创建的对象 拦截器是springmvc容器创建的对象
2、过滤器实现了Filter接口 拦截器实现了HandlerInterceptor接口
3、过滤器是用来设置request，response的参数，属性等，侧重于对数据的过滤
     拦截器是用来拦截用户请求，能够截断（停止）请求的
4、过滤器在拦截器之前执行
5、过滤器只有一个执行时间点 拦截器有三个执行时间点
6、过滤器可以处理jsp，html，js等资源
拦截器侧重于controller中的请求的拦截，如果你的请求不能被DispatcherServlet中央调度器接收
则不会被拦截器拦截
7、过滤器是过滤请求和响应 拦截器是普通的方法执行操作
【注意】：必须声明mvc:annotation-dirven注解驱动
评论
0 条评论
下一页
为你推荐
查看更多
MVC
MVC
MVC
MVC
mvc
mvc
mvc
mvc
spring-mvc流程图
spring-mvc流程图
MVC
MVC
Spring技术
Spring技术
MVC模型
MVC模型
MVC
MVC
JSP——MVC
JSP——MVC