Log4j XML Configuration Primer

Basic example

Below is a basic xml configuration file for log4j that will get you started:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
  <appender name="console" class="org.apache.log4j.ConsoleAppender"> 
    <param name="Target" value="System.out"/> 
    <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%-5p %c{1} - %m%n"/> 
    </layout> 
  </appender> 

  <root> 
    <priority value ="debug" /> 
    <appender-ref ref="console" /> 
  </root>
  
</log4j:configuration>

This will print all debug or higher messages to the console/screen. Items of note:

• The appender is defined first, with a name (in this case "console"). A layout is defined for the appender (in this case  PatternLayout ), and a pattern is defined for the layout. What is required for the layout is layout specific, so check the javadoc description for the layout class you choose to use ( PatternLayout  is used most commonly).

• No loggers are defined in this example, but the configuration for the "root" logger is defined. It is configured to level debug, and the appender named "console" is attached to it. All loggers inherit from root, so in this example, all debug or higher messages from all loggers will be printed to the console appender.

XML Configuration Format

In order to better understand the more detailed examples, it is useful to understand the expected format for the xml configuration files. This is defined by the log4j.dtd which is located in the log4j distribution jar in the package org.apache.log4j.xml. The contents of this file will not be listed in its entirety, so please feel free to open/print the file yourself. If you are not familiar with xml dtd file formats, then you should go find a good book on that subject first.

Near the beginning of the file is the following declaration:

<!ELEMENT log4j:configuration (renderer*, appender*,(category|logger)*,root?, categoryFactory?)>

This element defines the expected structure of the xml configuration file: 0 or more renderer elements, followed by 0 or more appender elements, followed by 0 or more logger elements, followed by 0 or 1 root element, followed by 0 or 1 categoryFactory element. If this order is not followed, then errors will be printed by the xml parser at the time the xml file is read in. Also, as a note, the "category" element is the same as the logger element. Prior to log4j version 1.2, loggers were known as category. Much of the documentation still refers to category. Just understand that they are the same thing.

Further along in the log4j.dtd is the following declaration which defines the allowed attributes:

<!ATTLIST log4j:configuration
  xmlns:log4j              CDATA #FIXED "http://jakarta.apache.org/log4j/"  
  threshold                (all|debug|info|warn|error|fatal|off|null) "null" 
  debug                    (true|false|null)  "null" 
>

• debug - Probably the most important attribute for log4:configuration, setting it to "true" will print out information as the configuration file is read and used to configure the log4j environment. Very useful when trying to fiure out why your configuration file is not doing what you expect.

• threshold - <yet to be described>

Understanding the expected structure of the xml configuration file makes it easier to concentrate on the specific elements one needs to configure.

Appender Configuration

One can instrument all the code one writes to output useful debug trace messages, but if log4j is not configured to have at least one appender, all will be for naught. None of the useful messages will be displayed anywhere.

Looking again to the log4j.dtd, appender elements are declared to be:

<!ELEMENT appender (errorHandler?, param*, layout?, filter*, appender-ref*)>
<!ATTLIST appender
  name          ID      #REQUIRED
  class         CDATA   #REQUIRED
>

An appender element must have name and class attributes. The name is the value used to reference the appender in the rest of the configuration file. The class attribute should be the fully qualified class name of the appender class to use (ie  org.apache.log4j.ConsoleAppender ).

An appender element can also contain child elements:

• 0 or 1 errorHandler element - <yet to be described>

• 0 or more param elements - Each appender can be configured with setting specific to the functioning of the appender. This is implemented by getter and setter methods in the appender class. The param element is used to access the setter methods. The format for param elements is simple; they are atomic elements with a name attribute and a value attribute. The name attribute should be the name of the setter method with the "set" part of the method name omitted (ie method name "setTarget" would be "Target"). The value attribute is the value the setter method should be set with.

• 0 or 1 layout element - Not all appenders use or require a layout. For appenders that do, the layout element defines what layout class to use. The layout element has one attribute, class, which is the fully qualified class name of the layout class to use. Similar to the appender element, the layout element is allowed to have 0 or more param child elements. Again, the param elements are used to set specific values for the layout class, which varies based on what layout class is used.

• 0 or more filter elements - See the Filter Configuration section below for more details.

• 0 or more appender-ref elements - <yet to be described>

