SMVC3: 页面跳转与数据传递

最新推荐文章于 2022-03-03 14:36:00 发布

云杉先生和他的鹿

最新推荐文章于 2022-03-03 14:36:00 发布

阅读量200

点赞数

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

本文链接：https://blog.csdn.net/qq_44700366/article/details/120479329

版权

SpringMVC 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring MVC中的页面跳转，包括视图解析器的作用、不使用视图解析器时的字符串拼接以及转发与重定向的区别和使用。同时，讲解了数据接收的三种方式：参数名一致、不一致以及对象参数。最后，讨论了数据回显的三种方法，并探讨了处理乱码问题的多种解决方案，包括自定义过滤器和Spring MVC内置过滤器的使用。

摘要由CSDN通过智能技术生成

3.1 页面跳转

3.1.1 简介

在使用转发与重定向之前，我们需要明白：什么是视图解析器。来自官方的官话，使得这个所谓的视图解析器看起来高深莫测，但实则不然。我们在配置springmvc-dao.xml文件时，需要配置一个视图解析器，而它主要有两个子标签： 前缀与后缀 。所以，所谓的视图解析器，主要就是一个字符串拼接而已。视图跳转有两种方式：forward与redirect 。

3.1.2 不使用视图解析器

springmvc-servlet.xml:

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

    <context:component-scan base-package="com.yun.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

</beans>

提示： 此处的xml配置文件没有配置视图解析器。

MyController.java:

package com.yun.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class MyController {

    @RequestMapping(value = "/rest/{a}/{b}",method = RequestMethod.GET)
    public String restFul(@PathVariable int a, @PathVariable int b, Model model){
        int result = a+b;
        model.addAttribute("res","参数结果"+result);
        return "/WEB-INF/jsp/restPage.jsp";
    }
}

提示： 当我们通过URL栏进入到此处之后，视图依旧能够跳转成功。而我们并没有在springmvc-servlet.xml中配置视图解析器。只是这个地方，我们将返回视图写死、写全了而已。由此可见，视图解析器主要负责的就是字符串的拼接。

3.1.3 转发与重定向的使用

1) 简介

转发与重定向，就是两个关键字而已：forward与redirect 。

2) 区别

转发，是将请求进行转发给一个新页面，新页面依旧处理同一个请求。重定向，是重新开启一个对象页面的请求。
转发时，URL地址栏会显示转发前的页面地址。重定向时，URL地址栏会显示新页面的地址。
转发速度比重定向更快，因为重定向需要重新发起请求。

3) 使用

package com.yun.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class MyController {

    @RequestMapping(value = "/rest/{a}/{b}",method = RequestMethod.GET)
    public String restFul(@PathVariable int a, @PathVariable int b, Model model){
        int result = a+b;
        model.addAttribute("res","参数结果"+result);
        return "restPage";
    }
}

重定向

package com.yun.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class MyController {

    @RequestMapping(value = "/rest/{a}/{b}",method = RequestMethod.GET)
    public String restFul(@PathVariable int a, @PathVariable int b, Model model){
        int result = a+b;
        model.addAttribute("res","参数结果"+result);
        return "redirect:/restPage";
    }
}

提示： 这里有些小细节要注意的是， return 返回视图的默认方式则是转发。当然，我们也可以显式使用forward关键字与redirect关键字。不过值得注意的是，当我们拥有视图解析器时，如果我们显式使用关键字，那么 视图跳转并不会走视图解析器 ，所以，此时我们需要手动写路径。并且，这种方式的重定向，似乎无法进入WEB-INF目录，但是转发可以。

3.2 数据接收与回显

3.2.1 数据接收

1) 简介

当我们使用控制器进行功能处理时，往往需要接收来自前端的数据。而对于前端数据接收有三种方式：参数名一致、参数名不一致、对象参数 。

2) 使用

参数名一致

DataController.java:

package com.yun.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class DataController {
    @GetMapping("/data")
    public String dateTest(String Name, Model model){
        model.addAttribute("data","输出结果是："+Name);

        return "forward:/index.jsp";
    }
}

index.jsp:

<%--
  Created by IntelliJ IDEA.
  User: yun
  Date: 2021/9/25
  Time: 13:40
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  $END ${data}
  </body>
</html>

<!--URL状态栏中输入，http://localhost:8080/SpringMVC_04_data_war_exploded/data?Name=张三-->

提示： 当我们在URL栏中输入相应的地址之后，我们只需要在访问 data 请求时，携带 Name=张三 这样的参数即可，达到向控制器传参的目的。但值得注意的是，此参数名字与控制器中方法参数的名字必须一致，否则传递失败。

参数名不一致

DataController.java:

package com.yun.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class DataController {
    @GetMapping("/data")
    public String dateTest(@RequestParam("testName") String Name, Model model){
        model.addAttribute("data","输出结果是："+Name);

        return "forward:/index.jsp";
    }
}
<!--URL状态栏中输入，http://localhost:8080/SpringMVC_04_data_war_exploded/data?testName=张三-->

提示： 当前端参数名与后端控制器方法参数名不一致时，我们可以通过 RequestParam 注解来解决问题。相当于起了一个别名，但是，在进行传参是，前端参数名必须是别名，不能够是后端原来的参数名。

对象传递

User.java:

package com.yun.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private int gender;
}

DataController.java:

package com.yun.controller;

