SpringMVC 总结及 SSM 整合

SpringMVC

SpringMVC的核心架构：

具体流程：

（1）首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

（2）DispatcherServlet——>HandlerMapping，映射处理器将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象；

（3）DispatcherServlet——>HandlerAdapter，处理器适配器将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

（4）HandlerAdapter——>调用处理器相应功能处理方法，并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；

（5）ModelAndView对象（Model部分是业务对象返回的模型数据，View部分为逻辑视图名）——> ViewResolver，视图解析器将把逻辑视图名解析为具体的View；

（6）View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构；

（7）返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

@RequestMapping(value="/{tag}")

public String getArticleListByTag(HttpServletRequest request, @PathVariable String tag, QueryCondition queryCondition) throws Exception{

tag = new String(tag.getBytes("ISO-8859-1"), "UTF-8");

System.out.println("tag="+tag);

}

1. mvc 框架要做哪些事情：

a) 将 url 映射到 Java 类或 Java 类的方法。

b) 封装用户提交的数据

c) 处理请求----调用相关的业务处理----封装响应的数据

d) 将响应的数据进行渲染，jsp,html,freemarker等。

2. springMVC 是一个轻量级的，基于请求响应的 mvc 框架。

3. 为什么要学习 springMVC框架？

性能较 struts2 好。

简单，便捷，易学。

天生和 Spring 无缝集成（使用 Spring IOC，AOP）。

使用约定优于配置。

能够进行简单的 Junit 测试。

支持 Restful 风格。

异常处理。

本地化、国际化。

数据验证、类型转换。

拦截器等其他优势... 使用人多~

SpringMVC：

1. 导入相关jar包

2. 配置web.xml 核心分发器：org.springframework.web.servlet.DispatcherServlet

<servlet-name>dispatcherServlet</servlet-name>

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

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:springmvc.xml</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>dispatcherServlet</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

3. 添加 springMVC 配置文件：默认在 WEB-INF 下添加 [DispatcherServletName]-servlet.xml 文件

4. 编写代码。Controller（Action）

5. 使用注解开发。@Controller 需要在web.xml 中添加扫描context:component-scan

Controller 配置总结：

第一种： URL 对应 Bean

如果要使用此类配置方式，需要在 XML 中做如下样式配置：

以上配置，访问 /hello.do 就会寻找 id 为 /hello.do 的 Bean，此类方式仅适用小型的应用系统

第二种：为 URL 分配 Bean

使用一个统一配置集合，对各个 URL 对应的 Controller 做关系映射

<props>

<prop key="/hello.do" > helloController </prop>

</props>

</property>

</bean>

此类配置还可以使用通配符，访问 /hello.do 时， Spring 会把请求分配给 helloController 进行处理

第三种： URL 匹配 Bean

如果定义的 Controller 名称规范，也可以使用如下配置

第四种：注解

首先在配置文件中开启注解

<context:component-scan base-package="com.darryl.springmvc.controller" />

在编写类上使用注解 @org.springframework.stereotype.Controller 标记这个 Controller 对象

使用 @RequestMapping("/hello.do") 指定方法对应处理的路径

* @Component：一个普通的Bean类。

* @Repository ：用于标注持久层DAO类

* @Service ：用于标注业务层类

* @Controller ：用于标注控制器类

* @RequestMapping： Spring MVC使用@RequestMapping注解为控制器指定请求的URL。

* @RequestMapping的value、method、params及heads分别表示请求url，请求方法，请求参数及请求头的映射条件，他们之间是与的关系，联合使用多个条件可以让请求更加精确化。

* params和headers支持简单的表达式。

* param1：表示请求必须包含param1的请求参数。

* !param1：表示请求不能包含param1的请求参数。

* param1!=value1：表示请求参数param1不能等于value1。

* {"param1=value1","param2"}：表示请求参数param1必须等于value1，必须包含请求参数param2。

* @PathVariable：URL模版方式用来映射URL中的占位符。映射的变量名必须和占位符中的名称一致。

* @RequestParam：获取请求参数获取页面传递过来的参数，GET和POST都支持。当参数与传递的参数同名时，可以省略@Requestparam