So, from the above, the simple example of the appender named "console" from the basic example starts to make more sense:

  <appender name="console" class="org.apache.log4j.ConsoleAppender">
    <param name="Target" value="System.out"/>
    <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%-5p %c{1} - %m%n"/> 
    </layout> 
  </appender> 

The name of of the appender is "console" and this is the name that is used to refer to the appender in the rest of the configuration file. The class to use for the appender is  org.apache.log4j.ConsoleAppender .

The console appender has one param element defined. Looking at the javadoc for  ConsoleAppender , the  setTarget  method is used to choose which console stream to print messages to, System.out or System.err. The example configures the appender to use System.out.

The console appender also has a layout element defined which uses  org.apache.log4j.PatternLayout . Looking at the javadoc for  PatternLayout , the setConversionPattern method takes a string describing the layout for messages. The details of this format can also be found in the javadoc.

The details of the configuration for a specific appender class vary from class to class. Your best bet is to review the javadoc for the appender class you want to use. Pay particular attention to the setter property methods and the values they expect. Each setter method can be accessed using the param element in the xml configuration.

Currently, the following appender classes exist:

• org.apache.log4j.ConsoleAppender ConsoleAppender

• org.apache.log4j.FileAppender FileAppender

• org.apache.log4j.jdbc.JDBCAppender JDBCAppender

• org.apache.log4j.AsyncAppender AsyncAppender

• org.apache.log4j.net.JMSAppender JMSAppender

• org.apache.log4j.lf5.LF5Appender LF5Appender

• org.apache.log4j.nt.NTEventLogAppender NTEventLogAppender

• org.apache.log4j.varia.NullAppender NullAppender

• org.apache.log4j.net.SMTPAppender SMTPAppender

• org.apache.log4j.net.SocketAppender SocketAppender

• org.apache.log4j.net.SocketHubAppender SocketHubAppender

• org.apache.log4j.net.SyslogAppender SyslogAppender

• org.apache.log4j.net.TelnetAppender TelnetAppender

• org.apache.log4j.WriterAppender WriterAppender

Logger Configuration

Now the appenders are configured. But how to configure loggers to output messages at a certain level? How to configure loggers to output to specific appender? Welcome to logger configuration.

The most important logger you need to configure is the root logger. From the simple example, this was done with the following configuration:

  <root> 
    <priority value ="debug" /> 
    <appender-ref ref="console" /> 
  </root> 

The root logger is configured to output log message at level "debug" or higher to the appender named "console". All loggers inherit their settings from the root logger, so with no other configuration settings, all loggers will output all of their messages to the "console" appender automatically. This may be fine for simple debugging, but eventually more specific logger configuration is going to be required.

Looking again to the log4j.dtd, logger elements are declared to be:

<!ELEMENT logger (level?,appender-ref*)>
<!ATTLIST logger
  name          ID      #REQUIRED 
  additivity    (true|false) "true"   
>

A logger element must have a name attribute. This is the name of the logger used when creating the Logger instance(usually the fully qualified class name). It can also have an optional additivity attribute. More on this later.

A logger element can also contain child elements:

• 0 or 1 level element - This defines the level of log messages that will be allowed to be logged for this logger. Normal usage has a value of "debug", "info", "warn", "error", or "fatal". Only that level or above will be reported to the log.

• 0 or more appender-ref elements - This references a defined appender that log messages from this logger should be directed to. Appender-ref elements are simple elements that have a ref attribute. The value for this attribute should be the name of the appender.

A typical logger configuration element would look similar to this:

<logger name="com.mycompany.apackage.MyClass">
  <level value="info"/> 
</logger>

Logger Inheritance

<yet to be described>

Additivity

The output of a log statement of logger C will go to all the appenders in C and its ancestors. This is the meaning of the term "appender additivity".

However, if an ancestor of logger C, say P, has the additivity flag set to false, then C's output will be directed to all the appenders in C and it's ancestors upto and including P but not the appenders in any of the ancestors of P.

Loggers have their additivity flag set to true by default.

Example config;

<logger name="com.eatmutton.muttonsite.torque" additivity="false">
   <level value="info" />
   <appender-ref ref="local-torque" />
</logger>

Additivitiy section taken from http://logging.apache.org/log4j/docs/manual.html.

Converting Configuration Files To XML format

