SpringMVC

最新推荐文章于 2024-08-10 16:43:15 发布

张施文

最新推荐文章于 2024-08-10 16:43:15 发布

阅读量1.2k

点赞数

分类专栏： SSM 文章标签：过滤器 mvc ajax

本文链接：https://blog.csdn.net/qq_41344974/article/details/105862718

版权

SSM 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

SpringMVC

MVC全名是Model View Controller 模型视图控制器，每个部分各司其职。
Model：数据模型，JavaBean的类，用来进行数据封装。
View：指JSP、HTML用来展示数据给用户
Controller：用来接收用户的请求，整个流程的控制器。用来进行数据校验等。

SpringMVC的概述

是一种基于Java实现的MVC设计模型的请求驱动类型的轻量级WEB框架。
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供
了构建 Web 应用程序的全功能 MVC 模块。
使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的
SpringMVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts2等。

入门程序

坐标

<!-- 版本锁定 -->
    <properties>
        <spring.version>5.0.2.RELEASE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

在web.xml配置文件中核心控制器DispatcherServlet

<!-- SpringMVC的核心控制器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servletclass>
        <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!-- 配置servlet启动时加载对象 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

编写springmvc.xml的配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
        <!-- 配置spring创建容器时要扫描的包 -->
        <context:component-scan base-package="com.itheima"></context:component-scan>
        <!-- 配置视图解析器 -->
        <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
        <!-- 配置spring开启注解mvc的支持
        <mvc:annotation-driven></mvc:annotation-driven>-->
    </beans>

写index.jsp和HelloController控制器类

    <body>
        <h3>入门案例</h3>
        <a href="${ pageContext.request.contextPath }/hello">入门案例</a>
    </body>

/**
 * 控制器
 * @author rt
 */
@Controller
public class HelloController {
    /**
     * 接收请求
     * @return
     */
    @RequestMapping(path="/hello")
    public String sayHello() {
        System.out.println("Hello SpringMVC!!");
        return "success";
    }
}

在WEB-INF目录下创建pages文件夹，编写success.jsp的成功页面

<body>
<h3>入门成功！！</h3>
</body>

执行流程
6. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，
就会加载springmvc.xml配置文件
7. 开启了注解扫描，那么HelloController对象就会被创建
8. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解
找到执行的具体方法
9. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件
10. Tomcat服务器渲染页面，做出响应

RequestMapping注解

RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系
RequestMapping注解可以作用在方法和类上
1. 作用在类上：第一级的访问目录
2. 作用在方法上：第二级的访问目录
3. 细节：路径可以不编写 / 表示应用的根目录开始
4. 细节：${ pageContext.request.contextPath }也可以省略不写，但是路径上不能写 /
RequestMapping的属性
1. path 指定请求路径的url
2. value value属性和path属性是一样的
3. method 指定该方法的请求方式
4. params 指定限制请求参数的条件，要求参数的类型和值
5. headers 发送的请求中必须包含的请求头

请求参数的绑定

请求参数的绑定说明
1. 绑定机制
  1. 表单提交的数据都是k=v格式的 username=haha&password=123
  2. SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
  3. 要求：提交表单的name和参数的名称是相同的
2. 支持的数据类型
  1. 基本数据类型和字符串类型
  2. 实体类型（JavaBean）
  3. 集合数据类型（List、map集合等）
基本数据类型和字符串类型
1. 提交表单的name和参数的名称是相同的
2. 区分大小写
实体类型（JavaBean）
1. 提交表单的name和JavaBean中的属性名称需要一致
2. 如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成：对象.属性例如：
  address.name
给集合属性数据封装
1. JSP页面编写方式：list[0].属性
请求参数中文乱码的解决
1. 在web.xml中配置Spring提供的过滤器类

 <!-- 配置过滤器，解决中文乱码的问题 -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filterclass>
        <!-- 指定字符集 -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

自定义类型转换器
1. 表单提交的任何数据类型全部都是字符串类型，但是后台定义Integer类型，数据也可以封装上，说明
  Spring框架内部会默认进行数据类型转换。
2. 如果想自定义数据类型转换，可以实现Converter的接口
  1. 自定义类型转换器