* value：指定参数的名称

* required：指定参数是否为必填

* defaultValue：指定参数的默认值

* @RequestHeader：获取请求头内容请求头包含了若干的属性，用来获取客户端的信息。通过@RequestHeader可以用来获取请求头中的信息

* @CookieValue：用来获取客户端Cookie信息。

* @SessionAttributes：将模型中的某个属性存储到Session中，以便多个请求之间共享这个属性。

* 当类使用@SessionAttributes修饰，而方法中使用了和SessionAttributes修饰同名的映射参数，确没有添加@ModelAttribute修饰时，则会报错。

HTTP Status 500 - Session attribute 'user' required - not found in session

解决方案

* 参数前使用@ModelAttribute修改映射的名称。

* 和@SessionAttributes中的名称不同。

* @ModelAttribute：方法形参标记该注解后，形参对象就会放到模型中。

* @ModelAndView：控制器处理方法如果返回ModelAndView，即包含视图信息，也包含模型信息。

结果跳转方式：

1. 设置 ModelAndView 对象。根据 View 的名称，和视图解析器跳转到指定的页面。

页面：视图解析器的前缀 + view name + 视图解析器的后缀

ModelAndView mv = new ModelAndView();

//封装要显示到视图中的数据

mv.addObject("msg","hello annotation");

//视图名

mv.setViewName("hello");

2. 通过 ServletAPI 对象来实现。不需要视图解析器的配置

通过 HttpServletResponse 来进行输出。

通过 HttpServletResponse 实现重定向。

通过 HttpServletRequest 实现转发。

3. 通过 SpringMVC 来实现转发和重定向----没有视图解析器

转发的实现1：直接 return “路径”

转发的实现2：直接 return “forward:路径”

重定向的实现：直接 return“redirect:路径”

4. 通过 SpringMVC 来实现转发和重定向----有视图解析器

转发的实现：直接 return "viewName"

注意：重定向不需要视图解析器 return“redirect:路径”

SpringMVC 数据的处理

1. 提交数据的处理

a. 提交的域名称和处理方法的参数名一致即可。

提交的数据

处理方法

b. 如过域名称和参数名不一致

提交的数据

处理方法

c. 提交的是一个对象

要求提交的表单域名和对象的属性名一致，参数使用对象即可。

处理方法

2. 将数据显示到 UI 层

第一种：通过 ModelAndView——需要视图解析器

第二种：通过 ModelMap 来实现，不需要视图解析器，在方法参数中添加 ModelMap 参数

ModelAndView 和 ModelMap 的区别：

相同点：都可以将数据封装显示到表示层页面中

不同点：ModelAndView 可以指定跳转的视图，而 ModelMap不能

ModelAndView 需要视图解析器，ModelMap 不需要配置视图解析器

SpringMVC 乱码及 restful

1. 乱码的解决——通过过滤器来解决乱码：SpringMVC 中提供 CharacterEncodingFilter 解决 post 乱码

<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>

如果是 get 方式乱码

a）修改 tomcat 的配置解决

b ) 自定义乱码解决的过滤器

2. restful 风格的url

优点：轻量级，安全，效率高

//http://localhost:8080/restful/1/123/delete.do

@RequestMapping("/{id}/{uid}/delete")

public String delete(@PathVariable int uid,@PathVariable int id) {

System.out.println("id "+id);

System.out.println("uid "+uid);

return "/index.jsp";

}

3.同一个 Controller 通过参数来达到不同的处理方法——不重要

SpringMVC 实现文件上传

方式一：

1. 通过 commons-fileupload 来实现，导入相关jar包

commons-fileupload,commons-io

2. 配置 SpringMVC 的配置文件

<bean id="multipartResolver"

class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

</bean>

3. jsp页面

file:<input type="file" name="file"/>

</form>

4. Controller 代码

@RequestMapping("/upload")