I have converted the configuration examples from the log4j manual to xml format. Hopefully people can use this to convert their own configuration files.

Example 1

# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender

# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
  <!-- A1 is set to be a ConsoleAppender -->
  <appender name="A1" class="org.apache.log4j.ConsoleAppender">
    <!-- A1 uses PatternLayout -->
    <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%-4r [%t] %-5p %c %x - %m%n"/> 
    </layout> 
  </appender> 
  <root> 
    <!-- Set root logger level to DEBUG and its only appender to A1 -->
    <priority value ="debug" /> 
    <appender-ref ref="A1" /> 
  </root>
</log4j:configuration>

Example 2

log4j.rootLogger=DEBUG, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout

# Print the date in ISO 8601 format
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n

# Print only messages of level WARN or above in the package com.foo.
log4j.logger.com.foo=WARN

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
  <appender name="A1" class="org.apache.log4j.ConsoleAppender"> 
    <layout class="org.apache.log4j.PatternLayout"> 
      <!-- Print the date in ISO 8601 format -->
      <param name="ConversionPattern" value="%d [%t] %-5p %c - %m%n"/> 
    </layout> 
  </appender> 
  <logger name="com.foo">
    <!-- Print only messages of level warn or above in the package com.foo -->
    <level value="warn"/> 
  </logger>
  <root> 
    <priority value ="debug" /> 
    <appender-ref ref="A1" /> 
  </root>
</log4j:configuration>

Example 3

log4j.rootLogger=debug, stdout, R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
  <appender name="stdout" class="org.apache.log4j.ConsoleAppender"> 
    <layout class="org.apache.log4j.PatternLayout"> 
      <!-- Pattern to output the caller's file name and line number -->
      <param name="ConversionPattern" value="%5p [%t] (%F:%L) - %m%n"/> 
    </layout> 
  </appender> 
  <appender name="R" class="org.apache.log4j.RollingFileAppender"> 
    <param name="file" value="example.log"/>
    <param name="MaxFileSize" value="100KB"/>
    <!-- Keep one backup file -->
    <param name="MaxBackupIndex" value="1"/>
    <layout class="org.apache.log4j.PatternLayout"> 
      <param name="ConversionPattern" value="%p %t %c - %m%n"/> 
    </layout> 
  </appender> 
  <root> 
    <priority value ="debug" /> 
    <appender-ref ref="stdout" /> 
    <appender-ref ref="R" /> 
  </root>
</log4j:configuration>

Filter Configuration

Filters can be defined at appender level. For example, to filter only certain levels, the LevelRangeFilter can be used like this:

        <appender name="TRACE" class="org.apache.log4j.ConsoleAppender">
                <layout class="org.apache.log4j.PatternLayout">
                        <param name="ConversionPattern" value="[%t] %-5p %c - %m%n" />
                </layout>
                <filter class="org.apache.log4j.varia.LevelRangeFilter">
                        <param name="levelMin" value="DEBUG" />
                        <param name="levelMax" value="DEBUG" />
                </filter>
        </appender>

Advanced Topics

<yet to be described>

More examples

(Please feel free to add your own configuration examples here)

Note that TimeBasedRollingPolicy can only be configured with xml, not log4j.properties

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- Note that this file is refreshed by the server every 60seconds, as specified in web.xml -->

<log4j:configuration debug="true">

        <appender name="ROLL" class="org.apache.log4j.rolling.RollingFileAppender">
                <!-- The active file to log to -->
                <param name="file" value="/applogs/myportal/portal.log" />
                <param name="append" value="true" />
                <param name="encoding" value="UTF-8" />

                <rollingPolicy class="org.apache.log4j.rolling.TimeBasedRollingPolicy">
                        <!-- The file to roll to, this is a fairly intelligent parameter, if the file
                        ends in .gz, it gzips it, based on the date stamp it rolls at that time, 
                        default is yyyy-MM-dd, (rolls at midnight)
                        See: http://logging.apache.org/log4j/companions/extras/apidocs/org/apache/log4j/rolling/TimeBasedRollingPolicy.html -->
                        <param name="FileNamePattern" value="/applogs/myportal/portal.%d.log.gz" />
                </rollingPolicy>

                <layout class="org.apache.log4j.PatternLayout">
                        <!-- The log message pattern -->
                        <param name="ConversionPattern" value="%5p %d{ISO8601} [%t][%x] %c - %m%n" />
                </layout>
        </appender>
        
        <!-- Loggers to filter out various class paths -->

        <logger name="org.hibernate.engine.loading.LoadContexts" additivity="false">
                <level value="error"/>
                <appender-ref ref="ROLL" />
        </logger>
        
        <!-- Debugging loggers -->
        
        <!-- Uncomment to enable debug on calpoly code only -->
        <!--
        <logger name="edu.calpoly">
                <level value="debug"/>
                <appender-ref ref="ROLL" />
        </logger>
        -->
        
        <root>
                <priority value="info" />
                <appender-ref ref="ROLL" />
        </root>
        
