JSP/Servlet基础语法

http://my.oschina.net/chape/blog/170247
http://docs.oracle.com/cd/E13222_01/wls/docs81/webapp/web_xml.html
http://blog.csdn.net/liaoxiaohua1981/article/details/6761053
http://computer.c.blog.163.com/blog/static/102524482012314537670/
http://www.blogjava.net/w2gavin/articles/358641.html
http://www.douban.com/note/310522851/
http://mianhuaman.iteye.com/blog/1105522
http://blog.csdn.net/li_jinjian2005/article/details/2915462
http://210.44.193.6/JSP/07.htm
http://www.ibm.com/developerworks/cn/java/j-lo-servlet30/

1. J2EE WEB应用文件目录结构
2. web.xml基础语法
3. JSP基础语法
4. Servlet基础语法

1. 应用程序根目录，可以取任意的名字，所有的HTML、JSP文件都放在这个目录下
    1.1 WEB-INF目录: 必须目录 
        1.1.1 web.xml: Web应用部署描述文件，必须文件
        1.1.2 classes目录: 
            1) 用于存放单个*.classes字节码文件，Servlet类文件也存放在这个目录下
        1.1.3 lib目录: 
            1) 存放第三方类库文件，即打包后的JAR文件
        1.1.4 TLD文件: 标签库描述文件 
    1.2 其他静态文件:
        1.2.1 HTML
        1.2.2 CSS
        1.2.3 JavaScript
        1.2.4 图片等
    1.3 *.jsp: 存放任意多个JSP页面

1. JSP环境参数初始化
2. 配置和管理Servlet
3. 配置和管理Listener
4. 配置和管理Filter
5. 配置和管理JNDI
6. Session配置
7. MIME TYPE配置
8. 错误处理
9. 配置标签库
10. 配置JSP属性
11. 配置和管理JAAS授权认证
12. 配置和管理资源引用
13. WEB应用默认首页(welcome文件)的设置

/*
<?xml version="1.0" encoding="GBK"?>是一个基本的XML文件的框架，不管是什么配置文件，只要是基于XML的，它的基本结构都是这样
*/
<?xml version="1.0" encoding="GBK"?>
/*
web.xml文件的根元素是<web-app.../>元素，整个web.xml只有这个根元素，每个web.xml必须以这个<web-app>根元素作为开头，在Servlet 3.0规范中，该元素新增了
metadata-complete属性，当该属性值为true时，该web应用"不会"加载Annotation配置的WEB组件(如Servlet、Filter、Listener等)，反之则加载
*/
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
    /*
    1. icon信息: 用来指定web站点中小图标和大图标的路径
        1) small-icon: 大小为16 X 16 pixel,但是图象文件必须为GIF或JPEG格式,扩展名必须为:.gif或
.jpg.
        2) large-icon: 大小为32 X 32 pixel,但是图象文件必须为GIF或JPEG的格式,扩展名必须为; gif
或jpg. 
    */
    <small-icon>/路径/smallicon.gif</small-icon>
    <large-icon>/路径/largeicon-jpg</large-icon>

    /*
    2. 描述信息
    display-name: 定义站点的名称
    description: 对站点的描述
    */
    <display-name>站点名称</display-name>
    <description>站点描述</discription>

    /*
    3. distributable
    distributable元素为空标签,它的存在与否可以指定站台是否可分布式处理.如果web.xml中出现这个元素,则代表站台在开发时已经被设计为能在多个JSP Container之间分散执行
    */ 
    <distributable/> 

    /*
    4. JSP环境参数: context-param
    context-param元素用来设定web站台的环境参数(context),它包含两个子元素:
        1) param-name: 参数名称
        2) param-value: 值 
    此所设定的参数,在JSP网页中可以使用下列方法来取得:
    ${initParam.param_name}
    若在Servlet可以使用下列方法来获得:
    String param_name=getServletContext().getInitParamter("param_name");
    */ 
    <context-param>
       <param-name>param_name</param-name>
       <param-value>param_value</param-value>
    </context-param>

    /*
    5. filter过滤器、filter-mapping
    用于指定WEB容器的过滤器，在请求和响应对象在Servlet处理之前和之后，可以通过此过滤器对这两个对象进行处理  
    filter-class 中指定的过滤器类须继承 javax.servlet.Filter具有须有以下三种方法
    init(FilterConfig filterConfig)：初始化;一般情况下时读取配置文件中的init-param参数值 如 filterConfig.getInitParameter("encoding")
    doFilter(...)：用于对request,response进行处理，并能过chain.doFilter(...) 交过下一个控制器
    destroy()：资源销毁
    filter-mapping则指示需要进行过滤器处理的URL访问模式，可以理解为当我们的URL匹配到指定的模式后，则对这个请求执行指定的"过滤处理流程"(可以把它理解为一种路由机制)
    */
    <filter>
        <small-icon>/路径/smallicon.gif</small-icon>
        <large-icon>/路径/largeicon-jpg</large-icon>
        <filter-name>encodingfilter</filter-name>
        <display-name>站点名称</display-name>
        <description>站点描述</discription>
        <filter-class>com.my.app.EncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingfilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    /*
    6. servlet、servlet-mapping
    和filter过滤器类似，servlet也是用来配置映射处理机制的
    和filter-mapping的作用类似，servlet-mapping用来定义servlet所对应URL.
    */
    <servlet>
        <small-icon>/路径/smallicon.gif</small-icon>
        <large-icon>/路径/largeicon-jpg</large-icon>
        <servlet-name>MyServletName</servlet-name>
        <display-name>站点名称</display-name>
        <description>站点描述</discription>
        /*
        servlet-class、jsp-file有且只能出现一个
        */
        <servlet-class>com.Little.MyServlet</servlet-class>
        <jsp-file>/path/index.jsp</jsp-file> 
        <init-param>
            <param-name>name1</param-name>
            <param-value>value1</param-value>
        </init-param> 
        /*
        指定当Web应用启动时，装载Servlet的次序
        1) 当值为正数或零时: 容器在应用启动时就加载这个servlet，Servlet容器先加载数值小的servlet，再依次加载其他数值大的servlet
        2) 当值为负或未定义: 容器在该servlet被选择时才加载，即Servlet容器将在Web客户首次访问这个servlet时加载它
        */
        <load-on-startup></load-on-startup>
        /*
        设定运行时角色，可以使当前Servlet以一个特定的角色运行，有利于安全权限控制
        */
        <run-as>    
            <description>Security role for anonymous access</description>    
            <role-name>tomcat</role-name>    
        </run-as> 
        /*
        security-role-ref子元素提供出现在服务器专用口令文件中的安全角色名的一个别名。例如，假如编写了一个调用 request.isUserInRole("boss")的servlet，
但后来该servlet被用在了一个其口令文件调用角色manager而不 是boss的服务器中。下面的程序段使该servlet能够使用这两个名称中的任何一个
        */
        <security-role-ref>
            <role-name>boss</role-name> <!-- New alias -->
            <role-link>manager</role-link> <!-- Real name -->
        </security-role-ref>  
    </servlet>
    
    <servlet-mapping>
        <servlet-name>LoginChecker</servlet-name>
        <url-pattern>/LoginChecker</url-pattern>
        <servlet-name>MyServletName</<servlet-name>
    </servlet-mapping>

    /*
    7. security-role(虚拟安全用户)
    给出安全角色的一个列表，这些角色将出现在servlet元素内的security-role-ref元素的role-name元素中。分别声明角色可使高级IDE处理安全信息更为容易。
    */
    <security-role>
        <description>安全账户描述</discription>
        <role-name>admin</role-name>
    </security-role>

    /*
    8. listener
    监听器也叫Listener，是Servlet的监听器，它可以监听客户端的请求、服务端的操作等。通过监听器，可以自动激发一些操作，Servlet本身在一些特定的关键处理流程节点上增加Hook
回调机制，使得我们可以在这些节点位置配置监听器
    常见的监听器如下:
    Listener接口 
    1) ServletContextListener: ServletContextEvent
    2) ServletContextAttributeListener: ServletContextAttributeEvent
    3) HttpSessionListener: HttpSessionEvent
    4) HttpSessionActivationListener: HttpSessionAttributeListener
    5) HttpSessionBindingEvent: HttpSessionBindingListener
    6) ServletRequestListener: ServletRequestEvent
    7) ServletRequestAttributeListener: ServletRequestAttributeEvent 
    */
    <listener>
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>

    /*
    9. session配置
    session-config包含一个子元素session-timeout.定义web站台中的session参数，定义这个web站台所有session的有效期限.单位为分钟
    */
    <session-config>
        <session-timeout>20</session-timeout>
    </session-config>

    /*
    10. mime-mapping
    mime-mapping包含两个子元素extension和mime-type.定义某一个扩展名和某一MIME Type做对映，和apache中的文件扩展处理器原理类似，对指定的扩展名指定相应的处理程序
    */
    <mime-mapping>
        <extension>doc</extension>
        <mime-type>application/vnd.ms-word</mime-type>
    </mime-mapping> 
    <mime-mapping>
        <extension>xls</extension>
        <mime-type>application/vnd.ms-excel</mime-type>
    </mime-mapping>

    /*
    11. welcome-file-list
    welcome-file-list包含一个子元素welcome-file.用来定义首页列单，即当客户端的请求没有指定具体的页面时，服务区器默认指定的首页脚本
    */
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>index.htm</welcome-file>
    </welcome-file-list>

    /*
    12. error-page
    错误处理机制，error-page元素包含三个子元素error-code,exception-type和location.将错误代码(Error Code)或异常(Exception)的种类对应到web站点资源路径。
简单来说就是返回特定HTTP状态代码或者特定类型的异常被抛出时，制定响应将要显示的页面。
    */
    <error-page>
        <error-code>404</error-code>
        <exception-type>java.lang.Exception</exception-type>
        <location>/error404.jsp</location>
    </error-page>
    <error-page>
        <exception-type>java.lang.Exception</exception-type>
        <exception-type>java.lang.NullException</exception-type>
        <location>/except.jsp</location>
    </error-page>

    /*
    13. jsp-config
    JSP相关配置 
    */
    <jsp-config>
        <taglib>
            /*
            taglib-uri定义TLD文件的URI,JSP网页的taglib指令可以经由这个URI存取到TLD文件
            */
            <taglib-uri>Taglib</taglib-uri>
            /*
            taglib-location定义TLD文件对应Web站台的存放位置
            */
            <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
        </taglib>
        <jsp-property-group>
            <description>
                Special property group for JSP Configuration JSP example.
            </description>
            <display-name>JSPConfiguration</display-name>
            /*
            设定值所影响的范围,如:/CH2 或者/*.jsp
            */
            <uri-pattern>/*</uri-pattern> 
            /*
            若为true,表示不支持EL语法
            */
            <el-ignored>true</el-ignored>
            /*
            设定JSP网页的编码
            */
            <page-encoding>GB2312</page-encoding>
            /*
            若为true表示不支持<%scription%>语法.
            */
            <scripting-inivalid>true</scripting-inivalid> 
            /*
            设置JSP网页的结尾,扩展名为.jspf
            */
            <include-coda>.jspf</include-coda>
            /*
            设置JSP网页的抬头,扩展名为.jspf
            */
            <include-prelude>.jspf</include-prelude>
        </jsp-property-group>
    </jsp-config>

    /*
    14. resource-ref、resource-env-ref
    resource-ref声明资源工厂使用的外部资源
    resource-env-ref声明与资源相关的管理对象
    */
    <resource-ref>
        <description>JNDI JDBC DataSource of JSPBook</description> <!-- 资源说明 -->
        <res-ref-name>jdbc/sample_db</res-ref-name> <!-- 资源名称 -->
        <res-type>javax.sql.DataSoruce</res-type> <!-- 资源种类 -->
        <res-auth>Container</res-auth> <!-- 资源由Application或Container来许可 -->
        <res-sharing-scope>Shareable|Unshareable</res-sharing-scope> <!-- 资源是否可以共享.默认值为 Shareable -->
    </resource-ref>

    <resource-env-ref>    
        <resource-env-ref-name>jms/StockQueue</resource-env-ref-name>    
    </resource-env-ref>    

    /*
    15. EJB配置 
    ejb-ref用于声明一个EJB的主目录的引用
    用于声明一个EJB的本地主目录的应用。
    */
    <ejb-ref>    
        <description>Example EJB reference</decription>    
        <ejb-ref-name>ejb/Account</ejb-ref-name>    
        <ejb-ref-type>Entity</ejb-ref-type>    
        <home>com.mycompany.mypackage.AccountHome</home>    
        <remote>com.mycompany.mypackage.Account</remote>    
    </ejb-ref>    

    <ejb-local-ref>    
        <description>Example Loacal EJB reference</decription>    
        <ejb-ref-name>ejb/ProcessOrder</ejb-ref-name>    
        <ejb-ref-type>Session</ejb-ref-type>    
        <local-home>com.mycompany.mypackage.ProcessOrderHome</local-home>    
        <local>com.mycompany.mypackage.ProcessOrder</local>    
    </ejb-local-ref>    

    /*
    16. WEB应用环境参数配置
    */
    <env-entry>  
        <description>环境参数说明</description>
        <env-entry-name>minExemptions</env-entry-name>    
        <env-entry-value>1</env-entry-value>    
        <env-entry-type>java.lang.Integer</env-entry-type>    
    </env-entry> 
    
    /*
    17. 安全配置、资源限制访问配置
    在Web应用程序的web.xml中创建security-constraint、login-config和security-role元素
    */
    /*
    配置对指定资源、指定角色的访问权限
    */
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>HelloServlet</web-resource-name>
            <url-pattern>/HelloServlet</url-pattern>
            <http-method>GET</http-method>
            <http-method>POST</http-method>
        </web-resource-collection>
        <auth-constraint>
            <description>This applies only to the "tomcat" security role</description>
            <role-name>admin</role-name>
        </auth-constraint>
        <user-data-constraint>
            <transport-guarantee>NONE</transport-guarantee>
        </user-data-constraint>
    </security-constraint>
      
    /*
    auth-method的方法有:
        1) BASIC
        BASIC是一种常见的Web认证方式，浏览器给用户提示一个对话框，要求输入用户名和密码，随后Tomcat将给出的用户名和密码与tomcat-users.xml中的用户名和密码进行比较，
然后使用前面的security-constraint配置来确定用户是否可访问受保护的servlet
        2) FORM
        3) CLIENT-CERT
        4) DIGEST
    */
    <login-config>
        <realm-name>在HTTP验证返回包中的显示名称</<realm-name>
        <auth-method>BASIC</auth-method>
        <form-login-config>如果auth-method采用FORM，则这里填写form-login-config名称</form-login-config> 

    </login-config>
    /*
    关于security-role，在前面的servlet已经说明过，这里要强调一下:
    web.xml中的HTTP认证方法实际上有两个步骤：
        1) 检查提供的用户名和密码是否正确。
        2) 判断用户是否映射到特定的安全角色。例如，用户可能提供了正确的用户名和密码，但没有映射到特定的安全角色，也将被禁止访问特定的Web资源。
    */
    <security-role>
        <role-name>admin</role-name>
    </security-role>  