package cn.itcast.utils;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.core.convert.converter.Converter;
**
 * 把字符串转换成日期的转换器
 * @author rt
 */
public class StringToDateConverter implements Converter<String, Date>{
    /**
     * 进行类型转换的方法
     */
    public Date convert(String source) {
// 判断
        if(source == null) {
            throw new RuntimeException("参数不能为空");
        }
       
        try {
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
// 解析字符串
            Date date = df.parse(source);
            return date;
        } catch (Exception e) {
            throw new RuntimeException("类型转换错误");
        }
    }
}

	2. 注册自定义类型转换器，在springmvc.xml配置文件中编写配置

  <!-- 注册自定义类型转换器 -->
    <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="cn.itcast.utils.StringToDateConverter"/>
            </set>
        </property>
    </bean>
    <!-- 开启Spring对MVC注解的支持 -->
    <mvc:annotation-driven conversion-service="conversionService"/>

在控制器中使用原生的ServletAPI对象
1. 只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象

常用的注解

RequestParam注解
1. 作用：把请求中的指定名称的参数传递给控制器中的形参赋值
2. 属性
  1. value：请求参数中的名称
  2. required：请求参数中是否必须提供此参数，默认值是true，必须提供
3. 代码如下

    /**
     * 接收请求
     * @return
     */
    @RequestMapping(path="/hello")
    public String sayHello(@RequestParam(value="username",required=false)String name) {
        System.out.println("aaaa");
        System.out.println(name);
        return "success";
    }

RequestBody注解
1. 作用：用于获取请求体的内容（注意：get方法不可以）
2. 属性
  1. required：是否必须有请求体，默认值是true
3. 代码如下

/**
     * 接收请求
     * @return
     */
    @RequestMapping(path="/hello")
    public String sayHello(@RequestBody String body) {
        System.out.println("aaaa");
        System.out.println(body);
        return "success";
    }

PathVariable注解
1. 作用：拥有绑定url中的占位符的。例如：url中有/delete/{id}，{id}就是占位符
2. 属性
  1. value：指定url中的占位符名称
3. Restful风格的URL
  1. 请求路径一样，可以根据不同的请求方式去执行后台的不同方法
  2. restful风格的URL优点
    1. 结构清晰
    2. 符合标准
    3. 易于理解
    4. 扩展方便
4. 代码如下

<a href="user/hello/1">入门案例</a>
/**
 * 接收请求
 * @return
 */
@RequestMapping(path="/hello/{id}")
public String sayHello(@PathVariable(value="id") String id) {
        System.out.println(id);
        return "success";
        }

RequestHeader注解
1. 作用：获取指定请求头的值
2. 属性
  1. value：请求头的名称
3. 代码如下

@RequestMapping(path="/hello")
public String sayHello(@RequestHeader(value="Accept") String header) {
        System.out.println(header);
        return "success";
        }

CookieValue注解
1. 作用：用于获取指定cookie的名称的值
2. 属性
  1. value：cookie的名称
3. 代码

@RequestMapping(path="/hello")
public String sayHello(@CookieValue(value="JSESSIONID") String cookieValue) {
        System.out.println(cookieValue);
        return "success";
        }

ModelAttribute注解
1. 作用
  1. 出现在方法上：表示当前方法会在控制器方法执行前线执行。
  2. 出现在参数上：获取指定的数据给参数赋值。
2. 应用场景
  1. 当提交表单数据不是完整的实体数据时，保证没有提交的字段使用数据库原来的数据。
3. 具体的代码
  1. 修饰的方法有返回值

/**
 * 作用在方法，先执行
 * @param name
 * @return
 */
@ModelAttribute
public User showUser(String name) {
        System.out.println("showUser执行了...");
// 模拟从数据库中查询对象
        User user = new User();
        user.setName("哈哈");
        user.setPassword("123");
        user.setMoney(100d);
        return user;
        }
/**
 * 修改用户的方法
 * @param cookieValue
 * @return
 */
@RequestMapping(path="/updateUser")
public String updateUser(User user) {
        System.out.println(user);
        return "success";
        }

修饰的方法没有返回值

/**
 * 作用在方法，先执行
 * @param name
 * @return
 */
