【SpringMVC 笔记】结果跳转、数据处理、乱码问题

怼烎@ 2023-02-17 02:33 103阅读 0赞

### 结果跳转和数据处理 ###

*  结果跳转方式
 *   *  ModelAndView
     *  Servlet API
     *  SpringMVC — 无视图解析器
     *  SpringMVC — 有视图解析器
 *  处理提交数据
 *   *  1、提交的域名称和处理方法的参数名一致
     *  2、提交的域名称和处理方法的参数名不一致
     *  3、提交的是一个对象
 *  数据显示到前端
 *   *  通过 ModelAndView
     *  通过 ModelMap
     *  通过 Model
     *  三者对比
 *  乱码问题
 *   *  SpringMVC 提供的过滤器
     *  自定义过滤器

> 更多内容参见 SpringMVC 学习笔记目录：[【Spring MVC】学习笔记汇总][Spring MVC]

# 结果跳转方式 #

## 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 org.springframework.web.servlet.mvc.Controller { 
    
        @Override
        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { 
            // 返回一个模型视图对象
            ModelAndView mv = new ModelAndView();
            mv.addObject("msg", "ControllerTest1");
            mv.setViewName("test");
            return mv;
        }
    }

## Servlet API ##

通过设置 `ServletAPI`，**不需要视图解析器**。

*  通过 `HttpServletResponse` 进行 **输出**
 *  通过 `HttpServletResponse` 实现 **重定向**
 *  通过 `HttpServletResponse` 实现 **转发**

@Controller
    public class ResultGo { 
        @RequestMapping("/result/t1")
        public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException { 
            // ServletAPI 进行输出
            rsp.getWriter().println("Hello, SpringMVC 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);
        }
    }

## SpringMVC — 无视图解析器 ##

通过 SpringMVC 来实现转发和重定向（**无需视图解析器**）。

测试前，首先将视图解析器注释掉。

@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 — 有视图解析器 ##

通过 SpringMVC 来实现转发和重定向（**需要视图解析器**）；

重定向不需要视图解析器，本质就是重新请求一个新地方，所以注意路径问题。

不一定要重定向到某个页面，也可以重定向到另外一个请求实现。

@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 为另一个请求
        }
    }

# 处理提交数据 #

## 1、提交的域名称和处理方法的参数名一致 ##

提交数据 : `http://localhost:8080/hello/h1?name=zhenyu`

@RequestMapping("/hello/h1")
    // 提交的域名称和处理方法的参数名一致
    public String hello(String name) { 
        System.out.println(name);
        return "hello";
    }

## 2、提交的域名称和处理方法的参数名不一致 ##

提交数据：`http://localhost:8080/hello/h2?username=zhenyu`

@RequestMapping("/hello/h2")
    // 提交的域名称和处理方法的参数名不一致
    public String hello2(@RequestParam("username") String name) { 
        System.out.println(name);
        return "hello";
    }

## 3、提交的是一个对象 ##

提交数据：`http://localhost:8080/user/u1?id=1&name=zhenyu&age=21`

实体类：

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

提交方法：

@RequestMapping("/u1")
    public String user(User user) { 
        System.out.println(user);
        return "hello";
    }

# 数据显示到前端 #

## 通过 ModelAndView ##

利用 `ModelAndView` 的 `addObject` 方法：

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

利用 `ModelMap` 的 `addAttribute` 方法：

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

利用 `Mode` 的 `addAttribute` 方法：

@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 在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

> 请使用 80% 的时间打好扎实的基础，剩下 18% 的时间研究框架，2% 的时间去学点英文，框架的官方文档永远是最好的教程！

# 乱码问题 #

## SpringMVC 提供的过滤器 ##

解决乱码问题：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 配置文件，设置编码：

或者可以在代码中放入如下的 **自定义过滤器**：

## 自定义过滤器 ##

package com.yusael.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` 中配置这个过滤器即可。

<filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.yusael.filter.GenericEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

这是网上大神写的，一般情况下，SpringMVC 默认的乱码处理已经足够了。

[Spring MVC]: https://blog.csdn.net/weixin_43734095/article/details/106798883