</web-app>

web.xml 的加载顺序是：context-param -> listener -> filter -> servlet ，而相同类型节点之间的程序调用的顺序是根据对应的mapping的顺序进行调用的

1. 静态部分: 标准的HTML标签、静态的页面内容，也就是普通的HTML代码
2. 动态部分: 受java程序控制的内容，这些内容由Java程序来动态生成 

/*
1. JSP的编译指令 
*/
<%@ page contentType="text/html; charset=GBK" language="java" errorPage="" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>learn j2ee</title> 
    /*
    2. JSP注释 
    */ 
</head> 
/*
3. JSP声明 
*/
<body> 
/*
4. JSP表达式
*/
/*
5. JSP脚本
*/ 
/*
6. JSP的动作指令
*/ 
/*
7. JSP脚本中的内置对象
*/
</body>
</html>

JSP的编译指令是通过JSP引擎的消息，它不直接生成输出。编译指令都有默认值，我们并不需要为每个指令设置值。它的格式如下
<%@ 编译指令名 属性名="属性值"...%>(不同属性名之间用空格分开)
    1) page: Page指令为容器提供当前页面的使用说明。一个JSP页面可以包含多个page指令
        1.1) buffer: 指定缓冲区的大小。缓冲区是JSP内部对象"out"，它用于缓存JSP页面对客户端浏览器的输出，默认值为8KB，可以设置为none，也可以设置为其他的值，单位为Kb
        1.2) autoFlush: 当缓冲区即将满而溢出时，是否需要强制输出缓冲区的内容:
            1.2.1) 如果设置为true则正常输出
            1.2.2) 如果设置为false，则会在buffer溢出时产生一个异常
        1.3) contentType: 用于设定生成网页的文件格式(MIME类型)、和编码字符集(页面字符集类型)(text/html;charSet=ISO-8859-1)
            1.3.1) 默认的MIME类型是text/html
            1.3.2) 默认的字符集类型为ISO-8859-1
        1.4) errorPage: 指定错误处理页面，如果本页面产生了异常或错误，而该JSP页面没有对应的错误处理代码(没有用try、catch机制捕捉异常)，则会自动调用该属性所指定的JSP
