SSH框架之Struts2第二篇

1.2 知识点
        1.2.1 Struts2的Servlet的API的访问
            1.2.1.1 方式一 : 通过ActionContext实现
                页面：
                <h1>Servlet的API的访问方式一：解耦合的方式</h1>
                <form action="${ pageContext.request.contextPath }/requestDemo1.action" method="post">
                    姓名：<input type="text" name="name"/><br/>
                    年龄：<input type="text" name="age"><br/>
                    <input type="submit" value="提交">
                </form>
                编写Action
                /**
                 * Servlet的API的访问方式一：解耦合的方式
                 *     * 只能用于接收参数 和 操作域中的数据
                 * @author jt
                 */
                public class RequestDemo1Action extends ActionSupport{

                    @Override
                    public String execute() throws Exception {
                        // 接收数据：
                        /**
                         * 在ActionContext中提供了一些方法:操作域对象的数据
                         *     * Map<String,Object> getParameters();
                         *     * Map<String,Object> getSession();
                         *  * Map<String,Object> getApplication();
                         */
                        // 接收参数:
                        ActionContext actionContext = ActionContext.getContext();
                        Map<String,Object> map = actionContext.getParameters();
                        for (String key : map.keySet()) {
                            String[] arrs = (String[]) map.get(key);
                            System.out.println(key+"    "+Arrays.toString(arrs));
                        }
                        // 向request域中存值：
                        actionContext.put("reqName", "req如花");

                        // 向session域中存值:
                        actionContext.getSession().put("sessName", "sess凤姐");

                        // 向application域中存值：
                        actionContext.getApplication().put("appName","app石榴");
                        return SUCCESS;
                    }
                }

            1.2.1.2 方式二: 实现特定接口的方式实现:
                在struts中提供了一些接口 : ServletRequestAware,ServletResponseAware,ServletContextAware;
                页面：
                <h1>Servlet的API的访问方式二：实现特定接口的方式</h1>
                <form action="${ pageContext.request.contextPath }/requestDemo2.action" method="post">
                    姓名：<input type="text" name="name"/><br/>
                    年龄：<input type="text" name="age"><br/>
                    <input type="submit" value="提交">
                </form>

                编写Action:
                /**
                 * Servlet的API的访问方式二：
                 * @author jt
                 *
                 */
                public class RequestDemo2Action extends ActionSupport implements ServletRequestAware,ServletContextAware{

                    private HttpServletRequest request;
                    private ServletContext application;

                    @Override
                    public String execute() throws Exception {
                        // 接收数据：使用request对象。
                        Map<String, String[]> parameterMap = request.getParameterMap();
                        for (String key : parameterMap.keySet()) {
                            String[] arrs = parameterMap.get(key);
                            System.out.println(key+"   "+Arrays.toString(arrs));

                        }
                        // 向域中保存数据；
                //        向request域中保存数据
                        request.setAttribute("reqName", "r郝三");
                         // 向session域中保存数据
                        request.getSession().setAttribute("sessName", "s李四");
                        // 向application域中保存数据
                        application.setAttribute("appName", "a王五");
                        return NONE;
                    }

                    @Override
                    public void setServletRequest(HttpServletRequest request) {
                        this.request =  request;
                    }

                    @Override
                    public void setServletContext(ServletContext application) {
                        this.application = application;
                    }
                }
            1.2.1.3方式 : 通过ServletActionContext对象的静态方法实现 :
                页面:
                <h1>Servlet的API的访问方式三：通过ServletActionContext对象静态方法获取</h1>
                <form action="${ pageContext.request.contextPath }/requestDemo3.action" method="post">
                    姓名：<input type="text" name="name"/><br/>
                    年龄：<input type="text" name="age"><br/>
                    <input type="submit" value="提交">
                </form>
                编写Action:
                /**
                 * Servlet的API访问方式三：通过ServletActionContext的静态方法访问
                 * @author jt
                 *
                 */
                public class RequestDemo3Action extends ActionSupport {
                    public String execute() throws Exception {
                        //接收参数:
                        /*
                        ServletActionContext 在struts2的API中的 :
                        HttpServletRequest getRequest();
                        HttpServletResponse getResponse();
                        ServletContext getServletContext();

                        */
                        HttpServletRequest request = ServletActionContext.getRequest();
                        Map<String,String[]> parameterMap = request.getParameterMap();
                        for(String key : parameterMap.get()) {
                            String[] value = parameterMap.get(Key);
                            System.out.println(key + "  " + Arrays.toString(value));
                        }

                        //向域中存值 :
                        request.setAttribute("reqName" , "用request向域中存数据");
                        request.getSession.setAttribute("session","向session域中存数据");
                        ServletActionContext.getServletContext().setAttribute("ServletContext","向ServletContext域中存储数据");
                        return super.execute();

                    }
                }

            1.2.2.1 :结果页面的分类 :
                全局结果页面 :
                    针对一个包下所有的action都生效的一个页面.
                    <!--全局结果页面-->
                    <global-results>
                        <result>/jsp/1.jsp</result>
                    </global-results>
                局部结果页面 :
                    针对某一个action生效的一个页面 :
                    <action name="requestDemo1" class="com.baidu.struts2.demo1.ActionDemo1">
                    <result>/jsp/1.jsp</result>
                    </action>

            1.2.2.2 配置结果页面 :
                <result>标签配置:
                    name : 逻辑视图的名称.默认值是success.
                    type :
                        dispatcher         : 默认值,转发.(转发到jsp的页面)
                        redirect         : 重定向.(重定向到JSP的页面),被跳转的页面中丢失传递的信息.
                        chain               : 转发到另一个Action.
                        redirectAction  : 重定向到另一个Action.跳转的页面中丢失传递的信息
                        stream             : 文件的下载

            1.2.2.3 Struts2的多例性 :
                    原来的Servlet是单例存在,多次请求,请求都是同一个Servlet的实例.Struts2中Action是多实例的.有异常请求就会有一个Action的实例.
                现在可以在Action中定义成员属性了.

                大部分我们会优先使用模型驱动的方式，因为Struts2内部有很多结果是围绕模型驱动设计的。但如果页面向多个对象中封装，那么就需要使用属性驱动的方式二了。
                这些都是像某个对象中封装数据，

        1.2.3 Struts2的数据封装 :
            1.2.3.1 Struts2中的数据封装-属性驱动 :
                提供对应属性的set方法的方式 :
                    页面：
                    <h3>数据封装的方式一：提供属性的set方法的方式</h3>
                    <form action="${ pageContext.request.contextPath }/employee1Action.action" method="post">
                        姓名:<input type="text" name="name"/><br/>
                        年龄:<input type="text" name="age"/><br/>
                        性别:<input type="text" name="sex"/><br/>
                        工资:<input type="text" name="salary"/><br/>
                        <input type="submit" value="提交"/>
                    </form>
                    编写Action:
                    /**
                     * 数据封装的方式一：提供set方法的方式
                     * @author jt
                     *
                     */
                    public class Employee1Action extends ActionSupport{
                        private String name;
                        private Integer age;
                        private String sex;
                        private Double salary;

                        public void setName(String name) {
                            this.name = name;
                        }

                        public void setAge(Integer age) {
                            this.age = age;
                        }

                        public void setSex(String sex) {
                            this.sex = sex;
                        }

                        public void setSalary(Double salary) {
                            this.salary = salary;
                        }

                        @Override
                        public String execute() throws Exception {
                            System.out.println("员工姓名:"+name);
                            System.out.println("员工年龄:"+age);
                            System.out.println("员工性别:"+sex);
                            System.out.println("员工工资:"+salary);
                            // 手动封装数据：
                            Employee employee = new Employee();
                            employee.setName(name);
                            employee.setAge(age);
                            employee.setSex(sex);
                            employee.setSalary(salary);

                            return NONE;
                        }
                    }
                    这种方式不是特别常用，因为需要手动封装数据，而且如果属性很多，提供很多的set方法，导致Action类易读性变差

                页面中提供表达式的方式：
                    页面:
                    <h3>数据封装的方式二：页面提供OGNL表达式的写法</h3>
                    <form action="${ pageContext.request.contextPath }/employee2Action.action" method="post">
                        姓名:<input type="text" name="employee.name"/><br/>
                        年龄:<input type="text" name="employee.age"/><br/>
                        性别:<input type="text" name="employee.sex"/><br/>
                        工资:<input type="text" name="employee.salary"/><br/>
                        <input type="submit" value="提交"/>
                    </form>
                    编写Action:
                    /**
                     * 数据封装的方式二:页面提供表达式的方式
                     * @author jt
                     *
                     */
                    public class Employee2Action extends ActionSupport{
                        // 提供成员的属性employee，必须提供属性的get和set方法
                        private Employee employee;

                        public Employee getEmployee() {
                            return employee;
                        }
                        public void setEmployee(Employee employee) {
                            this.employee = employee;
                        }

                        @Override
                        public String execute() throws Exception {
                            System.out.println(employee);
                            return NONE;
                        }
                    }

            1.2.3.2 Struts2 中的数据封装-模型驱动 :
                采用模型驱动完成数据封装(推荐)
                页面:
                <h3>数据封装的方式三：采用模型驱动的方式</h3>
                <form action="${ pageContext.request.contextPath }/employee3Action.action" method="post">
                    姓名:<input type="text" name="name"/><br/>
                    年龄:<input type="text" name="age"/><br/>
                    性别:<input type="text" name="sex"/><br/>
                    工资:<input type="text" name="salary"/><br/>
                    <input type="submit" value="提交"/>
                </form>
                编写Action:
                /**
                 * 数据封装的方式三：采用模型驱动的方式
                 * @author jt
                 *
                 */
                public class Employee3Action extends ActionSupport implements ModelDriven<Employee>{
                    // 模型驱动使用的对象：必须手动构建对象的实例。
                    private Employee employee = new Employee();
                    @Override
                    public Employee getModel() {
                        return employee;
                    }
                    @Override
                    public String execute() throws Exception {
                        System.out.println(employee);
                        return NONE;
                    }
                }
                ***** 模型驱动只能向一个实体中封装数据，如果需要向多个实体封装数据优先采用第二种方式。
        1.2.4 Struts2 的复杂数据的封装 :
            1.2.4.1 封装到List集合 :
                页面:
                <form action="${ pageContext.request.contextPath }/product1Action.action" method="post">
                    商品名称:<input type="text" name="list[0].name"/><br/>
                    商品价格:<input type="text" name="list[0].price"/><br/>
                    商品名称:<input type="text" name="list[1].name"/><br/>
                    商品价格:<input type="text" name="list[1].price"/><br/>
                    商品名称:<input type="text" name="list[2].name"/><br/>
                    商品价格:<input type="text" name="list[2].price"/><br/>
                    <input type="submit" value="批量导入"/>
                </form>
                Action：
                /**
                 * 封装复杂的数据到List集合中。
                 * @author jt
                 *
                 */
                public class Product1Action extends ActionSupport{
                    private List<Product> list;

                    public List<Product> getList() {
                        return list;
                    }

                    public void setList(List<Product> list) {
                        this.list = list;
                    }

                    @Override
                    public String execute() throws Exception {
                        for (Product product : list) {
                            System.out.println(product);
                        }
                        return NONE;
                    }
                }

            1.2.4.2 封装到Map集合
                页面:
                <h1>批量插入商品:封装到Map集合</h1>
                <form action="${ pageContext.request.contextPath }/product2Action.action" method="post">
                    商品名称:<input type="text" name="map['one'].name"/><br/>
                    商品价格:<input type="text" name="map['one'].price"/><br/>
                    商品名称:<input type="text" name="map['two'].name"/><br/>
                    商品价格:<input type="text" name="map['two'].price"/><br/>
                    商品名称:<input type="text" name="map['three'].name"/><br/>
                    商品价格:<input type="text" name="map['three'].price"/><br/>
                    <input type="submit" value="批量导入"/>
                </form>
                Action：
                /**
                 * 复杂类型数据封装：封装到Map集合
                 * @author jt
                 *
                 */
                public class Product2Action extends ActionSupport {
                    private Map<String,Product> map;

                    public Map<String, Product> getMap() {
                        return map;
                    }

                    public void setMap(Map<String, Product> map) {
                        this.map = map;
                    }

                    @Override
                    public String execute() throws Exception {
                        for (String key : map.keySet()) {
                            Product product = map.get(key);
                            System.out.println(key+"   "+product);
                        }
                        return NONE;
                    }
                }