</log4j:configuration>

为什么要使用自定义标签呢？主要是为了取代丑陋的 JSP 脚本。在 HTML 页面中插入 JSP 脚本有如下几个坏处：

• JSP 脚本非常丑陋，难以阅读。
• JSP 脚本和 HTML 代码混杂，维护成本高。
• HTML 页面中嵌入 JSP 脚本，导致美工人员难以参与开发。

出于以上三点的考虑，我们需要一种可在页面中使用的标签，这种标签具有和 HTML 标签类似的语法，但由可以完成 JSP 脚本的功能——这种标签就是 JSP 自定义标签。

在 JSP1.1 规范中开发自定义标签库比较复杂，JSP 2 规范简化了标签库的开发，在 JSP 2 中开发标签库只需如下几个步骤：

1. 开发自定义标签处理类；
2. 建立一个 *.tld 文件，每个 *.tld 文件对应一个标签库，每个标签库对应多个标签；
3. 在 JSP 文件中使用自定义标签。

开发自定义标签类

当我们在 JSP 页面使用一个简单的标签时，底层实际上由标签处理类提供支持，从而可以使用简单的标签来封装复杂的功能，从而使团队更好地协作开发（能让美工人员更好地参与 JSP 页面的开发）。

早期 JSP 自定义标签类开发过程略微复杂一些，但 JSP 2 已经简化了这个过程，它只要自定义标签类都必须继承一个父类：javax.servlet.jsp.tagext.SimpleTagSupport，除此之外，JSP 自定义标签类还有如下要求。

• 如果标签类包含属性，每个属性都有对应的 getter 和 setter 方法。
• 重写 doTag() 方法，这个方法负责生成页面内容。

下面开发一个最简单的自定义标签，该标签负责在页面上输出 HelloWorld。

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

上面这个标签处理类非常简单，它继承了 SimpleTagSupport 父类，并重写 doTag() 方法，而 doTag() 方法则负责输出页面内容。该标签没有属性，因此无须提供 setter 和 getter 方法。

回页首

建立 TLD 文件

TLD 是 Tag Library Definition 的缩写，即标签库定义，文件的后缀是 tld，每个 TLD 文件对应一个标签库，一个标签库中可包含多个标签，TLD 文件也称为标签库定义文件。

标签库定义文件的根元素是 taglib，它可以包含多个 tag 子元素，每个 tag 子元素都定义一个标签。通常我们可以到 Web 容器下复制一个标签库定义文件，并在此基础上进行修改即可。例如 Tomcat6.0，在 webapps\examples\WEB-INF\jsp2 路径下包含了一个 jsp2-example-taglib.tld 文件，这就是示范用的标签库定义文件。

将该文件复制到 Web 应用的 WEB-INF/ 路径，或 WEB-INF 的任意子路径下，并对该文件进行简单修改，修改后的 mytaglib.tld 文件代码如下：

<?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://www.crazyit.org/mytaglib</uri>
    <!-- 定义第一个标签 -->
    <tag>
        <!-- 定义标签名 -->
        <name>helloWorld</name>
        <!-- 定义标签处理类 -->
        <tag-class>lee.HelloWorldTag</tag-class>
        <!-- 定义标签体为空 -->
        <body-content>empty</body-content>
    </tag>
</taglib>

上面标签库定义文件也是一个标准的 XML 文件，该 XML 文件的根元素是 taglib 元素，因此我们每次编写标签库定义文件都直接添加该元素即可。

taglib 下有三个子元素：