页面。值得注意的是，为页面指定错误发生时的错误提示页面是一种安全的做法，能够在一定程度上组织error-based-sql-injection的攻击
        1.5) isErrorPage: 指定当前页面是否可以作为另一个JSP页面的错误处理页面
        1.6) extends: JSP程序编译时所产生的Java类，需要继承的父类，或者需要实现的接口的全限定类名(即包含包名在内的完整路径)
        1.7) import: 用来导入包。默认自动导入的包(参数之间用逗号分隔)(java.lang.*,javax.servlet.*)
            1.7.1) java.lang.*
            1.7.2) javax.servlet.*
            1.7.3) javax.servlet.jsp.*
            1.7.4) javax.servlet.http.*
        1.8) info: 定义JSP页面的描述信息
        1.9) isThreadSafe: 指定对JSP页面的访问是否为线程安全
        1.10) language: 定义JSP页面所用的脚本语言，默认是Java
        1.11) session: 指定JSP页面是否使用session
        1.12) isELIgnored: 指定是否执行EL表达式
        1.13) isScriptingEnabled: 确定脚本元素能否被使用
    2) include: 用于指定包含另一个页面
    <%@include file="file.jsp"%>
    可以将外部文件嵌入到当前JSP文件中，同时解析这个页面中的JSP语句(如果有的话)，也就是说，它既可以包含静态的文本，也可以包含动态的JSP页面。包含页面在编译时将完全包含了被包
含页面的代码，融合成一个页面。作用和PHP中的inlcude、require类似。
    需要注意的是，要指出的是，静态包含还会将被包含页面的编译指令也包含进来，如果两个页面的编译指令冲突，那么页面就会出错(即被包含的页面中不能重复定义
page、include、taglib)
    3) taglib: 用于定义和访问自定义标签
    自定义标签库是一种非常优秀的表现层组件技术。通过使用自定义标签库，可以在简单的标签中封装复杂的功能，在JSP2中使用自定义标签需要以下步骤
        1) 开发自定义标签处理类
        在JSP页面使用一个标签时，底层实际上由标签处理类提供支持，从而可以通过简单的标签来封装复杂的功能，从而使团队更好地协作开发。自定义标签类应该继承一个父类: 
javax.servlet.jsp.tagext.SimpleTagSupport，除此之外，JSP自定义标签类还有如下要求(通过接口来强制性保证):
            1) 如果标签包含属性，每个属性都有对应的getter、setter方法
            2) 重写doTag()方法，这个方法负责生成页面内容
        example1: 无属性、无标签体的最简单的标签处理类
        package lee;
        import javax.servlet.jsp.tagext.*;
        import javax.servlet.jsp.*;
        import java.io.*;

        public class HelloWorldTag extends SimpleTagSupport
        {
            //重写doTag方法，该方法在标签结束生成页面内容
            public void doTag()throws JspException, IOException
            {
                //获取页面输出流，并输出字符串
                getJspContext().getOut().write("Hello World " + new java.util.Date());
            }
        }
        这个标签处理类继承了SimpleTagSupport父类，并重写了doTag()方法，doTag()负责输出页面内容(即标签代表的内容)

        example2: 带属性的标签处理类
        package lee;
        import javax.servlet.jsp.tagext.*;
        import javax.servlet.jsp.*;
        import java.io.*;
        import java.sql.*;

        public class QueryTag extends SimpleTagSupport
        {
            //标签的属性
            private String driver;
            private String url;
            private String user;
            private String pass;
            private String sql;

            //driver属性的setter和getter方法
            public void setDriver(String driver)
            {
                this.driver = driver;
            }
            public String getDriver()
            {
                return this.driver;
            }
            
            //url属性的setter和getter方法
            public void setUrl(String url)
            {
                this.url = url;
            }
            public String getUrl()
            {
                return this.url;
            }
            
            //user属性的setter和getter方法
            public void setUser(String user)
            {
                this.user = user;
            }
            public String getUser()
            {
                return this.user;
            }
            
            //pass属性的setter和getter方法
            public void setPass(String pass)
            {
                this.pass = pass;
            }
            public String getPass()
            {
                return this.pass;
            }    
            
            //sql属性的setter和getter方法
            public void setSql(String sql)
            {
                this.sql = sql;
            }
            public String getSql()
            {
                return this.sql;
            }    
            
            //conn属性的setter和getter方法
            public void setConn(Connection conn)
            {
                this.conn = conn;
            }
            public Connection getConn()
            {
                return this.conn;
            }
            
            //stmt属性的setter和getter方法
            public void setStmt(Statement stmt)
            {
                this.stmt = stmt;
            }
            public Statement getStmt()
            {
                return this.stmt;
            }    
            
            //rs属性的setter和getter方法
            public void setRs(ResultSet rs)
            {
                this.rs = rs;
            }
            public ResultSet getRs()
            {
                return this.rs;
            }
            
            //rsmd属性的setter和getter方法
            public void setRsmd(ResultSetMetaData rsmd)
            {
                this.rsmd = rsmd;
            }
            public ResultSetMetaData getRsmd()
            {
                return this.rsmd;
            }
            //执行数据库访问的对象 
            private Connection conn = null;
            private Statement stmt = null;
            private ResultSet rs = null;
            private ResultSetMetaData rsmd = null;
            public void doTag()throws JspException,
                IOException
            {
                try
                {
                    //注册驱动
                    Class.forName(driver);
                    //获取数据库连接
                    conn = DriverManager.getConnection(url,user,pass);
                    //创建Statement对象
                    stmt = conn.createStatement();
                    //执行查询
                    rs = stmt.executeQuery(sql);
                    rsmd = rs.getMetaData();
                    //获取列数目
                    int columnCount = rsmd.getColumnCount();
                    //获取页面输出流
                    Writer out = getJspContext().getOut();
                    //在页面输出表格
                    out.write("<table border=‘1‘ bgColor=‘#9999cc‘ width=‘400‘>");
                    //遍历结果集
                    while (rs.next())
                    {
                        out.write("<tr>");
                        //逐列输出查询到的数据
                        for (int i = 1 ; i <= columnCount ; i++ )
                        {
                            out.write("<td>");
                            out.write(rs.getString(i));
                            out.write("</td>");
                        }
                        out.write("</tr>");
                    }
                }
                catch(ClassNotFoundException cnfe)
                {
                    cnfe.printStackTrace();
                    throw new JspException("自定义标签错误" + cnfe.getMessage());
                }
                catch (SQLException ex)
                {
                    ex.printStackTrace();
                    throw new JspException("自定义标签错误" + ex.getMessage());
                }
                finally
                {
                    //关闭结果集
                    try
                    {
                        if (rs != null)
                            rs.close();
                        if (stmt != null)
                            stmt.close();
                        if (conn != null)
                            conn.close();
                    }
                    catch (SQLException sqle)
                    {
                        sqle.printStackTrace();
                    }
                }
            }
        }

        example3: 带标签体的标签处理类
        带标签体的标签可以在标签内嵌入其他内容(包括静态HTML、动态JSP内容)，通常用于完成一些逻辑运算
        package lee;
        import javax.servlet.jsp.tagext.*;
        import javax.servlet.jsp.*;
        import java.io.*;
        import java.sql.*;
        import java.util.*;

        public class IteratorTag extends SimpleTagSupport
        {
            //标签属性，用于指定需要被迭代的集合
            private String collection;
            //标签属性，指定迭代集合元素，为集合元素指定的名称
            private String item;
            
            //collection属性的setter和getter方法
            public void setCollection(String collection)
            {
                this.collection = collection;
            }
            public String getCollection()
            {
                return this.collection;
            }
            //item属性的setter和getter方法
            public void setItem(String item)
            {
                this.item = item;
            }
            public String getItem()
            {
                return this.item;
            }
            //标签的处理方法，简单标签处理类只需要重写doTag方法
            public void doTag() throws JspException, IOException
            {
                //从page scope中获取属性名为collection的集合
                Collection itemList = (Collection)getJspContext().getAttribute(collection);
                //遍历集合
                for (Object s : itemList)
                {
                    //将集合的元素设置到page 范围
                    getJspContext().setAttribute(item, s);
                    //输出标签体
                    getJspBody().invoke(null);
                }
            }
        }
    
        example4: 以"页面片段"作为属性的标签处理类
        package lee;
        import javax.servlet.jsp.tagext.*;
        import javax.servlet.jsp.*;
        import java.io.*; 

        public class FragmentTag extends SimpleTagSupport 
        {
            private JspFragment fragment;
            
            //fragment属性的setter和getter方法
            public void setFragment(JspFragment fragment)
            {
                this.fragment = fragment;
            }
            public JspFragment getFragment()
            {
                return this.fragment;
            }
            @Override
            public void doTag() throws JspException, IOException
            {
                JspWriter out = getJspContext().getOut();
                out.println("<div style=‘padding:10px;border:1px solid black‘>");
                out.println("<h3>下面是动态传入的JSP片段</h3>");
                //调用、输出“页面片段”
                fragment.invoke( null );
                out.println("</div");
            }
        }
        上面的程序定义了JspFragment类型的fragment属性，该属性代表了使用该标签时的"页面片段"

        example5: 动态属性的标签处理类
        在某些特殊情况下，我们需要传入自定义标签的属性个数是不确定的、属性名也是不确定的，这就需要使用到动态属性的标签
        package lee;
        import javax.servlet.jsp.tagext.*;
        import javax.servlet.jsp.*;
        import java.io.*;
        import java.util.*;

        public class DynaAttributesTag extends SimpleTagSupport implements DynamicAttributes
        {
            //保存每个属性名的集合
            private ArrayList<String> keys = new ArrayList<String>();
            //保存每个属性值的集合
            private ArrayList<Object> values = new ArrayList<Object>();

            @Override
            public void doTag() throws JspException, IOException
            {
                JspWriter out = getJspContext().getOut();
                //此处只是简单地输出每个属性
                out.println("<ol>");
                for( int i = 0; i < keys.size(); i++ )
                {
                    String key = keys.get( i );
                    Object value = values.get( i );
                    out.println( "<li>" + key + " = " + value + "</li>" );
                }
                out.println("</ol>");
            }
            
            /*
            实现DynamicAttributes接口必须实现setDynamicAttribute，该方法用于为该标签处理类动态添加属性名、属性值
            */
            @Override
            public void setDynamicAttribute( String uri, String localName, Object value) throws JspException
            {
                //添加属性名
                keys.add( localName );
                //添加属性值
                values.add( value );
            }
        }


        2) 建立一个*.tld文件，每个*.tld文件对应一个标签库，每个标签库可包含多个标签
        TLD(Tag Library Definition 标签库定义)的根元素是taglib，它可以包含多个tag子元素，每个tag元素都定义一个标签
        taglib结构如下
            1) tlib-version: 指定该标签库实现的内部版本号
            2) short-name: 该标签库的默认短名
            3) uri: 指定该标签库的唯一标识URI，JSP页面中使用标签库就是根据该URI属性来定位标签库的
            4) tag: 每个tag元素定义一个标签
                4.1) name: 该标签的名字
                4.2) tag-class: 该标签的处理类
                4.3) body-content: 指定标签体内容
                    4.3.1) tagdependent: 标签处理类自己负责处理标签体
                    4.3.2) empty: 该标签只能作为空标签使用
                    4.3.3) scriptless: 该标签可以是静态HTML元素、表达式语言，但不允许JSP脚本
                    4.3.4) JSP: 该标签可以使用JSP脚本
                    4.3.5) dynamic-attributes: 该标签是否支持动态属性
        JSP2规范的自定义标签还允许直接将一段"页面代码"作为属性，这种方式给自定义标签提供了更大的灵活性，它和普通标签的区别并不大，对于以"页面代码"作为属性的自定义标签来