public String fileupload(@RequestParam("file")CommonsMultipartFile file,HttpServletRequest request) throws IOException {

//获取文件名

//file.getOriginalFilename();

//获取上传文件的路径

String path = request.getRealPath("/fileupload");

InputStream is = file.getInputStream();

OutputStream os = new FileOutputStream(new File(path,file.getOriginalFilename()));

int len = 0;

byte[] buffer = new byte[400];

while ((len=is.read(buffer))!=-1)

os.write(buffer, 0, len);

os.close();

is.close();

return "/index.jsp";

}

在Controller的MultipartFile参数前面必须加上@RequestParam！

批量上传的代码：

@RequestMapping("/batch")

public String fileupload(@RequestParam("file")CommonsMultipartFile file[],HttpServletRequest request) throws IOException {

//获取文件名

//file.getOriginalFilename();

//获取上传文件的路径

String path = request.getRealPath("/fileupload");

for (int i = 0; i < file.length; i++) {

InputStream is = file[i].getInputStream();

OutputStream os = new FileOutputStream(new File(path,file[i].getOriginalFilename()));

int len = 0;

byte[] buffer = new byte[400];

while ((len=is.read(buffer))!=-1)

os.write(buffer, 0, len);

os.close();

is.close();

}

return "/index.jsp";

}

方式二：

* 导入CommonsMultipartResolver所依赖的jar包。

* 添加配置文件

</bean>

MultipartFile属性

* MultipartFile可以获取表单提交过来的文件域

* 常用方法

* isEmpty()：判断是否提交文件

* getContentType()：获取文件类型

* getName()：获取表单元素名称

* getOriginalFilename()：获取提交的文件名称

* getInputStream()：获取文件流

* getSize()：获取文件大小

* getBytes()：获取字节数组

<br />

<div class="msg">${message}</div>

</form>

<c:if test="${ !empty imageurl }">

</c:if>

@RequestMapping("/fileupload")

public String fileupload(ServletRequest request, @RequestParam("file") MultipartFile file, Model model)

throws IOException {

if (!file.isEmpty()) {

String imageurl = saveFile(request, file);

model.addAttribute("imageurl", imageurl);

} else {

model.addAttribute("message", "请选择要上传的文件");

}

return "fileupload";

}

private String saveFile(ServletRequest request, MultipartFile file) throws IOException {

// 获取文件的上传路径

String uploadPath = request.getServletContext().getRealPath("uploads");

File uploadPathFile = new File(uploadPath);

if (!uploadPathFile.exists()) {

uploadPathFile.mkdirs();

}

// 获取文件名称

String filename = file.getOriginalFilename();

// 截取文件后缀

String fileext = filename.substring(filename.lastIndexOf("."));

// 生成新的随机文件名称

String newfileName = UUID.randomUUID() + fileext;

// 文件保存路径

File savePath = new File(uploadPath + "/" + newfileName);

// 上传文件

file.transferTo(savePath);

return "uploads/" + newfileName;

}

如果提示文件找不到（404）需要修改springmvc.xml配置文件，加上以下配置

<mvc:default-servlet-handler/>

SpringMVC 中 form标签：

导入SpringMVC 表单标签：

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>

<form:form action="/loginPost" method="post" commandName="user">

</form:form>

<form:form action="/loginPost" method="post" modelAttribute="user">

</form:form>

普通标签

* form:input：对应<input type="text">

* form:password：对应<input type="password" />

* form:hidden：对应<input type="hidden" />

* form:textarea：对应<textarea />

* form:checkbox：对应<input type="checkbox" />

* form:radiobutton：对应<input type="radiobutton"/>

表单标签的通用属性

SpringMVC提供了多个表单标签，用以绑定表单字段的属性值，它们共有的属性如下。

* path：表单字段，对应html中的name属性，支持级联属性。

* htmlEscape：是否对表单的HTML特殊字符进行转换，默认值为true。

* cssClass：对应的css样式。

* cssErrorClass：发生错误时，对应的css样式。

支持绑定集合数据的标签标签：

* checkboxes：多选列表

* radiobuttons：单选列表

* select：下拉列表

* option/options：select中的元素

form:radiobuttons：单选框组标签，用于构造多个单选框

* path：（必填）名称，要绑定的属性。

* items：（必填）可以是一个list、String[]和Map。