@ModelAttribute
public void showUser(String name,Map<String, User> map) {
        System.out.println("showUser执行了...");
// 模拟从数据库中查询对象
        User user = new User();
        user.setName("哈哈");
        user.setPassword("123");
        user.setMoney(100d);
        map.put("abc", user);
        }
/**
 * 修改用户的方法
 * @param cookieValue
 * @return
 */
@RequestMapping(path="/updateUser")
public String updateUser(@ModelAttribute(value="abc") User user) {
        System.out.println(user);
        return "success";
        }

SessionAttributes注解
1. 作用：用于多次执行控制器方法间的参数共享
2. 属性
  1. value：指定存入属性的名称
3. 代码如下

@Controller
@RequestMapping(path="/user")
@SessionAttributes(value= {"username","password","age"},types=
        {String.class,Integer.class}) // 把数据存入到session域对象中
public class HelloController {
    /**
     * 向session中存入值
     * @return
     */
    @RequestMapping(path="/save")
    public String save(Model model) {
        System.out.println("向session域中保存数据");
        model.addAttribute("username", "root");
        model.addAttribute("password", "123");
        model.addAttribute("age", 20);
        return "success";
    }
    /**
     * 从session中获取值
     * @return
     */
    @RequestMapping(path="/find")
    public String find(ModelMap modelMap) {
        String username = (String) modelMap.get("username");
        String password = (String) modelMap.get("password");
        Integer age = (Integer) modelMap.get("age");
        System.out.println(username + " : "+password +" : "+age);
        return "success";
    }
    /**
     * 清除值
     * @return
     */
    @RequestMapping(path="/delete")
    public String delete(SessionStatus status) {
        status.setComplete();
        return "success";
    }
}

响应数据和结果视图

1. 返回值分类

返回字符串

@RequestMapping(value="/hello")
public String sayHello() {
        System.out.println("Hello SpringMVC!!");
// 跳转到XX页面
        return "success";
        }

@Controller
@RequestMapping("/user")
public class UserController {
    /**
     * 请求参数的绑定
     */
    @RequestMapping(value="/initUpdate")
    public String initUpdate(Model model) {
// 模拟从数据库中查询的数据
        User user = new User();
        user.setUsername("张三");
        user.setPassword("123");
        user.setMoney(100d);
        user.setBirthday(new Date());
        model.addAttribute("user", user);
        return "update";
    }
}
<h3>修改用户</h3>
        ${ requestScope }
<form action="user/update" method="post">
        姓名：<input type="text" name="username" value="${ user.username }"><br>
密码：<input type="text" name="password" value="${ user.password }"><br>
金额：<input type="text" name="money" value="${ user.money }"><br>
<input type="submit" value="提交">
</form>

返回值是void
1. 如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到。
  1. 默认会跳转到@RequestMapping(value="/initUpdate") initUpdate的页面。
2. 可以使用请求转发或者重定向跳转到指定的页面

@RequestMapping(value="/initAdd")
public void initAdd(HttpServletRequest request,HttpServletResponse response) throws
        Exception {
        System.out.println("请求转发或者重定向");
// 请求转发
// request.getRequestDispatcher("/WEB-INF/pages/add.jsp").forward(request,
        response);
// 重定向
// response.sendRedirect(request.getContextPath()+"/add2.jsp");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
// 直接响应数据
        response.getWriter().print("你好");
        return;
        }

返回值是ModelAndView对象
1. ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图
2. 具体的代码如下

/**
     * 返回ModelAndView
     * @return
     */
    @RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView(){
        // 创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        System.out.println("testModelAndView方法执行了...");
        // 模拟从数据库中查询出User对象
        User user = new User();
        user.setUsername("小凤");
        user.setPassword("456");
        user.setAge(30);

        // 把user对象存储到mv对象中，也会把user对象存入到request对象
        mv.addObject("user",user);

        // 跳转到哪个页面
        mv.setViewName("success");

        return mv;
    }

2. SpringMVC框架提供的转发和重定向

forward请求转发
1. controller方法返回String类型，想进行请求转发也可以编写成
2. redirect重定向
  1. controller方法返回String类型，想进行重定向也可以编写成