说，需要注意的是:
            1) 标签处理类中定义类型为JspFragment的属性，该属性代表了"页面片段"
            2) 使用标签库时，通过<jsp:attribute../>动作指令为标签库属性指定值
        除此之外，还可以动态属性的标签
        <?xml version="1.0" encoding="GBK"?>
        <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
            version="2.0">
            <tlib-version>1.0</tlib-version>
            <short-name>mytaglib</short-name>
            <!-- 定义该标签库的URI -->
            <uri>http://littlehann.cnblogs.com/mytaglib</uri>

            <!-- 定义第一个标签 -->
            <tag>
                <!-- 定义标签名 -->
                <name>helloWorld</name>
                <!-- 定义标签处理类 -->
                <tag-class>lee.HelloWorldTag</tag-class>
                <!-- 定义标签体为空 -->
                <body-content>empty</body-content>
            </tag>

            /*
            定义第二个标签，对于有属性的标签，需要为<tag../>元素增加<attribute../>子元素，每个attribute子元素定义一个标签元素。<attribute../>子元素通常还需要指定
如下子元素
                1) name: 属性名，子元素的值是字符串内容
                2) required: 该属性是否为必须属性，true or false
                3) fragment: 该属性是否支持JSP脚本、表达式等动态内容，true or false
            */
            <tag>
                <!-- 定义标签名 -->
                <name>query</name>
                <!-- 定义标签处理类 -->
                <tag-class>lee.QueryTag</tag-class>
                <!-- 定义标签体为空 -->
                <body-content>empty</body-content>
                <!-- 配置标签属性:driver -->
                <attribute>
                    <name>driver</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
                <!-- 配置标签属性:url -->
                <attribute>
                    <name>url</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
                <!-- 配置标签属性:user -->
                <attribute>
                    <name>user</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
                <!-- 配置标签属性:pass -->
                <attribute>
                    <name>pass</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
                <!-- 配置标签属性:sql -->
                <attribute>
                    <name>sql</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
            </tag>

            <!-- 定义第三个带标签体的标签 -->
            <tag>
                <!-- 定义标签名 -->
                <name>iterator</name>
                <!-- 定义标签处理类 -->
                <tag-class>lee.IteratorTag</tag-class>
                <!-- 定义标签体不允许出现JSP脚本 -->
                <body-content>scriptless</body-content>
                <!-- 配置标签属性:collection -->
                <attribute>
                    <name>collection</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
                <!-- 配置标签属性:item -->
                <attribute>
                    <name>item</name> 
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
            </tag>
            <tag>
                <!-- 定义以"页面片段"作为属性的标签名 -->
                <name>fragment</name>
                <!-- 定义标签处理类 -->
                <tag-class>lee.FragmentTag</tag-class>
                <!-- 指定该标签不支持标签体 -->
                <body-content>empty</body-content>
                <!-- 定义标签属性：fragment -->
                <attribute>
                    <name>fragment</name>
                    <required>true</required>
                    <fragment>true</fragment>
                </attribute>
            </tag>
            <!-- 定义接受动态属性的标签 -->
            <tag>
                <name>dynaAttr</name>
                <tag-class>lee.DynaAttributesTag</tag-class>
                <body-content>empty</body-content>
                <!-- 指定支持动态属性 -->
                <dynamic-attributes>true</dynamic-attributes>
            </tag>
        </taglib> 
        定义了上面的标签库定义文件之后，将标签库文件放在WEB应用的WEB-INF路径下，WEB容器会自动加载该文件，则该文件定义的标签库也将生效

        3) 在JSP文件中使用自定义标签
        在JSP页面中使用标签库步骤
            1) 导入标签库: 使用taglib编译指令导入标签库，由URI唯一标识指定标签库，并将标签库和指定前缀关联起来(即所有使用该前缀的标签将由此标签库处理)
            <%@ taglib uri="tagliburi" prefix="tagPrefix" %>
            2) 使用标签: 在JSP页面中使用自定义标签
            <tagPrefix:tagName tagAttribute="tagValue" ..>
                <tagBody/>
            </tagPrefix:tagName>
        example1: helloWorld标签使用
        <%@ taglib uri="http://littlehann.cnblogs.com/mytaglib" prefix="mytag"%>
        <mytag:helloWorld></mytag:helloWorld>

        example2: QueryTag标签使用
        <%@ taglib uri="http://littlehann.cnblogs.com/mytaglib" prefix="mytag"%>
        <mytag:query
        driver="com.mysql.jdbc.Driver"
        url="jdbc:mysql://localhost:3306/javaee"
        user="root"
        pass="32147"
        sql="select * from news_inf"/>
        可以看出自定义标签库的作用，以简单的标签，隐藏复杂的逻辑

        example3: IteratorTag标签使用
        <%@ taglib uri="http://littlehann.cnblogs.com/mytaglib" prefix="mytag"%>
        <%
        //创建一个List对象
        List<String> a = new ArrayList<String>();
        a.add("疯狂Java");
        a.add("www.crazyit.org");
        a.add("java");
        //将List对象放入page范围内
        pageContext.setAttribute("a" , a);
        %>
        <table border="1" bgcolor="#aaaadd" width="300">
            <!-- 使用迭代器标签，对a集合进行迭代 -->
            <mytag:iterator collection="a" item="item">
            <tr>
                <td>${pageScope.item}</td>
            <tr>
            </mytag:iterator>
        </table>
        可以看到，使用iterator标签遍历集合元素比使用JSP脚本遍历集合元素要优雅，这也是自定义标签的优势

        example4: fragment标签使用
        <%@ taglib uri="http://littlehann.cnblogs.com/mytaglib" prefix="mytag"%>
        <mytag:fragment>
        <!-- 使用jsp:attribute标签传入fragment参数 -->
        <jsp:attribute name="fragment">
            <!-- 下面是动态的JSP页面片段 -->
            <mytag:helloWorld/>
        </jsp:attribute>
        </mytag:fragment> 
        <mytag:fragment>
            <jsp:attribute name="fragment">
                <!-- 下面是动态的JSP页面片段 -->
                ${pageContext.request.remoteAddr}
            </jsp:attribute>
        </mytag:fragment>

        example5: dynaAttr标签使用
        <%@ taglib uri="http://littlehann.cnblogs.com/mytaglib" prefix="mytag"%>
        <mytag:dynaAttr name="crazyit" url="crazyit.org"/>  
        <mytag:dynaAttr 书名="疯狂Java讲义" 价格="99.0" 出版时间="2008年" 描述="Java图书"/>
        可以看到，不管传入多少属性，这个标签都可以处理 

    JSTL是Sun提供的一套标签库，DisplayTag是Apache组织下的一套开源标签库，主要用于生成页面并显示效果

