SpringMVC数据处理及跳转

1、ModelAndView（视图解析器）

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

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

在Spring核心配置文件中：

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>

对应的Controller类

这种方式的返回值为ModelView类型：

        //访问地址：http://localhost:8080/t1
        @RequestMapping("/t2")//请求地址
        public ModelAndView test2(){
    
    
            ModelAndView modelAndView=new ModelAndView("test");
            modelAndView.addObject("msg","ControllerTest1test2");
            return modelAndView;//返回值会的name属性被交给视图解析器处理并拼接为WEB-INF/jsp/test.jsp
        }
        //访问地址：http://localhost:8080/t2

测试：

2、使用ServletAPI

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

@Controller
public class ServletGo {
    
    
    //输出
    @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");//url是相对于当前web项目的地址
    }

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

输出：

重定向：

转发：

3、使用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";
  }
}

转发：

转发2：

重定向：

通过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为另一个请求/
    }
}

转发：

重定向：

4、数据处理

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

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

Controller：

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    //localhost：8080/user/t1?name=xxx;
    @GetMapping("/t1")
    public String test1(String name,Model model){
    
    
        //1.接收前端参数
        System.out.println("接收到前端的参数为："+name);
        //2.将返回的结果转给前端
        model.addAttribute("msg",name);
        //视图跳转
        return "test";
    }
}

测试：

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

提交数据：http://localhost:8080/user/t2?username=test2
（使用@RequestParam解决）
Controller:

//localhost：8080/user/t1?username=xxx;
@GetMapping("/t2")
//提交域名称称与处理方法参数名称不同时
public String test2(@RequestParam("username") String name, Model model){
    
    
    //1.接收前端参数
    System.out.println("接收到前端的参数为："+name);
    //2.将返回的结果转给前端
    model.addAttribute("msg",name);
    //视图跳转
    return "test";
}

测试：

3.提交的是一个对象

首先前端提交的url地址中的参数名称必须和后端提交的对对象的属性相对应否则将匹配不到、

实体类：这里的属性必须与前端的请求地址中的参数相对应

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

//前端接收的是一个对象：id，name，age
@GetMapping("/t3")
/*
* 1.接收前端传递的参数，判断参数名称，假设名字在方法上，可以直接使用。
* 2.假设传递的是一个User，匹配对象名，如果名字一致则OK，否则匹配不到，
* 这里要保证前端传递的参数名称必须和后端接收对象中的属性保持一致如果不一致则接收不到值
* */
public String test3(User user, Model model){
    
    
    System.out.println(user);
    return "test";
}

测试：

后端接收：
当前端与后端参数不对应时后端无法接收参数：
前端参数为：id1 后端参数为：id

会出现接收不到参数的情况：
int接收不到显示0 String接收不到显示null

5、数据显示到前端

第一种 : 通过ModelAndView

我们前面一直都是如此 . 就不过多解释

public class ControllerTest1 implements Controller {
    
    

   public ModelAndView handleRequest(HttpServletRequesthttpServletRequest, HttpServletResponse httpServletResponse) throwsException {
    
    
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest1");
       mv.setViewName("test");
       return mv;
  }
}

第二种 : 通过ModelMap

ModelMap

@Controller
public class Hello {
    
    
    @RequestMapping("/hello")
    public String hello(@RequestParam("username") String name, ModelMap map){
    
    
        //封装要显示到视图的数据：
        map.addAttribute("name",name);
        System.out.println("从前端接收的参数为："+name);
        return "hello";
    }

第三种 : 通过Model

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

6、乱码问题解决

测试步骤：

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

<form action="/e/t" method="post">
 <input type="text" name="name">
 <input type="submit">
</form>

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

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

input标签输入中文发现跳转过程中发现页面出现乱码：

解决办法：

方式一：

在web.xml中添加：

<!--配置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>

方式二：
添加自定义过滤器
新建filter包：添加类：GenericEncodingFilter

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;

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>filterEncoding</filter-name>
        <filter-class>com.he.filter.GenericEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>filterEncoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

测试：

控制台输出：

总结：一般情况下乱码问题可以通过配置SpringMVC的乱码过滤器解决，当乱码过滤器无法解决时可使用第二种方式解决。