• tlib-version：指定该标签库实现的版本，这是一个作为标识的内部版本号，对程序没有太大的作用。
• short-name：该标签库的默认短名，该名称通常也没有太大的用处。
• uri：这个属性非常重要，它指定该标签库的 URI，相当于指定该标签库的唯一标识。如上粗体字代码所示，JSP 页面中使用标签库时就是根据该 URI 属性来定位标签库的。

除此之外，taglib 元素下可以包含多个 tag 元素，每个 tag 元素定义一个标签，tag 元素下至少应包含如下三个子元素：

• name：该标签库的名称，这个属性很重要，JSP 页面中就是根据该名称来使用此标签的。
• tag-class：指定标签的处理类，毋庸置疑，这个属性非常重要，指定了标签由哪个 Java 类来处理。
• body-content：这个属性也很重要，它指定标签体内容。该元素的值可以是如下几个：
  • tagdependent：指定标签处理类自己负责处理标签体。
  • empty：指定该标签只能作用空标签使用。
  • scriptless：指定该标签的标签体可以是静态 HTML 元素，表达式语言，但不允许出现 JSP 脚本。
  • JSP：指定该标签的标签体可以使用 JSP 脚本。

实际上由于 JSP 2 规范不再推荐使用 JSP 脚本，所以 JSP 2 自定义标签的标签体中不能包含 JSP 脚本。所以实际上 body-content 元素的值不可以是 JSP。

定义了上面的标签库定义文件后，将标签库文件放在 Web 应用的 WEB-INF 路径，或任意子路径下，Java Web 规范会自动加载该文件，则该文件定义的标签库也将生效。

回页首

使用标签库

在 JSP 页面中确定指定标签需要 2 点：

• 标签库 URI：确定使用哪个标签库。
• 标签名：确定使用哪个标签。

使用标签库分成以下两个步骤：

1. 导入标签库：使用 taglib 编译指令导入标签库，就是将标签库和指定前缀关联起来。
2. 使用标签：在 JSP 页面中使用自定义标签。

taglib 的语法格式如下：

<%@ taglib uri="tagliburi" prefix="tagPrefix" %> 

其中 uri 属性确定标签库的 URI，这个 URI 可以确定一个标签库。而 prefix 属性指定标签库前缀，即所有使用该前缀的标签将由此标签库处理。

使用标签的语法格式如下：

<tagPrefix:tagName tagAttribute=”tagValue” … > 
	<tagBody/> 
</tagPrefix:tagName> 

如果该标签没有标签体，则可以使用如下语法格式：

<tagPrefix:tagName tagAttribute=”tagValue” … /> 

上面使用标签的语法里都包含了设置属性值，前面我们介绍的 HelloWorldTag 标签没有任何属性，所以使用该标签只需用 <mytag:helloWorld/> 即可。其中 mytag 是 taglib 指令为标签库指定的前缀，而 helloWorld 是标签名。

下面是使用 helloWorld 标签的 JSP 页面代码：

<%@ page contentType="text/html; charset=GBK"%>
<!-- 导入标签库，指定mytag前缀的标签，
	由http://www.crazyit.org/mytaglib的标签库处理 -->
<%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%>
<html>
<head>
<title>自定义标签示范</title>
</head>
<body bgcolor="#ffffc0">
<h2>下面显示的是自定义标签中的内容</h2>
<!-- 使用标签 ，其中mytag是标签前缀，根据taglib的编译指令，
	mytag前缀将由http://www.crazyit.org/mytaglib的标签库处理 -->
<mytag:helloWorld/><BR>
</body>
</html>

上面页面中第一行粗体字代码指定了 http://www.crazyit.org/mytaglib 标签库的前缀为 mytag，第二行粗体字代码表明使用 mytag 前缀对应标签库里的 helloWorld 标签。浏览该页面将看到如图 1 所示效果：

回页首

带属性的标签

前面的简单标签既没有属性，也没有标签体，用法、功能都比较简单。实际上还有如下两种常用的标签：

• 带属性的标签。
• 带标签体的标签。

正如前面介绍的，带属性标签必须为每个属性提供对应的 setter 和 getter 方法。带属性标签的配置方法与简单标签也略有差别，下面介绍一个带属性标签的示例：