import com.yun.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class DataController {
    @GetMapping("/data")
    public String dateTest(User user, Model model){
        model.addAttribute("data","输出结果是："+user.toString());

        return "forward:/index.jsp";
    }
}
<!--URL状态栏中输入，http://localhost:8080/SpringMVC_04_data_war_exploded/data?id=1&gender=1&name=李四-->

提示： 所谓的对象参数，其实并不是指前端传一个对象过来，而是，后端将前端的数据看作对象来接收。使用这个方法，必须满足：前端参数名必须与后端对象参数的属性名一致。否则，对象参数接收不到数据。当然，只需要名字一致即可，并不要求数据。

3.2.2 数据回显

1) 简介

所谓的数据回显，就是把数据传递出去。而对于数据回显来说，也有三种方法。当我们向前端传递数据之后，有三个对象可以使用：Model、ModelMap、ModelAndView 。

2) 区别

Model只有几个方法可以使用，但是操作比较简单，更容易理解。
ModelMap继承了LinkedMap，除了拥有Model的方法之外，还拥有LinkedMap的方法与特性。
ModelAndView不仅可以存储数据，还可以设置返回的视图逻辑。

3.3 乱码处理

3.3.1 环境

index.jsp:

<%--
  Created by IntelliJ IDEA.
  User: yun
  Date: 2021/9/25
  Time: 13:40
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <form action="${pageContext.request.contextPath}/data" method="get">
    <input type="text" name="testName"/>
    <input type="submit" value="提交"/>
  </form>
  </body>
</html>

提示： 这里的 action 值最好写上 ${pageContext.request.contextPath} ，然后再跟上自己的控制器，否则如果使用tomcat时，给项目配置了站点，那么访问路径就不再是 localhost:8080/ ，而是 localhost:8080/站点名/ 。那么此时，表单极有可能找不到请求路径。

DataController.java:

package com.yun.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class DataController {

    @RequestMapping("/data")
    public String dateTest(@RequestParam("testName") String Name, Model model){
        model.addAttribute("data",Name);

        return "result";
    }
}

reuslt.jsp:

<%--
  Created by IntelliJ IDEA.
  User: yun
  Date: 2021/9/25
  Time: 14:37
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>结果页面</title>
</head>
<body>
${data}
</body>
</html>

总结： 使用上述代码，可能会出现中文乱码的问题，但是也不一定，目前我的设备并没有出现乱码。

解决方案:

自定义过滤器（不一定有用，并没有测试）

package com.yun.filter;

import javax.servlet.*;
import java.io.IOException;

public class EncodingFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("UTF-8");
        servletResponse.setCharacterEncoding("UTF-8");
        
        filterChain.doFilter(servletRequest,servletResponse);
    }

    public void destroy() {

    }
}

web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <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:springmvc-servlet.xml</param-value>
        </init-param>

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

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>EncodingFilter</filter-name>
        <filter-class>com.yun.filter.EncodingFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>EncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

SpringMVC过滤器（大多数情况是有用的）

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <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:springmvc-servlet.xml</param-value>
        </init-param>

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

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

如果Spring的过滤器依旧没有，则查看Tomcat配置文件

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

终极解决方案，大神自定义过滤器

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
* 解决get和post请求 全部乱码的过滤器
*/
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       // 对request包装增强
       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);
  }

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
  }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;
   //是否编码的标记
   private boolean hasEncode;
   //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
   public MyRequest(HttpServletRequest request) {
       super(request);// super必须写
       this.request = request;
  }

   // 对需要增强方法 进行覆盖
   @Override
   public Map getParameterMap() {
       // 先获得请求方式
       String method = request.getMethod();
       if (method.equalsIgnoreCase("post")) {
           // post请求
           try {
               // 处理post乱码
               request.setCharacterEncoding("utf-8");
               return request.getParameterMap();
          } catch (UnsupportedEncodingException e) {
               e.printStackTrace();
          }
      } else if (method.equalsIgnoreCase("get")) {
           // get请求
           Map<String, String[]> parameterMap = request.getParameterMap();
           if (!hasEncode) { // 确保get手动编码逻辑只运行一次
               for (String parameterName : parameterMap.keySet()) {
                   String[] values = parameterMap.get(parameterName);
                   if (values != null) {
                       for (int i = 0; i < values.length; i++) {
                           try {
                               // 处理get乱码
                               values[i] = new String(values[i]
                                      .getBytes("ISO-8859-1"), "utf-8");
                          } catch (UnsupportedEncodingException e) {
                               e.printStackTrace();
                          }
                      }
                  }
              }
               hasEncode = true;
          }
           return parameterMap;
      }
       return super.getParameterMap();
  }

   //取一个值
   @Override
   public String getParameter(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
      }
       return values[0]; // 取回参数的第一个值
  }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
  }
}

提示： 记得在web.xml文件中，注册该过滤器。

你只看到有些人表面上风光无限，却不知道，他们在背地里，也是顺风顺水呢。

云杉先生和他的鹿

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SMVC3: 页面跳转与数据传递

3.1 页面跳转3.1.1 简介在使用转发与重定向之前，我们需要明白：什么是视图解析器。来自官方的官话，使得这个所谓的视图解析器看起来高深莫测，但实则不然。我们在配置springmvc-dao.xml文件时，需要配置一个视图解析器，而它主要有两个子标签：前缀与后缀。所以，所谓的视图解析器，主要就是一个字符串拼接而已。视图跳转有两种方式：forward与redirect 。3.1.2 不使用视图解析器springmvc-servlet.xml:<?xml version="1.0" e
复制链接

扫一扫

专栏目录