/**
* 使用forward关键字进行请求转发
* "forward:转发的JSP路径"，不走视图解析器了，所以需要编写完整的路径
* @return
* @throws Exception
*/
@RequestMapping("/delete")
public String delete() throws Exception {
System.out.println("delete方法执行了...");
// return "forward:/WEB-INF/pages/success.jsp";
return "forward:/user/findAll";
}

/**
* 重定向
* @return
* @throws Exception
*/
@RequestMapping("/count")
public String count() throws Exception {
System.out.println("count方法执行了...");
return "redirect:/add.jsp";
// return "redirect:/user/findAll";
}

3. ResponseBody响应json数据

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源（img、css、js）也会被拦截到，从而
不能被使用。解决问题就是需要配置静态资源不进行拦截，在springmvc.xml配置文件添加如下配置
1. mvc:resources标签配置不过滤
  1. location元素表示webapp目录下的包下的所有文件
  2. mapping元素表示以/static开头的所有请求路径，如/static/a 或者/static/a/b
  3. json字符串和JavaBean对象互相转换的过程中，需要使用jackson的jar包

<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
<mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
<mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->

jar包

 <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
    </dependency>
    <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-annotations</artifactId>
        <version>2.9.0</version>
    </dependency>

 /**
     * 模拟异步请求响应
     */
    @RequestMapping("/testAjax")
    public @ResponseBody User testAjax(@RequestBody User user){
        System.out.println("testAjax方法执行了...");
        // 客户端发送ajax的请求，传的是json字符串，后端把json字符串封装到user对象中
        System.out.println(user);
        // 做响应，模拟查询数据库
        user.setUsername("haha");
        user.setAge(40);
        // 做响应
        return user;
    }

}

 <script>
        // 页面加载，绑定单击事件
        $(function(){
            $("#btn").click(function(){
                // alert("hello btn");
                // 发送ajax请求
                $.ajax({
                    // 编写json格式，设置属性和值
                    url:"user/testAjax",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"username":"hehe","password":"123","age":30}',
                    dataType:"json",
                    type:"post",
                    success:function(data){
                        // data服务器端响应的json的数据，进行解析
                        alert(data);
                        alert(data.username);
                        alert(data.password);
                        alert(data.age);
                    }
                });

            });
        });

    </script>

 <button id="btn">发送ajax的请求</button>

实现文件上传

原始

导入文件上传的jar包

 <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency>

编写文件上传的JSP页面

<h3>文件上传</h3>
<form action="user/fileupload1" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload"/><br/>
    <input type="submit" value="上传文件"/>
</form>

编写文件上传的Controller控制器

/**
     * 文件上传
     * @return
     */
    @RequestMapping("/fileupload1")
    public String fileuoload1(HttpServletRequest request) throws Exception {
        System.out.println("文件上传...");

        // 使用fileupload组件完成文件上传
        // 上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断，该路径是否存在
        File file = new File(path);
        if(!file.exists()){
            // 创建该文件夹
            file.mkdirs();
        }

        // 解析request对象，获取上传文件项
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        // 解析request
        List<FileItem> items = upload.parseRequest(request);
        // 遍历
        for(FileItem item:items){
            // 进行判断，当前item对象是否是上传文件项
            if(item.isFormField()){
                // 说明普通表单向
            }else{
                // 说明上传文件项
                // 获取上传文件的名称
                String filename = item.getName();
                // 把文件的名称设置唯一值，uuid
                String uuid = UUID.randomUUID().toString().replace("-", "");
                filename = uuid+"_"+filename;
                // 完成文件上传
                item.write(new File(path,filename));
                // 删除临时文件
                item.delete();
            }
        }

        return "success";
    }

}

springMVC方式

 /**
     * SpringMVC文件上传
     * @return
     */
    @RequestMapping("/fileupload2")
    public String fileuoload2(HttpServletRequest request, MultipartFile upload) throws Exception {
        System.out.println("springmvc文件上传...");

        // 使用fileupload组件完成文件上传
        // 上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断，该路径是否存在
        File file = new File(path);
        if(!file.exists()){
            // 创建该文件夹
            file.mkdirs();
        }

        // 说明上传文件项
        // 获取上传文件的名称
        String filename = upload.getOriginalFilename();
        // 把文件的名称设置唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        filename = uuid+"_"+filename;
        // 完成文件上传
        upload.transferTo(new File(path,filename));

        return "success";
    }