随堂笔记 :
        1 strtus2对servlet API的访问

         1  使用ServletActionContext类的静态方法(重要)

         2  使用ActionContext对象的方法(理解)往域中存储数据,到页面展示(ps:这个对象获取不到域对象,只能操作域中的数据)
                    静态方法getContext()获取ActionContext对象

                特点: 只能接受页面的数据,以及对域中数据的进行操作

                       获取不response对象做不了响应,也获取不到域对象
                        使用ActionContext对象的方法(理解)
                    // getContext()  --获取ActionContext对象
                    // Map<String,Object> ----- getParameters() 获取页面的所有数据
                    // Map<String,Object> ------getSession()   获取session域中的数据
                    // Map<String,Object> -------getApplication()  获取servletContext域中的数据
         3  实现特定的接口来获取的方法(了解)
证明Action是单实例还是多实例?
            servlet是单实例  成员属性有线程危机
            Action是多实例   成员属性没有线程危机

2 结果页面的逻辑视图配置
        分类:
            全局配置
                针对一个包下所有的action都生效的一个页面

            局部配置
                针对某一个action生效的一个页面

            注意:如果全局配置和局部配置都配置了,局部配置的优先级大于全局配置

        result标签: 对返回的逻辑视图进行匹配

            name:
                逻辑视图的名称。默认值是success。

            type:
                dispatcher  默认  请求转发(用于转发到jsp页面)

                redirect   重定向(用于重定向到jsp页面)

                chain     请求转发(用于转发到action)

                redirectAction  重定向(用于重定向到action)

                stream  用于下载的(CRM3天案例)

