SpringMVC框架笔记及代码

最新推荐文章于 2023-07-24 14:45:23 发布

程序员小庞

最新推荐文章于 2023-07-24 14:45:23 发布

阅读量275

点赞数 1

分类专栏： # SpringMVC框架文章标签： mvc spring java

本文链接：https://blog.csdn.net/qq_45429856/article/details/120730625

版权

SpringMVC框架专栏收录该内容

6 篇文章 0 订阅

订阅专栏

SpringMVC框架

1、SpringMVC的基本用法

1.什么是SpringMVC

SpringMVC是一套标准的MVC框架，充当mvc中 c的一部分，是Spring框架的一个分支

Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，也简化了我们日常的Web开发

2.为什么要使用SpringMVC

配置简单使用更灵活、效率比较高。

能非常简单的设计出干净的Web层；

进行更简洁的Web层的开发;

天生与Spring框架集成（如IoC容器、AOP等）；

提供强大的约定大于配置的契约式编程支持；

支持灵活的URL到页面控制器的映射；

更加简单的异常处理；

对静态资源的支持；

支持Restful风格。

3.如何搭建环境

Controller类：同Servlet类一样，用于处理一个业务功能或模块，提供一系列的访问方法

a 导入spring的相关jar包

b 在src目录下创建SpringMVC容器(和Spring容器一样)——用于扫描注解(创建对象并注入对象)

c 在SpringMVC容器中配置 试图解析器InternalResourceViewResolver——用于配置跳转路径的前缀prefix和后缀suffix

d 在web.xml中

	处理针对post方式请求的中文乱码(配置一个编码的过滤器CharacterEncodingFilter)

	配置SpringMVC的 前端控制器DispatcherServlet(其实就是一个servlet)——加载SpringMVC容器和访问路径后缀

4.SpringMVC的基本使用

访问、跳转、传递参数、存值

配置访问：

	@Controller——创建控制层Controller对象

	@Scope("singleton/prototype")

	@RequestMapping(value="访问路径")——类和方法的方法路径

	在容器中扫描注解

配置跳转：默认为请求转发

	方法中返回跳转路径

	在容器中配置 视图解析器

传递参数：手动接收、自动接收

	注意：如果参数是对象类型，则页面直接使用对象中的属性名称

地址栏重写：通过url地址传递参数

存值：request/session/application同servlet一样

5.SpringMVC中的模型和视图对象

ModelAndView:模型视图对象——存值(等价于request.setAttribute("属性名",Object value))、存放视图路径

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"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 扫描注解 -->
	<context:component-scan base-package="com.zuxia.controller" />
	<!-- 创建SpringMVC视图解析器对象，bean:创建类实例对象-->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- property：为对象中的属性赋值(调用set方法) -->
		<property name="prefix" value="/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
</beans>

Controller

package com.zuxia.controller;

import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import com.zuxia.entity.UserInfo;

@Controller
@RequestMapping(value="/demo02C")
public class Demo02Controller {
	
	//预处理日期时间
	@InitBinder
	public void dateHandler(WebDataBinder binder){
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		binder.registerCustomEditor(Date.class, new CustomDateEditor(sdf, true));
	}
	
	@RequestMapping(value="/add")
	public String add(){
		System.out.println("add..........");
		return "index";
	}
	
