全面学习SpringMVC框架入门与提高(含详细代码)

最新推荐文章于 2024-08-18 21:29:33 发布

汐汐同学呀

最新推荐文章于 2024-08-18 21:29:33 发布

阅读量239

点赞数

分类专栏： SpringMVC框架 SpringMVC框架的作用过滤器与拦截器文章标签： java mvc spring

本文链接：https://blog.csdn.net/yk997575119/article/details/104322415

版权

SpringMVC框架同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

SpringMVC框架的作用

1 篇文章 0 订阅

订阅专栏

过滤器与拦截器

1 篇文章 0 订阅

订阅专栏

这一篇文章我将和大家一起回顾整个SpringMVC框架技术，由于内容较多，内容共分为三大部分。如果有不对的地方欢迎大家指正。

1.SpringMVC框架的流程、配置…

2.转发与重定向、Session、注解详解

3.拦截器、乱码问题、异常处理

<1>.SpringMVC框架的流程、配置…

1. SpringMVC框架的作用

解决了V-C之间的问题，简化开发。

V表示View，即视图，通常表现为HTML或JSP页面，C表示Controller，即控制器，在此前的学习中，表示的是Servlet。

原有的Controller，即Servlet存在的问题：默认情况下，每个Servlet对应1个请求路径，在实际项目开发中，就可能存在请求路径的种类较多，进而Servlet的数量也会较多，存在的问题就比较明显：配置复杂、管理难度大、Servlet实例太多，内存开销大……

2. SpringMVC框架的核心组件

在SpringMVC框架中，核心组件有：

DispatcherServlet：接收所有请求的Servlet（不包括例如css、js等），并且根据请求路径分发到各控制器；
HandlerMapping：记录请求路径与控制器或处理请求的方法之间的映射关系；
Controller：具体处理请求，确定如何响应的组件；
ModelAndView：控制器的返回结果，其中，Model表示数据，View表示最终负责响应的视图组件的名称；
ViewResolver：根据视图组件名称得到具体的视图组件。

3. SpringMVC-HelloWorld

3.1. 设计目标

在浏览器输入http://localhost:8080/??/hello.do，在页面中显示“Hello, SpringMVC.”。

3.2. 创建项目

创建项目是一个固定的流程：创建出项目，生成web.xml，复制Spring的配置文件到项目中，添加Tomcat运行环境。

项目Group Id为cn.tedu.springmvc，Artifact Id为SPRINGMVC-01-HELLO。

3.3. 配置DispatcherServlet

由于DispatcherServlet终究是一个Servlet，所以，需要在web.xml中进行配置：

<servlet>
	<servlet-name>SpringMVC</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>

<servlet-mapping>
	<servlet-name>SpringMVC</servlet-name>
	<url-pattern>*.do</url-pattern>
</servlet-mapping>

以上配置中，映射的请求路径是*.do，表示“所有以.do作为后缀的请求都将由这个Servlet进行处理”！

关于DispatcherServlet的全名，可以在任何Java类中声明这个变量，由Eclipse完成导包，则在import语句中就有了它的全名，复制并粘贴即可。

由于整个框架是基于Spring的，所以，需要加载Spring的配置文件，在DispatcherServlet的父类FrameworkServlet中，有contextConfigLocation属性，用于加载上下文配置文件，也就是Spring的配置文件，所以，为它配置初始化参数：

<servlet>
	<servlet-name>SpringMVC</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring-mvc.xml</param-value>
	</init-param>
</servlet>

<servlet-mapping>
	<servlet-name>SpringMVC</servlet-name>
	<url-pattern>*.do</url-pattern>
</servlet-mapping>

接下来，可以执行测试：创建任意Java类，显式添加无参数构造方法，在构造方法中输出字符串，并且，保证该类是由Spring管理的（注解+扫描）。完成后，将项目部署到Tomcat，并发出任何.do请求，尽管在浏览器报告404错误，但是，在Eclipse控制台可以看到输出的字符串。