3 struts2对页面数据的封装(模型驱动,属性驱动)

             1 属性驱动---set属性方式(例如:分页玩法)  (重点)
                  条件:
                     1 需要在action的成员位置提供属性,并且要有set()方法

             2 属性驱动---页面表达式的方式  (理解)
                 条件:
                    1 需要在action的成员位置上申明javabean对象,且提供get/set方法
                            例如:
                                private User user;
                                get()/set()

                    2 在页面上的参数name属性需要:
                            name=javabean对象.属性

                            例如: user.username;
                                  uiser.age;

             3 模型驱动(单一的对象)  (掌握)
                    条件:
                        1 让action实现一个接口: ModelDriven

                        2 需要在action的成员位置上申明javabean对象,并且这个对象得实例化 private User user=new User;

                        3 需要 ModelDriven 这个接口中的getModel()方法

                        4 需要在getModel()方法里面将我们的javabean对象以返回值的形式返回回去

                        主页:页面还是正常的写法

             4 批量方式(针对的是多个对象数据的封装)
                    条件:
                        需要在action中提供集合,且提供get()/set()方法

                list封装:

                      在action中集合名称:
                                ll

                      在页面需要:
                            ll[0].username
                            ll[0].age

                            ll[1].usrname
                            ll[1].age

                map封装:
                     在action中集合名称:
                                mm

                    在页面需要:

                            mm[键名].属性