	//接收参数：手动接收
	@RequestMapping(value="/t1")
	public String insert(HttpServletRequest req,HttpServletResponse res){
		String id = req.getParameter("id");
		String name = req.getParameter("name");
		System.out.println(id+"\t"+name);
		return "index";
	}
	//接收参数：手动接收
	@RequestMapping(value="/t2")
	public String insert1(HttpServletRequest req,HttpServletResponse res){
		String username = req.getParameter("username");
		String pwd = req.getParameter("password");
		String sex = req.getParameter("sex");
		int age = Integer.parseInt(req.getParameter("age"));
		
		System.out.println(username+"\t"+pwd+"\t"+sex+"\t"+age);
		return "index";
	}
	//接收参数：自动接收(方法参数名和请求参数名保持一致)
	@RequestMapping(value="/t3")
	public String insert2(String username,@RequestParam(name="password",defaultValue="111111")String pwd,String sex,int age){
		System.out.println(username+"\t"+pwd+"\t"+sex+"\t"+age);
		return "index";
	}
	//接收参数：自动接收(将请求参数自动封装到方法的对象参数中)
	@RequestMapping(value="/t4")
	public String insert3(HttpServletRequest req,UserInfo user){
		System.out.println(user);
		//存值
		req.setAttribute("ui", user);
		req.getSession().setAttribute("user", user);
		req.getServletContext().setAttribute("uinfo", user);
		return "redirect:/admin/index.jsp";
	}
	
	//地址栏传参
	@RequestMapping(value="/t5/{uid}")
	public String insert4(@PathVariable(name="uid")int id){
		System.out.println(id);
		//存值
		return "index";
	}
	
	@RequestMapping(value="/test")
	public ModelAndView test(@RequestParam(name="id",defaultValue="0")int id){
		System.out.println("test。。。。。。。。。。。");
		//处理过程
		//创建模型视图对象
		ModelAndView mav=new ModelAndView("admin/index");
		//设置视图名称
		if(id!=0){
			mav.setViewName("register");
		}
		//存入数据
		mav.addObject("msg","hello");
		return mav;
	}
	
}

2、SpringMVC中的Restful

1.什么是RestFul风格

RESTful架构，是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便。

2.RestFul的url特点

a) 非RestFul风格的URL：http://地址:端口/服务名称/xx.do?method=xx    http://地址:端口/服务名称/xx/xx.do

b) RestFul风格的URL：http://地址:端口/服务名称/xx/xx/xx

3.如何使用RestFul

四个动词：

	get(获取资源——查询)、post(新建资源——添加)、put(更新资源——修改)、delete(删除资源——删除)

web.xml中：

	修改前端控制器的访问路径(不要后缀，使用'/')

	配置隐藏方法的过滤器(过滤路径没有后缀，使用'/*')

	指定加载的静态资源(servlet-mapping)，主要针对js文件和css文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
	<!-- 配置中文乱码处理的过滤器 -->
	<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>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>*.do</url-pattern>
	</filter-mapping>
	<!-- 配置springMVC前端控制器 -->
	<servlet>
		<servlet-name>DispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 加载springmvc容器 -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-mvc.xml</param-value>
		</init-param>
	</servlet>
	<servlet-mapping>
		<servlet-name>DispatcherServlet</servlet-name>
		<url-pattern>*.do</url-pattern><!-- 配置controller的访问后缀 -->
	</servlet-mapping>
</web-app>

SpringMVC容器中处理静态资源

 <mvc:annotation-driven/>
    
    <!--注意：restful 处理静态资源(3.0.4以后的版本支持)-->
    <mvc:resources mapping="/css/**" location="/css/" />
    <!--可选：默认兼容tomcat，加上后可兼容tomcat和resin-->
    <mvc:default-servlet-handler />

3、SpringMVC中的文件上传下载

1.单文件上传

导入文件上传组件commons-fileupload、commons-io

配置上传对象及属性CommonsMultipartResolver

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
   <property name="maxUploadSize" value="50000000" />
   <property name="defaultEncoding" value="UTF-8" />
</bean> 

表单设置enctype=” multipart/form-data”属性

使用MultipartFile对象，表示表单提交的文件对象

调用transferTo()方法上传

2.多文件上传

将请求对象转换为MultipartRequest

调用getFileNames()得到所有上传的文件域名称

遍历并调用getFile()根据名称得到MultipartFile对象

