SpringMVC框架（二）

最新推荐文章于 2024-05-16 21:51:17 发布

沐暖沐

最新推荐文章于 2024-05-16 21:51:17 发布

阅读量838

点赞数 24

文章标签：大数据

本文链接：https://blog.csdn.net/weixin_47480200/article/details/135982463

版权

一、响应数据和结果视图

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

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

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

②返回值是void

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

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

③返回值是ModelAndView对象

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

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

/**
 * 返回String代替的mv对象
 * @return
 */
@RequestMapping("/save4.do")
public String save4(Model model){
    System.out.println("返回以Sting代替的mv对象执行了...");
    model.addAttribute("msg","返回以Sting代替的mv对象执行了...");
    return "suc";
}

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false"%>
<html>
<head>
    <title>成功</title>
</head>
<body>
成功了
<p>${msg}</p>
</body>
</html>

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

①forward请求转发

/**
 * 返回String
 * 请求转发
 * @return
 */
@RequestMapping("/save5.do")
public String save5(){
    System.out.println("请求转发执行了...");
    //request.getRequestDispatcher("/WEB-INF/pages/suc.jsp").forward(request,response);
    return "forward:/WEB-INF/pages/suc.jsp";
}

②redirect重定向

/**
 * 返回String
 * 重定向
 * @return
 */
@RequestMapping("/save6.do")
public String save6(){
    System.out.println("重定向执行了...");
    //response.sendRedirect("/suc.jsp");
    return "redirect:/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>
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.76</version>
</dependency>

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

标签配置不过滤

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

 <!-- 设置静态资源不过滤 -->
    <mvc:resources location="/css/" mapping="/css/**"/>  <!-- 样式 -->
    <mvc:resources location="/images/" mapping="/images/**"/>  <!-- 图片 -->
    <mvc:resources location="/js/" mapping="/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: "/user/save7.do",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"username":"haha","age":"20"}',
                    dataType: "json",
                    success:function(d){
                        // 编写很多代码
                        alert(d.username+" - "+d.age);
                    }
                });
            });
        });
    </script>
</head>
<body>

    <h3>返回值是String</h3>
    <a href="/user/save1.do" >返回String</a>

    <h3>返回值是void</h3>
    <a href="/user/save2.do" >返回void</a>

    <h3>返回值是ModelAndView</h3>
    <a href="/user/save3.do" >返回ModelAndView</a>

    <h3>返回值是String</h3>
    <a href="/user/save4.do" >返回值是String形式的ModelAndView</a>
    
    <h3>返回值是String</h3>
    <a href="/user/save5.do" >返回值是String</a>

    <h3>返回值是String</h3>
    <a href="/user/save6.do" >返回值是String</a>

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

</body>
</html>

controller代码编写

package com.qcby.controller;
import com.qcby.mapper.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {
    /**
     * 异步的数据交互
     * 重定向
     * @return
     */
    @RequestMapping("/save6.do")
    public @ResponseBody User save6(@RequestBody User user){
        System.out.println(user);

        // 模拟，调用业务层代码
        user.setUsername("hello");
        user.setAge(100);
        // 把user对象转换成json，字符串，再响应。使用@ResposeBody注解 response.getWriter().print()
        return user;
    }
}

实体类代码

package com.qcby.mapper;
import java.io.Serializable;

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="/fileupload.do" method="post" enctype="multipart/form-data">
        选择文件：<input type="file" name="upload" /><br/>
        <input type="submit" value="上传" />
    </form>
</body>
</html>

2. SpringMVC传统方式文件上传

配置文件解析器对象

<!--配置文件上传的解析器组件。id的名称是固定，不能乱写-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--设置上传文件的总大小 8M = 8 * 1024 * 1024 -->
        <property name="maxUploadSize" value="8388608" />
    </bean>
    <!--让映射器、适配器和处理器生效(默认不配置也是可以的)-->
    <mvc:annotation-driven/>

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

代码如下

package com.qcby.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.UUID;

@Controller
public class UploadController {
    /**
     * 文件上传
     * MultipartFile upload 文件上传解析器对象解析request后，文件上传对象
     * @return
     */
    @RequestMapping("/fileupload.do")
    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.mkdirs();
        }

        // 获取到上传文件的名称
        String filename = upload.getOriginalFilename();
        //字符串切割
        //String suffix = filename.substring(filename.lastIndexOf("."));
        // 把文件的名称修改成为一的值 sdfs-csdf-fwer-sdfw
        String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
        // 唯一的值
        filename = uuid+"_"+filename;
        System.out.println("文件名称："+filename);
        // 上传文件
        upload.transferTo(new File(file,filename));
        return "suc";
    }
}

三、SpringMVC的异常处理

1. 异常处理思路

Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进行异常的处理。

2. SpringMVC的异常处理

controller代码

package com.qcby.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 模拟异常
 */
@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 "suc";
         }
         */
    /**
     * 使用异常处理器方式
     * @return
     */
    @RequestMapping("/findAll.do")
    public String findAll(){
        System.out.println("执行了...");
        // 模拟异常
        int a = 10/0;
        return "suc";
    }
}

自定义异常类

package com.qcby.mapper;

/**
 *
 * 系统的异常类
 */
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;
    }
}

自定义异常处理器

package com.qcby.mapper;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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",e.getMessage());
        // 设置跳转的页面
        mv.setViewName("error");
        return mv;
    }
}

配置异常处理器

 <bean id="sysExceptionResolver" class="com.qcby.mapper.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. 拦截器的概述

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

2. 自定义拦截器步骤

controller中的方法

package com.qcby.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

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

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

package com.qcby.mapper;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 拦截器类
 */
public class MyInterceptor 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;
    }
}

在springmvc.xml中配置拦截器类

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

3. HandlerInterceptor接口中的方法

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

package com.qcby.mapper;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 拦截器类
 */
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("拦截器preHandle2方法执行了...");
        // 手动跳转页面
        // 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("postHandle2方法执行了...");
        // 也是可以进行页面的跳转
        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("afterCompletion2方法执行了...");
    }
}

3. 配置多个拦截器

再编写一个拦截器的类

package com.qcby.mapper;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 拦截器类
 */
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.mapper.MyInterceptor2" />
        </mvc:interceptor>

        <!--配置拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.qcby.mapper.MyInterceptor3" />
        </mvc:interceptor>
    </mvc:interceptors>

输出结果：

拦截器preHandle2方法执行了...

MyInterceptor3的preHandle方法执行了...

controller方法执行了...

MyInterceptor3的postHandle方法执行了...

postHandle2方法执行了...

MyInterceptor3的afterCompletion方法执行了...

afterCompletion2方法执行了...

沐暖沐

关注

24
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC框架（二）

SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器会按着定义的顺序执行。
复制链接

扫一扫