* itemValue：指定radio的value值，可以使集合中bean的一个属性值。

* itemLabel：指定radio的label值。

* delimiter：多个单选框可以通过delimiter指定分隔符。

form:errors：显示表单组件或数据效验所对应的错误。

* ：显示表单中所有的错误。

* <form:errors path="user" />：显示所有以user为前缀的属性对应的错误。

* ：显示username表单元素的错误。

@RequestMapping("dataBind")

public String dataBind(Map<String, Object> map) {

//生成绑定的集合属性

List<String> genderList = new ArrayList<String>();

genderList.add("男");

genderList.add("女");

map.put("genderList", genderList);

//生成绑定自定义类型的集合属性

List<Role> roleList = new ArrayList<Role>();

roleList.add(new Role(1, "管理员"));

roleList.add(new Role(2, "老师"));

roleList.add(new Role(3, "学生"));

map.put("roleList", roleList);

//User中必须包含和path同名的get和set方法，否则会报错

User user = new User();

user.setUsername("admin");

user.setPassword("123");

//绑定对象时，需要重写toString()方法才能比较值。

user.setGender("男");

user.setRole(new Role(3, "学生"));

user.setAge(22);

map.put("user", user);

return "dataBind";

}

<form:form action="loginPost" method="post" modelAttribute="user">

<table>

<tr>

</tr>

<tr>

</tr>

<tr>

<td>

<form:radiobuttons path="gender" items="${genderList}"/>

</td>

</tr>

<tr>

<td>

<form:input path="age"/>

</td>

</tr>

<tr>

<td>

<!-- 这里items表示要绑定的集合属性，如果是字符串集合，不需要指定itemValue

和itemLabel，如果是自定义的集合对象，则必须指定 -->

<form:radiobuttons path="role" itemValue="roleId" itemLabel="roleName"

items="${roleList}"/>

</td>

</tr>

<tr>

</tr>

</table></form:form>

SpringMVC 中 Ajax 的处理：

1. 使用 HttpServletResponse 来处理——不需要配置解析器

@RequestMapping("/ajax")

public void ajax(String name,HttpServletResponse response) throws IOException {

if("siggy".equals(name)) {

response.getWriter().println("true");

} else {

response.getWriter().println("false");

}

$(function() {

$("#txtName").blur(function() {

$.post("ajax.do",

{

'name' : $("#txtName").val()

}, function(data) {

alert(data);

})

});

2. SpringMVC处理 json 数据

a) 导入 jar 包

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

b) 配置 json 转换器

<bean id="stringConyerter"

class="org.springframework.http.converter.StringHttpMessageConverter">

<list>

<value>text/plain;charset=UTF-8</value>

</list>

</property>

</bean>

<bean id="jsonConverter"

class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">

</bean>

<list>

</list>

</property>

</bean>

c) Controller 代码

@RequestMapping("/json")

@ResponseBody

public List<User> json(){

List<User> list = new ArrayList<User>();

list.add(new User(1,"张三","男"));

list.add(new User(2,"李四","男"));

list.add(new User(3,"王五","男"));

return list;

}

d) jsp 代码

