spring支持的桌面 spring页面

这里整理一下Spring框架下，如何获取页面参数，以及如何将后台数据传到页面，最后是了解重定向的使用。前期的配置参考文末第一篇博文，这里添加一个登陆的界面，用于测试向页面传递参数，以及登陆完成后结果界面两个（成功界面和失败界面），其他就是添加一个控制器，往里面添加方法进行测试了。

测试页面准备

登陆界面

1 <%@page pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
 2 <!-- 通过httpServletRequest的方式获取页面参数 -->
 3 <!--  <form action="loginOK.do" method="GET" />-->
 4 <!-- 测试通过注解方式提交 -->
 5 <!-- <form action="loginOK_annotation.do" method="GET"> -->
 6 <!-- 通过javabean的方式 -->
 7 <!--   <form action="loginOK_javabean.do" method="GET"> -->
 8 <!-- 向页面传值测试 -->
 9 <!--  <form action="loginOK_param.do" method="GET">-->
10 <!-- 使用ModelAndView向页面传值 -->
11 <!--  form action="loginOK_ModelAndView.do" method="GET">-->
12 <!-- 使用ModelMap向页面传值 -->
13  <!--  <form action="loginOK_ModelMap.do" method="GET">-->
14 <!-- 使用session向页面传值 -->
15  <!--  <form action="loginOK_session.do" method="GET">-->
16 <!-- 如果方法的返回值是String,重定向写法 -->
17 <!--  form action="loginOK_redirect_str.do" method="GET">-->
18 <!-- 如果方法的返回值是ModelAndView,则需要先创建RedirectView，然后创建ModelAndView -->
19 <!-- <form action="loginOK_redirect_mm.do" method="GET"> -->
20 <input type="text" name="user"/>用户名 <br/>
21 <input type="password" name="pwd" />密码 <br/>
22 <button>登录</button>
23 </form>

登陆成功界面

1 <%@page pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
2 <h1>欢迎登陆</h1><br/>
3 <!-- 得到服务器返回的user参数，采用el表达式获取 -->
4 ${user }

登陆失败界面

1 <%@page pageEncoding="utf-8" contentType="text/html; charset=utf-8"%>
2 <h1>登陆失败</h1>

获取页面参数

方式1：通过request来获得，在前端控制器方法里添加HttpServletRequest类型的参数request，通过java反射机制，在调用方法前会检查参数类型，从而将request传入到服务器，可以获取request里面的参数

1 /**
 2      *登录检查
 3      * @return
 4      */
 5     @RequestMapping("/login.do")
 6     public String login() {
 7         System.out.println("跳转到登陆页面");
 8         return "login";
 9         
10     }
11     /**
12      * 获取页面参数值，进行登陆检查
13      * 登录时如何获取浏览器发送给服务器的参数呢，可以在logincheck里加参数HttpServletRequest
14      * DispatcherServlet前端控制器在调用处理器方法之前，会利用java反射机制分析方法的结构，如下方法
15      * 会通过分析，将request对象传过来
16      * @return
17      */
18     @RequestMapping("/loginOK.do")
19     public String logincheck(HttpServletRequest request) {
20         System.out.println("使用httpServletRequest的方式获取");
21         String name=request.getParameter("user");
22         String pwd=request.getParameter("pwd");
23         System.out.println("name是："+name);
24         System.out.println("pwd是："+pwd);
25         //模拟DAO检查数据库
26         loginDAO DAO=new loginDAO();
27         int result=DAO.loginCheck();
28         if(result>0) {
29             return "loginOK";
30         }else {
31             return "loginNG";
32         }            
33     }

测试结果

控制台

方式2：通过@RequestParam注解的方式，适合少量请求参数

1     /**
 2      * 通过注解方式获取参数，适合少量参数
 3      * @return
 4      */
 5     @RequestMapping("/loginOK_annotation.do")
 6     /*
 7      * JSP表单提交给服务器时，DispatherServlet在方法执行之前扫描里面的参数，发现有和JSP表单中同名的
 8      * user和pwd，这样会调用request.getParameter("user")和request.getParameter("pwd")方法
 9      * 得到参数。如果user和pwd和JSP表单中写的不一样怎么办？可以通过加注解@RequestParam("")来解决
10      * 如下，表单中提交的是pwd对应的参数，在注解里加上pwd即可
11      * 
12      * 建议参数前加上注解@RequestParam
13      */
14     public String login_annotation(String user,@RequestParam("pwd") String password) {
15       System.out.println("通过注解的方式获取参数");
16       System.out.println("用户名是："+user);
17       System.out.println("密码是："+password);
18         return "loginOK";
19     }

测试结果

控制台

方式3：将要请求的参数封装成javabean，适合大量请求参数，这里写一个javabean。

javabean