此时，Spring的配置文件会随着DispatcherServlet的初始化而加载，在SpringMVC工作流程中，更希望的是启动Tomcat时即加载，所以，可以为DispatcherServlet添加<load-on-startup>1</load-on-startup>，表示当Tomcat启动时就初始化这个Servlet，从而加载Spring的配置文件！

3.4. 处理请求

当DispatcherServlet接收到请求后，会去找HandlerMapping询问该请求路径映射的控制器，实际使用的HandlerMapping是SimpleUrlHandlerMapping类，可以在Spring的配置文件中进行路径与控制器的映射的配置，但是，仍存在配置可能较多的问题，所以，在实际开发时，并不使用这种做法！而是将路径与处理请求的方法在控制器类表现出来！

则，创建控制器类cn.tedu.spring.HelloController，关于控制器类，类名可以自由定义，需要保证的是：该类必须是由Spring框架所管理的！所以，需要为控制器类添加@Controller注解，并且保证它在组件扫描范围之内。

然后，在控制器类中添加处理请求的方法，关于方法的声明，暂定的标准是：

使用public权限；
使用String类型的返回值；
方法名称不限；
无参数；
使用@RequestMapping("路径")注解，来配置映射的请求路径。

所以：

@Controller
public class HelloController {
	
	@RequestMapping("hello.do")
	public String showHello() {
		// 测试输出
		System.out.println(
			"HelloController.showHello()");
		
		// 暂不考虑返回值
		return null;
	}

}

然后，在浏览器中输出访问地址，即可执行测试，此次，浏览器依然无法显示正常的页面，但是，在Eclipse控制台可以观察到处理请求的方法已经被执行！

3.5. 显示页面

首先，准备好最终显示的页面webapp/WEB-INF/hello.jsp，页面内部可以随意设计，文件名应该是hello.jsp，即名称部分需要与以上控制器的返回值保持一致！

当控制器已经返回时，DispatcherServlet会根据返回的视图名，向ViewResolver询问具体负责显示的视图组件，而ViewResolver是个接口，可用的实现类有几种，通常使用的是InternalResourceViewResolver，它的工作模式是将“前缀(prefix) + 视图名 + 后缀(suffix)”拼接出视图文件的路径，基于以上jsp文件的路径，所以，在Spring的配置文件中添加配置：

<!-- ViewResolver -->
<!-- 以webapp作为基准 -->
<!-- 根据 prefix + 视图名 + suffix 得到文件路径 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/" />
	<property name="suffix" value=".jsp" />
</bean>

完成后，即可在浏览器执行测试，正确的情况下，应该显示hello.jsp所设计的内容。

4. 新案例

4.1. 目标

暂定为：显示用户注册页面，地址为：http://localhost:8080/???/reg.do

4.2. 创建项目

创建项目的操作项：

生成web.xml；
添加Tomcat运行环境；
复制所需的依赖；
复制spring-mvc.xml；
复制web.xml中关于DispatcherServlet的配置。

4.3. 处理请求

先创建cn.tedu.spring.UserController，在类的声明之前添加@Controller，然后，添加处理请求的方法：

@RequestMapping("reg.do")
public String showReg() {
	return "reg";
}

4.4. 设计页面

在webapp/WEB-INF/下创建reg.jsp，页面内容可自行设计。

4.5. 课后练习

在reg.jsp页面中添加表单及相关元素，要求实现：用户可以在页面中输入用户名、密码、年龄、手机号码、电子邮箱，并添加“注册”按钮，点击时，暂不提交表单；
在已完成基础之上，添加“登录”功能，要求实现：通过http://localhost:8080/???/login.do可以显示登录页面（login.jsp），用户可以在页面中输入用户名、密码，并添加“登录”按钮；
添加主页，要求实现：通过http://localhost:8080/???/index.do可以显示主页（index.jsp），主页的内容不限。

<2>.转发与重定向、Session、注解详解

前课练习

