语源科技BlogJava-followith

SAX Parser

followith — Tue, 12 May 2009 07:29:00 GMT

什么是 SAX
读取和操纵 XML 文件的标准方法是 DOM（“文档对象模型”）。遗憾的是，这种方法需要读取整个文件并将它存储到树结构中，因而效率不高、缓慢，并且会过度使用资源。

一种替代方法是使用 Simple API for XML 或 SAX。SAX 允许正在读取文档时处理该文档，这避免了在采取操作之前需要等待存储文档的所有内容。

SAX 是由 XML-DEV 邮件列表的成员开发的，Java 版本由 David Megginson 维护。他们的目的是提供一种更自然的方法来使用 XML，这种方法不会涉及到使用 DOM 的那种开销。

结果是基于事件的 API。解析器将事件（譬如，元素的开始或结束）发送给处理信息的事件处理程序。然后，应用程序自己可以处理数据。虽然原始文档保持不变，但 SAX 提供了操纵数据的方法，然后会将该方法导向另一个过程或文档。

对于 SAX，没有官方的标准；万维网（W3C）或其它官方组织不维护 SAX，但在 XML 社区中，它是一个事实上的标准。

SAX 处理是如何工作的
SAX 分析经过其的 XML 流，这非常象老式的自动收报机纸条。考虑以下 XML 代码片断：

一般情况下，SAX 处理器分析这段代码将生成以下事件：



            Start document

            Start element (samples)

            Characters (white space)

            Start element (server)

            Characters (UNIX)

            End element (server)

            Characters (white space)

            Start element (monitor)

            Characters (color)

            End element (monitor)

            Characters (white space)

            End element (samples)

SAX API 允许开发者捕获这些事件，并对它们进行操作。

SAX 处理涉及以下几步：

创建事件处理程序。
创建 SAX 解析器。
将事件处理程序分配给解析器。
对文档进行解析，将每个事件发送给处理程序。

在SAX与DOM之间，如何选择
选择 DOM 还是 SAX，这取决于几个因素：

应用程序的目的：如果必须对数据进行更改，并且作为 XML 将它输出，则在大多数情况下，使用 DOM。与使用 XSL 转换来完成的简单结构更改不一样，如果是对数据本身进行更改，则尤其应该使用 DOM。
数据的数量：对于大文件，SAX 是更好的选择。
将如何使用数据：如果实际上只使用一小部分数据，则使用 SAX 将数据抽取到应用程序中，这种方法更好些。另一方面，如果知道将需要向后引用已经处理过的信息，则 SAX 可能不是正确的选择。
需要速度：通常，SAX 实现比 DOM 实现快。

记住 SAX 和 DOM 不是互斥的，这一点很重要。可以使用 DOM 来创建事件的 SAX 流，可以使用 SAX 来创建 DOM 树。事实上，大多数解析器实际常常使用 SAX 来创建 DOM 树！

使用 JAXP 来创建解析器
接下来我们来看一下JAXP的SAX Parser是怎么样工作的。

首先声明 XMLReader xmlReader。然后使用 SAXParserFactory 来创建 SAXParser。正是 SAXParser 给您了 XMLReader。



            import org.xml.sax.helpers.DefaultHandler;

            import javax.xml.parsers.SAXParser;

            import javax.xml.parsers.SAXParserFactory;

            import org.xml.sax.XMLReader;

            

            public class SurveyReader extends DefaultHandler

            {

            public SurveyReader() {

            }

            

            public static void main (String args[]) {

            XMLReader xmlReader = null;

            try {

            SAXParserFactory spfactory =

            SAXParserFactory.newInstance();

            spfactory.setValidating(false);	//设置验证选项,

            如果您的XML文件是有效文档的话,

            就不用验证.这将提高处理速度

            SAXParser saxParser = spfactory.newSAXParser();

            xmlReader = saxParser.getXMLReader();

            

            } catch (Exception e) {

            System.err.println(e);

            System.exit(1);

            }

            }

            }

设置内容处理程序
一旦创建了解析器，则需要将 SurveyReader 设置为内容处理程序，以便于其接收事件。

