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