在reg.jsp页面中添加表单及相关元素，要求实现：用户可以在页面中输入用户名、密码、年龄、手机号码、电子邮箱，并添加“注册”按钮，点击时，暂不提交表单；
在已完成基础之上，添加“登录”功能，要求实现：通过http://localhost:8080/???/login.do可以显示登录页面（login.jsp），用户可以在页面中输入用户名、密码，并添加“登录”按钮；
添加主页，要求实现：通过http://localhost:8080/???/index.do可以显示主页（index.jsp），主页的内容不限。

1. 获取用户提交的请求参数

1.1. 通过HttpServletRequest参数对象获取请求参数

在处理请求的方法声明时，添加HttpServletRequest类型的参数，然后，在方法内部，通过参数对象获取用户请求的请求参数即可：

@RequestMapping("handle_reg.do")
public String handleReg(HttpServletRequest request) {
	// 通过HttpServletRequest参数对象获取请求参数
	String username = request.getParameter("username");
	String password = request.getParameter("password");
	Integer age = Integer.valueOf(
			request.getParameter("age"));
	String phone = request.getParameter("phone");
	String email = request.getParameter("email");
	// 测试输出
	System.out.println("username=" + username);
	System.out.println("password=" + password);
	System.out.println("age=" + age);
	System.out.println("phone=" + phone);
	System.out.println("email=" + email);
	
	// 暂不关心后续的显示
	return null;
}

使用这种做法的优点：原生？

缺点：麻烦

1.2. 直接将请求参数声明为处理请求的方法的参数

可以将所需的用户提交的参数直接声明在方法的参数列表中：

@RequestMapping("handle_reg.do")
public String handleReg(
		String username, String password,
		Integer age, String phone, 
		String email) {
	// 测试输出
	System.out.println("username=" + username);
	System.out.println("password=" + password);
	System.out.println("age=" + age);
	System.out.println("phone=" + phone);
	System.out.println("email=" + email);
	
	// 暂不关心后续的显示
	return null;
}

注意：使用这种做法时，必须保证用户提交的参数名，与处理请求的方法的参数名称保持一致！

以控制器处理请求时添加了String username参数为例，如果用户在表单中没有填写用户名，则接收到的数据是""，即长度为0的字符串；如果用户根本就没有提交名为username的属性（例如表单中用户的name不是这个名称），则接收到的是null。

如果请求参数名称与方法中的参数名称无法保持一致，在方法中声明参数时，可以添加@RequestParam注解：

@RequestParam("uname") String username

注意：使用这种固然简单，但是，不适合处理提交的数据太多的应用场景，例如，比较复杂的表单中可能有10项或是20项甚至更多数据，如果采取当前做法，则需要在方法中添加10个或20个参数，很显然是不合适的！

1.3. 直接使用自定义类型接收请求参数

例如自定义User类，并在类中声明所有参数，然后，在处理请求时，使用User作为参数类型即可！

@RequestMapping("handle_reg.do")
public String handleReg(User user) {
	System.out.println(user);
	
	// 暂不关心后续的显示
	return null;
}

1.4. 小结

第1种方式，通过HttpServletRequest获取请求参数，是Java EE原生做法，使用比较麻烦，代码量较多，并且，当期望的类型不是String还需要自行处理类型转换；

第2种方式，直接将请求参数添加到处理请求的方法的参数列表中，并且不限数据类型，当请求参数与参数列表中的参数名称不匹配时，还可以添加@RequestParam注解来解决，但是，不适合处理参数数量较多的应用场景；

第3种方式，声明包含所有参数的数据类型，使用该数据类型作为处理请求的方法的参数即可，这种方式也很简便，当然，也存在不足，例如名称不匹配时无法接收参数，或者在某些场景中大材小用。

通常，并不推荐使用第1种方式，而第2种和第3种可以根据实际情况来选取使用，甚至组合使用！

2. 转发和重定向

2.1. 重定向

默认情况下，在处理请求的方法中，String类型的返回值表示转发或重定向！

返回的字符串使用"redirect:"作为前缀时，表示重定向，在冒号的右侧，应该是重定向的目标的绝对路径或相对路径。