3.文件下载
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 http://www.springframework.org/schema/context/spring-context.xsd 
	http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- 扫描注解 -->
	<context:component-scan base-package="com.zuxia.controller" />
	
	<!-- 创建SpringMVC视图解析器对象，bean:创建类实例对象-->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- property：为对象中的属性赋值(调用set方法) -->
		<property name="prefix" value="/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
	
	<!-- 文件上传 -->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="maxUploadSize" value="500000000" />
		<property name="defaultEncoding" value="UTF-8" />
	</bean>
	
	<!-- 处理静态资源 -->
	<mvc:annotation-driven />
	<mvc:resources location="/css/" mapping="/css/**" />
	<mvc:default-servlet-handler/>
</beans>

Controller类

package com.zuxia.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Iterator;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartRequest;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping(value="/fileC")
public class FileController {
	//单文件上传
	@PostMapping(value="/fileUpload")
	public ModelAndView fileUpload(@RequestParam(name="f1")MultipartFile mfile,HttpServletRequest req){
		ModelAndView mav=new ModelAndView("login");
		//确定上传的文件位置
		File f=new File(req.getServletContext().getRealPath("/")+"files/"+mfile.getOriginalFilename());
		try {
			//实现文件上传
			mfile.transferTo(f);
		} catch (IllegalStateException | IOException e) {
			e.printStackTrace();
		}
		return mav;
	}
	
	//多文件上传
	@PostMapping(value="/fileUploadMore")
	public ModelAndView fileUploadMore(HttpServletRequest req){
		ModelAndView mav=new ModelAndView("show");
		//将req请求对象转换为多文件请求对象
		MultipartRequest mreq=(MultipartRequest)req;
		Iterator<String> it = mreq.getFileNames();
		while(it.hasNext()){
			MultipartFile mfile = mreq.getFile(it.next());
			File f=new File(req.getServletContext().getRealPath("/")+"files/"+mfile.getOriginalFilename());
			try {
				//实现文件上传
				mfile.transferTo(f);
			} catch (IllegalStateException | IOException e) {
				e.printStackTrace();
			}
		}
		
		//得到所有上传的文件
		File f=new File(req.getServletContext().getRealPath("/")+"files/");
		mav.addObject("fs", f.listFiles());
		return mav;
	}
	