public class QueryTag extends SimpleTagSupport
{
    //标签的属性
    private String driver;
    private String url;
    private String user;
    private String pass;
    private String sql;
    //执行数据库访问的对象 
    private Connection conn = null;
    private Statement stmt = null;
    private ResultSet rs = null;
    private ResultSetMetaData rsmd = null;
    //标签属性driver的setter方法
    public void setDriver(String driver) {
        this.driver = driver; 
    }
        //标签属性url的setter方法
    public void setUrl(String url) {
        this.url = url; 
    }
        //标签属性user的setter方法
    public void setUser(String user) {
        this.user = user; 
    }
        //标签属性pass的setter方法
    public void setPass(String pass) {
        this.pass = pass; 
    }
        //标签属性driver的getter方法
    public String getDriver() {
        return (this.driver); 
    }
        //标签属性url的getter方法
    public String getUrl() {
        return (this.url); 
    }
        //标签属性user的getter方法
    public String getUser() {
        return (this.user); 
    }
        //标签属性pass的getter方法
    public String getPass() {
        return (this.pass); 
    }
        //标签属性sql的getter方法
    public String getSql() {
        return (this.sql); 
    }
        //标签属性sql的setter方法
    public void setSql(String sql) {
        this.sql = sql; 
    }
    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();
            }
        }
    }
}

上面这个标签稍微复杂一点，它包含了 5 个属性，如程序中粗体字代码所示，则程序需要为这 5 个属性提供 setter 和 getter 方法。

该标签输出的内容依然由 doTag() 方法决定，该方法会根据 SQL 语句查询数据库，并将查询结果显示在当前页面中。

对于有属性的标签，需要为 tag 元素增加 attribute 子元素，每个 attribute 子元素定义一个属性，attribue 子元素通常还需要指定如下几个子元素：

• name：设置属性名，子元素的值是字符串内容。
• required：设置该属性是否为不需属性，该子元素的值是 true 或 false。
• fragment：设置该属性是否支持 JSP 脚本、表达式等动态内容，子元素的值是 true 或 false。

为了配置上面的 QueryTag 标签，我们需要在 mytaglib.tld 文件中增加如下配置片段：

<!-- 定义第二个标签 -->
<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>

上面 5 行粗体字代码分别为该标签配置了 driver、url、user、pass 和 sql 等 5 个属性，并指定这 5 个属性都是必填属性、而且属性值支持动态内容。

配置完毕后，就可在页面中使用标签，先导入标签库，然后使用标签。使用标签的 JSP 页面片段如下：

<!-- 导入标签库，指定mytag前缀的标签，
    由http://www.crazyit.org/mytaglib的标签库处理 -->
<%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%>
...
<!-- 其他HTML内容 -->
<!-- 使用标签 ，其中mytag是标签前缀，根据taglib的编译指令，
    mytag前缀将由http://www.crazyit.org/mytaglib的标签库处理 -->
<mytag:query
    driver="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/javaee"
    user="root"
    pass="32147"
    sql="select * from newsinf"/>

在浏览器中浏览该页面，效果如图 2 所示。

图 2 中看到从数据库里查询到 2 条记录，当然这也需要底层 javaee 数据库里包含 newsinf 数据表，且该数据表里包含这两条记录才行。

在 JSP 页面中只需要使用简单的标签，即可完成“复杂”的功能：执行数据库查询，并将查询结果在页面上以表格形式显示。这也正是自定义标签库的目的——以简单的标签，隐藏复杂的逻辑。

当然，并不推荐在标签处理类中访问数据库，因为标签库是表现层组件，它不应该包含任何业务逻辑实现代码，更不应该执行数据库访问，它只应该负责显示逻辑。

回页首

带标签体的标签

带标签体的标签，可以在标签内嵌入其他内容（包括静态的 HTML 内容和动态的 JSP 内容），通常用于完成一些逻辑运算，例如判断和循环等。下面以一个迭代器标签为示例，介绍带标签体标签的开发过程。

一样先定义一个标签处理类，该标签处理类的代码如下：

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);
        }
    }
}

上面标签处理类与前面处理类并没有太大的不同，该处理类包含 2 个属性，并为这两个属性提供了 setter 和 getter 方法。标签处理类的 doTag 方法首先从 page 范围内获取了指定名称的 Collection 对象，然后遍历 Collection 对象的元素，每次遍历都调用了 getJspBody() 方法，如程序中粗体字代码所示，该方法返回该标签所包含的标签体：JspFragment 对象，执行该对象的 invoke() 方法，即可输出标签体内容。该标签的作用是：遍历指定集合，每遍历一个集合元素，即输出标签体一次。

