SpringMVC TWO

第一章：响应数据和结果视图

1. 返回值分类

搭建开发环境
坐标
<!‐‐ 版本锁定 ‐‐>

<!--版本锁定-->
<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>

前端控制器和过滤器

<!‐‐配置解决中文乱码问题的过滤器‐‐>
<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>
<!‐‐配置前端控制器‐‐>
<servlet>
<servlet‐name>dispatcherServlet</servlet‐name>
<servlet‐class>org.springframework.web.servlet.DispatcherServlet</servlet‐class>
<!‐‐加载springmvc.xml配置文件，配置的是Spring配置‐‐>
<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>*.do</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"><!‐‐配置了内容，启动Tomcat服务器的时候，就会被加载‐‐>
<!‐‐配置注解扫描‐‐>
<context:component‐scan base‐package="com.qcby" />
<!‐‐配置视图解析器，进行页面的跳转‐‐>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!‐‐跳转的页面的路径‐‐>
<property name="prefix" value="/pages/" />
<!‐‐跳转页面的后缀名称‐‐>
<property name="suffix" value=".jsp" />
</bean>
<!‐‐让映射器、适配器和处理器生效(默认不配置也是可以的)‐‐>
<mvc:annotation‐driven/>
</beans>

①、返回String

1. Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器转为物理视图的地址。

@Controller
@RequestMapping("/user")
public class UserController {
/**
* 返回String
* @return
*/
@RequestMapping("/save1.do")
public String save1(){
System.out.println("执行了...");
return "suc";
}}

在方法的参数中，存在一个Model类型的对象，可以设置绑定数据
@Controller
@RequestMapping("role")
public class RoleController {

    @RequestMapping("run.do")
   public String run(Model model) {
        model.addAttribute("name","gs");
        return "suc";
   }
}

②、返回值是void

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

@Controller
@RequestMapping("/user")
public class UserController {
/**
* 返回void
* 默认查询 /pages/sav2.do.jsp的页面
* @return
*/
@RequestMapping("/save2.do")
public void save2(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
System.out.println("执行了...");
// request.getRequestDispatcher("/pages/suc.jsp").forward(request,response);
// 做出相应的操作
response.getWriter().print("hello");
return;
}
}

③、返回值是ModelAndView对象

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

/**
* 返回ModelAndView对象的方式
* @return
*/
@RequestMapping("/save3.do")
public ModelAndView save3(){
System.out.println("执行了...");
// 创建mv对象
ModelAndView mv = new ModelAndView();
// 把一些数据，存储到mv对象中
mv.addObject("msg","用户名或者密码已经存在");
// 设置逻辑视图的名称
mv.setViewName("suc");
return mv;
}


2. SpringMVC框架提供的转发和重定向
forward请求转发
1. controller方法返回String类型，想进行请求转发也可以编写成
/**
* 返回String
* 请求转发（可以传值，一般用的多）
* @return
*/
@RequestMapping("/save4.do")
public String save4(){
System.out.println("执行了...");
return "forward:/pages/suc.jsp";
}

redirect重定向
1. controller方法返回String类型，想进行重定向也可以编写成
/**
* 返回String
* 重定向（不能传值，直跳，一般用的少）
* @return
*/
@RequestMapping("/save5.do")
public String save5(){
System.out.println("执行了...");
return "redirect:/pages/suc.jsp";
}

3. ResponseBody响应json数据
   json和JavaBean对象互相转换的过程中，需要使用jackson的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>

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源（img、css、js）也会被拦截到，从而不能被使用。解决问题就是需要配置静态资源不进行拦截，在springmvc.xml配置文件添加如下配置
标签配置不过滤

1. location元素表示webapp目录下的包下的所有文件
2. mapping元素表示以/static开头的所有请求路径，如/static/a 或者/static/a/b

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

jsp代码编写

<%@ page contentType="text/html;charset=UTF‐8" language="java" %>
<html>
<head>
<title>Controller方法的返回值</title>
<%‐‐引入jq‐‐%>
<script src="/js/jquery.min.js" type="text/javascript"></script>
<script>
// 页面加载
$(function(){
// 单击事件
$("#btn").click(function(){
// 发送ajax的请求
$.ajax({
type: "post",
url: "/dept/save6.do",
data:{username:"haha",age:"20"},
success:function(d){
// 编写很多代码
alert(d.username+" ‐ "+d.age);
}
});
});
});
</script>
</head>
<body>

<h3>异步的数据交互</h3>
<input type="button" value="ajax交互" id="btn">
</body>
</html>

后台代码编写

/**
* 异步的数据交互
* 重定向
* @return
*/
@RequestMapping("/save6.do")
public @ResponseBody User save6(User user){
System.out.println(user);
// 模拟，调用业务层代码
user.setUsername("hello");
user.setAge(100);
// 把user对象转换成json，字符串，再响应。使用@ResposeBody注解 response.getWriter().print()
return user;
}