<%-- 注释内容 --%>
JSP注释用于标注在程序开发过程中的开发提示，"不会"输出到客户端，即客户端连注释符号都看不到 

JSP声明用于声明变量和方法，值得注意的是，JSP声明将会转换成对应的Servlet(.java文件)的成员变量或成员方法(牢记这点，后因为我们还会看到在<%..%>中声明的是局部成员)，
因此JSP声明依然符合java语法。
<%! 声明部分 %>

关于JSP的变量声明
梳理一下，在JSP中声明变量总共有2中情况:
1) 局部变量
<% 在JSP(本质是java代码)中声明变量 %>，又因为JSP代码是会被Tomcat翻译成Servlet的面向对象的java代码，所以在<% %>中声明的变量全都是局部变量(即在代码块中声明的变量)，
它们不能使用private、public、static等修饰
2) 类变量
<%! %>
用这种方式声明的变量是在类的范围域中声明的，属于类变量，它们可以使用private、public、static等修饰
使用的使用一定要注意

example:
<%!
//声明一个整形变量
public int count;
//声明一个方法
public String info()
{
    return "hello";
}
%>

JSP提供了一种输出表达式值的简单方法
<%=表达式%> 

example:
<%!
public int count; 
%>
<%=count++%> 

所有可执行性java代码都可以通过JSP脚本嵌入HTML页面

example:
<%
out.println(new java.util.Date());
%>

动作指令与编译指令不同:
    1) 编译指令是通知Servlet引擎的处理消息，是在将JSP编译成Servlet时起作用
    2) 动作指令只是运行时的动作，通常可替换成JSP脚本，它只是JSP脚本的标准化写法
JSP的动作指令主要有如下7个:

1) jsp:forward: 
执行页面转向，将请求的处理转发到下一个页面，可以转发到:
    1) 静态HTML页面
    2) 动态的JSP页面
    3) 容器中的Servlet
语法1:
<jsp:forward page="{relativeURL|<%=expression%>}"/>
语法2:
<jsp:forward page="{relativeURL|<%=expression%>}">
    {<jsp:param.../>}
</jsp:forward>
第二种语法用于在转发时增加额外的请求参数。增加的请求参数的值可以通过HttpServletRequest类的getParameter()方法获取
request.getParameter("");
从本质上来说，jsp:forward这个动作指令只是一个内部转发，即<jsp:forward../>并没有重新向新页面发送了请求，它只是完全采用了新页面来对用户生成响应(内部转发)，请求依然是一次
请求，所以请求参数、请求属性都不会丢失

2) jsp:include:
动态引入一个JSP页面，它不会导入被include页面的编译指令，仅仅将被导入页面的body内容插入本页面中
<jsp:include page="{relativeURL|<%=expression%>}" flush="true"/>
或者
<jsp:include page="{relativeURL|<%=expression%>}" flush="true">
    <jsp:param name="parameterName" value="parameerValue"/>
</jsp:include>
这里要注意和编译指令的inlcude进行区分
1) 静态引入(编译指令)
<%@include file="file.jsp"%>
可以将外部文件嵌入到当前JSP文件中，同时解析这个页面中的JSP语句(如果有的话)，也就是说，它既可以包含静态的文本，也可以包含动态的JSP页面。包含页面在编译时将完全包含了被包含
页面的代码。需要指出的是，静态包含还会将被包含页面的编译指令也包含进来，如果两个页面的编译指令冲突，那么页面就会出错
2) 动态引入(动作指令)
<jsp:include>
归纳起来，动态导入和静态导入的区别有
1. 静态导入是将被导入页面的代码完全融入，两个页面融合成一个整体Servlet
2. 动态导入则在Servlet中使用include方法来引入被导入页面的内容
3. 静态导入时被导入页面的编译指令会起作用。
4. 动态导入时被导入页面的编译指令则失去作用，只是插入被导入页面的body内容
5. 动态导入可以增加额外的参数
实际上，forward动作指令和include动作指令(动态引入)十分相似，它们都采用方法来引入目标页面
forward指令使用_jspx_page_context.forward()方法来引入目标页面
include指令使用org.apache.jasper.runtime.JspRuntimeLibrary.include()方法来引入目标页面
区别在于，执行forward时，被forward的页面将完全代替原有的页面，而执行include时，被include的页面只是插入原有页面
即forward拿目标页面代替原有页面，而include则拿目标页面插入原有页面

3) JavaBean相关
    3.1) jsp:useBean: 在JSP页面中初始化一个JavaBean的实例
    <jsp:useBean id="name" class="Classname" scope="page|request|session|application"/>
        3.1.1) id: JavaBean的实例名 
        3.1.2) class: 确定JavaBean的实现类
        3.1.3) scope: 指定JavaBean实例的作用范围
            3.1.3.1) page: 该JavaBean实例仅在该页面有效
            3.1.3.2) request: 在本次请求有效
            3.1.3.3) session: 在本次session内有效
            3.1.3.4) application: 在本应用中一直有效 
        3.1.4) 
    3.2) jsp:setProperty: 设置JavaBean实例的属性值
    <jsp:setProperty name="BeanName" property="propertyName" value="value" />
        3.2.1) name: JavaBean的实例名
        3.2.2) property: 确定需要设置的属性名
        3.2.3) value: 确定需要设置的属性值
    3.3) jsp:getProperty: 输出JavaBean实例的属性值
    <jsp:getProperty name="BeanName" property="propertyName" />
        3.3.1) name: 确定需要输出的JavaBean实例名
        3.3.2) property: 确定需要输出的属性名
这三个指令都是与JavaBean相关的指令，如果多个JSP页面中需要重复使用某段代码，我们可以把这段代码定义成java类的方法，然后让多个JSP页面调用该方法即可，这样可以达到较好的代码
复用
在.jsp页面中我们可以这样编码
<!-- 创建lee.Person的实例，该实例的实例名为p1 -->
<jsp:useBean id="p1" class="lee.Person" scope="page"/>
<!-- 设置p1的name属性值 -->
<jsp:setProperty name="p1" property="name" value="wawa"/>
<!-- 设置p1的age属性值 -->
<jsp:setProperty name="p1" property="age" value="23"/>
<!-- 输出p1的name属性值 -->
<jsp:getProperty name="p1" property="name"/><br/>
<!-- 输出p1的age属性值 -->
<jsp:getProperty name="p1" property="age"/>
从代码中可以看到，我们使用了useBean、setProperty、getProperty来操作JavaBean的方法，同时我们需要明白的是，对于property="name"，在JavaBean中提供了setName()、
getName()方法来操作，property="age"也是同理
代码中对应的JavaBean的Person类源代码如下
package lee;
public class Person
{
    private String name;
    private int age;
    
    //无参数的构造器
    public Person()
    {
    }
    //初始化全部属性的构造器
    public Person(String name , int age)
    {
        this.name = name;
        this.age = age;
    }
    
    //name属性的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }
    
    //age属性的setter和getter方法
    public void setAge(int age)
    {
        this.age = age;
    }
    public int getAge()
    {
        return this.age;
    }
} 

4) plugin指令
plugin指令主要用于下载服务器端的JavaBean、或Applet到客户端执行。由于程序在客户端执行，因此客户端必须安装虚拟机

5) param指令
param指令用于设置参数值，这个指令本身不能单独使用，因为单独的param没有实际意义。param指令可以与以下三个指令结合使用
    5.1) jsp:include
    当与include指令结合使用时，param指令用于将参数值传入被导入的页面
    5.2) jsp:forward
    当与forward指令结合使用时，param指令用于将参数值传入被转向的页面
    5.3) jsp:plugin
    当与plugin指令结合使用时，用于将参数传入页面中的JavaBean实例或Applet实例