因为该标签的标签体不为空，配置该标签时指定 body-content 为 scriptless，该标签的配置代码片段如下代码所示：

<!-- 定义第三个标签 -->
<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>

上面配置片段中粗体字代码指定该标签的标签体可以是静态 HTML 内容，也可以是表达式语言。

为了测试在 JSP 页面中使用该标签的效果，我们首先把一个 List 对象设置成 page 范围的属性，然后使用该标签来迭代输出 List 集合的全部元素。

JSP 页面代码如下：

<%@ page import="java.util.*"%>
<%@ page contentType="text/html; charset=GBK"%>
<!-- 导入标签库，指定mytag前缀的标签，
    由http://www.crazyit.org/mytaglib的标签库处理 -->
<%@ taglib uri="http://www.crazyit.org/mytaglib" prefix="mytag"%>
<html>
    <head>
        <title>带标签体的标签-迭代器标签</title>
    </head>
    <body>
        <h2>带标签体的标签-迭代器标签</h2>
        <hr>
        <%
        //创建一个List对象
        List<String> a = new ArrayList<String>();
        a.add("hello");
        a.add("world");
        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>
    </body>
</html>

上面页面代码中粗体字代码即可实现通过 iterator 标签来遍历指定集合，浏览该页面即看到如图 3 所示界面：

图 3 显示了使用 iterator 标签遍历集合元素的效果，从 iteratorTag.jsp 页面的代码来看，使用 iterator 标签遍历集合元素比使用 JSP 脚本遍历集合元素要优雅得多，这就是自定义标签的魅力。

实际上 JSTL 标签库提供了一套功能非常强大标签，例如普通的输出标签，像我们刚刚介绍的迭代器标签，还有用于分支判断的标签等等，JSTL（JSP 标准标签库）都有非常完善的实现。除此之外，Apache 下还有一套 DisplayTags 的标签库实现，做得也非常不错。
本文转自：http://www.ibm.com/developerworks/cn/java/j-lo-jsp2tag/index.html

经常需要将一些受到版本控制的文件夹挪作他用，在用版本库的同学都知道，里面的 .svn 文件夹不仅遍布整个文件夹的各个层级，而且里面东西很多，如果遇到要删除的情况，手动一一删除可就累了，小D就经常为了删这些.svn文件夹而删到手酸，吃过几次苦之后决定找出批量删除的方法… 还好，只要有需求就用解决方法，这就分享给大家吧，说不定哪天就能用上，适用于windows客户端：

确定要删除的是下面这样的文件夹，此方面就适用于此，可别弄错了：

安装：建立一个文本文件，随意起个名字，例如aaa.reg（扩展名由txt改为reg，可以在txt编辑的时候点另存为…类型所有、文件名aaa.reg、保存即可），内容如下：

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\DeleteSVN]
@="Delete SVN Folders"

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\DeleteSVN\command]
@="cmd.exe /c \"TITLE Removing SVN Folders in %1 && COLOR 9A && FOR /r \"%1\" %%f IN (.svn) DO RD /s /q \"%%f\" \""

保存之后，双击这个reg文件，会提示是否允许添加到注册表，确定并提示成功后，在每一个文件夹上点击右键都会有一个“Delete SVN Folders”的选项，点击就可以删除这个文件夹及子目录里面所有的.svn文件了，很方便吧；

注：“Delete SVN Folders”可根据自己的喜好修改，将文件中@="Delete SVN Folders"双引号内的内容修改成其他即可。

卸载：有同学又要问了：我这次用完了，很好！但我不想要了，点右键就出来影响美观怎么办？

小D考虑到了这点，现在就告诉你怎么删，刚才是添加到了注册表，那我们可以直接去注册表删：

运行 regedit 进入注册表->依次打开：HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Folder\shell\->看到DeleteSVN文件夹->删除就可以了，也很简单吧，但小D要提醒你，注册表不要随便改动，最好备份一下啊。

OK，分享完毕，感谢收听。
本人转自http://www.didiao.net/?p=455

第二步、创建相应的部署目录
..\Tomcat 6.0\webapps1
..\Tomcat 6.0\webapps2
同时可以将Tomcat 6.0\webapps下的有用的复制到新建的部署目录