$(function() {

$("#btn").click(function() {

$.post("json.do"

, function(data) {

//alert(data);

var html="";

for(var i=0;i<data.length;i++) {

html+="<tr><td>"+data[i].id+"</td><td>"+data[i].name+"</td><td>"+data[i].sex+"</td></tr>";

}

$("#content").html(html);

})

});

</script>

</head>

<body>

<tr>

</tr>

</tbody>

</table>

</body>

SpringMVC 数据校验及国际化

SpringMVC数据效验步骤

* 导入Hibernate-validator包。

* 添加配置信息 <mvc:annotation-driven/>

* 在实体类上添加验证注解。

* 在目标方法Bean类型的前面添加@Valid注解。

<form:form action="${pageContext.request.contextPath}/emp/add" method="post" modelAttribute="employee">

姓名:<form:input path="name" /><form:errors path="name" /><br>

邮箱:<form:input path="email" /><form:errors path="email" /><br>

性别:<form:radiobuttons items="${genders}" path="gender" /><br>

部门：<form:select path="dept.id" items="${depts}" itemValue="id" itemLabel="name"></form:select><br><br>

生日：<form:input path="birthday" /><form:errors path="birthday" /><br>

金额：<form:input path="salary" /><form:errors path="salary" /><br>

<form:errors path="*" /><br />

</form:form>

public class Employee implements Serializable {

* @Null 被注释的元素必须为 null

* @NotNull 被注释的元素必须不为 null

* @AssertTrue 被注释的元素必须为 true

* @AssertFalse 被注释的元素必须为 false

* @Min(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最小值

* @Max(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值

* @DecimalMin(value) 被注释的元素必须是一个数字，其值必须大于等于指定的最小值

* @DecimalMax(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值

* @Size(max, min) 被注释的元素的大小必须在指定的范围内

* @Digits (integer, fraction) 被注释的元素必须是一个数字，其值必须在可接受的范围内

* @Past 被注释的元素必须是一个过去的日期

* @Future 被注释的元素必须是一个将来的日期

@NotEmpty

private String name;

@Email

private String email;

private String gender;

private Dept dept;

@DateTimeFormat(pattern="yyyy-MM-dd")

private Date birthday;

@NumberFormat(pattern="#,####,###.#")

@DecimalMin("1000")

@DecimalMax("9999")

private Double salary;

// 忽略set、get方法

}

private void loadEmpData(Map<String, Object> map) {

List<String> genderList = new ArrayList<String>();

genderList.add("男");

genderList.add("女");

map.put("genders", genderList);

List<Dept> depts = new ArrayList<Dept>();

depts.add(new Dept(1, "开发部"));

depts.add(new Dept(2, "技术部"));

depts.add(new Dept(3, "产品部"));

map.put("depts", depts);

}

@RequestMapping("/add")

public String add(@Valid Employee emp, BindingResult result, Map<String, Object> map, Model model){

if (result.hasErrors()) {

// result.rejectValue("name", "NotEmpty", "名称不能为空");

for (ObjectError error : result.getAllErrors()) {

System.err.println(error.getObjectName() + ":" + error.getCode() + "-->" + error.getDefaultMessage());

}

loadEmpData(map);

return "register";

}

System.out.println("emp:" + emp);

return "redirect:/emps";

}

提示消息的国际化

#语法：实体类上属性的注解.验证目标方法的modleAttribute 属性值(如果没有默认为实体类首字母小写).注解修饰的属性

#以第一个为例：Employee实体类中属性name用了NotEmpty注解修饰，表示不能为空。所以前缀是NotEmpty

#验证的目标方法 public String add(@Valid Employee emp, ...) emp被注解@Valid修饰，但又被modleAttribute修饰(modelAttribute="employee")。所以中间是employee

#后缀就是被注解修饰的属性名name

NotEmpty.employee.name=用户名不能为空

Email.employee.email=Email格式不正确

Past.employee.birthday=出生日期不能是一个将来的日期

DecimalMin.employee.salary=工资必须大于等于1000

DecimalMax.employee.salary=工资必须小于等于1000

注册国际化资源文件

<!-- 注入绑定的资源文件名称 i18n

i18n_en.properties

i18n_zh_CN.properties

-->

</bean>

jsp页面国际化

* 添加i18n拦截器的配置

<mvc:interceptors>

</mvc:interceptors>

* 页面添加springmvc的tags标签库

<%@taglib uri="http://www.springframework.org/tags" prefix="spring"%>

* 页面使用message标签显示国际化内容

<spring:message code="label.user.name"></spring:message>

code属性是国际化文件内的key

对页面内容进行国际化

* 页面中使用Spring的message标签

* 在bean中注入ResourceBundleMessageSource，使用其对应的getMessage()方法即可。

* 配置LocalResolver和LocaleChangeIntercepter。

添加资源文件

* i18n_zh_CN.properties

* i18n_en_US.properties

注册国际化资源文件

</bean>

实现页面国际化

* 在页面中添加spring标签

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>

* 使用message标签显示国际化内容

<spring:message code="i18n.name" />

* 控制器中对输出内容进行国际化操作

@Controller

public class localControllor {

@Autowired

private ResourceBundleMessageSource messageSource;

//添加local参数，会自动获取网页中的语言

@RequestMapping("/testlocale")

public String testLocal(Locale locale, Map<String,Object> map){

//通过getMessage方法获取资源文件中的key值

String name = messageSource.getMessage("i18n.name", null, locale);

map.put("name", name);

return "locale";

}

切换语言

本地化解析器和本地化拦截器

* AcceptHeaderLocalResolver：根据HTTP请求头的Accept-Language参数确定本地化类型，如果没有显示定义本地化解析器，SpringMVC使用该解析器。

* CookieLocalResolver：根据指定的Cookie值确定本地化类型。

* SessionLocalResolver：根据Session中特定的属性确定本地化类型。

* LocaleChangeIntercepter：本地化拦截器，从请求参数中获取本次请求对应的本地化类型。

代码实现

* 配置LocalResolver用来获取本地化语言

* 配置LocaleChangeInterceptor拦截器

<mvc:interceptors>

</mvc:interceptors>

* 配置超链接进行语言切换

SpringMVC 拦截器

1. 拦截器与过滤器的区别：

过滤器可以简单理解为“取你所想取”，忽视掉那些你不想要的东西；拦截器可以简单理解为“拒你所想拒”，关心你想要拒绝掉哪些东西，比如一个BBS论坛上拦截掉敏感词汇。

1）. 拦截器是基于java反射机制的，而过滤器是基于函数回调的。

2）. 过滤器依赖于servlet容器，而拦截器不依赖于servlet容器。

3）. 拦截器只对action起作用，而过滤器几乎可以对所有请求起作用。

4）. 拦截器可以访问action上下文、值栈里的对象，而过滤器不能。

5）. 在action的生命周期里，拦截器可以多起调用，而过滤器只能在容器初始化时调用一次。

2. 实现拦截器

1）. 实现HandlerInterceptor 接口。

public class MyInterceptor implements HandlerInterceptor {

//在请求处理的方法之前执行

//如果返回 true 那么执行下一个拦截器，如果返回false 不去执行下一个拦截器

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

throws Exception {

System.out.println("————————处理前————————————");

return true;

}

//在请求处理的方法执行之后执行

@Override

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,

ModelAndView modelAndView) throws Exception {

System.out.println("——————处理后——————");

}

//在 DispatcherServlet 处理后执行——清理工作

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

throws Exception {

}

2）. 配置拦截器

<!--

/** : 表示包括路径及其子路径

如果是/admin/* —— 拦截的是 /admin/add,/admin/list etc. /admin/user/add 不被拦截

如果是/admin/** —— 拦截：/admin/add,/admin/user/add

-->

<mvc:interceptors>

<mvc:interceptor>

<mvc:mapping path="/**" />

</mvc:interceptor>

</mvc:interceptors>

3）. 如果被拦截——能否到达指定的页面？

使用 HttpServletResponse 或者 HttpServletRequest 可以实现转发或者重定向

//在请求处理的方法之前执行

//如果返回 true 那么执行下一个拦截器，如果返回false 不去执行下一个拦截器

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

throws Exception {

System.out.println("————————处理前————————————");

//拦截后重定向至 index.jsp页面

response.sendRedirect(request.getContextPath()+"/index.jsp");

return true;

}

4）. 拦截器应用——登录拦截器

public class LoginInterceptor implements HandlerInterceptor{

//允许哪些url不被拦截，哪些需要被拦截

private List<String> allowedPass;

//在请求处理的方法之前执行

//如果返回 true 那么执行下一个拦截器，如果返回false 不去执行下一个拦截器

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)

throws Exception {

String url = request.getRequestURI().toString();

//先判断 Session 中是否有

Object user = request.getSession().getAttribute("user");

if (user!=null) {

return true;

}

//然后判断是否为允许

for (String string : allowedPass) {

if(url.endsWith(string)) {

return true;

}

response.sendRedirect(request.getContextPath()+"/login.jsp");

return false;

}

//在请求处理的方法执行之后执行

@Override

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,

ModelAndView modelAndView) throws Exception {}

//在 DispatcherServlet 处理后执行——清理工作

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

throws Exception {}

public List<String> getAllowedPass() {return allowedPass;}

public void setAllowedPass(List<String> allowedPass) {this.allowedPass = allowedPass;}

}

@Controller

public class UserController {

@RequestMapping("/login")

public String login(User user,HttpSession session) {

if ("siggy".equals(user.getName())&& "1111".equals(user.getPwd())) {

System.out.println("登录成功");

session.setAttribute("user", user);

return "redirect:/index.jsp";

}

return "redirect:/login.jsp";

}

@RequestMapping("/add")

public String add() {

System.out.println("add");

return "redirect:/index.jsp";

}

<mvc:interceptors>

<mvc:interceptor>

<mvc:mapping path="/**"/>

<list>

<value>login.do</value>

</list>

</property>

</bean>

</mvc:interceptor>

</mvc:interceptors>

用户名:<input type="text" name="name" /><br>

密码:<input type="password" name="pwd" /><br>

</form>

Springmvc异常处理的三种方式

* 使用SimpleMappingExceptionResolver实现异常处理：仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适用

* 实现HandlerExceptionResolver 接口自定义异常处理器：能获取导致出现异常的对象，有利于提供更详细的异常处理信息

* 使用@ExceptionHandler注解实现异常处理：无需配置，不能获取除异常以外的数据

SimpleMappingExceptionResolver实现异常处理

* 配置异常信息

<props>

<prop key="java.lang.ArrayIndexOutOfBoundsException">error</prop>

</props>

</property>

</bean>

* 在/WEB-INF/views下新建一个error.jsp视图

<body>

<h1>Error Page</h1>

${requestScope.ex}

</body>

* 控制器代码

@RequestMapping("index")

public String index() {

int[] array = new int[]{1, 2};

// 出现下标越界异常会进入error.jsp页面

System.out.println(array[3]);

return "success";

}

HandlerExceptionResolver 接口自定义异常处理器

* 实现HandlerExceptionResolver 接口，重写resolveException方法，全局处理所有异常

@Component // 将自定义异常类装载到spring容器中

public class CustomeException implements HandlerExceptionResolver {

@Override

public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,

Exception ex) {

Map<String, Object> map = new HashMap<String, Object>();

if (ex instanceof NullPointerException) {

map.put("ex", ex);

return new ModelAndView("nullPointer", map); // 指定异常对应的视图页面

}

if (ex instanceof IndexOutOfBoundsException) {

return new ModelAndView("indexOutOf", map); // 指定异常对应的视图页面

}

return new ModelAndView("error", map);

}

@ExceptionHandler注解实现异常处理

/**

* 全局异常处理类，在项目中推荐使用全局异常处理类去处理所有异常信息

* @author Administrator

*/@ControllerAdvicepublic class ExceptionHandlerAdvice {

/**

* 在项目总如果没有对异常有页面要求，那么一个异常页面就够了

* 有些项目需要对每一类型的异常都有对象异常页面，比如前台的异常处理、后台异常处理

* @param request

* @param response

* @param handler

* @param ex

* @return

@ExceptionHandler(value = { NullPointerException.class, IndexOutOfBoundsException.class })

public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,

Exception ex) {

// 如果要将异常传递到视图中（jsp页面），必须使用ModelAndView来进行数据传递

// 不能使用Map形参的方式，否则会报错

System.out.println("ExceptionHandlerAdvice.resolveException()");

Map<String, Object> map = new HashMap<String, Object>();

map.put("ex", ex);

ModelAndView mv = new ModelAndView("error", map);

return mv;

}

SpringMVC + Spring + Mybatis 整合

1. 导入相关 jar 包

<spring.version>5.1.1.RELEASE</spring.version>

<mybatis.version>3.4.6</mybatis.version>

<mybatis-spring.version>1.3.2</mybatis-spring.version>

<slf4j.version>1.8.0-beta2</slf4j.version>

<mysql.version>8.0.13</mysql.version>

<json.version>2.9.7</json.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>