学习SpringMVC的第四天——＞SpringMVC-04-数据处理以及跳转

4、数据处理及跳转

4.1、结果跳转方式

4.1.1、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 request, HttpServletResponse response) throws Exception {
         //返回一个模型视图对象
         ModelAndView mv = new ModelAndView();
         mv.addObject("msg","ControllerTest1");
         mv.setViewName("test");
         return mv;
    }
  }
  

4.1.2、ServletAPI

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

1. 通过HttpServletResponse进行输出

2. 通过HttpServletResponse实现重定向

3. 通过HttpServletReques实现请求转发

   @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);
     }
   
   }
   

4.1.3、SpringMVC

1. 通过SpringMVC来实现转发和重定向 - 无需视图解析器；

   如果已经设置了视图解析器，可以将它注释掉

   @Controller
   public class ModelTest01 {
   
       /**
        * 在没有视图解析器的情况下，怎么做？
        */
   
       @RequestMapping("m1/t1")
       public String test1(Model model){
           // 请求转发 全限定名
           model.addAttribute("msg","test01");
           return "/WEB-INF/jsp/test01.jsp";
       }
   
       @RequestMapping("m1/t2")
       public String test2(Model model){
           model.addAttribute("msg","test02");
           // 请求转发
           return "forward:/WEB-INF/jsp/test01.jsp";
       }
   
       @RequestMapping("m1/t3")
       public String test3(Model model){
           model.addAttribute("msg","test03");
           // 重定向
           return "redirect:/index.jsp";
       }
   }
   

2. 通过SpringMVC来实现转发和重定向 - 有视图解析器；

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

   @Controller
   public class ModelTest02 {
      @RequestMapping("/m2/t1")
      public String test1(){
          //转发
          return "test";
     }
   
      @RequestMapping("/m2/t2")
      public String test2(){
          //重定向
          return "redirect:/index.jsp";
     }
   
   }
   

4.2、数据处理

4.2.1、处理提交数据

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

   提交数据 : http://localhost:8080/user/t1?name=zhangsan

   @RequestMapping("user/t1")
   public String test01(Model model,String name){
       // 1. 接收前端传来的数据
       String rName = name;
       System.out.println("name>"+name); // name>zhangsan
       // 2. 将返回的结果传递给前端
       model.addAttribute("msg",rName);
       // 3. 页面跳转
       return "test01";
   }
   

   后台输出：name>>zhangsan

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

   提交数据 : http://localhost:8080/user/t2?username=zhangsan

   @RequestMapping("user/t2")
   public String test02(Model model,@RequestParam("username") String name){
       // 1. 输出前端传来的数据
       System.out.println("name>>"+name); // name>>zhangsan
       // 2. 将返回的结果传递给前端
       model.addAttribute("msg",name);
       // 3. 页面跳转
       return "test01";
   }
   

   后台输出 ：name>>zhangsan

3. 提交的是一个对象

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

   1. 实体类

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

   2. 提交数据 : http://localhost:8080/user/t3?name=ww&id=1&age=15

   3. 处理方法：

      @RequestMapping("user/t3")
      public String test03(User user){
          // 1. 接收前端传来的数据
          System.out.println("user>>>>>>"+user); 
          // 2. 页面跳转
          return "test01";
      }
      

      后台输出：User{id=1,name=‘ww’,age=15}

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

4.2.1、数据显示到前端

1. 第一种：通过ModelAndView

   我们之前使用的一直都是这种方式。

   // 实现Controller接口的类即获得控制器功能
   public class ControllerTest01 implements Controller {
       // 返回一个视图
       public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
           ModelAndView mv = new ModelAndView();
           mv.addObject("msg","ControllerTest01");
           mv.setViewName("test01");
           return mv;
       }
   }
   

2. 第二种：通过ModelMap

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

3. 第三种：通过Model

   @RequestMapping("t1")
   public String test1(Model model){
       model.addAttribute("msg","ControllerTest03");
       return "test01";
   }
   

4. 对比

   就对于新手而言简单来说使用区别就是：

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

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

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

4.3、乱码问题

测试步骤：

1、我们可以在首页编写一个提交的表单

<form action="/test/t1" method="post">
 <input type="text" name="name">
 <input type="submit">
</form>

2、后台编写对应的处理类

@Controller
public class Encoding {
   @RequestMapping("/t1")
   public String test(Model model,String name){
       model.addAttribute("msg",name); //获取表单提交的值
       return "test"; //跳转到test页面显示输入的值
  }
}

3、输入中文测试，发现乱码

不得不说，乱码问题是在我们开发中十分常见的问题，也是让我们程序猿比较头大的问题！

以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 .

修改了xml文件需要重启服务器！

<!--2.配置SpringMVC的乱码过滤-->
<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>

其中init-param 标签中的 encoding，该encoding属性是在CharacterEncodingFilter类中的属性

但是我们发现 , 有些极端情况下.这个过滤器对get的支持不好 .

处理方法 :

1. 修改tomcat配置文件 ：设置编码！

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

2. 自定义过滤器

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

这个也是我在网上找的一些大神写的，一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了！

然后在web.xml中配置这个过滤器即可！

乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

————————————————to be continue————————————————