第三步、创建配置文件目录和配置文件
..\Tomcat 6.0\conf\Catalina1\localhost
..\Tomcat 6.0\conf\Catalina2\localhost

host-manager.xml
manager.xml

配置文件的配置可参照..\Tomcat 6.0\conf\Catalina\localhost下的，只需要修改一下对应目录即可

大概的配置步骤就是这些，现在可以把不同的war包放在不同的位置来访问了
以上配置方法同样适合Tomcat 5.5

事实上，速查表就是来帮助我们把日常中最常用到的信息聚集起来，方便使用，使我们做工作时更有效率。有了它们，免去了你的大脑花额外时间去记忆它们的烦恼——你只需要打开简表，马上能查到你想要的信息。

这篇文章里，你可以看到最实用的HTML，CSS，JavaScript速查表，它们可以当作参考资料，备忘录，能帮助你以最快的速度找到想要的信息。

看看这些简表是不是你想要的，请在文章下面留下你的建议，谢谢！

HTML

HTML帮助手册

HTML速查手册

HTML特殊字符速查表

Dreamweaver

Dreamweaver快速参考指导

CSS

CSS 3 速查表

Blueprint CSS

YUI Grid CSS

CSS 速记简表

CSS速查表(V2)

CSS速记表

CSS2参考指导(V2)

实用CSS速查表

Javascript

jQuery 1.4.2 直观速查表

JavaScript 速查表

JavaScript参考单

JavaScript真经

常用DOM方法

JavaScript快速参考单

Mootools 1.2速查表

jQuery速查表

Prototype速查表

希望你能喜欢我收集到的这些速查表，并请分享给你的做开发工作的朋友们。

[英文出处]：Most Useful Cheat Sheet For HTML, CSS and Javascript

Celestia 是一款免费开放源代码软件。国内有软件介绍把它称作「宇宙穿梭机」或是「鸟瞰地球」，这都名副其实。Celestia 会通过检测操作系统语言自动切换软件语言，对中文支持良好。

用十字指针指向一个星球，在 Celestia 左上角即显示星球的信息。也可以像下图一样选择显示星座，就是在现实看见的同样的星座，没有连线，观赏感受也是不同的。Celestia 的功能多以关键字执行，刚上手也许会感觉不知所措，一时了解不到其中的趣味，只要认识了 Celestia 的基本操作，就能发觉把玩 Celestia 是一件多么有趣的事。

同样作为新手，波斯推荐一定要看 Celestia 的内置演示，就在帮助菜单可以找到。演示有字幕介绍星球的著名点，带你用 Celestia 遨游太阳系，从地球到月球，再去逛土星……就像一个无影的导游在带你进行太空旅行。刚打开 Celestia，我觉得它超闷，但是看了演示后，探索 Celestia 的热情就被激发起来了。

Celestia 还能通过插件增强功能，不过目前插件还只有 1 个。（笑）

下载地址：http://www.shatters.net/celestia/download.html | 自用版本分流 | 35M。

2. Stellarium – 从地球看星际

Stellarium 非常强悍地内置了非常多国语言，光是中文就有 3 种（为什么有 3 种？）。从设置上来说，可控制的比 Celestia 更多，当然在用途上也有所出入。最不同的是，Stellarium 给你一种从自家阳台抬头望天的观赏感受，而这点 Celestia 是做不到的。Stellarium 也是免费开放源代码软件。

Stellarium 同样能点击星球显示信息，显示信息比 Celestia 的全面。在星座显示上，还能显示形象配图。所见区域也能选择地域而定，不过预设的中国区域太少了，找来找去才只有一个 Acheng, China。

用户可以通过拖拽天空看到头顶上的星际。默认是实时显示，所以波斯的截图就不是夜间版了，夜间版比较有说服力的说。背景的图，就是下图可见的树木房屋之类都是可换的。

不过 Stellarium 貌似对字体有要求，也许是波斯换了语言后没有设置好，如图所见的本来应该显示星球名称的地方都变成了小方块。不过跟 GDI++ 字体渲染没有冲突。

Stellarium 在官方主页有新手教学，比 Celestia 重视新人用户培养呢。

下载地址：http://www.stellarium.org/zh/ | Windows 版本约 41M。

希望你也能从这两款软件找到你久违的星空吧！离题地说一句，大家要爱护环境，保护地球噢！