总结:
     1 struts2怎么样获取到servlet的API(request,response,session,ServletContext,以及接受页面的数据)

            1 通过ServletActionContext类的静态方法

            2 通过ActionContext对象的方法(理解)
                        getActionContext()--对象的获取
                        注意:只能接受操作页面参数,以及操作域中的数据
                             不能获取到域对象,也不能做响应(response对象也获取不到)

            3 通过特定的接口来实现
                      ServletRequestAware,ServletResponseAware,ServletContextAware,SessionAware

    2 结果逻辑视图的配置
            全局配置 针对的是一个包下的所有action
            局部配置 针对的是指定的action
            2个都存在的情况下优先级:局部>全局
            result标签:
            name: 逻辑视图的名称。默认值是success。
            type:
                dispatcher    :默认值，请求转发。（请求转发到JSP的页面）
                  redirect    :重定向。（重定向到JSP的页面）
                  chain        :转发到另一个Action。
                  redirectAction:重定向到另一个Action。
                  stream    :文件的下载。

    3 struts2对页面数据封装的方式: 4种  ps:action多实例的,每访问一次就创建一个action对象,所以它成员位置的属性不存在线程危机
            1 属性驱动---set方式
                条件: action提供相应的成员属性,必须得有set方法

            2 属性驱动---页面表达式的方式
                条件:
                    1 需要在action的成员位置上申明javabean对象,且提供get/set方法
                    2 在页面上的参数name属性需要:
                            name=javabean对象.属性

                            例如: user.username;
                                  uiser.age;

            3 模型驱动
                条件:
                        1 让action实现一个接口: ModelDriven

                        2 需要在action的成员位置上申明javabean对象,并且这个对象得实例化 private User user=new User;

                        3 需要 ModelDriven 这个接口中的getModel()方法

                        4 需要在getModel()方法里面将我们的javabean对象以返回值的形式返回回去

                        主页:页面还是正常的写法

            4 批量封装
                条件: 提供集合且提供set/get方法

                list:
                    在action中: ll

                    在页面: ll[索引].属性

                map:
                    在action中: mm
                    在页面: mm['键名'].属性