@RequestMapping("handle_reg.do")
public String handleReg(User user) {
	System.out.println(user);
	
	// 假设注册成功，重定向登录
	return "redirect:login.do";
}

2.2. 通过HttpServletRequest转发

在处理请求的方法的参数列表中，添加HttpServletRequest类型的参数，当需要转发数据时，仅需要将数据封装到request中即可。

@RequestMapping("handle_reg.do")
public String handleReg(User user,
		HttpServletRequest request) {
	// 测试获取到的请求参数
	System.out.println(user);
	
	// 假设用户名root已经被占用，是不允许注册的
	if ("root".equals(user.getUsername())) {
		String msg = "您尝试注册的用户名已经被占用！";
		request.setAttribute("message", msg);
		return "error";
	}
	// 假设手机号13800138001已经被占用，是不允许注册的
	if ("13800138001".equals(user.getPhone())) {
		String msg = "您尝试注册的手机号码已经被占用！";
		request.setAttribute("message", msg);
		return "error";
	}
	
	// 假设注册成功，重定向登录
	return "redirect:login.do";
}

课堂练习：处理用户登录，仅当用户名为root时是正确的，其它用户名均不存在，且正确的密码是1234，如果登录信息有误，通过error.jsp进行提示，如果登录信息正确，则显示主页！

2.3. 使用ModelAndView作为返回值

首先，将处理请求的方法的返回值类型声明为ModelAndView，推荐使用的构造方法有：

ModelAndView()
ModelAndView(String viewName)
ModelAndView(String viewName, Map<String, ?> model)

在ModelAndView中，Model是Map类型的，表示需要转发的数据，而View指的是视图，当需要转发时，将数据封装到Model中，通过View确定视图组件名称，然后返回即可！

相比之下，ModelAndView的使用比较麻烦，所以，一般不推荐使用！

2.4. 使用ModelMap封装即将转发的数据

在处理请求的方法的参数列表中添加ModelMap参数，然后，当需要转发数据时，将参数封装到其中即可：

@RequestMapping("handle_login.do")
public String handleLogin(
	String username, String password,
	ModelMap modelMap) {
	// 声明可能提示的错误信息
	String msg;
	// 仅当用户名为root时是正确的
	if ("root".equals(username)) {
		
	} else {
		// 用户名不存在
		msg = "尝试登录的用户不存在！";
		// 封装即将转发的数据
		modelMap.addAttribute("message", msg);
		// 执行转发
		return "error";
	}
	
	return null;
}

2.5. 小结

当需要重定向时，返回的String应该是例如：redirect:???.do；

当需要转发时，可以通过HttpServletRequest、ModelMap封装转发数据，甚至可以将方法的返回值声明为ModelAndView，推荐，更推荐使用的是ModelMap。

课堂练习：在主页中显示当前登录的用户的用户名！

3. 使用HttpSession

3.1. 使用方式

参考HttpServletRequest。

3.2. 什么时候需要使用Session

HTTP协议是无状态的，所以，request不可以长时间保存数据！

需要较长时间却不是永久保存用户的数据。

3.3. 什么样的数据使用Session存储

当前来访用户的唯一标识，例如：用户的id
使用频率很高的数据，例如：用户名、用户头像
不适合使用其它方案暂时存储的数据……

4. 关于@RequestMapping注解

@RequestMapping注解表示“请求映射”，主要用于配置方法映射的请求路径。

该注解也可以添加在类的声明之前！表示请求路径中的路径，在例如http://localhost:8080/???/user/reg.do路径中，中间的user这层路径就是通过类之前的@RequestMapping来配置的！

在类和方法之前使用@RequestMapping注解的作用是不相同的！

一旦在类的声明之前配置了该注解，则当前类中的所有请求路径，在使用时都需要添加中间层的路径。

在@RequestMapping中配置路径时，以下4种配置方案都是正确的：

类		方法			是否正确
user	reg.do		      T
/user	/reg.do		      T
/user	reg.do		      T
user	/reg.do		      T

通常，建议使用第2种（也可以是第1种）。

其实，注解中的每个配置都是有属性名称的，例如：