实体类代码

public class User implements Serializable{
private String username;
private Integer age;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
}

第二章：SpringMVC实现文件上传

1. 文件上传的准备

导入文件上传的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页面

<%@ page contentType="text/html;charset=UTF‐8" language="java" %>
<html>
<head>
<title>文件上传</title>
</head>
<body>
<h3>文件上传</h3>
<form action="/dept/upload.do" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload" /><br/>
    <input type="submit" value="上传" />
</form>
</body>
</html>

2. SpringMVC文件上传

配置文件解析器对象
配置文件上传的解析器组件，id的名称是固定，不能乱写

<?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">
<!‐‐如果<url‐pattern>/</url‐pattern>，任何资源都会拦截‐‐>
<!‐‐配置哪些资源不被拦截<mvc:resources mapping="/js/" location="/js/**" />
<mvc:resources mapping="/css/" location="/css/**" />
<mvc:resources mapping="/image/" location="/image/**" />
‐‐>
<!‐‐配置了内容，启动Tomcat服务器的时候，就会被加载‐‐>
<!‐‐配置注解扫描‐‐>
<context:component‐scan base‐package="com.qcby" />
<!‐‐配置视图解析器，进行页面的跳转‐‐>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!‐‐跳转的页面的路径‐‐>
<property name="prefix" value="/pages/" />
<!‐‐跳转页面的后缀名称‐‐>
<property name="suffix" value=".jsp" />
</bean>
<!‐‐配置文件上传的解析器组件。id的名称是固定，不能乱写‐‐>
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!‐‐设置上传文件的总大小 8M = 8 * 1024 * 1024 ‐‐>
<property name="maxUploadSize" value="8388608" />
</bean>
<!‐‐让映射器、适配器和处理器生效(默认不配置也是可以的)‐‐>
<mvc:annotation‐driven/>
</beans>

SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的name属性名称相同。
代码如下

/**
 * @program: wfby_springmvc01
 * @author: 郭帅
 * @create: 2021-06-05 09:13
 **/
@Controller
@RequestMapping("dept")
public class DeptController {

    @RequestMapping("upload")
    public String upload(MultipartFile upload, HttpServletRequest request) throws IOException {
        //文件上传到哪个位置
        String realPath = request.getSession().getServletContext().getRealPath("/uploads");
        //创建该文件夹
        File file = new File(realPath);
        //判断该文件夹是否存在
        if(!file.exists()){
            file.mkdir();
        }
        //获取到上传文件的名称
        String filename = upload.getOriginalFilename();
        //把文件的名称修改成唯一的值
        String s = UUID.randomUUID().toString().replaceAll("-","").toUpperCase();
        filename = s+"_"+filename;
        //打印最后的文件名
        System.out.println(filename);
        File file1 = new File(file, filename);
        //打印文件对象（具体的文件路径）
        System.out.println(file1);
        //上传文件
        upload.transferTo(file1);
        return "suc";
    }

}

测试：页面上传文件后，去对应的目录下查看是否有文件，则可测试文件上传解析器配置成功以及文件上传流程整体没有问题

第三章：SpringMVC的异常处理

1. 异常处理思路
   Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进行异常的处理。
2. SpringMVC的异常处理
   controller代码

@Controller
@RequestMapping("/role")
public class RoleController {
/**
* 自己处理异常
* @return
@RequestMapping("/findAll.do")
public String findAll(){
try {
System.out.println("执行了...");
// 模拟异常
int a = 10/0;
} catch (Exception e) {
e.printStackTrace();
// 跳转到友好提示页面
return "404";
}
return "suc";
}
*/
/**
* 使用异常处理器方式
* @return
*/
@RequestMapping("/findAll.do")
public String findAll(){
System.out.println("执行了...");
// 模拟异常
int a = 10/0;
return "suc";
}
}

自定义异常类

public class SysException extends Exception{
// 提示消息
private String message;
@Override
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 o
* @param e
* @return
*/
@Override
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse
response, Object o, Exception e) {
e.printStackTrace();
// 做强转
SysException exception = null;
// 判断
if(e instanceof SysException){
exception = (SysException)e;
}else{
exception = new SysException("系统正在维护，请联系管理员");
}
// 存入异常提示信息
ModelAndView mv = new ModelAndView();
mv.addObject("errorMsg",exception.getMessage());
// 设置跳转的页面
mv.setViewName("error");
return mv;
}
}

配置异常处理器

<bean id="sysExceptionResolver" class="com.qcby.demo3.SysExceptionResolver" />

jsp页面代码

<%@ page contentType="text/html;charset=UTF‐8" language="java" isELIgnored="false" %>
<html>
<head>
<title>错误提示页面</title>
</head>
<body>
<h3>错误的友好提示页面</h3>
${errorMsg}
</body>
</html>

第四章：SpringMVC框架中的拦截器