	//下载文件
	@GetMapping(value="downFile")
	public void downFile(String fname,HttpServletRequest req,HttpServletResponse resp){
		try {
			//处理get请求中文乱码
			fname=new String(fname.getBytes("ISO-8859-1"), "UTF-8");
			//设置下载响应的头部信息
			resp.setHeader("Content-Disposition", "attachment;filename="+URLEncoder.encode(fname, "UTF-8"));
			//输入输出流
			InputStream is=new FileInputStream(new File(req.getServletContext().getRealPath("/")+"files/"+fname));
			OutputStream os=resp.getOutputStream();
			byte[] bt=new byte[1024];
			int size=0;
			while((size = is.read(bt))!=-1){
				os.write(bt, 0, size);
				bt=new byte[1024];
			}
			os.close();
			is.close();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

上传的前端页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<form action="${pageContext.request.contextPath }/fileC/fileUpload" method="post" enctype="multipart/form-data">
		文件：<input type="file" name="f1"/>
		<input type="submit" value="上传"/>
	</form><br />
	<form action="${pageContext.request.contextPath }/fileC/fileUploadMore" method="post" enctype="multipart/form-data">
		文件1：<input type="file" name="f1"/>
		文件2：<input type="file" name="f2"/>
		<input type="submit" value="上传"/>
	</form>
</body>
</html>

下载的前端页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:forEach items="${fs }" var="f">
		<a href="${pageContext.request.contextPath }/fileC/downFile?fname=${f.name}">${f.name }</a><br /><br />
	</c:forEach>
</body>
</html>

4、SpringMVC的异步与拦截器

1.异步请求与响应

请求：ajax

响应：

	方式一：response.getWriter().print(数据);
	
	方式二：返回字符串作为响应内容,响应文本数据

		使用注解@ResponseBody修饰方法

		方法中return 字符串

		容器中处理响应中文乱码：produces = {"text/html;charset=UTF-8"}，默认的是ISO-8859-1

package com.zuxia.controller;

import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import javax.servlet.http.HttpServletResponse;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.zuxia.entity.UserInfo;
import com.zuxia.util.StateCode;

@Controller
@Scope("singleton")
@RequestMapping(value="/ajaxC")
public class AjaxController {
	
	@GetMapping(value="/t1")
	public void test1(String uname,HttpServletResponse resp) throws IOException{
		resp.setCharacterEncoding("GBK");
		if(uname.matches("[a-z0-9]{6,}")){
			resp.getWriter().print("用户名["+uname+"]可用");
		}else{
			resp.getWriter().print("用户名["+uname+"]格式不正确");
		}
	}
	
	@GetMapping(value="/t2",produces="text/html;charset=UTF-8")
	@ResponseBody
	public String test2(String uname){
		if(uname.matches("[a-z0-9]{6,}")){
			return "用户名["+uname+"]可用";
		}else{
			return "用户名["+uname+"]格式不正确";
		}
	}
	
	@GetMapping(value="/t3",produces="application/json;charset=UTF-8")
	@ResponseBody
	public UserInfo test3(){
		UserInfo user=new UserInfo(1, "张三", "女", 4545, new Date());
		
		return user;
	}
	
	@GetMapping(value="/t4",produces="application/json;charset=UTF-8")
	@ResponseBody
	public List<UserInfo> test4(){
		UserInfo user1=new UserInfo(1, "张三", "女", 4545, new Date());
		UserInfo user2=new UserInfo(2, "李四", "男", 4545, new Date());
		UserInfo user3=new UserInfo(3, "admin", "女", 6666, new Date());
		UserInfo user4=new UserInfo(4, "test", "女", 8885, new Date());
		
		return Arrays.asList(user1,user2,user3,user4);
	}
}

	方式三：返回对象/集合作为响应内容,响应json格式数据

		在messageConverters中处理响应格式为json格式，则在springmvc配置文件中配置

   <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
      <property name="messageConverters">
        <list>
          <!-- 配置json格式转换器 -->
          <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter" />
        </list>
      </property>
    </bean>
    
    <!-- 针对中文出现乱码，处理如下：produces = {"application/json;charset=UTF-8"} -->

Controller类中
@GetMapping(value="/t4",produces="application/json;charset=UTF-8")
	@ResponseBody
	public List<UserInfo> test4(){
		UserInfo user1=new UserInfo(1, "张三", "女", 4545, new Date());
		UserInfo user2=new UserInfo(2, "李四", "男", 4545, new Date());
		UserInfo user3=new UserInfo(3, "admin", "女", 6666, new Date());
		UserInfo user4=new UserInfo(4, "test", "女", 8885, new Date());
		
		return Arrays.asList(user1,user2,user3,user4);
	}
	
	@GetMapping(value="/t5",produces="application/json;charset=UTF-8")
	@ResponseBody
	public StateCode<UserInfo> test5(){
		UserInfo user1=new UserInfo(1, "张三", "女", 4545, new Date());
		UserInfo user2=new UserInfo(2, "李四", "男", 4545, new Date());
		UserInfo user3=new UserInfo(3, "admin", "女", 6666, new Date());
		UserInfo user4=new UserInfo(4, "test", "女", 8885, new Date());
		
		StateCode<UserInfo> scode=new StateCode<>(0, "success", Arrays.asList(user1,user2,user3,user4));
		
		return scode;
	}

封装json格式

package com.zuxia.util;

import java.util.List;

public class StateCode<T> {
	private int code;
	private String msg;
	private List<T> data;
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
	public List<T> getData() {
		return data;
	}
	public void setData(List<T> data) {
		this.data = data;
	}
	public StateCode(int code, String msg, List<T> data) {
		super();
		this.code = code;
		this.msg = msg;
		this.data = data;
	}
	public StateCode() {
		super();
	}
	
}

2.SpringMVC拦截器

1）什么是拦截器

Spring MVC中的拦截器（Interceptor）类似于Servlet中的过滤器（Filter），主要用于拦截用户请求并做相应的处理。例如通过拦截器可以进行权限验证、记录请求信息的日志、判断用户是否登录等。



2）如何使用拦截器

自定义拦截器类继承自HandlerInterceptor(推荐) 或 继承实现了HandlerInterceptor接口的类

重写以下方法：

	preHandle()在访问目标方法 之前 执行,返回true继续执行，返回false阻止执行

	postHandle()访问目标方法体之后，但在return之前执行

	afterCompletion()目标方法返回之后执行

//自定义拦截器类继承自HandlerInterceptor(推荐) 或 继承实现了HandlerInterceptor接口的类
package com.zuxia.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class MyInterceptor implements HandlerInterceptor {
	//执行目标方法前被调用，返回boolean表示是否继续
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
		System.out.println("preHandle.........");
		return true;
	}
	
	//执行目标方法体且在return之前被调用
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {
		System.out.println("postHandle..........");
		System.out.println("方法的目标返回试图："+modelAndView.getViewName());
//		modelAndView.setViewName("show");
	}
	
	//执行目标方法后被调用
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)throws Exception {
		System.out.println("afterCompletion..............");
	}
}

容器中配置拦截器：
 <mvc:interceptors>
    <mvc:interceptor>
    	<mvc:mapping path="拦截路径"/>
    	……
    	<bean class="自定义拦截器类" />
    </mvc:interceptor>
    ……
</mvc:interceptors>