@RequestMapping(value="reg.do")

关于@RequestMapping注解，还有另一个属性method，用于限制请求方式：

@RequestMapping(value="handle_login.do", 
		method=RequestMethod.POST)

以上配置的value和method属性的值都是数组类型的。

5. 关于@RequestParam注解

使用@RequestParam注解可以解决请求参数的名称与处理请求的方法中参数名称不一致的问题：

@RequestParam("uname") String username

一旦添加了该注解，该参数就是必须提供的参数，如果请求参数中没有包含该参数，则提示400错误，例如：

HTTP Status 400 - Required String parameter 'uname' is not present

关于@RequestParam注解，可以配置：

value：请求参数的名称，如果没有提供该名称对应的参数，默认会报400错误，如果允许不提交，则服务器视该参数值为null；
name：等效于value；
required：是否必须提供该参数，取值为布尔值，默认值为true，也可以自行设置为false；
defaultValue：默认值，即提供的请求参数中如果不包含该参数，则默认视为提供了某个指定的值，该属性仅当required=false时才有效。

基于该注解的特性，常用的应用场景应该是：

需要保证名称一致时；
强制要求提供某参数时；
允许不提供某参数且设置默认值时。

<3>.拦截器、乱码问题、异常处理

1. 【复习】过滤器（Filter）

过滤器是Java EE中的组件。

过滤器是执行在Servlet之前的组件。

过滤器可以对请求进行过滤，如果不满足自行指定的条件，可以拦截下来，不予放行，请求就不会被Servlet处理。

过滤器也需要在web.xml中配置注册，通常，映射的路径范围较大，因为它通常用于处理多个甚至所有Servlet需要执行的任务。

同一个应用中可以存在多个过滤器，形成“过滤器链”，当某个请求被服务器处理时，会依次执行各个过滤器，只有全部放行，才会被Servlet处理。

过滤器的配置与Servlet非常相似：

<filter>
	<filter-name></filter-name>
	<filter-class></filter-class>
</filter>

<filter-mapping>
	<filter-name></filter-name>
	<url-pattern></url-pattern>
</filter-mapping>

2. SpringMVC中的拦截器（Interceptor）

2.1. 基本概念

SpringMVC中的拦截器的作用与过滤器非常相似，也是可以设置为诸多请求都会执行的组件，它执行时，优先于控制器（其实，每个拦截器都会执行3次，1次在控制器之前，2次在控制器之后，通常关注的是在控制器之前执行的那一次）。

2.2. 基本使用

自定义拦截器需要实现HandlerInterceptor接口，该接口中共3个抽象方法，其中，preHandle()方法是在控制器之前执行的，可以起到拦截效果，该方法的返回值表示是否拦截，为true时放行，为false时拦截。

public class LoginInterceptor implements HandlerInterceptor {

	public boolean preHandle(
			HttpServletRequest request, 
			HttpServletResponse response, 
			Object handler)
			throws Exception {
		// 测试输出
		System.out.println("LoginInterceptor.preHandle()");
		
		// 拦截规则：
		// 如果未登录，重定向到登录，并拦截
		// 如果已登录，直接放行
		HttpSession session = request.getSession();
		if (session.getAttribute("username") == null) {
			response.sendRedirect("../user/login.do");
			return false;
		}
		
		// 返回：true=放行，false=拦截
		return true;
	}

	// ... 其它代码...
}

所有拦截器还必须在Spring的配置文件中进行配置：

<!-- 拦截器链 -->
<mvc:interceptors>
	<!-- 第1个拦截器 -->
	<mvc:interceptor>
		<!-- 1. 黑名单 -->
		<mvc:mapping path="/user/*"/>
		<!-- 2. 白名单 -->
		<mvc:exclude-mapping path="/user/reg.do"/>
		<mvc:exclude-mapping path="/user/login.do"/>
		<mvc:exclude-mapping path="/user/handle_reg.do"/>
		<mvc:exclude-mapping path="/user/handle_login.do"/>
		<!-- 3. 拦截器类 -->
		<bean class="cn.tedu.spring.LoginInterceptor" />
	</mvc:interceptor>
