jsp笔记+el表达式+javabean+BeanUtils框架（待整理）

1、jsp概述 
    * jsp：java server pages，java服务器端的页面
    * sun公司提供用于开发动态网站的技术 servlet  jsp
    * jsp最终也会被编译成servlet
    ** 会放到tomcat的work目录下

    * jsp包含：html + java代码 + jsp自身指令....

    * 在jsp里面如何嵌入java代码
    ** 有三种方式
        * <%! %>
        * <% %>
        * <%= %>

    * 题目
    <%=x %>
    <% x=5; %>
    <% int x = 10; %>
    <% this.x = 20; %>
    <%=x %>
    <%! int x = 0; %> 

    A.0 10  B.10 20  C.0 20  D.20 0

    最终的结果是 0 10 

    * <%! int x = 0; %> <%//定义一个成员变量x 值是 0  %>
    <%=x %>            <%//把成员变量x的值 输出  0  %>
    <% x=5; %>         <%//把成员变量x赋值5  %>
    <% int x = 10; %>  <%//在service方法里面定义了一个变量 x 值 10  %>
    <% this.x = 20; %>  <%//把当前的成员变量x的值赋值20 %>
    <%=x %>             <%//把方法里面定义的变量x输出  %>

２、jsp的注释
    * jsp包含 html+java+jsp自身的....

    * 在jsp里面可以写html注释，可以写java注释，可以写jsp自身的注释

    * 这三类注释在jsp的执行过程中，哪个阶段出现
    ** 在jsp的源代码阶段，这三类注释都存在
    ** 在jsp编译成servlet之后，html注释存在，java注释存在，但是jsp的注释没有了
    ** servlet显示到页面上，html注释存在，java注释和jsp注释都没有了

    * <!-- html注释 -->

    <!-- java的注释 -->
    <%
        //单行注释
        /*多行注释
        */
        /**文档注释
        */
     %>

     <!-- jsp的注释 -->
     <%--jsp的注释 --%>