xmlReader 的 setContentHandler() 方法完成这项工作。



            ...

            xmlReader = saxParser.getXMLReader();

            

            xmlReader.setContentHandler(new SurveyReader());

            

            } catch (Exception e) {

            ...

当然，对于内容处理程序，这不是唯一的选项。

解析 InputSource
为了对文件进行实际地解析，需要 InputSource。这个 SAX 类封装了所有将要处理的数据，所以不必担心它来自哪里。

现在，准备对文件进行实际解析。应用程序将封装在 InputSource 中的文件传递给 parse()，然后应用程序会继续运行。



            ...

            

            import org.xml.sax.InputSource;

            

            ...

            xmlReader = saxParser.getXMLReader();

            xmlReader.setContentHandler(new SurveyReader());

            

            InputSource source = new InputSource("surveys.xml");

            xmlReader.parse(source);

            

            

            } catch (Exception e) {

            ...

可以编译和运行该程序，但这时应该什么也没有发生，因为应用程序还没有定义任何事件。

创建 ErrorHandler
当然总会有可能在试图进行解析时，数据有问题。在这样的情况下，有一个处理程序来处理错误和内容将是有帮助的。

就如同创建内容处理程序一样，可以创建出错处理程序。通常，将作为 ErrorHandler 的单独实例来创建它，但为了简化该示例，出错处理正是包含在 SurveyResults 中。由于该类继承了 DefaultHandler 且没有扩展 ContentHandler，所以这种双重用法是可能的。

需要关注的事件有三个：警告、错误和致命错误。



            ...

            

            import org.xml.sax.SAXParseException;

            

            

            public class SurveyReader extends DefaultHandler

            {

            

            public SurveyReader() {

            }

            public void error (SAXParseException e) {

            System.out.println("Error parsing the file: "+e.getMessage());

            }

            public void warning (SAXParseException e) {

            System.out.println("Problem parsing the file: "+e.getMessage());

            }

            public void fatalError (SAXParseException e) {

            System.out.println("Error parsing the file: "+e.getMessage());

            System.out.println("Cannot continue.");

            System.exit(1);

            }

            }

            ....

            xmlReader.setContentHandler(new SurveyReader());

            

            xmlReader.setErrorHandler(new SurveyReader());

            //设置 ErrorHandler

            

            InputSource source = new InputSource("surveys.xml");

            ....

            

            public static void main (String args[]) {

            ...

SAX 事件
以下事件是常用的；它们都在 org.xml.sax 包的 HandlerBase 类中定义。

startDocument 表示文档开始。
endDocument 表示文档结束。
startElement 表示元素开始。当一对标记中的起始标记中的所有内容被处理后，解析器激发此事件。包括了标记名和其属性。
endElement 表示元素结束。
characters 包含字符数据，类似于 DOM 的一个 Text 节点。

还有更多的 SAX 事件：

ignorableWhitespace 此事件类似于我们前面所讨论的无用 DOM 节点。它与 character 事件的区别，好处是:如果您不需要空格符，您可以通过忽略这个事件来忽略所有的空格符。
warning、error 和 fatalError 这三个事件表示了解析错误。您可根据需要来响应它们。
setDocumentLocator 这个事件允许您存储一个 SAX 的 Locator 对象。Locator 对象可以用来找出在文档中确切发生事件的地方。

转自：http://www-128.ibm.com/developerworks/cn/xml/x-cert/part8/

followith 2009-05-12 15:29 发表评论

JSP的重定向有两种：forward和sendRedirect，它们的原理以及区别

followith — Fri, 24 Apr 2009 03:39:00 GMT

JSP的重定向有两种：forward和sendRedirect，它们的原理以及区别是什么呢？

它们在使用上的区别有很多，那些都是表面现象，在理解了它们各自的原理以后，使用上的区别那就能容易掌握了。

一、原理.

1、 Forward

这种方式是在服务器端作的重定向。服务器往client发送数据的过程是这样的：服务器在向客户端发送数据之前，是先将数据输出到缓冲区，然后将缓冲区中数据发送给client端。什么时候将缓冲区里的数据发送给client端呢？（1）当对来自client的request处理完，并把所有数据输出到缓冲区，（2）当缓冲区满，（3）在程序中调用缓冲区的输出方法out.flush()或 response.flushbuffer()，web container才将缓冲区中的数据发送给client。

这种重定向方式是利用服务器端的缓冲区机制，在把缓冲区的数据发送到客户端之前，原来的数据不发送，将执行转向重定向页面，发送重定向页面的数据，重定向调用页的数据将被清除。如果在之前有很多输出，前面的输出已使缓冲区满，将自动输出到客户端，那么这种重定向方式将不起作用，这一点应该特别注意。

public void doPost(HttpServletRequest request,HttpServletResponse response)  throws ServletException,IOException
{
       response.setContentType("text/html; charset=UTF-8");
       ServletContext sc = getServletContext();
       RequestDispatcher rd = null;
       rd = sc.getRequestDispatcher("/index.jsp");
       rd.forward(request, response);
}

2、 sendRedirect

这种方式是在客户端作的重定向处理。该方法通过修改HTTP协议的HEADER部分,对浏览器下达重定向指令的，让浏览器对在location中指定的URL提出请求，使浏览器显示重定向网页的内容。该方法可以接受绝对的或相对的URLs。如果传递到该方法的参数是一个相对的URL，那么Web container在将它发送到客户端前会把它转换成一个绝对的URL。public void doPost(HttpServletRequest request,HttpServletResponse response)   throws ServletException,IOException
{
       response.setContentType("text/html; charset=UTF-8");
       response.sendRedirect("/index.jsp");
}

二、区别.

1、forward重定向是在容器内部实现的同一个Web应用程序的重定向，所以forward方法只能重定向到同一个Web应用程序中的一个资源，重定向后浏览器地址栏URL不变，而sendRedirect方法可以重定向到任何URL，因为这种方法是修改http头来实现的，URL没什么限制，重定向后浏览器地址栏URL改变。

2、forward重定向将原始的HTTP请求对象（request）从一个servlet实例传递到另一个实例，而采用sendRedirect方式两者不是同一个application。

3、基于第二点，参数的传递方式不一样。forward的form参数跟着传递，所以在第二个实例中可以取得HTTP请求的参数。sendRedirect只能通过链接传递参数，response.sendRedirect(“login.jsp?param1=a”)。

4、sendRedirect能够处理相对URL，自动把它们转换成绝对URL，如果地址是相对的，没有一个‘/’，那么Web container就认为它是相对于当前的请求URI的。比如，如果为response.sendRedirect("login.jsp")，则会从当前servlet 的URL路径下找login.jsp： http://10.1.18.8:8081/dms/servlet/Servlet 重定向的URL: http://10.1.18.8:8081/dms/servlet/login.jsp，如果为response.sendRedirect("/login.jsp")则会从当前应用径下查找url:http://10.1.18.8:8081/login.jsp。而forward不能这样处理相对路径。

followith 2009-04-24 11:39 发表评论

Log4j分析

followith — Wed, 22 Apr 2009 02:43:00 GMT

1、Log4j可以帮助调试(有时候debug是发挥不了作用的)和分析，要下载和了解更详细的内容可以访问官方网站：http://jakarta.apache.org/log4j
2、log4j概念
Log4j中有三个主要的组件，它们分别是Logger、Appender和Layout，Log4j允许开发人员定义多个Logger，每个Logger拥有自己的名字，Logger之间通过名字来表明隶属关系。有一个Logger称为Root，它永远存在，且不能通过名字检索或引用，可以通过Logger，getRootLogger（）方法获得，其他Logger通过Logger.getLogger(String name)方法
Appender则是用来指明将所有log信息存放到什么地方，Log4j中支持多种appender，如console，files，GUI components、NT Event Loggers等，一个Logger可以拥有多个Appender，也就是你既可以将Log信息输出到屏幕，同时存储到一个文件中。
Layout的作用是控制Log信息的输出方式，也就是格式化输出的信息
Log4j中将要输出的Log信息定义了5中级别，依次为DEBUG、INFO、WARN、ERROR和FATAL，当输出时只有级别高过配置中规定的级别的信息才能真正的输出，这样就很方便的来配置不同情况下要输出的内容，而不需要更改代码，这点实在是方便。
3、log4j的配置文件
虽然可以不用配置文件，而在程序中实现配置，但这种方法在如今的系统开发中显然是不可取的，能采用配置文件的地方一定一定要采用配置文件。Log4j支持两种格式的配置文件：xml格式和java的property格式

log4j.roorLogger=debug,stdout,R
log4j.appender.stout=org.apache.log4j.ConsoleAppender
log4j.appender.stout.layout=org.apache.log4j.PatternLayout

#pattern to output the caller's file name and line number
log4j.apender.stout.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

首先，是设置root，格式为appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。配置日志信息输出目的地Appender，其语法为
log4j.appender.appenderName = fully.qualified.name.of.appender.class
log4j.appender.appenderName.option1 = value1
...
log4j.appender.appenderName.option = valueN
Log4j提供的appender有以下几种：
org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生新文件）
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
配置日志信息的格式（布局），其语法为：
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
log4j.appender.appenderName.layout.option1 = value1
....
log4j.appender.appenderName.layout.option = valueN
Log4j提供的layout有以下几种：
org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
%r 输出自应用启动到输出该log信息耗费的毫秒数
%c 输出所属的类目，通常就是所在类的全名
%t 输出产生该日志事件的线程名
%n 输出一个回车换行符，Windows平台为“"r"n”，Unix平台为“"n”
%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似： 2002年10月18日 22：10：28，921
%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

4、Log4j在程序中的使用
要在自己的程序中使用Log4j，首先需要将commons-logging.jar和logging-log4j-1.2.9.jar导入到构建路径中。然后再将log4j.properties放到src根目录下。这样就可以在程序中使用log4j了。在类中使用log4j，首先声明一个静态变量 Logger logger=Logger.getLog("classname")；现在就可以使用了，用法如下：logger.debug("debug message")或者logger.info("info message")，看下面一个小例子：

import com.foo.Bar;
import org.apache.log4j.Logger;
  import org.apache.log4j.PropertyConfigurator;
  public class MyApp {
static Logger logger = Logger.getLogger(MyApp.class.getName());
   public static void main(String[] args) {
    // BasicConfigurator replaced with PropertyConfigurator.
     PropertyConfigurator.configure(args[0]);
      logger.info("Entering application.");
      Bar bar = new Bar();
      bar.doIt();
      logger.info("Exiting application.");
    }
  }

followith 2009-04-22 10:43 发表评论

jsp中forward和redirect的区别

followith — Mon, 23 Mar 2009 02:00:00 GMT

（1）共同点：

都实现了根据自己的条件实现的页面的跳转。

（2）区别

类别	概念	共享数据	应用
Redirect	URL重新定向：可以是任意的URL	不能共享request里面的数据	一般用于用户注销登录时返回主页面和跳转到其它的网站等等
Forward	页面的转发：只能是同一个Web应用程序的其他Web组件	转发页面和转发到的页面可以共性request里面的数据	一般用于用户登录的时候根据角色转发到相应的模块等等

（3）例子：

譬如：client 通过XXX"index.jsp?name=gauss&pwd=123访问index.jsp,而index.jsp中有< jsp:forward page="login.jsp"/>,则在login.jsp中可以通过request.getParameter()得到name和pwd，而<%response.sendRedirect("login.jsp");%>得不到。

（4）注意

一般在index.jsp页面之前有个提交数据的页面 default.jsp，则defautl.jsp页面提交的数据就可以在login.jsp页面得到，而不是得到index.jsp页面提交的数据，index.jsp页面只是执行的一个转发操作当然在里面可以增加写业务操作，它可以得到request的数据，用 XXX"index.jsp?name=gauss&pwd=123这种方式登录就是省略了index.jsp前面的一个页面提交数据而已

followith 2009-03-23 10:00 发表评论

Apache+Tomcat负载平衡设置（workers）详解

followith — Thu, 26 Feb 2009 09:52:00 GMT

一、简介：

每个 Tomcat worker是一个服务于web server、等待执行servlet的Tomcat实例。例如我们经常使用像Apache之类的web server转发sevlet请求给位于其后面的一个Tomcat进程（也就是前面所说的worker）。本文详细介绍了如何配置各种类型worker和 loadbalance，并说明了各种类型worker的特性和loadbalance配置的原理。

二、为什么使用Tomcat workers：

上文描述了一个非常简单的结构，事实上能够配置多个Tomcat workers来处理web server转发的servlet请求。而这样配置的理由不外乎以下几种假想环境：

* 我们在开发环境中发布不同的Tomcat workers为各自不同的应用服务。当然在开发环境中的开发者共享同一个web server，但是每个Tomcat worke服务于拥有它的开发者。

* 我们在不同的Tomcat进程上定义各自的虚拟主机，这样不同的公司可以使用各自的web site，从而使他们的web site得到了合理的分割。

* 我们提供负载平衡的web site，也就意味着同时使用多个Tomcat workers，而每个Tomcat worker具有独立的主机并且在workers之间要分配通过web server转发来的请求。

当然，这些假想情况也许并不能涵盖使用多个workers的所有状况。

三、workers.properties配置说明：

定义Tomcat workers的方法是在apache的conf目录下编写一个名为“workers.properties”的属性文件。本文将详细解释如何进行配置的：

1.定义Workers列表：

定义workers的方法就是在apache的conf目录下编写一个workers.properties文件，使其作为apache的插件来发挥作用。

定义workers列表的格式：

worker.list =<使用“,”分割的worker 名字列表>

例如：

worker.list= worker1, worker2

当apache启动时，workers.properties作为插件将初始化出现在worker.list列表中的workers。

2.定义Workers的类型：

每个被命名的worker都应有一些关于其自身的附加信息。这些信息包括了worker的类型和其它相关信息。这里讨论的是JK1.2.5中定义的workers类型。

定义worker类型的格式：

worker . worker名字. type =

worker名字的命名最好遵循java的命名规范。

worker类型取值于下面的表格：

定义一个名为“local”的worker，其使用ajpv12协议与Tomcat 进程通讯：

worker.local.type=ajp12

定义一个名为“remote”的worker，其使用ajpv13协议与Tomcat 进程通讯：

worker.remote.type=ajp13

定义一个名为“fast”的worker，其使用JNI的方式与Tomcat 进程通讯：

worker.fast.type=jni

定义一个名为“loadbalancer”的worker，其作为对多个Tomcat 进程的负载平衡使用：

worker.loadbalancer.type=lb

各个类型具有不同的行为，我们在下文中会详细解释。

3.设置Worker属性：

在定义worker之后，还需要提供各个worker的属性，这些属性的定义使用下面的方式：

worker..<属性>=<属性值>

3-1 ajp12类型的Worker属性：

ajp12类型的worker工作时使用基于TCP/IP socket的ajpv12协议转发请求给“进程外”Tomcat worker。

ajp12 worker属性如下：

host：

侦听ajp12请求的Tomcat worker主机。

port：

Tomcat worker主机的侦听端口。

lbfactor：

当此Tomcat worker被用于一个负载平衡worker使用时，此属性将被使用。它定义了此worker的负载平衡权值。

例如：下面的“worker1”定义了一个位于www.x.com主机上的Tomcat，它使用8007端口侦听apache发来的请求，并具有2.5的负载权值

worker.worker1.host=www.x.comworker.worker1.port=8007worker.worker1.lbfactor=2.5

注意：在ajpv12协议中，针对每个请求都要一个连接建立、使用、关闭。其默认侦听端口为8007。

3-2 ajp13类型的Worker属性：

ajp13类型的worker工作时使用基于TCP/IP socket的ajpv13协议转发请求给“进程外”Tomcat worker。

ajpv13协议与ajpv12协议的主要不同：

* ajpv13具有更丰富的二进制协议，它使用将频繁使用的字符串编码为小整数的方式对请求数据进行压缩。

* ajpv13重用打开的socket并保留这些打开的socket以处理将来的请求。这在apache与Tomcat之间具有防火墙的网络环境下是必要的。

* ajpv13具有对SSL信息的处理能力，以致容器能够实现SSL的相关方法（如isSecure()）。

注意：ajp13当前只能用于支持“进程外”协议的Tomcat 4.0.x, 4.1.x and 5。

下表描述了ajp13worker接受的属性：

host：

侦听ajp13请求的Tomcat worker主机。

port：

Tomcat worker主机的侦听端口。

lbfactor：

当此Tomcat worker被用于一个负载平衡worker使用时，此属性将被使用。它定义了此worker的负载平衡权值。

cachesize：

当在多线程的web server（例如apache2.0、IIS 、Netscape）中使用JK时，此属性是有效的。如果将cachesize的值设置为较高的值，这些支持多线程的web server将获得很好的处理能力。如果此属性不被设置，则连接cache特性将失效。

cache_timeout：

本属性用于声明JK在cache中保留一个打开的socket的时间，它对减少web serer的线程数有所帮助。

使用cache_timeout的原因：

众所周知，一个身背重负的web server（例如apache）建立childs/threads来处理负载，而当负载减少时它将销毁无用的childs/threads。每个 child在转发请求给Tomcat时要打开一个ajp13连接，而在Tomcat那一端也将建立一个ajp13线程与之通讯。

但是问题出现在一个ajp13连接建立完成后，child没有及时的释放那个ajp13连接，由于web server1将保持它的childs/threads运行已处理高负载，即使childs/threads处理快速的静态内容，在Tomcat端也将积累很多的无用ajp13线程。

socket_keepalive：

当防火墙位于web server与Tomcat之间时，防火墙将尝试断开未激活的网络连接。此属性将告诉操作系统在未激活的连接中发送KEEP_ALIVE信息(发送间隔时间依赖于操作系统的设置，一般为120秒)，这样将防止防火墙切断未激活的网络连接。

但此设置并不是万能钥匙，它对于某些防火墙也无能为力。

socket_timeout：

此属性说明连接在未激活的状况下持续多久，web server将主动切断之。这是一个使Tomcat端的陈旧线程不致过多的好方法，但是也带来了在下一次请求到来时需要重新打开socket的开销。此属性与cache_timeout有类似的功效，但是它工作在non-cache模式。

connect_timeout：

web server在连接建立后将一个PING请求发送到ajp13协议的连接上。此属性说明了web server等待PONG回应的时间（以ms为单位）。此属性在jk 1.2.6版本被增加进来，以求避免Tomcat的死机，Tomcat 3.3.2+, 4.1.28+ and 5.0.13+实现了对使用ajp13的 ping/pong的支持。此属性默认为失效的。

prepost_timeout：

web server在转发一个请求后将一个PING请求发送到ajp13协议的连接上。此属性说明了web server等待PONG回应的时间（以ms为单位）。此属性在jk 1.2.6版本被增加进来，以求避免Tomcat的死机，Tomcat 3.3.2+, 4.1.28+ and 5.0.13+实现了对使用ajp13的 ping/pong的支持。此属性默认为失效的。

reply_timeout：

此属性告诉web server在接到远端的Tomcat已死并实时的切换到集群中的另外一个Tomcat的回应之前等待一段时间。默认情况下web server将永远等待。属性值为web server要等待回应的时间（以ms为单位），所以如果具有运行时间较长的servlet时设置其值要小心。此属性在jk 1.2.6版本被增加进来，以求避免Tomcat的死机和在支持ajp13的servlet引擎上发生的问题。此属性默认为失效的。

recovery_options：

此属性说明了web server在检测到Tomcat失败后如何进行恢复工作。默认情况下，web server将转发请求给处于负载平衡模式中的另一个Tomcat。属性值为0，说明全部恢复；属性值为1，说明如果在Tomcat接到请求后出现失败状况，则不进行恢复；属性值为2，说明如果在Tomcat发送http头给客户端后出现失败状况，则不进行恢复；属性值为3，说明如果在Tomcat接到请求后出现失败状况或者在Tomcat发送http头给客户端后出现失败状况，则不进行恢复。

此属性在jk 1.2.6版本被增加进来，以求避免Tomcat的死机和在支持ajp13的servlet引擎上发生的问题。此属性默认为全部恢复。

例如：一个名为“worker2”的worker的配置：

worker.worker2.host=www2.x.comworker.worker2.port=8009worker.worker2.lbfactor=3.5worker.worker2.cachesize=10worker.worker2.cache_timeout=600worker.worker2.socket_keepalive=1worker "worker2" want ajp13connection to be dropped after 5mn (timeout)worker.worker2.socket_timeout=300

说明：上例中的worker要求操作系统在连接上发送KEEP-ALIVE信号。

注意：在ajpv13协议中默认端口为8009。

4.设置lb Worker属性：

负载平衡类型的worker并不与Tomcat worker通讯，它负责管理这些Tomcat worker。

其管理范围如下：

* 初始化在web server的worker列表中定义的worker。

* 使用worker的负载平衡权值，执行基于权值的负载平衡，将数量多的请求发送到负载平衡权值高（在web server看来就是更加健壮的）的worker。

* 维护在同一个Tomcat worker上的同一个session的请求，使其发送到同一个Tomcat worker上。以达到Tomcat worker上的session一致性、持续性。

* 标识已经失败的Tomcat workers，悬空发向它们的请求，在被lb worker管理的其它workers上寻找可以失败恢复的worker。

被同一个lb worker管理多个worker之间的负载平衡的（基于它们的lbfactor和当前用户session），也可以尽量避免由于单一的Tomcat进程死掉而造成这个网站被“杀”的不良反应。

下表说明了lb worker接受的属性：

* balanced_workers：一个由“，”分割的worker列表，用来声明lb worker需要被管理的workers。这些workers不应出现在worker.list属性中。

* sticky_session：表述是否将对SESSION ID的请求路由回到相同的Tomcat worker。如果属性值不为0，它将被设置为JK_TRUE，session将是粘性的，即SESSION ID的请求路由回到相同的Tomcat worker；当Tomcat正使用能够跨越多个Tomcat实例持久化session数据的Session Manager时，它将被设置为JK_FALSE。属性默认值为JK_TRUE。

例如：worker balance1管理着两个workers：worker1、worker2：

worker.balance1.balanced_workers=worker1, worker2

5.高级lb Worker属性：

JK 1.2.x版本通过增加两个新的属性：local_worker_only 和 local_worker 为lb worker增添了新的负载平衡和容错支持。

下面让我们举一个实际的环境作为example：

一个集群具有两个节点(worker1+worker2)，一个web server与tomcat workers一前一后，一个负载平衡器（lb Worker）位于节点的前面、web server的后面。

配置如下：

worker.list=router# Define a 'local_worker' worker using ajp13worker.worker1.port=8009worker.worker1.host=node1.domain.orgworker.worker1.type=ajp13worker.worker1.lbfactor=1worker.worker1.local_worker=1#Define another 'local_worker' worker using ajp13worker.worker2.port=8009worker.worker2.host=node2.domain.orgworker.worker2.type=ajp13worker.worker2.lbfactor=1worker.worker2.local_worker=0# Define the LB workerworker.router.type=lbworker.router.balanced_workers=worker1,worker2worker.router.local_worker_only=1

在worker1和worker2上的local_worker标志告诉lb_worker哪个连接属于本地worker。

如果local_worker值为非0，则它将被设置为JK_TRUE，用来标记“local worker”，而JK_FALSE的情况则相反。如果至少一个worker被标记为local worker，则lb_worker将工作于local worker模式。这种模式下，所有的local workers将被移到在lb_worker中的内部worker列表的头部。

这意味着一个带有session id的请求到达lb_worker时，相应的worker（根据权值排序，权值最大的那个worker）将被确定作为此请求的接受/处理者。如果这个 worker死掉/当机，请求将被发送到处于非错误状态的第一个local worker；如果一个没有session id的请求到达lb_worker时，此请求将被路由到第一个local worker。

如果所有的local worker均处于错误状态，则这时“local_worker_only”标志显得尤其重要。如果local_worker_only的属性值为非0，则它被设置为 JK_TRUE，否则被设置为 JK_FALSE。

当它被设置为 JK_TRUE时，这个没有session id的请求将得到一个错误作为回应，否则lb_worker将尝试将请求路由到其它的被管理的worker上。如果其中的一个worker处于错误状态，并且恢复会话的工作并没有任何改变，local worker将查找这个没有session id的请求（因为在local worker中保存有这个请求的session），而其它的worker只能查找带有session id的请求。

注意：local_worker默认值是0，local_worker_only默认值也是0。

例如：设置“wrkjni”的JVM shared lib (IBM SDK on Linux)。

worker.wrkjni.jvm_lib=/opt/IBMJava2-131/jre/bin/classic/libjvm.so

例如：设置“wrkjni”的JVM shared lib (Sun SDK on Windows)。

worker.wrkjni.jvm_lib=c:"JDK"1.3.1"jre"bin"classic

worker.worker名.stdout：设置JVM写它的System.out的完整路径位置。

例如：将“wrkjni”的JVM系统输出路径设置为/var/log/http/jk-jvm-out.log。

worker.wrkjni.stdout=/var/log/http/jk-jvm-out.log

worker.worker名.stderr：设置JVM写它的System.err的完整路径位置。

例如：将“wrkjni”的JVM系统错误输出路径设置为/var/log/http/jk-jvm-err.log

worker.wrkjni.stderr=/var/log/http/jk-jvm-out.log

worker.worker名.ms：设置JVM的初始堆大小。

例如：设置“wrkjni”的JVM的初始堆为64M。

worker.wrkjni.ms=64

worker.worker名.mx：设置JVM的最大的堆大小。

例如：设置“wrkjni”的JVM堆最大为128M

worker.wrkjni.mx=128

worker.worker名.sysprops：设置JVM的系统属性。

例如：设置“wrkjni”的JVM使用法语。

worker.wrkjni.sysprops=-Duser.region=FR

worker.worker名.ld_path：设置附加的动态链接库路径(类似于LD_LIBRARY_PATH)

例如：添加一些动态链接库路径到“wrkjni”的java环境中。

worker.wrkjni.ld_path=/opt/IBMJava2-131/jre/bin/worker.wrkjni.ld_path=/opt/IBMJava2-131/jre/bin/classic

注意：在Linux下，上面的ld_path并不能更新LD_LIBRARY_PATH，所以需要在执行web server之前手动更新LD_LIBRARY_PATH,。

8.属性文件宏：

我们可以在属性文件中定义“宏”。这些宏让我们定义属性，并在以后使用它们来构建其它的属性文件。当我们修改Java Home、Tomcat Home、系统路径分隔符时这是很有用的。

例如：定义了属性workers.tomcat_home、workers.java_home。

workers.tomcat_home=d:"tomcatworkers.java_home=d:"sdk"jdk1.2.2

在定义worker.inprocess.class_path时就可以使用前面定义的workers.tomcat_home。

worker.inprocess.class_path=$(workers.tomcat_home)$(ps)classes

9.一个简单而完整的worker.properties：
件中定义了比较完整的结构，可以做为参考模版：

* 一个位于localhost的使用8007端口的ajp12 worker；

* 一个位于localhost的使用8008端口的ajp13 worker；

* 一个jni worker；

* 一个lb worker：负责ajp12 worker、ajp13 workers的负载平衡。

文件内容如下：

# Define some propertiesworkers.apache_log=/var/log/httpd/workers.tomcat_home=/var/tomcat3workers.java_home=/opt/IBMJava2-131/ps=/# Define 4 workers, 3 real workers using ajp12, ajp13, jni, the last one being a loadbalancing workerworker.list=worker1,worker2, worker3, worker4# Set properties for worker1 (ajp12)worker.worker1.type=ajp12worker.worker1.host=locahostworker.worker1.port=8007worker.worker1.lbfactor=5# Set properties for worker2 (ajp13)worker.worker2.type=ajp13worker.worker2.host=locahostworker.worker2.port=8009worker.worker2.lbfactor=50worker.worker2.cachesize=10worker.worker2.cache_timeout=600worker.worker2.socket_keepalive=1worker.worker2.socket_timeout=300# Set properties for worker3 (jni)worker.worker3.type=jni# Set worker3 bridge type, here Tomcat 3.3worker.worker3.bridge=tomcat33# Set worker3 classpathworker.worker3.class_path=$(workers.tomcat_home)$(ps)classesworker.worker3.class_path=$(workers.tomcat_home)$(ps)lib$(ps)tomcat.jar# Setworker3 tomcat command lineworker.worker3.cmd_line=-homeworker.worker3.cmd_line=$(workers.tomcat_home)# Set worker3 Tomcat/JVM settingsworker.worker3.jvm_lib=$(workers.java_home)$(ps)jre$(ps)bin$(ps)classic$(ps)libjvm.soworker.worker3.stdout=$(workers.apache_log)$(ps)inprocess.stdoutworker.worker3.stderr=$(workers.apache_log)$(ps)inprocess.stderrworker.worker3.sysprops=tomcat.home=$(workers.tomcat_home)# Set properties for worker4 (lb) which use worker1 and worker2worker.worker4.balanced_workers=worker1,worker2

followith 2009-02-26 17:52 发表评论

上传任意多个文件

followith — Fri, 13 Feb 2009 03:53:00 GMT

摘要: 从《Struts1.x系列教程（8）：上传单个文件》中给出的例子可以看出，在Struts1.x中上传单个文件是非常简单的，但在实际应用中，上传文件的个数一般是不确定的，如在网络硬盘中，用户可以根据自己的需要上传任意多个文件（当然，网络硬盘一次上传文件的数目一般也是有上限的，如50个，但用户可以只上传了3个文件，因此，在这种情况下，上传文件的个数也是不确定的）。如果读者用过“... 阅读全文

followith 2009-02-13 11:53 发表评论

cookie的用法

followith — Mon, 08 Dec 2008 08:37:00 GMT

1 import javax.servlet.http.Cookie;
2 //实例化一个Cookie
3 Cookie cookie = new Cookie(key,value)
4 //设置cookie的生命周期
5 cookie.setMaxAge(60*60*24*365)
6 //以秒为单位
7 //为避免字符乱码，先设置一下response的编码方式，默认是GBK的
8 response.setCharacterEncoding("utf-8")
9 response.addCookie(cookie)
10
11 //读取cookie
12 Cookie[] cookie = request.getCookies()
13 for(int i = 0 ; i <cookie.length(); i++){
14   Cookie c = cookie[i]
15   if(c.getName().equals("cookie")){
16 //这里的cookie是你实例化cookie的名称
17     def value = null
18     value = c.getValue()
19   }
20 }
如果还存在字符编码的问题，可以将value值在实例化之前在encode一下，然后读出的时候在decode
使用到的方法 java.net.URLEncoder.encode(str,"utf-8")以及 java.net.URLDecoder.decode(str,"UTF-8")

followith 2008-12-08 16:37 发表评论

ant cxf webservice

followith — Wed, 29 Oct 2008 08:16:00 GMT

ant ${target}

followith 2008-10-29 16:16 发表评论

java解压zip文件

followith — Tue, 21 Oct 2008 09:40:00 GMT

try {
                            File outFile = new File(outputDirectory);
                          if (!outFile.exists()) {
                         outFile.mkdirs();
                          }
                            org.apache.tools.zip.ZipFile zipFile = new org.apache.tools.zip.ZipFile(uploadFileName);
                            java.util.Enumeration e = zipFile.getEntries();
                            org.apache.tools.zip.ZipEntry zipEntry = null;
                            while (e.hasMoreElements()){
                                zipEntry = (org.apache.tools.zip.ZipEntry)e.nextElement();
                                def zipEntryName = zipEntry.getName()
                              if (zipEntry.isDirectory()) {
                           // mkdir directory
                                def dirName = zipEntryName.substring(0, zipEntryName.length() - 1);
                                File f = new File(outFile.getPath() + File.separator + dirName);
                                f.mkdirs();
                                }
                                if (! zipEntry.isDirectory()){
                                   //mkdir entryDirectory
                                    if( -1 != zipEntry.getName().indexOf("/")){
                                               def fileDirName = zipEntryName.substring(0,zipEntryName.lastIndexOf("/"))
                                               //println(fileDirName)
                                               File fDir = new File(outFile.getPath() + File.separator + fileDirName)
                                               //println(fDir.mkdirs())
                                           }
                               File f = new File(outputDirectory + File.separator + zipEntry.getName());
                               if(!f.exists()){
                                 f.createNewFile()
                                           }
                             InputStream fin = zipFile.getInputStream(zipEntry);
                             FileOutputStream out = new FileOutputStream(f);
                               int c;
                               byte[] b = new byte[1024];
                               while((c=fin.read(b)) != -1){
                               out.write(b,0,c);
                               }
                               out.close();
                               fin.close();
                           }
                       }
                       zipFile.close();
           }catch (Exception ex){
               ex.printStackTrace();
           }
               new File(uploadFileName).delete()

followith 2008-10-21 17:40 发表评论

js、jQuery增加select的

followith — Wed, 08 Oct 2008 09:43:00 GMT

(1)var option = new Option(item.name,item.businessCode)
$("#serviceCode")[0].options.add(option)//注意[0]的用法

(2)$("