</mvc:interceptors>

在配置时，可以使用星号*作为通配符，但是，它只能匹配1级路径，例如：/user/*可以通配/user/reg.do、/user/login.do等，却无法匹配/user/a/list.do！如果需要表示多级路径中的通配，则需要使用2个星号**！

3. 处理请求参数的乱码问题

<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>/*</url-pattern>
</filter-mapping>

4. SpringMVC处理异常

演示之前，准备案例：

访问http://localhost:8080/???/null.do时，处理该请求的方法将抛出NullPointerException；
访问http://localhost:8080/???/array.do时，处理该请求的方法将抛出ArrayIndexOutOfBoundsException；

在Java中，RuntimeException及其子孙类异常不是必须处理的，也就是既不需要try...catch也不需要通过throw和throws抛出，但是，如果出现这些异常，例如NullPointerException或ClassCastException等，Tomcat会将异常的跟踪信息显示在页面，一方面会造成不好的用户体验，另一方面还可能暴露程序的执行流程甚至相关参数等，是非常不合适的，所以，还是应该对这些异常进行处理！但是，这些异常出现的频率极高，在每个处理请求的方法中都进行处理，工作量大，且不便于管理！

SpringMVC提供了统一处理异常的方式，使得开发者在编写处理请求的方法时，不必关心这些异常，而是在统一的方式中处理即可，一旦出现异常，也是由统一处理异常的方案来解决。

SimpleMappingExceptionResolver

它是一个配置异常与页面的映射关系的类，即：当出现指定的异常时，会自动转发到对应的页面！使用时，在Spring的配置文件中进行配置即可：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
	<property name="exceptionMappings">
		<props>
			<prop key="java.lang.NullPointerException">ex_null</prop>
		</props>
	</property>
</bean>

这种做法存在的问题：无法精准提示！不一定可以反馈给客户端，因为客户端需要的可能不是一个页面，而只是一些数据！还可能存在其它转发的弊端！

@ExceptionHandler

可以在控制器类的内部添加一个处理异常的方法，关于方法的声明：

使用public权限；
设计返回值的规则与处理请求的方法相同；
方法名称不限；
必须添加异常为参数；
必须添加@ExceptionHandler注解；
在Spring的配置文件中添加注解驱动<mvc:annotation-driven />

小结

以上2种处理异常的方式是可以共存的！

使用SimpleMappingExceptionResovler是全局配置，即任何控制器出现异常，都可以应用映射所配置的处理方式。

同一个类中可以有多个添加了@ExceptionHandler来处理异常的方法！

处理异常的方法只能作用于当前类，例如MainController中对NullPointerException进行了处理，而UserController没有处理，后续，当UserController处理请求时，如果出现了NullPointerException，是不会被处理的！如果希望处理异常的方法可以通用，则创建一个控制器类的父类，在父类中处理异常，每个子类继承得到后，就都可以处理相关的异常了！

可以在@ExceptionHandler注解中添加详细配置，注解参数是Class<? extends Throwable>[]，用于限制所处理的异常的类型，例如：

@ExceptionHandler({ClassCastException.class, IndexOutOfBoundsException.class})

表示仅处理以上2种异常及其子孙类异常，而其它的异常将不由接下来的方法进行处理！

5. SpringMVC小结

理解SpringMVC执行流程图；
掌握@RequestMapping与@RequestParam注解的详细使用，前者可以配置2个属性，后者可以配置3个属性；
掌握获取请求参数的做法：直接声明参数，使用对象接收多个参数；
掌握转发数据的做法：使用ModelMap；
掌握重定向的做法；
掌握拦截器的使用：创建并编写拦截方法，配置拦截路径与例外；
掌握通过@ExceptionHandler处理异常；
在web.xml中需要配置DispatcherServlet和CharacterEncodingFilter，在Spring的配置文件中需要配置组件扫描、视图解析器、注解驱动，请理解这些配置的意义与配置方式，后续使用时，直接复制粘贴即可。

6. 课后作业

创建数据库t_ums
创建数据表t_user，该表中至少包含：id、username、password、age、phone、email，字段约束可自行设计，并保留SQL语句，下同
向t_user表添加不少于10条数据
查询t_user表中所有数据
获取t_user表中数据的数量
获取t_user表指定username值为xx的数据
获取t_user表中年龄从高到低排列的前5条数据
删除t_user表中指定username值为xx的数据
将t_user表中年龄大于xx的数据的密码修改为xx
修改t_user表中指定id为xx的数据的电子邮箱是xx

1. 过滤器和拦截器的区别

使用环境不同：过滤器是Java EE中的组件，任何Java Web项目都可以使用；拦截器是SpringMVC中的组件，仅当项目中使用了SpringMVC框架后才可以使用！

执行时间节点不同：过滤器是执行在Servlet之前的，拦截器是执行在Controller之前的（暂不考虑拦截器在控制器之后的2次执行）！

使用复杂程度不同：过滤器只能配置1个路径（<url-pattern>）表示过滤范围，拦截器可以配置若干个<mvc:mapping>表示拦截范围，同时还可以使用若干个<mvc:exclude-mapping>表示例外（白名单），所以配置时更加灵活！

当然，也有一些相同之处，例如：都在控制器之前执行，都可以起到“拦截效果”，都可以形成“链”。

2. 关于乱码

出现乱码的原因：使用的编码不统一！

解决乱码的做法：统一编码！

什么是编码：由于计算机处理数据都是使用二进制，即0和1组成的序列，例如使用0100 0011表示A，这样的对应规则是固定的，1个字节可以表示的字符集是通过ASCII表约定的，在ASCII码表中，全部使用1个字节表示字符，1个字节有8个二进制位，表现的内容非常有限，如果表示中文，必须使用至少2个字节！使用中文时，可选编码较多，例如：UTF8、UTF16、GBK、GB2312……各种不同的编码中，存储的二进制数与字符的对应关系是不同的！如果存和取都使用相同的编码，就不会出现乱码问题！在ASCII字符集中的字符是不会出现乱码，因为无论是哪种编码格式，对于这些字符的编码都是相同的！在开发时，不要使用某些根本就不支持中文的编码，例如：ISO-8859-1、Latin1……

在哪些位置需要设定并统一编码：项目的源码，界面使用的编码，存储数据的编码，数据传输时使用的编码。

是不是一定要显式的设置编码：不一定，如果显式的、统一的设置了编码，一定不会出现乱码，反之，则有可能出现乱码！

3. 关于异常

异常的体系结构：

Throwable
	Error：错误
		OutOfMemoryError：OOM，使用的内存超出了限制
	Exception：异常
		SqlException
		IOException
			FileNotFoundException
		RuntimeException
			NullPointerException
			ClassCastException
			IndexOutOfBoundsException
				ArrayIndexOutOfBoundsException
			IllegalArgumentException
			ArithmeticException
			ClassNotFoundException

关于以上异常，非RuntimeException是必须处理的，而RuntimeException是不要求处理的！处理异常的方式可以是：

使用try...catch包裹可能出现异常的代码块；
在方法的声明中添加throws声明抛出，由当前方法的调用者去处理；

RuntimeException及其子孙类异常，从语法上没有任何处理异常相关的约束，主要原因是：

这些异常出现的频率可能极高，如果一定要处理，可能通篇代码都在处理范围之内！
这些异常都属于可以杜绝的异常，通过严谨的编程，可以使得异常一定不会出现！

汐汐同学呀

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
全面学习SpringMVC框架入门与提高(含详细代码)

这一篇文章我将和大家一起回顾整个SpringMVC框架技术，由于内容较多，内容共分为三大部分。如果有不对的地方欢迎大家指正。1.初识Spring框架，声明周期和延时加载…2.注入，自动装配，注入集合类型，注入properties类型…3.Spring简介，对象获取方式，对象声明周期…...
复制链接

扫一扫

专栏目录