3、jsp的指令
    * 语法 ： <%@ 指令的名称 属性="属性值"%>
    * jsp的指令包含三个指令

    ** 第一个指令 page
    *** 设置jsp页面一些信息
    *** 写法： <%@ page 属性="属性值"%>
    *** page指令里面的属性：
    * language：jsp页面支持的语言类型，但是目前只是支持java
    * extends：jsp编译成servlet，编译成的servlet会继承哪一个类 ，默认 HttpJspBase
    * session：在jsp中是否可以直接使用session对象，session属性值 true | false，默认是true

    * import：jsp里面需要导入的包
    ** 可以分开导入包 
    <%@ page import="java.util.Date"%>
    <%@ page import="java.util.ArrayList"%>
    <%@ page import="java.util.List"%>
    ** 可以写在一起
    <%@ page import="java.util.List,java.util.ArrayList"%>

    * buffer：输出的缓冲区大小 8kb
    * autoFlush：超出缓冲区是否会正常输出

    * errorPage：如果当前的jsp页面出现了异常，跳转到错误页面
        ** errorPage="错误页面"

    * isErrorPage：在错误页面中，是否可以显示错误信息。这个属性一般是程序员调试程序时候使用，把程序给客户时候，
    这个属性一定设置成false
    ** 值 true和false，默认值是false，不会生成下面的代码
    ** 当在错误页面中，设置这个属性的值true之后，生成的servlet里面，多出几行代码
        java.lang.Throwable exception = org.apache.jasper.runtime.JspRuntimeLibrary.getThrowable(request);
        if (exception != null) {
          response.setStatus(javax.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }

    * contentType：jsp最终要编译成servlet，最终使用浏览器进行打开，设置打开程序的浏览器的编码
    * pageEncoding：jsp编译成servlet，设置使用的编码

    * isElIgnored：jsp里面是否忽略el表达式，在jsp里面是否可以使用el表达式
    ** 默认情况下，不忽略的，可以使用el表达式，值是true和false，默认的值false
    ** 如果把值修改成true，写el表达式之后，把当成普通文本输出

    *** 重点记住的page里面的属性 import errorPage  pageEncoding


    ** 第二个指令 include （静态包含）
    *** 静态包含的过程：相当于代码复制，把多个jsp页面最终会编译成一个servlet
    *** jsp包含其他的jsp页面
    *** 写法 <%@ include file="包含的jsp页面"%>
    *** 注意：
    **** 在被包含的页面中，只需要保留包含的内容就可以了
    **** 在被包含的页面不能加参数
    **** 被包含的页面不能通过变量传递


    ** 第三个指令 taglib
    *** 作用：引入标签库 jstl，替代页面中的<% %>
    *** 写法 ： <%@ taglib uri="标签库的路径" prefix="标签库的名称"%>

    *** jsp里面三个指令是什么
    *** jsp里面三个指令作用

4、jsp的内置对象
    * 在jsp里面可以直接使用的对象
    * 在jsp里面有九个内置对象

    request：相当于servlet里面HttpServletRequest，代表请求，获取提交的参数，是一个域对象，设置值和取值
    response：相当于servlet里面HttpServletResponse，代表响应，向页面输出内容
    session：相当于servlet里面HttpSession，也是域对象，范围会话
    config：相当于servlet里面ServletConfig，获取servlet名称，获取初始化参数
    application：相当于servlvet里面servletContext，域对象，范围整个web项目，获取全局初始化参数
    exception：获取异常信息 getMessage方法
        * 需要把错误页面属性 isErrorPage设置true，才生成这个对象
        *java.lang.Throwable exception = org.apache.jasper.runtime.JspRuntimeLibrary.getThrowable(request);
        if (exception != null) {
          response.setStatus(javax.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }

    page：jsp编译成servlet，表示当前运行的servlet对象

    out：向页面输出内容
        out.write()代码
        使用response.getWriter()也可以向页面输出

        * out和response.getWriter()使用的不是一个对象
        ** out使用的JspWriter
        ** response.getWriter()使用PrintWriter

        ** 输出的机制
        ** 首先产生两个缓冲区，一个是out缓冲区和response缓冲区
        ** out输出不会直接向页面输出，首先把内容先放到out缓冲区，把out缓冲区里面的内容放到response缓存区，
        最终通过response缓冲区向页面输出


    pageContext（***）：
        * 父类 JspContext
        * pageContext也是域对象
            * 只能在jsp里面使用，servlet里面没有页面的概念
            * 作用范围：当前的jsp页面
            * 设置值 setAttribute(java.lang.String name, java.lang.Object value)
            * 获取值 getAttribute(java.lang.String name) 
            * 代码
                <!-- 向pageContext域里面设置值 -->
                <%
                pageContext.setAttribute("page1", "itcastpage1");
                 %>
                 <!-- 使用传统方式获取 -->
                 <%=pageContext.getAttribute("page1") %>
                 <hr/>
                 <!-- 使用el表达式获取 -->
                 ${page1 }

        * pageContext可以向其他的域对象里面设置值
            * 方法 setAttribute(java.lang.String name, java.lang.Object value, int scope) 
            ** 三个参数
            *** 第一个参数，域对象的名称
            *** 第二个参数，域对象的值
            *** 第三个参数，向哪一个域对象里面设置值
                - 直接使用pageContext里面常量 REQUEST_SCOPE ........            
            *代码
                <!-- 分别向四个域对象里面设置值 -->
                <%
                //向pageContext域里面设置值
                pageContext.setAttribute("page11", "pagevalue", pageContext.PAGE_SCOPE);
                //向request域里面设置值
                pageContext.setAttribute("request11", "requestvalue", pageContext.REQUEST_SCOPE);
                //向session和application里面设置值
                pageContext.setAttribute("session11", "sessionvalue", pageContext.SESSION_SCOPE);
                pageContext.setAttribute("application11", "applicationvalue", pageContext.APPLICATION_SCOPE);
                 %>

        * pageContext可以从其他的域对象里面获取值
            * 方法  getAttribute(java.lang.String name, int scope) 
            ** 两个参数：第一个参数是域对象的名称，第二个参数是哪一个域对象
            * 代码
                 <%=pageContext.getAttribute("page11",pageContext.PAGE_SCOPE) %>
                 <%=pageContext.getAttribute("request11", pageContext.REQUEST_SCOPE) %>
                 <%=pageContext.getAttribute("session11", pageContext.SESSION_SCOPE) %>
                 <%=pageContext.getAttribute("application11", pageContext.APPLICATION_SCOPE) %>

             * 还有一个重要的方法  findAttribute(java.lang.String name) 
             ** 得到域对象范围最小的范围里面的值
             * <%=pageContext.findAttribute("itcast") %>

        * pageContext内置对象可以获取其他的八个内置对象
            * 经常用在框架里面，只需要传递一个对象pageContext
            *     <%
                //得到request对象
                pageContext.getRequest();
                //得到response
                pageContext.getResponse();
                //得到session对象
                pageContext.getSession();
                ......
                  %>

        * 四个域对象 
        ** pageContext : 范围是jsp页面，这个对象只能在jsp里面使用
        ** request ：范围一次请求，经常和转发一起使用
        ** session  ：范围一次会话
        ** application：范围整个web项目
        *** 四个域对象都使用setAttribute设置值，使用getAttribute获取值

    * 记住jsp里面有几个内置对象 
    * 记住每个内置对象名称和含义（做什么）

5、jsp的动作标签
    * 在jsp里面有6个动作标签
    * 语句 <jsp:动态标签名称 属性="属性值"></jsp:动态标签名称>

    * 第一类与javabean操作没有关系的标签
    ** <jsp:forward>：表示转发的操作
        - <jsp:forward page="转发到路径 不要带项目名称"></jsp:forward>

        - <!-- 使用jsp里面的forward的动作标签 -->
        <jsp:forward page="/jsp/hello.jsp"></jsp:forward>

    ** <jsp:include>：表示页面包含（包含其他的jsp页面，动态包含）
        * 多个jsp页面，会编译成多个servlet
        * 代码
        <jsp:include page="head.jsp"></jsp:include>

    ** <jsp:param>：表示传递参数 
        * <jsp:param value="参数的值" name="参数名称"/>
        * 相当于在地址后面加一个参数，类似get请求
        * 代码   <!-- 使用jsp里面的forward的动作标签 -->
           <!-- 相当于在hello.jsp?id11=itcast200 -->
           <jsp:forward page="/jsp/hello.jsp">
                <jsp:param value="itcast200" name="id11"/>
           </jsp:forward>

    * 第二类是操作javabean动作标签
    ** <jsp:useBean> ： 设置要操作哪一个javabean
    ** <jsp:setProperty>：设置javabean里面的属性的值
    ** <jsp:getProperty>：获取属性的值

================================================================================================

6、javabean简介
    * 什么是javabean，就是一个java类，但是javabean要遵循一定的书写规范
    * 遵循的规范
    * 第一个规范：必须有一个公开没有参数构造方法
    * 第二个规范：属性必须是私有的
    * 第三个规范：属性必须通过公开的方法暴露出来

    * javabean作用：存数据（封装数据）

    * 使用传统方式向javabean里面封装数据
    ** 创建jsp页面，写提交的表单，让表单提交到servlet里面，在servlet里面封装数据到javabean
    ** 代码
        //获取通过表单提交的数据
        String id = request.getParameter("id");
        String username = request.getParameter("username");
        String age = request.getParameter("age");
        //创建Person对象
        Person p = new Person();
        //使用person类里面setXX方法进行封装
        p.setId(id);
        p.setUsername(username);
        p.setAge(age);


    * 使用jsp的动作标签实现封装数据到javabean
    ** 要求：使用jsp动作标签封装数据时候，表单输入项的name的值必须要和javabean里面属性的值相同

    * 代码
       <!-- 使用jsp的动作标签实现封装数据到javabean -->
       <!-- id：表示创建javabean对象名称
            class：javabean包类路径
       -->
      <jsp:useBean id="p1" class="cn.itcast.bean.Person" scope="page"></jsp:useBean> 
      <!-- 数据的封装 -->
      <!-- 
        property：封装javabean里面属性的名称
        name：javabean对象值
      -->
    <%--   <jsp:setProperty property="id" name="p1"></jsp:setProperty>
      <jsp:setProperty property="username" name="p1"></jsp:setProperty>
      <jsp:setProperty property="age" name="p1"></jsp:setProperty> --%>

      <!-- 
        在property写*，把所有的属性都进行封装
      -->
      <jsp:setProperty property="*" name="p1"></jsp:setProperty>

      <!-- 输出封装的值 -->
      <!-- 
        property：封装javabean里面属性的名称
        name：javabean对象值
      -->
      <jsp:getProperty property="id" name="p1"></jsp:getProperty>
      <jsp:getProperty property="username" name="p1"></jsp:getProperty>
      <jsp:getProperty property="age" name="p1"></jsp:getProperty>

7、javabean的内省（了解）
    * 完成javabean数据的封装

    * 使用到类
    * Introspector：
    ** 方法
    *** BeanInfo getBeanInfo(Class<?> beanClass) ：得到javabean里面的内容
    ****参数 Class类，javabean字节码文件，
    **** 三种方式可以得到Class类 类名.class   对象.getClass()  Class.forName("包类路径")

    * BeanInfo
    ** PropertyDescriptor[] getPropertyDescriptors()  ：得到属性描述，返回数组

    * PropertyDescriptor
    ** Method getReadMethod()  ：表示读的方法，javabean里面的getXX方法
    ** Method getWriteMethod()  ：表示写的方法，javabean里面的setXX方法

    * Method
    ** invoke(Object obj, Object... args) ：让方法去执行

    ** 创建jsp页面，写提交表单，表单提交到servlet里面，在servlet里面使用内省实现封装数据到javabean

    ** 代码
        /*
         * 1、得到javabean内容 BeanInfo
         * 2、使用BeanInfo得到属性的描述 getPropertyDescriptors() 
         * 3、遍历数组，得到每一个属性的描述
         * 4、封装数据
         * */
        Class clazz = o.getClass();
        BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
        //得到属性的描述 
        PropertyDescriptor[] propertyDes = beanInfo.getPropertyDescriptors();
        //遍历数组
        for (PropertyDescriptor pd1 : propertyDes) {

            //得到属性的名称
            String name1 = pd1.getName();
            //把map里面的值和name1做匹配
            if(map.containsKey(name1)) {
                //封装数据,得到javabean写方法
                Method m1 = pd1.getWriteMethod();
                m1.invoke(o, map.get(name1)[0]);
            }
        }


8、BeanUtils框架的使用
    * 作用：封装数据到javabean
    * 是apache组织开发的一个小型操作javabean的api

    * 如果想要使用beanUtils，必须要导入支持的jar包（导入两个jar包）

    * web项目里面如何导入jar包
    ** 把需要导入的jar包，复制到webroot--WEB-INF--lib目录下面，自动把jar包导入到项目中

    * 注意：表单输入项name的值必须要和javabean里面的属性名称要相同

    * 使用到的类 org.apache.commons.beanutils 下面
    ** BeanUtils
    *** populate(Object bean, Map properties)：完成数据的封装
    *** 两个参数：第一个参数是javabean对象，第二个参数表单输入的值和输入的值，map集合

    ** 创建jsp页面，写提交表单，表单提交到servlet里面，在servlet里面使用框架实现封装数据到javabean操作
    ** 代码
        //得到表单提交的数据
        //创建javabe对象
        //使用框架实现封装
        Person p12 = new Person();
        try {
            BeanUtils.populate(p12, request.getParameterMap());
        } catch (Exception e) {
            e.printStackTrace();
        } 

    ** 使用框架，如果属性的类型是基本数据类型和String类型完成封装，但是如果不是这些类型出现转换的异常

    ** ConvertUtils
        ** register(Converter converter, Class clazz)
        *** 两个参数：第一个参数是转换器，第二个参数是转换类型Class
        ** String d1 = (String) o;
        //把字符串的日期类型转换成Date类型
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");   
        Date date = null;
        try {
            date = format.parse(d1);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;

9、el表达式
    * 用途：获取域对象里面的值
    * 语法： ${域对象的名称}

    （1）使用el表达式获取域对象的值
    ** 代码
        <!-- 向四个域对象里面设置值 -->
        <%
        pageContext.setAttribute("itcast", "pagevalue");
        request.setAttribute("itcast", "requestvalue");
        session.setAttribute("itcast", "sessionvalue");
        application.setAttribute("itcast", "applicationvalue");
         %>
         <!-- 使用el表达式获取值 -->
         ${pageScope.itcast }
         ${requestScope.itcast }
         ${sessionScope.itcast }
         ${applicationScope.itcast }

    （2）使用el表达式获取域对象里面的数组的值
    * 使用数组的下标获取，如果数组的下标不存在，返回空字符串""
    ** 代码
       <!-- 使用el表达式获取域对象里面的数组的值 -->
       <%
            String[] arr = {"tom","jack","lucy"};
            //把这个数组放到域对象里面
            request.setAttribute("arr", arr);
        %>
        <!-- 使用el表达式获取数组里面的值 -->
        ${arr[1] }

    （3）使用el表达式获取域对象里面集合里面的值
        * 向域对象里面放list集合
        ** 使用集合下标获取值
        ** 代码
            <!-- 使用el表达式获取域对象里面list的值 -->
            <%
            List list = new ArrayList();
            list.add("AAAA");
            list.add("TTTT");
            list.add("wwww");
            request.setAttribute("list", list);
             %>
             ${list[10] }

        * 向域对象里面map集合
        **      
             <%
            Map map = new HashMap();
            map.put("aaa", "AAAA");
            map.put("bbb", "BBBB");
            map.put("ccc", "CCCC");
            request.setAttribute("map", map);
              %>
              ${map.aaa }

    （4）使用el表达式获取域对象里面的对象的属性的值
    ** 代码
          <!--  使用el表达式获取域对象里面对象的属性的值-->
          <%
        Person1 p11 = new Person1();
        p11.setId("404");
        p11.setUsername("mary");
        p11.setAge("500");
        request.setAttribute("p11", p11);
           %>
           ${p11.id }
        ${p11.username }
         ${p11.age }

    （5）执行运算
    * 算数运算 + - 
        ** 代码
            <!-- 执行算术的操作 -->
            <%
            pageContext.setAttribute("aa", "11");
            pageContext.setAttribute("bb", "22");
             %>
           ${aa+bb }

    * 关系运算 > < <= >= 

    * 逻辑运算 &&  || 

    * 三元运算符(三目运算)
        ${ user != null ? user.name : "" }
        ${ empty user ? user.name : "" }： empty表示空
        ${not empty user  ? user.name : "" }: not empty不是空

10、使用EL表达式操作web开发常用的对象
    * el表达式里面提供了11个隐含对象
    ** param：得到提交的参数，相当于request.getParameter();
    ** paramValues: 得到多个值，相当于request.getParameterValues();
    ** header: 得到头信息，相当于request.getHeader();
    ** initParam: 得到全局的初始化参数

    ** pageContext：得到内置对象
    **   <!-- pageContext对象 -->
         ${pageContext.request }
         ${pageContext.response }