跨服务器上传

    <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-core</artifactId>
        <version>1.18.1</version>
    </dependency>
    <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-client</artifactId>
        <version>1.18.1</version>
    </dependency>

/**
     * 跨服务器文件上传
     * @return
     */
    @RequestMapping("/fileupload3")
    public String fileuoload3(MultipartFile upload) throws Exception {
        System.out.println("跨服务器文件上传...");

        // 定义上传文件服务器路径
        String path = "http://localhost:9090/uploads/";

        // 说明上传文件项
        // 获取上传文件的名称
        String filename = upload.getOriginalFilename();
        // 把文件的名称设置唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        filename = uuid+"_"+filename;

        // 创建客户端的对象
        Client client = Client.create();

        // 和图片服务器进行连接
        WebResource webResource = client.resource(path + filename);

        // 上传文件
        webResource.put(upload.getBytes());

        return "success";
    }

SpringMVC的异常处理

自定义异常类

@Controller
@RequestMapping("/user")
public class UserController {


    @RequestMapping("/testException")
    public String testException() throws SysException{
        System.out.println("testException执行了...");

        try {
            // 模拟异常
            int a = 10/0;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 抛出自定义异常信息
            throw new SysException("查询所有用户出现错误了...");
        }



        return "success";
    }

}

/**
 * 自定义异常类
 */
public class SysException extends Exception{

    // 存储提示信息的
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public SysException(String message) {
        this.message = message;
    }

}

自定义异常处理器

/**
 * 异常处理器
 */
public class SysExceptionResolver implements HandlerExceptionResolver{

    /**
     * 处理异常业务逻辑
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @return
     */
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 获取到异常对象
        SysException e = null;
        if(ex instanceof SysException){
            e = (SysException)ex;
        }else{
            e = new SysException("系统正在维护....");
        }
        // 创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",e.getMessage());
        mv.setViewName("error");
        return mv;
    }

}

配置异常处理器

<!-- 配置异常处理器 -->
<bean id="sysExceptionResolver" class="cn.itcast.exception.SysExceptionResolver"/>

拦截器（关卡）

SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链
中的拦截器会按着定义的顺序执行。
拦截器和过滤器的功能比较类似，有区别
1. 过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。
2. 拦截器是SpringMVC框架独有的。
3. 过滤器配置了/*，可以拦截任何资源。
4. 拦截器只会对控制器中的方法进行拦截。
拦截器也是AOP思想的一种实现方式
想要自定义拦截器，需要实现HandlerInterceptor接口。

<!--配置拦截器-->
    <mvc:interceptors>
        <!--配置拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体的方法-->
            <mvc:mapping path="/user/*"/>
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""/>
            -->
            <!--配置拦截器对象-->
            <bean class="cn.itcast.controller.cn.itcast.interceptor.MyInterceptor1" />
        </mvc:interceptor>

        <!--配置第二个拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体的方法-->
            <mvc:mapping path="/**"/>
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""/>
            -->
            <!--配置拦截器对象-->
            <bean class="cn.itcast.controller.cn.itcast.interceptor.MyInterceptor2" />
        </mvc:interceptor>
    </mvc:interceptors>

/**
 * 自定义拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor{

    /**
     * 预处理，controller方法执行前
     * return true 放行，执行下一个拦截器，如果没有，执行controller中的方法
     * return false不放行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor1执行了...前1111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /**
     * 后处理方法，controller方法执行后，success.jsp执行之前
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor1执行了...后1111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     * success.jsp页面执行后，该方法会执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor1执行了...最后1111");
    }

}

张施文

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC

SpringMVCMVC全名是Model View Controller 模型视图控制器，每个部分各司其职。Model：数据模型，JavaBean的类，用来进行数据封装。View：指JSP、HTML用来展示数据给用户Controller：用来接收用户的请求，整个流程的控制器。用来进行数据校验等。SpringMVC的概述是一种基于Java实现的MVC设计模型的请求驱动类型的轻量级W...
复制链接

扫一扫

专栏目录