<jsp:param name="paramName" value="paramValue"/>
*/

JSP脚本中包含内置对象，这些内置对象都是Servleet API接口的实例，JSP规范对它们进行了默认初始化(由JSP页面对应的Servlet的_jspService()方法来创建这些实例)。即它们已经是对
象了，可以直接在JSP脚本中使用了
内置对象依次如下:
    1) application:
    javax.servlet.ServletContext的实例，该实例代表JSP所属的WEB应用本身，因此可以使用application来操作WEB相关的数据，application对象通常有如下两个作用:
        1.1) 在整个WEB应用的多个JSP、Servlet之间共享数据
        application通过setAttribute(String attrName, Object value)方法将一个值设置成application的attrName属性，该属性的值对整个WEB应用有效，因此该WEB应用的每
个JSP页面或Servlet都可以访问该属性，访问属性的方法为getAttribute(String attrName)
            1) put-application.jsp
            <% application.setAttribute("counter",String.valueOf(++i)); %>
            2) get-application.jsp
            <%=application.getAttribute("counter")%> 
            3) GetApplication.java
            ServletContext sc = getServletConfig().getServletContext();
            out.println(sc.getAttribute("counter"));
        因为application代表的是整个WEB应用，因此可以在JSP、Servlet之间共享数据，由于在Servlet中并没有application内置对象，所以需要获取该web应用的ServletContext
实例，每个web应用只有一个ServletContext实例，而在JSP中可以直接通过application内置对象访问该实例
        1.2) 访问WEB应用的配置参数
        除了共享数据，application还可用于从web.xml中获得WEB应用的配置参数
        //从配置参数中获取驱动
        String driver = application.getInitParameter("driver");
        从以上的代码可以看到，可以使用application的getInitParameter(String paramName)来获取WEB应用的配置参数，这些参数应该在web.xml文件中使用context-param元素
配置，每个<context-param../>元素配置一个参数
        <context-param>
            <param-name>driver</param-name>
            <param-value>com.mysql.jdbc.Driver</param-value>
        </context-param>

    2) config对象
    javax.servlet.ServletConfig类的实例，config对象代表当前JSP配置信息
    <%=config.getServletName()%>
    因为所有的JSP页面都有相同的名字: jsp，所以这段JSP代码永远输出jsp
    实际上，我们也可以在web.xml文件中配置JSP，这样就可以为JSP页面指定配置信息，并为JSP页面指定一个虚拟路径
        1) configTest2.jsp
        <!-- 输出该JSP名为name的配置参数 -->
        name配置参数的值:<%=config.getInitParameter("name")%><br/>
        <!-- 输出该JSP名为age的配置参数 -->
        age配置参数的值:<%=config.getInitParameter("age")%>
        2) web.xml
        <servlet>
        <!-- 指定Servlet名字 -->
        <servlet-name>config</servlet-name>
        <!-- 指定将哪个JSP页面配置成Servlet -->
        <jsp-file>/configTest2.jsp</jsp-file>
        <!-- 配置名为name的参数，值为yeeku -->
        <init-param>
            <param-name>name</param-name>
            <param-value>yeeku</param-value>
        </init-param>
        <!-- 配置名为age的参数，值为30 -->
        <init-param>
            <param-name>age</param-name>
            <param-value>30</param-value>
        </init-param>
        </servlet>
        <servlet-mapping>
            <!-- 指定将config Servlet配置到/config URL-->
            <servlet-name>config</servlet-name>
            <url-pattern>/config</url-pattern>
        </servlet-mapping>

    3) exception对象
    exception对象是Throwable的实例，代表JSP脚本中产生的错误和异常，是JSP异常机制的一部分。在JSP脚本中无须处理异常，即使该异常是checked异常，JSP脚本包含的异常都可以交
给错误处理页面处理，exception对象也仅在异常处理页面中才有效。
    打开普通的JSP页面所生成的Servlet类，可以看到如下代码段
    public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException 
    {
        ..
        try 
        {
            response.setContentType("text/html; charset=GBK");
            ..
            out.write(‘ ‘);
        } 
        catch (java.lang.Throwable t) 
        {
            .. 
            if (_jspx_page_context != null) 
                _jspx_page_context.handlePageException(t);
            else 
                throw new ServletException(t);
        } 
        finally 
        {
            _jspxFactory.releasePageContext(_jspx_page_context);
        }
    }
    从以上代码可以看出，JSP脚本和静态HTML部分都已经转换成_jspService()方法里的执行型代码，这就是JSP脚本无须处理异常的原因，因为这些脚本都已经被包含在try块中了。一旦try
块中捕捉到JSP脚本的异常，并且_jspx_page_context不为null，就会由该对象来处理异常。_jspx_page_context对异常的处理也非常简单: 如果该页面的page指令指定了errorPage属性
，则将请求forward到errorPage属性指定的页面，否则使用系统页面来输出异常信息 

    4) out对象
    out对象代表一个页面输出流，通常用于在页面删输出变量值、及常量。所有使用out的地方，都可以使用输出表达式来代替，而且输出表达式更加简洁。从底层原理来看，<%=..%>的本质就
是out.write(..);

    5) pageContext对象
    pageContext对象代表页面上下文，该对象主要用于访问JSP之间的共享数据。使用pageContext可以访问page、request、session、application范围的变量。
    pageContext是javax.servlet.jsp.PageContext类的实例，它提供了
    getAttribute(String name, int scope)来取得指定范围内的name属性，其中scope可以是如下值:
        1) PageContext.PAGE_SCOPE(对应于page范围，默认值)
        2) PageContext.REQUEST_SCOPE(对应于requsst范围)
        3) PageContext.SESSION_SCOPE(对应于session范围)
        4) PageContext.APPLICATION_SCOPE(对应于application范围)
    与getAttribute相对的，PageContext内置对象自然也有一个setAttribute()方法，用于将指定变量放入page、request、session、application范围内
    <%
    //使用pageContext设置属性，该属性默认在page范围内
    pageContext.setAttribute("page","hello");     
    //下面获取各属性所在的范围：
    out.println("page变量所在范围：" + pageContext.getAttributesScope("page") + "<br/>");
    %>

    除此之外，pageContext还可用于获取其他内置对象，pageContext对象还包含如下方法
        1) ServletRequest getRequest(): 获取request对象
        2) ServletResponse getResponse(): 获取response对象
        3) ServletConfig getServletConfig(): 获取config对象
        4) ServletContext getServletContext(): 获取application对象
        5) HttpSession getSession(): 获取session对象
    因此，pageContext对象是一个很重要的对象，一旦在JSP、Servlet编程中获取了pageContext对象，就可以通过它提供的相应方法来获取其他内置对象

    6) request对象
    request对象是JSP中重要的对象，每个request对象封装着一次用户请求，并且所有的请求参数都被封装在request对象中，因此request对象是获取"请求参数"的重要途径。除此之外，
request可代表本次请求的范围，所以还可用于操作request范围的属性
    和request对象相关的功能有:
        1) 获取请求头/请求参数
        request是HttpServletRequest接口的实例，它提供了如下几个方法来获得"请求参数"(GET、POST、COOKIE)
            1.1) String getParameter(String paramName): 获取paramName参数的值
            1.2) Map getParameterMap(): 获取所有请求参数名和参数值所组成的Map对象
            1.3) Enumeration getParameterNames(): 获取所有请求参数名和参数值所组成的Enumeration对象
            1.4) String[] getParameterValues(String name): 获取参数name的值，如果有同名的多个，则返回数组
        HttpServletRequest提供了如下方法来访问HTTP请求头
            1.1) String getHeader(String name): 获取指定HTTP头的参数值
            1.2) java.util.Enumeration<String> getHeaderNames(): 获取所有请求头的名称
            1.3) java.util.Enumeration<String> getHeaders(String name): 获取指定请求头的所有值
            1.4) int getIntHeader(String name): 获取指定请求头的值，并转化为整数值返回
        
        2) 操作request范围的属性
        HttpServletRequest还包含如下两个方法，用于设置和获取request范围的属性
            2.1) setAttribute(String attName, Object attValue): 将attValue设置成request范围的属性(用于JSP页面间共享变量)
            2.2) Object getAttribute(String attName): 获取request范围的属性
        
        3) 执行forward、或include
        request还有一个功能是执行forward和include，也就是代替JSP所提供的forward和include动作指令。
        HttpServletRequest类提供了一个:
        RequesDispatcher getRequestDispatcher(String path):
            1) path为希望forward或include的目标路径
        返回了一个RequesDispatcher对象，它提供如下两个方法：
            1) forward(ServletRequest request, ServletResponse response): 执行forward
            getRequestDispatcher("/a.jsp").forward(request, response);
            2) include(ServletRequest request, ServletResponse response): 执行include
            getRequestDispatcher("/a.jsp").include(request, response);
        
    7) response对象
    response代表服务器对客户端的响应。大部分时候，使用out(页面输出流)生成响应更简单。但out是JspWriter的实例，JspWriter是Writer的子类，而Writer是字符流，无法输出非字
