1、Java EE WEB 工程项目文件结构

组成:静态HTML页、Servlet、JSP和其他相关的class;

每个组件在WEB应用中都有固定的存放目录。

WEB应用的配置信息存放在web.xml文件中。

每发布一个组件都必须在web.xml文件中添加相应的配置信息Java Web 应用程序必须使用规范的目录结构。

应用程序根目录,可以取任意的名字,所有的HTML、JSP文件都放在这个目录下
    1.1 WEB-) 存放第三方类库文件,即打包后的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页面

2、web.xml文件

位于每个WEB应用的的WEB-INF路径下的web.xml文件被称为配置描述符,这个web.xml文件对于Java Web应用十分重要,总体来说,web.xml主要负责以下内容:

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文件)的设置

web文件及注释

<?xml version="1.0" encoding="GBK"?>

/*
<?xml version="1.0" encoding="GBK"?>是一个基本的XML文件的框架,不管是什么配置文件,只要是基于XML的,它的基本结构都是这样
*/
<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">

/*
web.xml文件的根元素是<web-app.../>元素,整个web.xml只有这个根元素,每个web.xml必须以这个<web-app>根元素作为开头,在Servlet 3.0规范中,该元素新增了
metadata-complete属性,当该属性值为true时,该web应用"不会"加载Annotation配置的WEB组件(如Servlet、Filter、Listener等),反之则加载
*/

<small-icon>/路径/smallicon.gif</small-icon>
    <large-icon>/路径/largeicon-jpg</large-icon>

/*
    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.
    */

<display-name>站点名称</display-name>
    <description>站点描述</discription>

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

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

<context-param>
       <param-name>param_name</param-name>
       <param-value>param_value</param-value>
    </context-param>
   /*
    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");
    */

<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>

/*
    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匹配到指定的模式后,则对这个请求执行指定的"过滤处理流程"(可以把它理解为一种路由机制)
    */

/*</url-pattern>
    </filter-mapping> 
       <servlet>
        <small-icon>/路径/smallicon.gif</small-icon>
        <large-icon>/路径/largeicon-jpg</large-icon>
        <servlet-name>MyServletName</servlet-name>
        <display-name>站点名称</display-name>
        <description>站点描述</discription>

/*
    6. servlet、servlet-mapping
    和filter过滤器类似,servlet也是用来配置映射处理机制的
    和filter-mapping的作用类似,servlet-mapping用来定义servlet所对应URL.
    */

<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>

/*
        servlet-class、jsp-file有且只能出现一个
        */
 
        /*
        指定当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>
            <role-name>boss</role-name> <!-- New alias -->
            <role-link>manager</role-link> <!-- Real name -->
        </security-role-ref>

/*
        security-role-ref子元素提供出现在服务器专用口令文件中的安全角色名的一个别名。例如,假如编写了一个调用 request.isUserInRole("boss")的servlet,
但后来该servlet被用在了一个其口令文件调用角色manager而不 是boss的服务器中。下面的程序段使该servlet能够使用这两个名称中的任何一个
        */
  
    </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中有一些环境参数的加载配置,它们之间存在优先级的关系

web.xml 的加载顺序是:context-param -> listener -> filter -> servlet ,而相同类型节点之间的程序调用的顺序是根据对应的mapping的顺序进行调用的3、JSP文件

JSP的本质是Servlet,当用户向指定Servlet发送请求时,Servlet利用输出流动态生成HTML页面,包括每一个静态的HTML标签和所有在HTML页面中出现的内容
JSP页面由如下两部分组成:

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

JSP文件样式:

/*
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组织下的一套开源标签库,主要用于生成页面并显示效果

Java EE 学习总结的更多相关文章

  1. Java EE学习——Quartz的Cron表达式

    经历过低谷后,还是要好好学习,越失落会越来越落后. 今天写一下Cron表达式的用法,虽然是之前自己写的,也过了挺长一段时间,这次就拿出来作为回顾吧. Cron表达式是Quartz的精髓(个人觉得),比 ...

  2. Java EE 学习(9):IDEA + maven + spring 搭建 web(5)- 博客文章管理

    转载:Gaussic(一个致力于AI研究却不得不兼顾项目的研究生) . 注:在阅读本文前,请先阅读: Java EE 学习(5):IDEA + maven + spring 搭建 web(1) Jav ...

  3. Java EE 学习(8):IDEA + maven + spring 搭建 web(4)- 用户管理

    转载:Gaussic(一个致力于AI研究却不得不兼顾项目的研究生) 注:在阅读本文前,请先阅读: Java EE 学习(5):IDEA + maven + spring 搭建 web(1) ava E ...

  4. Java EE 学习(7):IDEA + maven + spring 搭建 web(3)- 配置数据库

    参考: https://my.oschina.net/gaussik/blog/513444 注:在阅读本文前,请先阅读: Java EE 学习(5):IDEA + maven + spring 搭建 ...

  5. Java EE 学习(6):IDEA + maven + spring 搭建 web(2)- 配置 Spring

    参考:https://my.oschina.net/gaussik/blog/513353 注:此文承接上一文:Java EE 学习(5):IDEA + maven + spring 搭建 web(1 ...

  6. Java EE 学习(5):IDEA + maven + spring 搭建 web(1)

    参考:http://www.cnblogs.com/lonelyxmas/p/5397422.html http://www.ctolib.com/docs-IntelliJ-IDEA-c--1590 ...

  7. Java EE 学习(4):IDEA + maven 搭建 web(2)

    参考:http://www.bubuko.com/infodetail-1855067.html 现使用 Maven 创建项目:本节接Java EE 学习(3):IDEA + maven 搭建 web ...

  8. 【Java EE 学习 80 上】【WebService】

    一.WebService概述 什么是WebService,顾名思义,就是基于Web的服务,它使用Http方式接收和响应外部系统的某种请求,从而实现远程调用.WebService实际上就是依据某些标准, ...

  9. 【Java EE 学习 74 上】【数据采集系统第六天】【使用Jfreechart的统计图实现】【Jfreechart的基本使用方法】

    之前已经实现了数据的采集,现在已经有了基本的数据,下一步就需要使用这些数据实现统计图的绘制了.这里使用Jfreechart实现这些统计图的绘制.首先看一下Jfreechart的基本用法,只有知道了它的 ...

  10. 【Java EE 学习 69 中】【数据采集系统第一天】【SSH框架搭建】

    经过23天的艰苦斗争,终于搞定了数据采集系统~徐培成老师很厉害啊,明明只是用了10天就搞定的项目我却做了23天,还是模仿的...呵呵,算了,总之最后总算是完成了,现在该好好整理该项目了. 第一天的内容 ...

随机推荐

  1. C++的性能C#的产能?! - .Net Native 系列《二》:.NET Native开发流程详解

    之前一文<c++的性能, c#的产能?!鱼和熊掌可以兼得,.NET NATIVE初窥> 获得很多朋友支持和鼓励,也更让我坚定做这项技术的推广者,希望能让更多的朋友了解这项技术,于是先从官方 ...

  2. 深度分析mysql GROUP BY 与 ORDER BY

    鉴于项目的需要,就从网上找到该文章,文章分析得很详细也很易懂,在android里,(不知道是不是现在水平的限制,总之我还没找到在用ContentProvider时可以使用子查询),主要方法是用SQLi ...

  3. win10 Unistack 服务组 占用资源如何解决

    开始菜单>设置>隐私,隐私界面的左侧栏目,找最后一个“后台应用”,把后台运行的应用全部关掉即可

  4. C#可扩展编程之MEF学习笔记(二):MEF的导出(Export)和导入(Import)

    上一篇学习完了MEF的基础知识,编写了一个简单的DEMO,接下来接着上篇的内容继续学习,如果没有看过上一篇的内容, 请阅读:http://www.cnblogs.com/yunfeifei/p/392 ...

  5. Scalaz(7)- typeclass:Applicative-idomatic function application

    Applicative,正如它的名称所示,就是FP模式的函数施用(function application).我们在前面的讨论中不断提到FP模式的操作一般都在管道里进行的,因为FP的变量表达形式是这样 ...

  6. Css3图标库

    最近在研究icon font图标字库,觉得很有意思,于是找了一些比较好的在线字库.大都是开源的,而且各有特色,推荐给大家! 阿里icon font字库 http://www.iconfont.cn/ ...

  7. 5.6 TestNg的使用

          Java语言编写的WebDriver测试程序通常使用单元测试框架运行.TestNG单元测试框架比JUnit单元测试框架更强大,它提供了更多的扩展功能.目前很大一部分自动化测试工程师已经开始 ...

  8. bug报告-常用词汇中英对照表

  9. 利用Jenkins自动部署工具间接构建kettle的调度平台

    关于Jenkins的介绍我就不说了,自己百度,因为这个工具调用脚本只是他的功能的冰山一角,其他功能我也不能理解,因为不是那个领域.        下面我就介绍一下为什么我们需要一个调度平台,以及学习完 ...

  10. Zookeeper,Kafka,Spark关系

    Kafka中ZooKeeper的用途 正如ZooKeeper用于分布式系统的协调和促进,Kafka使用ZooKeeper也是基于相同的原因.ZooKeeper用于管理.协调Kafka代理.每个Kafk ...