1. 拦截器的概述

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

2. 自定义拦截器步骤

controller中的方法

@Controller
@RequestMapping("/dept")
public class DeptController {
/**
* 测试方法
* @return
*/
@RequestMapping("/findAll.do")
public String findAll(){
System.out.println("controller方法执行了...");
return "suc";
}
}

创建类，实现HandlerInterceptor接口，重写需要的方法

public class MyInterceptor2 implements HandlerInterceptor{
/*在controller方法执行前执行的方法*/
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    System.out.println("拦截器中preHandle方法执行了");
    //request.getRequestDispatcher("/test1.jsp").forward(request,response);
    //正常逻辑代码 书写
    return true; //放行
    //return  false;//不放行
}

/*在controller方法执行后的执行的方法*/
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    //postHandle方法中可以页面跳转（请求转发、冲定性）
    request.getRequestDispatcher("/test1.jsp").forward(request,response);
    System.out.println("拦截器中postHandle方法执行了");
}

/*controller中的跳转页面也执行后的执行的方法*/
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
   /*afterCompletion方法中不可以跳转页面了*/
    System.out.println("拦截器中afterCompletion方法执行了");
}
}

在springmvc.xml中配置拦截器类

<!‐‐配置拦截器们‐‐>
<mvc:interceptors>
<!‐‐配置拦截器‐‐>
<mvc:interceptor>
<!‐‐该拦截器拦截哪些资源‐‐>
<mvc:mapping path="/dept/**"/>
<!‐‐哪些资源不想拦截
<mvc:exclude‐mapping path="" />
‐‐>
<!‐‐拦截器对象‐‐>
<bean class="com.qcby.demo4.MyInterceptor2" />
</mvc:interceptor>
</mvc:interceptors>

3. HandlerInterceptor接口中的方法(重写方法快捷键ctrl+o)

1. preHandle方法是controller方法执行前拦截的方法
   1. 可以使用request或者response跳转到指定的页面
   2. return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。
   3. return false不放行，不会执行controller中的方法。
2. postHandle是controller方法执行后执行的方法，在JSP视图执行前。
   1. 可以使用request或者response跳转到指定的页面
   2. 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
   3. postHandle方法是在JSP执行后执行
      3.afterCompletion是controller跳转的jsp页面都执行完成了，最后执行该方法
3. request或者response不能再跳转页面了

public class MyInterceptor2 implements HandlerInterceptor{
/**
* 拦截controller中方法。放行了，执行controller中方法。
* return true 方向
* return false 拦截
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object
handler) throws Exception {
System.out.println("拦截器preHandle方法执行了...");
// 手动跳转页面
// request.getRequestDispatcher("/index.jsp").forward(request,response);
// 拦截，不放行
//return false;
// 放行
return true;
}

/**
* controller方法执行后，要拦截的方法
* @param request
* @param response
* @param handler
* @param modelAndView
* @throws Exception
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object
handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle方法执行了...");
// 也是可以进行页面的跳转
request.getRequestDispatcher("/index.jsp").forward(request,response);
return;
}
/**
* controller跳转的jsp页面都执行完成了，最后执行该方法
* @param request
* @param response
* @param handler
* @param ex
* @throws Exception
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object
handler, Exception ex) throws Exception {
System.out.println("afterCompletion方法执行了...");
}
}

4. 配置多个拦截器

再编写一个拦截器的类

public class MyInterceptor3 implements HandlerInterceptor{
/**
* 拦截controller中方法。放行了，执行controller中方法。
* return true 方向
* return false 拦截
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object
handler) throws Exception {
System.out.println("MyInterceptor3的preHandle方法执行了...");
// 放行
return true;
}
/**
* controller方法执行后，要拦截的方法
* @param request
* @param response
* @param handler
* @param modelAndView
* @throws Exception
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object
handler, ModelAndView modelAndView) throws Exception {
System.out.println("MyInterceptor3的postHandle方法执行了...");
}
/**
* controller跳转的jsp页面都执行完成了，最后执行该方法
* @param request
* @param response
* @param handler
* @param ex
* @throws Exception
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object
handler, Exception ex) throws Exception {
System.out.println("MyInterceptor3的afterCompletion方法执行了...");
}
}

配置2个拦截器

<!‐‐配置拦截器们‐‐>
<mvc:interceptors>
<!‐‐配置拦截器‐‐>
<mvc:interceptor>
<!‐‐该拦截器拦截哪些资源‐‐>
<mvc:mapping path="/dept/**"/>
<!‐‐哪些资源不想拦截
<mvc:exclude‐mapping path="" />
‐‐>
<!‐‐拦截器对象‐‐>
<bean class="com.qcby.demo4.MyInterceptor2" />
</mvc:interceptor>
<!‐‐配置拦截器‐‐>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.qcby.demo4.MyInterceptor3" />
</mvc:interceptor>
</mvc:interceptors>