1 package Controller;
 2 /**
 3  * 用于封装请求参数值的类，属性名和请求参数名一致，类型要匹配，并提供参数get set方法
 4  * （如果类型不一样，会自动做类型转换，比如将string类型自动转化为int类型）
 5  * 
 6  * @author yangchaolin
 7  *
 8  */
 9 public class userParam {
10     private String user;
11     private String pwd;
12     private int age;
13     //get set方法
14     public int getAge() {
15         return age;
16     }
17     public void setAge(int age) {
18         this.age = age;
19     }
20     public String getUser() {
21         return user;
22     }
23     public void setUser(String user) {
24         this.user = user;
25     }
26     public String getPwd() {
27         return pwd;
28     }
29     public void setPwd(String pwd) {
30         this.pwd = pwd;
31     }    
32 }

View Code

1     /**
 2      * 通过javabean的方式获取参数，适合大量参数
 3      * DispatcherServlet在方法执行之前会检查userParam类型的参数，发现里面有和JSP提交name相同的属性名
 4      * 则会将参数set到userParam对象中，然后通过类的get方法可以得到用户名和密码
 5      * @return
 6      */
 7     @RequestMapping("/loginOK_javabean.do")
 8     public String login_javabean(userParam up) {
 9         System.out.println("通过javabean的方式获取参数");
10         System.out.println("用户名是："+up.getUser());
11         System.out.println("密码是："+up.getPwd());
12         System.out.println("年龄是："+up.getAge());
13         return "loginOK";
14     }

测试结果

控制台

向页面传值

方式1 将数据绑定在request里，默认情况下DispatcherServlet会使用转发。

1     /**
 2      * 通过httpServletRequst向页面传值
 3      * @param up
 4      * @param request
 5      * @return
 6      */
 7     @RequestMapping("/loginOK_param.do")
 8     public String login_param(userParam up,HttpServletRequest request) {
 9         System.out.println("使用Request向页面传递参数");
10         System.out.println("用户名是："+up.getUser());
11         System.out.println("密码是："+up.getPwd());    
12         //将数据绑定到request，再转发JSP
13         request.setAttribute("user", up.getUser());
14         //默认情况下DispatcherServlet会使用转发
15         return "loginOK";
16     }

测试结果

控制台

方式2 返回ModleAndView对象，里面可以有包含数据的Map

1     /**
 2      * 使用ModelAndView的方式给页面传值
 3      * @return
 4      */
 5     @RequestMapping("/loginOK_ModelAndView.do")
 6     public ModelAndView login_modelAndView(userParam up) {
 7         System.out.println("使用ModelAndView向页面传递参数");
 8         String user=up.getUser();
 9         System.out.println("用户名是："+user);        
10         //1 将数据添加到map对象
11         Map<String,Object> map=new HashMap<String,Object>();
12         //map中数据会绑定到请求request中，相当于执行了request.setAttribute("user",user)
13         map.put("user", user);
14         //2 将数据对象map放到ModelAndView中 ,并返回
15         return new ModelAndView("loginOK",map);        
16     }

测试结果

控制台

方式3 将数据添加到ModelMap里

1     /**
 2      * 使用ModelMap向页面传值
 3      * @return
 4      */
 5     @RequestMapping("/loginOK_ModelMap")
 6     public String login_modelMap(userParam up,ModelMap mm) {
 7         System.out.println("使用ModelMap向页面传递参数");
 8         String user=up.getUser();System.out.println("user为："+user);
 9         mm.addAttribute("user", user);
10         return "loginOK";    
11     }

测试结果

控制台

方式4 将数据绑定到session里

1     /**
 2      * 测试使用session向页面传值，使用反射，将HttpSession放到方法里
 3      * 前端控制前在调用这个方法之前会检查方法里的参数，发现有session
 4      * 会把session对象传进来，会提前执行request.getSession()得到session然后传入到参数里
 5      * @param up
 6      * @param session
 7      * @return
 8      */
 9     @RequestMapping("loginOK_session.do")
10     public String login_session(userParam up,HttpSession session) {
11         System.out.println("使用session向页面传递参数");
12         session.setAttribute("user", up.getUser());        
13         return "loginOK";        
14     }

测试结果

在满足使用条件的情况下，优先使用生命周期短的，如request，可以节省内存资源，session的生命周期最长，最后考虑。

重定向

重定向执行了两次请求，最后面看到的是重定向后的地址。

case1 如果方法的返回值是String，方法return "redirect:login.do"

1     /**
 2      * 重定向，返回值是string的情况
 3      * @param up
 4      * @return
 5      */
 6     @RequestMapping("loginOK_redirect_str.do")
 7     public String login_redirect_str(userParam up) {
 8         System.out.println(up.getUser());
 9         System.out.println("页面提交后重定向到登录页面");
10         //重定向
11         return "redirect:login.do";        
12     }

控制台

case2 如果方法的返回值是ModelAndView，首先创建RedirectView rv=new RedirectView("login.do")，再创建ModelAndView mm=new ModelAndView(rv)返回到前端控制器;

1     /**
 2      * 重定向，返回值是ModelAndView的情况
 3      * @return
 4      */
 5     @RequestMapping("loginOK_redirect_mm.do")
 6     public ModelAndView login_redirect_mm() {
 7         System.out.println("页面提交后重定向到登录页面-ModelAndView");
 8         //先创建RedirectView,再创建ModelAndView
 9         RedirectView rv=new RedirectView("login.do");
10         ModelAndView mm=new ModelAndView(rv);
11         return mm;        
12     }

控制台