 <!-- 拦截器 -->
	<mvc:interceptors>
		 <mvc:interceptor>
			 <!--拦截的路径-->
			<mvc:mapping path="/**"/>
			<!--放行的路径-->
			<mvc:exclude-mapping path="/loginC/login"/>
			<bean class="com.zuxia.interceptor.LoginInterceptor"/>
		</mvc:interceptor>
	</mvc:interceptors>

3）拦截器与过滤器有什么区别

	a.实现原理不同:过滤器是基于函数回调的;而拦截器是基于Java的反射机制实现的。

	b.使用范围不同:过滤器实现的是 javax.servlet.Filter 接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter的使用要依赖于Tomcat等容器，导致它只能在web程序中使用;而拦截器(Interceptor) 是一个Spring组件，并由Spring容器管理，并不依赖Tomcat等容器，是可以单独使用的。

	c.拦截的请求范围不同:过滤器几乎可以对所有进入容器的请求起作用;而拦截器只会对Controller中请求或访问static目录下的资源请求起作用。

3.异常处理

1)局部异常

	定义方法并使用注解@ExceptionHandler， 当程序出现异常时执行此方法。

//Controller类中
//局部处理
	@ExceptionHandler
	public ModelAndView handerException(Exception ex){
		System.out.println("局部异常："+ex.getMessage());
		ModelAndView mav=new ModelAndView("error");
		mav.addObject("exception", ex);
		return mav;
	}

2）全局异常

	容器中处理全局异常
	 <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
  <property name="exceptionMappings">
    <props>
      <prop key="异常类型">视图名称</prop>
      ……
    </props>
  </property>
</bean>

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

	<!-- 扫描注解 -->
	<context:component-scan base-package="com.zuxia.controller" />
	
	<!-- 创建SpringMVC视图解析器对象，bean:创建类实例对象-->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- property：为对象中的属性赋值(调用set方法) -->
		<property name="prefix" value="/" />
		<property name="suffix" value=".jsp" />
	</bean>
	<!-- 全局处理 -->
	<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
		<property name="exceptionMappings">
			<props>
				<prop key="java.lang.NullPointerException">error</prop>
			</props>
		</property>
	</bean>
</beans>

程序员小庞

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC框架笔记及代码

SpringMVC框架1、SpringMVC的基本用法1.什么是SpringMVCSpringMVC是一套标准的MVC框架，充当mvc中 c的一部分，是Spring框架的一个分支Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，也简化了我们日常的Web开发2.为什么要使用SpringMVC配置简单使用更灵活、效率比较高。能非常简单的设计出干净的Web层；进行更简洁的Web
复制链接

扫一扫

专栏目录