符数据。如果需要在JSP中生成一副位图、PDF文档，则必须使用response作为响应输出
        7.1) response响应生成非字符响应
        response是HttpServletResponse接口的实例，该接口提供了一个getOutputStream()方法，该方法返回响应输出"字节流"
        <%-- 通过contentType属性指定响应数据是图片 --%>
        <%@ page contentType="image/jpeg" language="java"%>
        <%@ page import="java.awt.image.*,javax.imageio.*,java.io.*,java.awt.*"%>
        <%
        //创建BufferedImage对象
        BufferedImage image = new BufferedImage(340, 160, BufferedImage.TYPE_INT_RGB);
        //以Image对象获取Graphics对象
        Graphics g = image.getGraphics();
        //使用Graphics画图，所画的图像将会出现在image对象中
        g.fillRect(0,0,400,400);
        //设置颜色：红
        g.setColor(new Color(255,0,0));
        //画出一段弧
        g.fillArc(20, 20, 100,100, 30, 120);
        //设置颜色：绿
        g.setColor(new Color(0 , 255, 0));
        //画出一段弧
        g.fillArc(20, 20, 100,100, 150, 120);
        //设置颜色：蓝
        g.setColor(new Color(0 , 0, 255));
        //画出一段弧
        g.fillArc(20, 20, 100,100, 270, 120);
        //设置颜色：黑
        g.setColor(new Color(0,0,0));
        g.setFont(new Font("Arial Black", Font.PLAIN, 16));
        //画出三个字符串
        g.drawString("red:climb" , 200 , 60);
        g.drawString("green:swim" , 200 , 100);
        g.drawString("blue:jump" , 200 , 140);
        g.dispose();
        //将图像输出到页面的响应
        ImageIO.write(image , "jpg" , response.getOutputStream());
        %>
        从代码中可以看到几个关键点:
            1) 设置了服务器响应数据是image/jpeg，这表明服务器响应是一张JPG图片
            2) 最后的响应输出流是一个图片的字节流
        也可以在其他HTML页面中使用img标签来显示这张图片
        <img src="img.jsp">

        7.2) 重定向
        重定向是response的另外一个用处，要注意的是，和forward这种内部转接"不同"的是，response的重定向会丢失所有的原始请求参数和request范围的属性，因为重定向将生成第二
次请求，自然与前一次请求不在同一个request范围内。
        HttpServletResponse提供了一个sendRedirect(String path)方法，该方法用于"重定向"到path资源，即"重新"向path资源发送请求

        7.3) 增加Cookie
        增加Cookie也是使用response内置对象完成的，增加Cookie的步骤如下
            1) 创建Cookie实例，构造函数Cookie(String name, String value)
            2) 设置Cookie的生命周期，即该Cookie在多长时间内有效
            3) 向客户端写Cookie，void addCookie(Cookie cookie): 增加Cookie
        <%
        //获取请求参数
        String name = request.getParameter("name");
        //以获取到的请求参数为值，创建一个Cookie对象
        Cookie c = new Cookie("username" , name);
        //设置Cookie对象的生存期限
        c.setMaxAge(24 * 3600);
        //向客户端增加Cookie对象
        response.addCookie(c);
        %>

        获取客户端发送的Cookie的方法
        <%
        //获取本站在客户端上保留的所有Cookie
        Cookie[] cookies = request.getCookies();
        //遍历客户端上的每个Cookie
        for (Cookie c : cookies)
        {
            //如果Cookie的名为username，表明该Cookie是我们需要访问的Cookie
            if(c.getName().equals("username"))
            {
                out.println(c.getValue());
            }
        }
        %>
        要注意的是:
            1) 使用Cookie对象必须设置生存周期，否则Cookie将会随浏览器关闭而自动消失(session cookie)
            2) 如果要存入中文Cookie，则需要使用java.net.URLEncoder进行编码，在获取时用java.net.URLDncoder进行解码

    8) session对象 
    session对象代表一次用户会话，session范围内的属性可以在多个页面的跳转之间共享。session对象是HttpSession的实例，它有如下两个常用的方法:
        8.1) setAttribute(String attName, Object attValue): 设置session范围内attName属性的值为attValue
        8.2) getAttribute(String attName): 返回session范围内attName属性的值
    使用session对象要注意的是:
    考虑session本身的目的，通常只应该把与用户会话状态相关的信息放入session范围内。不要仅仅为两个页面之间交换信息，就将信息放入session范围内。如果仅仅是为了页面间交换信
息，可以将信息放入request范围内，然后forward请求即可。
    除此之外，session机制通常用于保存客户端的状态信息，这些状态信息需要保存到web服务器的硬盘上，所以要求session里的属性值必须是可序列化的，否则将引起"不可序列化异常"，
即session的属性值可以是任何可序列化的java对象

1) Servlet中没有内置对象，原来在JSP中的内置对象都必须由程序显示创建。JSP是Servlet的一种简化，使用JSP只需要完成程序员需要输出到客户端的内容，至于JSP脚本如何嵌入一个类中，
由JSP容器完成
2) 对于静态HTML标签，Servlet都必须使用页面输出流逐行输出。而Servlet则是一个完整的java类，这个类的service()方法用于生成对客户端的响应

1. 编辑好的Servlet源代码文件并不能响应用户请求，还必须将其编译成class文件。将编译好的.class文件放在WEB-INF/classes路径下，如果Servlet有包，则还应该将class文件放在对
应的包路径下
2. 为了让Servlet能响应用户请求，还必须将Servlet配置在web应用中，配置Servlet有两种方式
    1) 在Servlet类中使用@WebServlet Annotation进行配置
    使用@WebServlet时可制定如下常用属性
        1.1) asyncSupported: 声明Servlet是否支持异步操作模式，等价于<async-supported>标签
        1.2) displayName: 该Servlet的显示名，通常配合工具使用，等价于<display-name>标签
        1.3) initParams: 指定一组Servlet初始化参数，等价于<init-param>标签
        1.4) loadOnStartup: 指定Servlet的加载顺序，等价于<load-on-startup>标签
        1.5) name: 指定Servlet的name属性，等价于<servlet-name>，如果没有显式指定，则该Servlet的取值即为类的全限定名
        1.6) urlPatterns: 指定一组Servlet的URL匹配模式(虚拟路径)。等价于<url-pattern>标签
        1.7) value: 该属性等价于urlPatterns属性。两个属性不能同时使用
    example:
    @WebServlet(name="firstServlet", urlPatterns={"/firstServlet"})
    需要注意的是，如果打算采用Annotation来配置Servlet，需要注意如下两点:
        1) 不要在web.xml文件的根元素<web-app../>中指定metadata-complete="true"，因为当该属性值为true时，该web应用不会加载Annotation配置的WEB组件(如Servlet、
Filter、Listener等)
        2) 不要在web.xml文件中配置该Servlet
    2) 通过在web.xml文件中进行配置
        2.1) 配置Servlet的名字: 对应web.xml文件中的<servlet/>元素
        2.2) 配置Servlet的URL: 对应web.xml文件中的<servlet-mapping/>元素。这一步是可选的。但如果没有为Servlet配置URL(虚拟路径)，则该Servlet不能响应用户请求
    example:
    <servlet>
        <!-- 指定Servlet的名字，相当于指定@WebServlet的name属性 -->
        <servlet-name>firstServlet</servlet-name>
        <!-- 指定Servlet的实现类 -->
        <servlet-class>lee.FirstServlet</servlet-class>
    </servlet>
    <!-- 配置Servlet的URL -->
    <servlet-mapping>
        <!-- 指定Servlet的名字 -->
        <servlet-name>firstServlet</servlet-name>
        <!-- 指定Servlet映射的URL地址，相当于指定@WebServlet的urlPatterns属性-->
        <url-pattern>/aa</url-pattern>
    </servlet-mapping>
需要明白的，Annotation和web.xml配置，只要其中一种即可完成Servlet的配置

1. 客户端第一次请求某个Servlet时，系统创建该Servlet的实例: 大部分的Servlet都是这种情况
2. WEB应用启动时立即创建Servlet实例，即load-on-startup Servlet

1. 创建Servlet实例
2. WEB容器调用Servlet的init方法，对Servlet进行初始化
3. Servlet初始化之后，将一直存在于容器中，用于响应客户端请求:
    1) 如果客户端发送GET请求，容器调用Servlet的doGet方法处理并响应请求
    2) 如果客户端发送POST请求，容器调用Servlet的doPost方法处理并响应请求
    3) 或者统一用service()方法处理来响应用户请求
