SpringMVC 参数接收处理和结果跳转处理

结果跳转方式

ModelAndView

设置ModelAndView对象，根据view的名称，和视图解析器跳到指定页面

页面 {视图解析器前缀} + viewName + {视图解析器后缀}

<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
    id="internalResourceViewResolver">
  <!-- 前缀 -->
  <property name="prefix" value="/WEB-INF/jsp/" />
  <!-- 后缀 -->
  <property name="suffix" value=".jsp" />
</bean>

对应的controller类

public class ControllerTest1 implements Controller {
  public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
      //返回一个模型视图对象
      ModelAndView mv = new ModelAndView();
      mv.addObject("msg","ControllerTest1");
      mv.setViewName("test");
      return mv;
  }
}

ServletAPI

通过设置ServletAPI，不需要视图解析器
- 通过HttpServletResponse 进行输出
- 通过HttpServletResponse 实现重定向
- 通过HttpServletResponse 实现转发 ```java @Controller public class ResultGo {
  
  @RequestMapping(“/result/t1”) public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException { rsp.getWriter().println(“Hello,Spring BY servlet API”); }
  
  @RequestMapping(“/result/t2”) public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException { rsp.sendRedirect(“/index.jsp”); }
  
  @RequestMapping(“/result/t3”) public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception { //转发 req.setAttribute(“msg”,”/result/t3”); req.getRequestDispatcher(“/WEB-INF/jsp/test.jsp”).forward(req,rsp); }

}

<a name="bZIYk"></a>
## SpringMVC
- 通过SpringMVC 来实现转发和重定向 - 无需视图解析器
   - 测试前将视图解析器注释掉
```java
@Controller
public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发
        return "/index.jsp";
    }
    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发二
        return "forward:/index.jsp";
    }
    @RequestMapping("/rsm/t3")
    public String test3(){
        //重定向
        return "redirect:/index.jsp";
    }
}

通过SpringMVC来实现转发和重定向 - 有视图解析器
- 重定向，不需要视图解析器，本质是重新请求一个新地址，注意路径问题。可以重定向到另外一个请求实现 ```java @Controller public class ResultSpringMVC2 { @RequestMapping(“/rsm2/t1”) public String test1(){ //转发 return “test”; }
  
  @RequestMapping(“/rsm2/t2”) public String test2(){ //重定向 return “redirect:/index.jsp”; //return “redirect:hello.do”; //hello.do为另一个请求/ }

}

<a name="y57gI"></a>
# 数据处理
<a name="3GstB"></a>
## 处理提交数据
<a name="v0QAV"></a>
### 提交的域名称和处理方法的参数名一致
- 提交数据 : http://localhost:8080/hello?name=xxx
- 处理方法
```java
@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

提交的域名称和处理方法的参数名不一致的情况

提交数据 : http://localhost:8080/hello?username=xxxxx

//@RequestParam("username") : username提交的域的名称 .  注解中声明接收提交的域的名称
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
  System.out.println(name);
  return "hello";
}

提交的是一个对象

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

实体类

public class User {
  private int id;
  private String name;
  private int age;
  //构造
  //get/set
  //tostring()
}

提交数据 : http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15

处理方法

@RequestMapping("/user")  // 这里通过url 进行get方式的传值到后端
public String user(User user){
  System.out.println(user);
  return "hello";
}

注意：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

数据显示到前端

第一种：通过ModelAndView

public class ControllerTest1 implements Controller {
  public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
      //返回一个模型视图对象
      ModelAndView mv = new ModelAndView();
      mv.addObject("msg","ControllerTest1");
      mv.setViewName("test");
      return mv;
  }
}

第二种：通过ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
  //封装要显示到视图中的数据
  //相当于req.setAttribute("name",name);
  model.addAttribute("name",name);
  System.out.println(name);
  return "hello";
}

第三种：通过Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
  //封装要显示到视图中的数据
  //相当于req.setAttribute("name",name);
  model.addAttribute("msg",name);
  System.out.println(name);
  return "test";
}

对比

Model 只有几个方法只适合用于存储数据，简化了新手对于Model对象的操作和理解
ModelMap继承了LinkedMap ，除了实现自身的一些方法，同样继承LinkedMap的方法和特性
ModelAndView 可以在存储数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

乱码问题

SpringMVC提供了一个过滤器，可以在web.xml 中配置

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

但是在极端情况下，这个过滤器对get请求的支持不太友好
- 处理方法，
  - 修改tomcat配置文件设置编码
```
<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
   connectionTimeout="20000"
   redirectPort="8443" />
```
  - 自定义过滤器 ```java package com.kuang.filter;

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中配置这个过滤器。

Java 测试

SpringMVC Review -Day04 结果跳转&数据处理