4. WEB容器决定销毁Servlet时，先调用Servlet的destroy方法，通常在关闭web应用之前销毁Servlet

1) Filter对用于请求(HttpServletRequest)进行预处理
2) 接着将请求交给Servlet进行处理并生成响应
3) 最后Filter再对服务器响应(HttpServletResponse)进行后处理

1. 创建Filter类
创建Filter必须实现javax.servlet.Filter接口，在该接口中定义了如下3个方法
    1) void init(FilterConfig config): Filter的初始化
    2) void destroy(): 用于Filter销毁前，完成资源的回收等工作
    3) void doFilter(ServletRequest request, ServletResponse response, FilterChain chain): 实现过滤功能，该方法负责对每个请求、及响应增加额外的处理
example:
package lee;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.*;

@WebFilter(filterName="log", urlPatterns={"/*"})
public class LogFilter implements Filter 
{
    //FilterConfig可用于访问Filter的配置信息
    private FilterConfig config;
    //实现初始化方法
    public void init(FilterConfig config)
    {
        this.config = config; 
    }
    //实现销毁方法
    public void destroy()
    {
        this.config = null; 
    }
    //执行过滤的核心方法
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,ServletException
    {
        //---------下面代码用于对用户请求执行预处理---------
        //获取ServletContext对象，用于记录日志
        ServletContext context = this.config.getServletContext(); 
        long before = System.currentTimeMillis();
        System.out.println("开始过滤...");
        //将请求转换成HttpServletRequest请求
        HttpServletRequest hrequest = (HttpServletRequest)request;
        //输出提示信息
        System.out.println("Filter已经截获到用户的请求的地址： " + hrequest.getServletPath());
        //Filter只是链式处理，请求依然放行到目的地址
        chain.doFilter(request, response);
        //---------下面代码用于对服务器响应执行后处理---------
        long after = System.currentTimeMillis();
        //输出提示信息
        System.out.println("过滤结束");
        //输出提示信息
        System.out.println("请求被定位到" + hrequest.getRequestURI() + "   所花的时间为: " + (after - before)); 
    } 
}
从代码中可以看到，doFilter()方法中"请求预处理"和"响应后处理"的分界线是chain.doFilter()

2. 配置Filter
配置Filter和配置Servlet非常类似，需要配置如下两部分:
    1) 配置Filter名
    2) 配置Filter拦截URL模式: Servlet通常只配置一个URL，而Filter可以同时拦截多个请求的URL。因此在配置Filter的URL模式时通常会使用"模式字符串"(正则字符串)，使得
Filter可以拦截多个请求
        2.1) 在Filter类中通过Annotation进行配置
            2.1.1) asyncSupported: 声明Filter是否支持异步操作模式 
            2.1.2) dispatcherTypes: 指定该Filter仅对哪种dispatcher模式的请求进行过滤
                2.1.2.1) ASYNC
                2.1.2.2) ERROR
                2.1.2.3) FORWARD
                2.1.2.4) INLCUDE
                2.1.2.5) REQUEST
            这5种组合可以以OR的形式进行组合，dispatcherTypes的默认值是"同时"过滤5种模式的请求
            2.1.3) displayName: 该Filter的显示名 
            2.1.4) filterName: 指定该Filter的名称
            2.1.5) initParams: 指定一组Filter配置参数 
            2.1.6) servletName: 指定多个Servlet的名称，用于指定该Filter仅对这几个Servlet执行过滤
            2.1.7) urlPatterns: 指定一组Filter的URL匹配模式(虚拟路径) 
            2.1.8) value: 该属性等价于urlPatterns属性。两个属性不能同时使用
        2.2) 在web.xml文件中通过配置文件进行配置
        <filter>
            <!-- Filter的名字，相当于指定@WebFilter的filterName属性 -->
            <filter-name>log</filter-name>
            <!-- Filter的实现类 -->
            <filter-class>lee.LogFilter</filter-class> 
        </filter>
        <!-- 定义Filter拦截的URL地址 -->
        <filter-mapping>
            <!-- Filter的名字 -->
            <filter-name>log</filter-name>
            <!-- Filter负责拦截的URL，相当于指定@WebFilter的urlPatterns属性 -->
            <url-pattern>/*</url-pattern>
        </filter-mapping>

3. 使用Filter
Filter对应的.class文件被加载后，Filter就会根据设定的URL模式进行响应的预处理、后处理

从本质上来说，Filter和Servlet很相似，Filter里的doFilter()方法里的代码就是从多个Servlet的service()方法里抽取的通用代码，通过使用Filter可以实现更好的代码复用
(类似PHP中的auto_prepend_file、auto_append_file)
假设系统有包含多个Servlet，这些Servlet都需要进行一些通用处理，比如
1) 权限控制: 在预处理中判断用户是否登录，从而决定是否重定向到初始登录页面
2) 记录日志: 将用户的访问记录记录到日志中
3) URL Rewrite实现网站伪静态
所谓伪静态，是将*.jsp、*.php、这种动态URL伪装成静态HTML页面，目的是提供搜索引擎的收录率，我们可以通过Filter拦截所有发向*.html请求，然后按某种规则将请求forward到实际的
*.jsp页面
    3.1) 下载Url Rewrite: http://www.tuckey.org/urlrewrite/
    3.2) 将urlrewrite-3.2.0.jar放到WEB-INF\lib目录下
    3.3) 配置WEB-INF\web.xml
    <filter>
        <filter-name>UrlRewriteFilter</filter-name>
        <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
    </filter>
    <!-- 配置Url Rewrite的Filter拦截所有请求 -->
    <filter-mapping>
        <filter-name>UrlRewriteFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    3.4) 配置WEB-INF\urlrewrite.xml
    <urlrewrite>
        <rule>
            <!-- 所有配置如下正则表达式的请求 -->
            <from>/userinf-(\w*).html</from>
            <!-- 将被forward到如下JSP页面，其中$1代表上面第一个正则表达式所匹配的字符串 -->
            <to type="forward">/userinf.jsp?username=$1</to>
        </rule>
    </urlrewrite>
    3.5) 访问伪静HTML页面: http://localhost:8080/urlrewrite/userinf-LittleHann.html

1) web应用被启动
2) web应用被停止
3) 用户session开始
4) 用户session结束
5) 用户请求到达

1. 实现Listener类
监听不同的WEB事件的监听器也不相同。WEB事件监听器接口如下
    1) ServletContextListener: 用于监听WEB应用的启动和关闭
        1.1) contextInitialized(ServletContextEvent sce)
        1.2) contextDestroyed(ServletContextEvent sce)
    2) ServletContextAttributeListener: 用于监听ServletContext范围(application)内属性的改变
        2.1) attributeAdded(ServletContextAttributeEvent event) 
        2.2) attributeRemoved(ServletContextAttributeEvent event)
        2.3) attributeReplaced(ServletContextAttributeEvent event)
    3) ServletRequestListener: 用于监听用户请求
        3.1) requestInitialized(ServletRequestEvent sre) 
        3.2) requestDestroyed(ServletRequestEvent sre) 
    由于实现了ServletRequestListener接口的监听器可以非常方便地监听到每次请求的创建、销毁，因此web应用可通过该接口的监听器来监听访问该应用的每个请求，从而实现系统日志
    4) ServletRequestAttributeListener: 用于监听ServletRequest范围(request)内属性的改变
        4.1) attributeAdded(ServletRequestAttributeEvent event) 
        4.2) attributeRemoved(ServletRequestAttributeEvent event)
        4.3) attributeReplaced(ServletRequestAttributeEvent event) 
    5) HttpSessionListener: 用于监听用户session的开始和结束
        5.1) sessionCreated(HttpSessionEvent se) 
        5.2) sessionDestroyed(HttpSessionEvent se)
    实现HttpSessionListener接口的监听器可以监听每个用于会话的开始和断开，因此应用可以通过该监听器监听系统的在线用户
    6) HttpSessionAttributeListener: 用于监听HttpSession范围(session)内属性的改变
        6.1) attributeAdded(HttpSessionBindingEvent se) 
        6.2) attributeRemoved(HttpSessionBindingEvent se) 
        6.3) attributeReplaced(HttpSessionBindingEvent se) 
2. 配置Listener
配置Listener只要向web应用注册Listener实现类即可，无须配置参数，相对较简单
    1) 使用@WebListener修饰Listener实现类
    2) 在web.xml文档中使用<listener../>元素进行配置
    <listener>
        <!-- 指定Listener的实现类 -->
        <listener-class>lee.GetConnListener</listener-class>
    </listener>
3. 在指定事件发生时执行相应的函数，我们在实现相应的接口时就需要实现相应的函数