JMS始终在JavaEE五花八门的协议里，WebService满天飞的时候占一位置，是因为：

• 它可以把不影响用户执行结果又比较耗时的任务（比如发邮件通知管理员）异步的扔给JMS 服务端去做，而尽快的把屏幕返还给用户。
• 服务端能够多线程排队响应高并发的请求，并保证请求不丢失。
• 可以在Java世界里达到最高的解耦。客户端与服务端无需直连，甚至无需知晓对方是谁、在哪里、有多少人，只要对流过的信息作响应就行了，在企业应用环境复杂时作用明显。

    ActiveMQ的特性：

• 完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现，也是Apache Geronimo默认的JMS provider。
• POJO withdout EJB Container，不需要实现EJB繁琐复杂的Message Bean接口和配置。
• Spring Base，可以使用Spring的各种特性如IOC、AOP 。
• Effective，基于Jencks的JCA Container实现 pool connection，control transactions and manage security。 

1.2 SpringSide 的完全POJO的JMS方案   

  SpringSide 2.0在BookStore示例中，演示了用户下订单时，将发通知信到用户邮箱的动作，通过JMS交给JMS服务端异步完成，避免了邮件服务器的堵塞而影响用户的下订。

  全部代码于examples\bookstore\src\java\org\springside\bookstore\components\activemq 目录中。

  一个JMS场景通常需要三者参与：

• 一个POJO的的Message Producer，负责使用Spring的JMS Template发送消息。
• 一个Message Converter，负责把Java对象如订单(Order)转化为消息，使得Producer能够直接发送POJO。
• 一个MDP Message Consumer，负责接收并处理消息。

  SpringSide 2.0采用了ActiveMQ 4.1-incubator 与Spring 2.0 集成，对比SS1.0M3，有三个值得留意的地方，使得代码中几乎不见一丝JMS的侵入代码：

1. 采用Spring2.0的Schema式简化配置。
2. 实现Message Converter转化消息与对象，使得Producer能够直接发送POJO而不是JMS Message。
3. 使用了Spring2.0的DefaultMessageListenerContainer与MessageListenerAdapter，消息接收者不用实现MessageListener 接口。
4. 同时，Spring 2.0 的DefaultMessageListenerContainer 代替了SS1.0M3中的Jenck(JCA Container)，充当MDP Container的角色。

2.引入ActiveMQ的XSD

  ActiveMQ4.1 响应Spring 2.0号召，支持了引入XML Schema namespace的简单配置语法，简化了配置的语句。 

  在ApplicationContext.xml(Spring的配置文件)中引入ActiveMQ的XML Scheam 配置文件),如下:

<beans
  xmlns="http://www.springframework.org/schema/beans"
  xmlns:amq="http://activemq.org/config/1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://activemq.org/config/1.0 http://people.apache.org/repository/org.apache.activemq/xsds/activemq-core-4.1-incubator-SNAPSHOT.xsd">

由于ActiveMQ4.1 SnapShot的那个XSD有部分错误，因此使用的是自行修改过的XSD。

先在ClassPath根目录放一个修改过的activemq-core-4.1-incubator-SNAPSHOT.xsd。

在ClassPath 下面建立META-INF\spring.schemas 内容如下。这个spring.schemas是spring自定义scheam的配置文件,请注意"http:\://"部分写法

http\://people.apache.org/repository/org.apache.activemq/xsds/activemq-core-4.1-incubator-SNAPSHOT.xsd=/activemq-core-4.1-incubator-SNAPSHOT.xsd

3. 配置方案

3.1 基础零件 

1. 配置ActiveMQ Broker  

   暂时采用在JVM中嵌入这种最简单的模式，  当spring初始化时候，ActiveMQ embedded Broker 就会启动了。

<!--  lets create an embedded ActiveMQ Broker -->
<amq:broker useJmx="false" persistent="false">
  	<amq:transportConnectors>
　　　　		<amq:transportConnector uri="tcp://localhost:0"/>
　	</amq:transportConnectors>
　</amq:broker>

2. 配置(A)ConnectionFactory

  由于前面配置的Broker是JVM embedded 所以URL为:vm://localhost

<!--  ActiveMQ connectionFactory to use  -->
 <amq:connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost"/>

3 配置(B)Queue

<!--  ActiveMQ destinations to use  -->
 <amq:queue name="destination" physicalName="org.apache.activemq.spring.Test.spring.embedded"/>

4. 配置(C)Converter

   配置Conveter，使得Producer能够直接发送Order对象，而不是JMS的Message对象。

<!--  OrderMessage converter  -->
 <bean id="orderMessageConverter" class="org.springside.bookstore.components.activemq.OrderMessageConverter"/>  

3.2  发送端 

1 配置JmsTemplate

   Spring提供的Template，绑定了(A)ConnectionFactory与(C)Converter。

<!--  Spring JmsTemplate config -->
 <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
  <property name="connectionFactory">
   <!--  lets wrap in a pool to avoid creating a connection per send -->
   <bean class="org.springframework.jms.connection.SingleConnectionFactory">
    <property name="targetConnectionFactory" ref="jmsConnectionFactory"/>
   </bean>
  </property>
  <!-- custom MessageConverter -->
  <property name="messageConverter" ref="orderMessageConverter"/>
 </bean>

2.Producer

   消息发送者，使用JmsTemplate发送消息，绑定了JmsTemplate (含A、C)与(B)Queue。

<!-- POJO which send Message uses  Spring JmsTemplate，绑定JMSTemplate 与Queue -->
 <bean id="orderMessageProducer" class="org.springside.bookstore.components.activemq.OrderMessageProducer">
  <property name="template" ref="jmsTemplate"/>
  <property name="destination" ref="destination"/>
 </bean>

3.3 接收端

  1.接收处理者(MDP)

    使用Spring的MessageListenerAdapter，指定负责处理消息的POJO及其方法名，绑定(C)Converter。

  <!--  Message Driven POJO (MDP)，绑定Converter -->
 <bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
  <constructor-arg>
   <bean class="org.springside.bookstore.components.activemq.OrderMessageConsumer">
    <property name="mailService" ref="mailService"/>
   </bean>
  </constructor-arg>
  <!--  may be other method -->
  <property name="defaultListenerMethod" value="sendEmail"/>
  <!-- custom MessageConverter define -->
  <property name="messageConverter" ref="orderMessageConverter"/>
 </bean> 

2. listenerContainer

    负责调度MDP， 绑定(A) connectionFactory, (B)Queue和MDP。

<!--  this is the attendant message listener container -->
 <bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
  <property name="connectionFactory" ref="jmsConnectionFactory"/>
  <property name="destination" ref="destination"/>
  <property name="messageListener" ref="messageListener"/>
 </bean>

  互相绑定的关系有点晕，发送端和接收端都以不同形式绑定了(A) connectionFactory, (B)Queue和 (C)Converter。

4. 下篇

1. 说明

   请先阅读ActiveMQ4.1 +Spring2.0的POJO JMS方案(上)

   本篇将补充说明了：

   1) 使用数据库持久化消息，保证服务器重启时消息不会丢失
   2) 使用Jencks作正宗的JCA Container。

2.持久化消息

2.1 给Broker加入Persistence 配置

在配置文件applicationContext-activemq-embedded-persitence.xml中的<amq:broker>节点加入  

<amq:persistenceAdapter>
<amq:jdbcPersistenceAdapter id="jdbcAdapter" dataSource="#hsql-ds" createTablesOnStartup="true" useDatabaseLock="false"/>
</amq:persistenceAdapter>

请注意MSSQL(2000/2005)和HSQL由于不支持[SELECT  * ACTIVEMQ_LOCK FOR UPDATE ]语法,因此不能使用默认的userDatabaseLock="true",只能设置成useDatabaseLock="false"

2.2 配置多种数据源

配置多种数据源,给jdbcPersistenceAdapter使用，SpringSide 中使用的内嵌HSQL

 <!-- The HSQL Datasource that will be used by the Broker -->
<bean id="hsql-ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
<property name="url" value="jdbc:hsqldb:res:hsql/activemq"/>
<property name="username" value="sa"/>
<property name="password" value=""/>
<property name="poolPreparedStatements" value="true"/>
</bean>

2. 3 说明

   笔者仅仅使用了jdbcPersistenceAdapter,其实在ActiveMQ的XSD已经描述了多种PersistenceAdapter,可以参考对应的XSD文件.

  另外对于数据库的差异主要表现在设置了userDatabaseLock="true"之后，ActiveMQ使用的[SELECT * ACTIVEMQ_LOCK FOR UPDATE] 上面，会导致一些数据库出错(测试中MSSQL2000/2005,HSQL都会导致出错)。另外HSQL的脚本请参见activemq.script。

3. Jenck(JCA Container)  

   Spring 2.0本身使用DefaultMessageListenerContainer 可以充当MDP中的Container角色，但是鉴于Jencks是JCA标准的，它不仅仅能够提供jms的jca整合,包括其他资源比如jdbc都可以做到jca管理

所以,同时完成了这个ActiveMQ+Spring+Jencks 配置演示,更多的针对生产系统的JCA特性展示,会在稍后的开发计划讨论中确定。

     此文档适用于说明使用 Jecncks 和 使用Spring 2.0(DefaultMessageListenerContainer)  充当MDP Container时的区别，同时演示Jecnks 的Spring 2.0 新配置实例。

3.1 引入ActiveMQ ResourceAdapter 和Jencks 的XSD

  在ApplicationContext.xml(Spring的配置文件)中引入ActiveMQ ResourceAdapter 和Jencks 的XML Scheam 配置文件),如下:

   ActiveMQ4.1 响应Spring 2.0号召，支持了引入XML Schema namespace的简单配置语法，简化了配置的语句。 

  在ApplicationContext.xml(Spring的配置文件)中引入ActiveMQ的XML Scheam 配置文件),如下:

<beans
xmlns="http://www.springframework.org/schema/beans"   xmlns:amq="http://activemq.org/config/1.0"   xmlns:ampra="http://activemq.org/ra/1.0"   xmlns:jencks="http://jencks.org/1.3"   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://activemq.org/config/1.0 http://people.apache.org/repository/org.apache.activemq/xsds/activemq-core-4.1-incubator-SNAPSHOT.xsd
  http://activemq.org/ra/1.0 http://people.apache.org/repository/org.apache.activemq/xsds/activemq-ra-4.1-incubator-SNAPSHOT.xsd
  http://jencks.org/1.3 http://repository.codehaus.org/org/jencks/jencks/1.3/jencks-1.3.xsd">

由于ActiveMQ RA和Jencks 那个XSD 仍然有部分错误，因此使用的是自行修改过的XSD。(是xs:any元素引起的错误)

先在ClassPath根目录放一个修改过的activemq-ra-4.1-incubator-SNAPSHOT.xsd和jencks-1.3.xsd。

同样修改 ClassPath 下面META-INF\spring.schemas 增加内容如下。这个spring.schemas是spring自定义scheam的配置文件,请注意"http:\://"部分写法

http\://people.apache.org/repository/org.apache.activemq/xsds/activemq-ra-4.1-incubator-SNAPSHOT.xsd=/activemq-ra-4.1-incubator-SNAPSHOT.xsd
http\://repository.codehaus.org/org/jencks/jencks/1.3/jencks-1.3.xsd=/jencks-1.3.xsd

3.2  配置方案

3.2.1 基础零件 

1. 配置ActiveMQ Broker  参见 ActiveMQ+Spring

2. 配置ActiveMQ Resource Adapter

<amqra:managedConnectionFactory id="jmsManagedConnectionFactory" resourceAdapter="#resourceAdapter"/><amqra:resourceAdapter id="resourceAdapter" serverUrl="vm://localhost" />

3. 配置Jencks 基础配置

   具体的配置可以参见Jencks的XSD

<!-- jencks PoolFactory config-->
<jencks:singlePoolFactory id="poolingSupport" maxSize="16" minSize="5" blockingTimeoutMilliseconds="60" idleTimeoutMinutes="60" matchOne="true" matchAll="true" selectOneAssumeMatch="true" /> <!-- jencks XATransactionFactory -->
<jencks:xATransactionFactory id="transactionSupport" useTransactionCaching="true" useThreadCaching="true" />  
<!-- jencks ConnectionManagerFactory -->
<jencks:connectionManagerFactory id="connectionManager" containerManagedSecurity="false"  poolingSupport="#poolingSupport" transactionSupport="#transactionSupport" /> <!-- jencks TransactionContextManagerFactory -->
<jencks:transactionContextManagerFactory id="transactionContextManagerFactory"/>
  

4. 配置给JmsTemplate使用的connectionFactory (主要是生成者/发送者 使用)

   这里注意下,在配置jmsTemplate的使用的targetConnectionFactory就是使用jencks配置的connectionManager

<!-- spring config jms with jca-->
 <bean id="jmsManagerConnectionFactory" class="org.springframework.jca.support.LocalConnectionFactoryBean">
  <property name="managedConnectionFactory">
   <ref local="jmsManagedConnectionFactory" />
  </property>
  <property name="connectionManager">
   <ref local="connectionManager" />
  </property>
 </bean>
 
 <!--  Spring JmsTemplate config -->
 <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
  <property name="connectionFactory">
   <!--  lets wrap in a pool to avoid creating a connection per send -->
   <bean class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="jmsManagerConnectionFactory" />
   </bean>
  </property>
  <!-- custom MessageConverter -->
  <property name="messageConverter" ref="orderMessageConverter" />
 </bean>  

5. 配置Spring 2.0的MessageListenerAdapter,保证不需要用户实现MessageListener

   见ActiveMQ+Spring

 6.配置Jecnks 充当MDP的Container

  就是把上面的MessageListenerAdapter配置到Jencks里面,完成整个MDP的配置

 <!-- Jencks Container-->
 <jencks:jcaContainer>  	<jencks:bootstrapContext>
   		<jencks:bootstrapContextFactory threadPoolSize="25" />
  	</jencks:bootstrapContext>
  		<jencks:connectors>
   	   <!-- use jencks container (use spring MessageListenerAdapter)-->
   		<jencks:connector ref="messageListener">
    			<jencks:activationSpec>
     				<amqra:activationSpec destination="org.apache.activemq.spring.Test.spring.embedded" destinationType="javax.jms.Queue" />
    			</jencks:activationSpec>
   		</jencks:connector>  	</jencks:connectors> 		 <jencks:resourceAdapter>
   		<amqra:resourceAdapter serverUrl="vm://localhost" />
  	</jencks:resourceAdapter>
 </jencks:jcaContainer>

NIO 是带有 JDK 1.4 的 Java 平台的最有名（如果不是最出色的）的添加部分之一。下面的许多文章阐述了 NIO 的基本知识及如何利用非阻塞通道的好处。但它们所遗漏的一件事正是，没有充分地展示 NIO 如何可以提高 J2EE Web 层的可伸缩性。对于企业开发人员来说，这些信息特别密切相关，因为实现 NIO 不像把少数几个 import 语句改变成一个新的 I/O 包那样简单。首先，Servlet API 采用阻塞 I/O 语义，因此默认情况下，它不能利用非阻塞 I/O。其次，不像 JDK 1.0 中那样，线程不再是“资源独占”（resource hog），因此使用较少的线程不一定表明服务器可以处理更多的客户机。

在本文中，为了创建基于 Servlet 并实现了 NIO 的 Web 服务器，您将学习如何解决 Servlet API 与非阻塞 I/O 的不配合问题。我们将会看到在多元的 Web 服务器环境中，这个服务器是如何针对标准 I/O 服务器（Tomcat 5.0）进行伸缩的。为符合企业中生存期的事实，我们将重点放在当保持 socket 连接的客户机数量以指数级增长时，NIO 与标准 I/O 相比较的情况如何。

注意，本文针对某些 Java 开发人员，他们已经熟悉了 Java 平台上 I/O 编程的基础知识。有关非阻塞 I/O 的介绍，请参阅 参考资料 部分。

线程不再昂贵

大家都知道，线程是比较昂贵的。在 Java 平台的早期（JDK 1.0），线程的开销是一个很大负担，因此强制开发人员自定义生成解决方案。一个常见的解决方案是使用 VM 启动时创建的线程池，而不是按需创建每个新线程。尽管最近在 VM 层上提高了线程的性能，但标准 I/O 仍然要求分配惟一的线程来处理每个新打开的 socket。就短期而言，这工作得相当不错，但当线程的数量增加超过了 1K，标准 I/O 的不足就表现出来了。由于要在线程间进行上下文切换，因此 CPU 简直变成了超载。

由于 JDK 1.4 中引入了 NIO，企业开发人员最终有了“单线程”模型的一个内置解决方案：多元 I/O 使得固定数量的线程可以服务不断增长的用户数量。

多路复用（Multiplexing）指的是通过一个载波来同时发送多个信号或流。当使用手机时，日常的多路复用例子就发生了。无线频率是稀有的资源，因此无线频率提供商使用多路复用技术通过一个频率发送多个呼叫。在一个例子中，把呼叫分成一些段，然后给这些段很短的持续时间，并在接收端重新装配。这就叫做 时分多路复用（time-division multiplexing），即 TDM。

在 NIO 中，接收端相当于“选择器”（参阅 java.nio.channels.Selector ）。不是处理呼叫，选择器是处理多个打开的 socket。就像在 TDM 中那样，选择器重新装配从多个客户机写入的数据段。这使得服务器可以用单个线程管理多个客户机。

回页首

Servlet API 和 NIO

对于 NIO，非阻塞读写是必要的，但它们并不是完全没有麻烦。除了不会阻塞之外，非阻塞读不能给呼叫方任何保证。客户机或服务器应用程序可能读取完整信息、部分消息或者根本读取不到消息。另外，非阻塞读可能读取到太多的消息，从而强制为下一个呼叫准备一个额外的缓冲区。最后，不像流那样，读取了零字节并不表明已经完全接收了消息。

这些因素使得没有轮询就不可能实现甚至是简单的 readline 方法。所有的 servlet 容器必须在它们的输入流上提供 readline 方法。因此，许多开发人员放弃了创建基于 Servlet 并实现了 NIO 的 Web 应用程序服务器。不过这里有一个解决方案，它组合了 Servlet API 和 NIO 的多元 I/O 的能力。

在下面的几节中，您将学习如何使用 java.io.PipedInput 和 PipedOutputStream 类来把生产者/消费者模型应用到消费者非阻塞 I/O。当读取非阻塞通道时，把它写到正由第二个线程消费的管道。注意，这种分解映射线程不同于大多数基于 Java 的客户机/服务器应用程序。这里，我们让一个线程单独负责处理非阻塞通道（生产者），让另一个线程单独负责把数据作为流消费（消费者）。管道也为应用程序服务器解决了非阻塞 I/O 问题，因为 servlet 在消费 I/O 时将采用阻塞语义。

回页首

示例服务器

示例服务器展示了 Servlet API 和 NIO 不兼容的生产者/消费者解决方案。该服务器与 Servlet API 非常相似，可以为成熟的基于 NIO 应用程序服务器提供 POC (proof of concept)，是专门编写来衡量 NIO 相对于标准 Java I/O 的性能的。它处理简单的 HTTP get 请求，并支持来自客户机的 Keep-Alive 连接。这是重要的，因为多路复用 I/O 只证明在要求服务器处理大量打开的 scoket 连接时是有意的。

该服务器被分成两个包： org.sse.server 和 org.sse.http 包中有提供主要 服务器 功能的类，比如如下的一些功能：接收新客户机连接、阅读消息和生成工作线程以处理请求。 http 包支持 HTTP 协议的一个子集。详细阐述 HTTP 超出了本文的范围。有关实现细节，请从 参考资料 部分下载代码示例。

现在让我们来看一下 org.sse.server 包中一些最重要的类。

回页首

Server 类

Server 类拥有多路复用循环 —— 任何基于 NIO 服务器的核心。在清单 1 中，在服务器接收新客户机或检测到正把可用的字节写到打开的 socket 前， select() 的调用阻塞了。这与标准 Java I/O 的主要区别是，所有的数据都是在这个循环中读取的。通常会把从特定 socket 中读取字节的任务分配给一个新线程。使用 NIO 选择器事件驱动方法，实际上可以用单个线程处理成千上万的客户机，不过，我们还会在后面看到线程仍有一个角色要扮演。

每个 select() 调用返回一组事件，指出新客户机可用；新数据准备就绪，可以读取；或者客户机准备就绪，可以接收响应。server 的 handleKey() 方法只对新客户机（ key.isAcceptable() ）和传入数据 ( key.isReadable() ) 感兴趣。到这里，工作就结束了，转入 ServerEventHandler 类。

public void listen() {
            SelectionKey key = null;
            try {
            while (true) {
            selector.select();
            Iterator it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
            key = (SelectionKey) it.next();
            handleKey(key);
            it.remove();
            }
            }
            } catch (IOException e) {
            key.cancel();
            } catch (NullPointerException e) {
            // NullPointer at sun.nio.ch.WindowsSelectorImpl, Bug: 4729342
            e.printStackTrace();
            }
            }
            

回页首

ServerEventHandler 类

ServerEventHandler 类响应服务器事件。当新客户机变为可用时，它就实例化一个新的 Client 对象，该对象代表了那个客户机的状态。数据是以非阻塞方式从通道中读取的，并被写到 Client 对象中。 ServerEventHandler 对象也维护请求队列。为了处理（消费）队列中的请求，生成了不定数量的工作线程。在传统的生产者/消费者方式下，为了在队列变为空时线程会阻塞，并在新请求可用时线程会得到通知，需要写 Queue 。

为了支持等待的线程，在清单 2 中已经重写了 remove() 方法。如果列表为空，就会增加等待线程的数量，并阻塞当前线程。它实质上提供了非常简单的线程池。

public class Queue extends LinkedList
            {
            private int waitingThreads = 0;
            public synchronized void insert(Object obj)
            {
            addLast(obj);
            notify();
            }
            public synchronized Object remove()
            {
            if ( isEmpty() ) {
            try	{ waitingThreads++; wait();}
            catch (InterruptedException e)  {Thread.interrupted();}
            waitingThreads--;
            }
            return removeFirst();
            }
            public boolean isEmpty() {
            return 	(size() - waitingThreads <= 0);
            }
            }
            

工作线程的数量与 Web 客户机的数量无关。不是为每个打开的 socket 分配一个线程，相反，我们把所有请求放到一个由一组 RequestHandlerThread 实例所服务的通用队列中。理想情况下，线程的数量应该根据处理器的数量和请求的长度或持续时间进行调整。如果请求通过资源或处理需求花了很长时间，那么通过添加更多的线程，可以提高感知到的服务质量。

注意，这不一定提高整体的吞吐量，但确实改善了用户体验。即使在超载的情况下，也会给每个线程一个处理时间片。这一原则同样适用于基于标准 Java I/O 的服务器；不过这些服务器是受到限制的，因为会 要求 它们为每个打开的 socket 连接分配一个线程。NIO 服务器完全不用担心这一点，因此它们可以扩展到大量用户。最后的结果是 NIO 服务器仍然需要线程，只是不需要那么多。

回页首

请求处理

Client 类有两个用途。首先，通过把传入的非阻塞 I/O 转换成可由 Servlet API 消费的阻塞 InputStream ，它解决了阻塞/非阻塞问题。其次，它管理特定客户机的请求状态。因为当全部读取消息时，非阻塞通道没有给出任何提示，所以强制我们在协议层处理这一情况。 Client 类在任意指定的时刻都指出了它是否正在参与进行中的请求。如果它准备处理新请求， write() 方法就会为请求处理而将该客户机排到队列中。如果它已经参与了请求，它就只是使用 PipedInputStream 和 PipedOutputStream 类把传入的字节转换成一个 InputStream 。

图 1 展示了两个线程围绕管道进行交互。主线程把从通道读取的数据写到管道中。管道把相同的数据作为 InputStream 提供给消费者。管道的另一个重要特性是：它是进行缓冲处理的。如果没有进行缓冲处理，主线程在尝试写到管道时就会阻塞。因为主线程单独负责所有客户机间的多路复用，因此我们不能让它阻塞。

在 Client 自己排队后，工作线程就可以消费它了。 RequestHandlerThread 类承担了这个角色。至此，我们已经看到主线程是如何连续地循环的，它要么接受新客户机，要么读取新的 I/O。工作线程循环等待新请求。当客户机在请求队列上变为可用时，它就马上被 remove() 方法中阻塞的第一个等待线程所消费。

public void run() {
            while (true) {
            Client client = (Client) myQueue.remove();
            try {
            for (; ; ) {
            HttpRequest req = new HttpRequest(client.clientInputStream,
            myServletContext);
            HttpResponse res = new HttpResponse(client.key);
            defaultServlet.service(req, res);
            if (client.notifyRequestDone())
            break;
            }
            } catch (Exception e) {
            client.key.cancel();
            client.key.selector().wakeup();
            }
            }
            }
            

然后该线程创建新的 HttpRequest 和 HttpResponse 实例，并调用 defaultServlet 的 service 方法。注意， HttpRequest 是用 Client 对象的 clientInputStream 属性构造的。 PipedInputStream 就是负责把非阻塞 I/O 转换成阻塞流。

从现在开始，请求处理就与您在 J2EE Servlet API 中期望的相似。当对 servlet 的调用返回时，工作线程在返回到池中之前，会检查是否有来自相同客户机的另一个请求可用。注意，这里用到了单词 池 (pool)。事实上，线程会对队列尝试另一个 remove() 调用，并变成阻塞，直到下一个请求可用。

回页首

运行示例

示例服务器实现了 HTTP 1.1 协议的一个子集。它处理普通的 HTTP get 请求。它带有两个命令行参数。第一个指定端口号，第二个指定 HTML 文件所驻留的目录。在解压文件后， 切换到项目目录，然后执行下面的命令，注意要把下面的 webroot 目录替换为您自己的目录：

java -cp bin org.sse.server.Start 8080
            "C:\mywebroot"
            

还请注意，服务器并没有实现目录清单，因此必须指定有效的 URL 来指向您的 webroot 目录下的文件。

回页首

性能结果

示例 NIO 服务器是在重负载下与 Tomcat 5.0 进行比较的。选择 Tomcat 是因为它是基于标准 Java I/O 的纯 Java 解决方案。为了提高可伸缩性，一些高级的应用程序服务器是用 JNI 本机代码优化的，因此它们没有提供标准 I/O 和 NIO 之间的很好比较。目标是要确定 NIO 是否给出了大量的性能优势，以及是在什么条件下给出的。

如下是一些说明：

• Tomcat 是用最大的线程数量 2000 来配置的，而示例服务器只允许用 4 个工作线程运行。
  
• 每个服务器是针对相同的一组简单 HTTP get 测试的，这些 HTTP get 基本上由文本内容组成。
  
  
• 把加载工具（Microsoft Web Application Stress Tool）设置为使用“Keep-Alive”会话，导致了大约要为每个用户分配一个 socket。然后它导致了在 Tomcat 上为每个用户分配一个线程，而 NIO 服务器用固定数量的线程来处理相同的负载。

图 2 展示了在不断增加负载下的“请求/秒”率。在 200 个用户时，性能是相似的。但当用户数量超过 600 时，Tomcat 的性能开始急剧下降。这最有可能是由于在这么多的线程间切换上下文的开销而导致的。相反，基于 NIO 的服务器的性能则以线性方式下降。记住，Tomcat 必须为每个用户分配一个线程，而 NIO 服务器只配置有 4 个工作线程。

图 3 进一步显示了 NIO 的性能。它展示了操作的 Socket 连接错误数/分钟。同样，在大约 600 个用户时，Tomcat 的性能急剧下降，而基于 NIO 的服务器的错误率保持相对较低。

回页首

结束语

在本文中您已经学习了，实际上可以使用 NIO 编写基于 Servlet 的 Web 服务器，甚至可以启用它的非阻塞特性。对于企业开发人员来说，这是好消息，因为在企业环境中，NIO 比标准 Java I/O 更能够进行伸缩。不像标准的 Java I/O，NIO 可以用固定数量的线程处理许多客户机。当基于 Servlet 的 NIO Web 服务器用来处理保持和拥有 socket 连接的客户机时，会获得更好的性能。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
• 下载本文中使用的 源代码。
  
  
  
  
• 看看“ Merlin 给 Java 平台带来了非阻塞 I/O”（ developerWorks，2002 年 3 月），获得 NIO 语义的进一步知识。
  
  
  
  
• 综合的 developerWorks 教程“ NIO 入门”（ developerWorks，2003 年 11 月）从高级的概念到底层的编程细节，详细论及了 NIO 库。
  
  
  
  
• Merlin Hughes 的由两部分组成的文章“ Turning streams inside out”（ developerWorks，2002 年 9 月）为 Java I/O（标准版和 NIO 版）的一些普遍的挑战提供了制作精巧的设计解决方案。
  
  
  
  
• 为获取有关 Java I/O 问题的一些背景知识，请参阅 Allen Holub 的“ 关于解决 Java 编程语言线程问题的建议 ”（ developerWorks，2000 年 10 月）。
  
  
  
  
• 访问 NIO 主页，从资源中学习非阻塞 I/O。
  
  
  
  
• JavaNIO.info 是查找有关 NIO 的资源的理想地方。
  
  
  
  
• 为从书本系统学习 NIO，请参阅该领域的经典著作：Ron Hitchens 的 Java NIO（O'Reilly & Associates，2002 年）。
  
  
  
  
• 在 developerWorks Java 技术专区可以找到有关 Java 编程各个方面的文章。
  
  
  
  
• 访问 Developer Bookstore，获取技术书籍的完整列表，其中包括数百本 Java 相关的图书。
  
  
  
  
• 也请参阅 Java 技术专区教程页，从 developerWorks 获取免费的 Java 专门教程的完整列表。
  
  
  

关于作者

		Taylor Cowan 是一位软件工程师，也是一位专攻 J2EE 的自由撰稿人。他从 North Texas 大学的计算机科学专业获得了硕士学位，另外，他还从 Jazz Arranging 获得了音乐学士学位。

    public class Test extends Thread{
      public Test(){
      }
      public static void main(String args[]){
        Test t1 = new Test();
        Test t2 = new Test();
        t1.start();
        t2.start();
      }
      public void run(){
        //do thread's things
      }
    }

    public class Test implements Runnable{
      Thread thread1;
      Thread thread2;
      public Test(){
        thread1 = new Thread(this,"1");
        thread2 = new Thread(this,"2");
      }
      public static void main(String args[]){
        Test t = new Test();
        t.startThreads();
      }
      public void run(){
        //do thread's things
      }
      public void startThreads(){
        thread1.start();
        thread2.start();
      }
    }

    两种创建方式看起来差别不大,但是弄不清楚的话，也许会将你的程序弄得一团糟。两者区别有以下几点：

1.当你想继承某一其它类时,你只能用后一种方式.

2.第一种因为继承自Thread,只创建了自身对象,但是在数量上，需要几个线程，就得创建几个自身对象；第二种只创建一个自身对象，却创建几个Thread对象.而两种方法重大的区别就在于此，请你考虑：如果你在第一种里创建数个自身对象并且start()后，你会发现好像synchronized不起作用了，已经加锁的代码块或者方法居然同时可以有几个线程进去，而且同样一个变量，居然可以有好几个线程同时可以去更改它。（例如下面的代码）这是因为，在这个程序中，虽然你起了数个线程，可是你也创建了数个对象，而且，每个线程对应了每个对象也就是说，每个线程更改和占有的对象都不一样，所以就出现了同时有几个线程进入一个方法的现象，其实，那也不是一个方法，而是不同对象的相同的方法。所以，这时候你要加锁的话，只能将方法或者变量声明为静态，将static加上后，你就会发现，线程又能管住方法了，同时不可能有两个线程进入同样一个方法，那是因为，现在不是每个对象都拥有一个方法了，而是所有的对象共同拥有一个方法，这个方法就是静态方法。

    而你如果用第二种方法使用线程的话，就不会有上述的情况，因为此时，你只创建了一个自身对象，所以，自身对象的属性和方法对于线程来说是共有的。

    因此，我建议，最好用后一种方法来使用线程。

public class mainThread extends Thread{
  int i=0;
  public static void main(String args[]){
    mainThread m1 = new mainThread();
    mainThread m2 = new mainThread();
    mainThread m3 = new mainThread();
    mainThread m4 = new mainThread();
    mainThread m5 = new mainThread();
    mainThread m6 = new mainThread();
    m1.start();
    m2.start();
    m3.start();
    m4.start();
    m5.start();
    m6.start();
  }
  public synchronized void t1(){
    i=++i;
    try{
      Thread.sleep(500);
    }
    catch(Exception e){}
    //每个线程都进入各自的t1()方法，分别打印各自的i
    System.out.println(Thread.currentThread().getName()+" "+i);
  }
  public void run(){
    synchronized(this){
      while (true) {
        t1();
      }
    }
  }
}

    下面我们来讲synchronized的4种用法吧:

    1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
 
      例如:

      public synchronized void synMethod() {
        //方法体
      }

    2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.例如:

      public int synMethod(int a1){
        synchronized(a1) {
          //一次只能有一个线程进入
        }
      }
    3.synchronized后面括号里是一对象,此时,线程获得的是对象锁.例如:

public class MyThread implements Runnable {
  public static void main(String args[]) {
    MyThread mt = new MyThread();
    Thread t1 = new Thread(mt, "t1");
    Thread t2 = new Thread(mt, "t2");
    Thread t3 = new Thread(mt, "t3");
    Thread t4 = new Thread(mt, "t4");
    Thread t5 = new Thread(mt, "t5");
    Thread t6 = new Thread(mt, "t6");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
  }

  public void run() {
    synchronized (this) {
      System.out.println(Thread.currentThread().getName());
    }
  }
}

 
    对于3,如果线程进入,则得到对象锁,那么别的线程在该类所有对象上的任何操作都不能进行.在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：

class FineGrainLock {

   MyMemberClass x, y;
   Object xlock = new Object(), ylock = new Object();

   public void foo() {
      synchronized(xlock) {
         //access x here
      }

      //do something here - but don't use shared resources

      synchronized(ylock) {
         //access y here
      }
   }

   public void bar() {
      synchronized(this) {
         //access both x and y here
      }
      //do something here - but don't use shared resources
   }
}

    4.synchronized后面括号里是类.例如:

class ArrayWithLockOrder{
  private static long num_locks = 0;
  private long lock_order;
  private int[] arr;

  public ArrayWithLockOrder(int[] a)
  {
    arr = a;
    synchronized(ArrayWithLockOrder.class) {//-----------------------------------------这里
      num_locks++;             // 锁数加 1。
      lock_order = num_locks;  // 为此对象实例设置唯一的 lock_order。
    }
  }
  public long lockOrder()
  {
    return lock_order;
  }
  public int[] array()
  {
    return arr;
  }
}

class SomeClass implements Runnable
{
  public int sumArrays(ArrayWithLockOrder a1,
                       ArrayWithLockOrder a2)
  {
    int value = 0;
    ArrayWithLockOrder first = a1;       // 保留数组引用的一个
    ArrayWithLockOrder last = a2;        // 本地副本。
    int size = a1.array().length;
    if (size == a2.array().length)
    {
      if (a1.lockOrder() > a2.lockOrder())  // 确定并设置对象的锁定
      {                                     // 顺序。
        first = a2;
        last = a1;
      }
      synchronized(first) {              // 按正确的顺序锁定对象。
        synchronized(last) {
          int[] arr1 = a1.array();
          int[] arr2 = a2.array();
          for (int i=0; i<size; i++)
            value += arr1[i] + arr2[i];
        }
      }
    }
    return value;
  }
  public void run() {
    //...
  }
}

    对于4,如果线程进入,则线程在该类中所有操作不能进行,包括静态变量和静态方法,实际上,对于含有静态方法和静态变量的代码块的同步,我们通常用4来加锁.

以上4种之间的关系：

    锁是和对象相关联的，每个对象有一把锁，为了执行synchronized语句，线程必须能够获得synchronized语句中表达式指定的对象的锁，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。
    在方法前面加上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。

  下面谈一谈一些常用的方法:

  wait(),wait(long),notify(),notifyAll()等方法是当前类的实例方法,
   
        wait()是使持有对象锁的线程释放锁;
        wait(long)是使持有对象锁的线程释放锁时间为long(毫秒)后,再次获得锁,wait()和wait(0)等价;
        notify()是唤醒一个正在等待该对象锁的线程,如果等待的线程不止一个,那么被唤醒的线程由jvm确定;
        notifyAll是唤醒所有正在等待该对象锁的线程.
        在这里我也重申一下,我们应该优先使用notifyAll()方法,因为唤醒所有线程比唤醒一个线程更容易让jvm找到最适合被唤醒的线程.

    对于上述方法,只有在当前线程中才能使用,否则报运行时错误java.lang.IllegalMonitorStateException: current thread not owner.

    下面,我谈一下synchronized和wait()、notify()等的关系:

1.有synchronized的地方不一定有wait,notify

2.有wait,notify的地方必有synchronized.这是因为wait和notify不是属于线程类，而是每一个对象都具有的方法，而且，这两个方法都和对象锁有关，有锁的地方，必有synchronized。

另外，请注意一点：如果要把notify和wait方法放在一起用的话，必须先调用notify后调用wait，因为如果调用完wait，该线程就已经不是current thread了。如下例：

/**
 * Title:        Jdeveloper's Java Projdect
 * Description:  n/a
 * Copyright:    Copyright (c) 2001
 * Company:      soho  http://www.ChinaJavaWorld.com
 * @author jdeveloper@21cn.com
 * @version 1.0
 */
import java.lang.Runnable;
import java.lang.Thread;

public class DemoThread
    implements Runnable {

  public DemoThread() {
    TestThread testthread1 = new TestThread(this, "1");
    TestThread testthread2 = new TestThread(this, "2");

    testthread2.start();
    testthread1.start();

  }

  public static void main(String[] args) {
    DemoThread demoThread1 = new DemoThread();

  }

  public void run() {

    TestThread t = (TestThread) Thread.currentThread();
    try {
      if (!t.getName().equalsIgnoreCase("1")) {
        synchronized (this) {
          wait();
        }
      }
      while (true) {

        System.out.println("@time in thread" + t.getName() + "=" +
                           t.increaseTime());

        if (t.getTime() % 10 == 0) {
          synchronized (this) {
            System.out.println("****************************************");
            notify();
            if (t.getTime() == 100)
              break;
            wait();
          }
        }
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

}

class TestThread
    extends Thread {
  private int time = 0;
  public TestThread(Runnable r, String name) {
    super(r, name);
  }

  public int getTime() {
    return time;
  }

  public int increaseTime() {
    return++time;
  }

}

    下面我们用生产者/消费者这个例子来说明他们之间的关系:

    public class test {
  public static void main(String args[]) {
    Semaphore s = new Semaphore(1);
    Thread t1 = new Thread(s, "producer1");
    Thread t2 = new Thread(s, "producer2");
    Thread t3 = new Thread(s, "producer3");
    Thread t4 = new Thread(s, "consumer1");
    Thread t5 = new Thread(s, "consumer2");
    Thread t6 = new Thread(s, "consumer3");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
  }
}

class Semaphore
    implements Runnable {
  private int count;
  public Semaphore(int n) {
    this.count = n;
  }

  public synchronized void acquire() {
    while (count == 0) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        //keep trying
      }
    }
    count--;
  }

  public synchronized void release() {
    while (count == 10) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        //keep trying
      }
    }
    count++;
    notifyAll(); //alert a thread that's blocking on this semaphore
  }

  public void run() {
    while (true) {
      if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("consumer")) {
        acquire();
      }
      else if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("producer")) {
        release();
      }
      System.out.println(Thread.currentThread().getName() + " " + count);
    }
  }
}

       生产者生产,消费者消费,一般没有冲突,但当库存为0时,消费者要消费是不行的,但当库存为上限(这里是10)时,生产者也不能生产.请好好研读上面的程序,你一定会比以前进步很多.

      上面的代码说明了synchronized和wait,notify没有绝对的关系,在synchronized声明的方法、代码块中,你完全可以不用wait,notify等方法,但是,如果当线程对某一资源存在某种争用的情况下,你必须适时得将线程放入等待或者唤醒.

2003 年 11 月 24 日

尽管 SSL 阻塞操作――当读写数据的时候套接字的访问被阻塞――与对应的非阻塞方式相比提供了更好的 I/O 错误通知，但是非阻塞操作允许调用的线程继续运行。本文中，作者同时就客户端和服务器端描述了如何使用Java Secure Socket Extensions （JSSE） 和 Java NIO （新 I/O）库创建非阻塞的安全连接，并且介绍了创建非阻塞套接字的传统方法，以及使用JSSE 和 NIO 的一种可选的（必需的）方法。

阻塞，还是非阻塞？这就是问题所在。无论在程序员的头脑中多么高贵……当然这不是莎士比亚，本文提出了任何程序员在编写 Internet 客户程序时都应该考虑的一个重要问题。通信操作应该是阻塞的还是非阻塞的？

许多程序员在使用 Java 语言编写 Internet 客户程序时并没有考虑这个问题，主要是因为在以前只有一种选择――阻塞通信。但是现在 Java 程序员有了新的选择，因此我们编写的每个客户程序也许都应该考虑一下。

非阻塞通信在 Java 2 SDK 的 1.4 版被引入 Java 语言。如果您曾经使用该版本编过程序，可能会对新的 I/O 库（NIO）留下了印象。在引入它之前，非阻塞通信只有在实现第三方库的时候才能使用，而第三方库常常会给应用程序引入缺陷。

NIO 库包含了文件、管道以及客户机和服务器套接字的非阻塞功能。库中缺少的一个特性是安全的非阻塞套接字连接。在 NIO 或者 JSSE 库中没有建立安全的非阻塞通道类，但这并不意味着不能使用安全的非阻塞通信。只不过稍微麻烦一点。

要完全领会本文，您需要熟悉：

• Java 套接字通信的概念。您也应该实际编写过应用程序。而且不只是打开连接、读取一行然后退出的简单应用程序，应该是实现 POP3 或 HTTP 之类协议的客户机或通信库这样的程序。
• SSL 基本概念和加密之类的概念。基本上就是知道如何设置一个安全连接（但不必担心 JSSE ――这就是关于它的一个“紧急教程”）。
• NIO 库。
• 在您选择的平台上安装 Java 2 SDK 1.4 或以后的版本。（我是在 Windows 98 上使用 1.4.1_01 版。）

如果需要关于这些技术的介绍，请参阅 参考资料部分。

那么到底什么是阻塞和非阻塞通信呢？

阻塞和非阻塞通信

阻塞通信意味着通信方法在尝试访问套接字或者读写数据时阻塞了对套接字的访问。在 JDK 1.4 之前，绕过阻塞限制的方法是无限制地使用线程，但这样常常会造成大量的线程开销，对系统的性能和可伸缩性产生影响。java.nio 包改变了这种状况，允许服务器有效地使用 I/O 流，在合理的时间内处理所服务的客户请求。

没有非阻塞通信，这个过程就像我所喜欢说的“为所欲为”那样。基本上，这个过程就是发送和读取任何能够发送/读取的东西。如果没有可以读取的东西，它就中止读操作，做其他的事情直到能够读取为止。当发送数据时，该过程将试图发送所有的数据，但返回实际发送出的内容。可能是全部数据、部分数据或者根本没有发送数据。

阻塞与非阻塞相比确实有一些优点，特别是遇到错误控制问题的时候。在阻塞套接字通信中，如果出现错误，该访问会自动返回标志错误的代码。错误可能是由于网络超时、套接字关闭或者任何类型的 I/O 错误造成的。在非阻塞套接字通信中，该方法能够处理的唯一错误是网络超时。为了检测使用非阻塞通信的网络超时，需要编写稍微多一点的代码，以确定自从上一次收到数据以来已经多长时间了。

哪种方式更好取决于应用程序。如果使用的是同步通信，如果数据不必在读取任何数据之前处理的话，阻塞通信更好一些，而非阻塞通信则提供了处理任何已经读取的数据的机会。而异步通信，如 IRC 和聊天客户机则要求非阻塞通信以避免冻结套接字。

回页首

创建传统的非阻塞客户机套接字

Java NIO 库使用通道而非流。通道可同时用于阻塞和非阻塞通信，但创建时默认为非阻塞版本。但是所有的非阻塞通信都要通过一个名字中包含 Channel 的类完成。在套接字通信中使用的类是 SocketChannel， 而创建该类的对象的过程不同于典型的套接字所用的过程，如清单 1 所示。

SocketChannel sc = SocketChannel.open();
            sc.connect("www.ibm.com",80);
            sc.finishConnect();
            

必须声明一个 SocketChannel 类型的指针，但是不能使用 new 操作符创建对象。相反，必须调用 SocketChannel 类的一个静态方法打开通道。打开通道后，可以通过调用 connect() 方法与它连接。但是当该方法返回时，套接字不一定是连接的。为了确保套接字已经连接，必须接着调用 finishConnect() 。

当套接字连接之后，非阻塞通信就可以开始使用 SocketChannel 类的 read() 和 write() 方法了。也可以把该对象强制转换成单独的 ReadableByteChannel 和 WritableByteChannel 对象。无论哪种方式，都要对数据使用 Buffer 对象。因为 NIO 库的使用超出了本文的范围，我们不再对此进一步讨论。

当不再需要套接字时，可以使用 close() 方法将其关闭：

sc.close();
            

这样就会同时关闭套接字连接和底层的通信通道。

回页首

创建替代的非阻塞的客户机套接字

上述方法比传统的创建套接字连接的例程稍微麻烦一点。不过，传统的例程也能用于创建非阻塞套接字，不过需要增加几个步骤以支持非阻塞通信。

SocketChannel 对象中的底层通信包括两个 Channel 类： ReadableByteChannel 和 WritableByteChannel。 这两个类可以分别从现有的 InputStream 和 OutputStream 阻塞流中使用 Channels 类的 newChannel() 方法创建，如清单 2 所示：

清单 2. 从流中派生通道

ReadableByteChannel rbc = Channels.newChannel(s.getInputStream()); WriteableByteChannel wbc = Channels.newChannel(s.getOutputStream());

Channels 类也用于把通道转换成流或者 reader 和 writer。这似乎是把通信切换到阻塞模式，但并非如此。如果试图读取从通道派生的流，读方法将抛出 IllegalBlockingModeException 异常。

相反方向的转换也是如此。不能使用 Channels 类把流转换成通道而指望进行非阻塞通信。如果试图读从流派生的通道，读仍然是阻塞的。但是像编程中的许多事情一样，这一规则也有例外。

这种例外适合于实现 SelectableChannel 抽象类的类。 SelectableChannel 和它的派生类能够选择使用阻塞或者非阻塞模式。 SocketChannel 就是这样的一个派生类。

但是，为了能够在两者之间来回切换，接口必须作为 SelectableChannel 实现。对于套接字而言，为了实现这种能力必须使用 SocketChannel 而不是 Socket 。

回顾一下，要创建套接字，首先必须像通常使用 Socket 类那样创建一个套接字。套接字连接之后，使用 清单 2中的两行代码把流转换成通道。

清单 3. 创建套接字的另一种方法

Socket s = new Socket("www.ibm.com", 80); ReadableByteChannel rbc = Channels.newChannel(s.getInputStream()); WriteableByteChannel wbc = Channels.newChannel(s.getOutputStream());

如前所述，这样并不能实现非阻塞套接字通信――所有的通信仍然在阻塞模式下。在这种情况下，非阻塞通信必须模拟实现。模拟层不需要多少代码。让我们来看一看。

从模拟层读数据

模拟层在尝试读操作之前首先检查数据的可用性。如果数据可读则开始读。如果没有数据可用，可能是因为套接字被关闭，则返回表示这种情况的代码。在清单 4 中要注意仍然使用了 ReadableByteChannel 读，尽管 InputStream 完全可以执行这个动作。为什么这样做呢？为了造成是 NIO 而不是模拟层执行通信的假象。此外，还可以使模拟层与其他通道更容易结合，比如向文件通道内写入数据。

清单 4. 模拟非阻塞的读操作

/* The checkConnection method returns the character read when determining if a connection is open. */ y = checkConnection(); if(y <= 0) return y; buffer.putChar((char ) y); return rbc.read(buffer);

向模拟层写入数据

对于非阻塞通信，写操作只写入能够写的数据。发送缓冲区的大小和一次可以写入的数据多少有很大关系。缓冲区的大小可以通过调用 Socket 对象的 getSendBufferSize() 方法确定。在尝试非阻塞写操作时必须考虑到这个大小。如果尝试写入比缓冲块更大的数据，必须拆开放到多个非阻塞写操作中。太大的单个写操作可能被阻塞。

清单 5. 模拟非阻塞的写操作

int x, y = s.getSendBufferSize(), z = 0; int expectedWrite; byte [] p = buffer.array(); ByteBuffer buf = ByteBuffer.allocateDirect(y); /* If there isn't any data to write, return, otherwise flush the stream */ if(buffer.remaining() == 0) return 0; os.flush() for(x = 0; x < p.length; x += y) { if(p.length - x < y) { buf.put(p, x, p.length - x); expectedWrite = p.length - x; } else { buf.put(p, x, y); expectedWrite = y; } /* Check the status of the socket to make sure it's still open */ if(!s.isConnected()) break; /* Write the data to the stream, flushing immediately afterward */ buf.flip(); z = wbc.write(buf); os.flush(); if(z < expectedWrite) break; buf.clear(); } if(x > p.length) return p.length; else if(x == 0) return -1; else return x + z;

与读操作类似，首先要检查套接字是否仍然连接。但是如果把数据写入 WritableByteBuffer 对象，就像清单 5 那样，该对象将自动进行检查并在没有连接时抛出必要的异常。在这个动作之后开始写数据之前，流必须立即被清空，以保证发送缓冲区中有发送数据的空间。任何写操作都要这样做。发送到块中的数据与发送缓冲区的大小相同。执行清除操作可以保证发送缓冲不会溢出而导致写操作被阻塞。

因为假定写操作只能写入能够写的内容，这个过程还必须检查套接字保证它在每个数据块写入后仍然是打开的。如果在写入数据时套接字被关闭，则必须中止写操作并返回套接字关闭之前能够发送的数据量。

BufferedOutputReader 可用于模拟非阻塞写操作。如果试图写入超过缓冲区两倍长度的数据，则直接写入缓冲区整倍数长度的数据（缓冲余下的数据）。比如说，如果缓冲区的长度是 256 字节而需要写入 529 字节的数据，则该对象将清除当前缓冲区、发送 512 字节然后保存剩下的 17 字节。

对于非阻塞写而言，这并非我们所期望的。我们希望分次把数据写入同样大小的缓冲区中，并最终把全部数据都写完。如果发送的大块数据留下一些数据被缓冲，那么在所有数据被发送的时候，写操作就会被阻塞。

模拟层类模板

整个模拟层可以放到一个类中，以便更容易和应用程序集成。如果要这样做，我建议从 ByteChannel 派生这个类。这个类可以强制转换成单独的 ReadableByteChannel 和 WritableByteChannel 类。

清单 6 给出了从 ByteChannel 派生的模拟层类模板的一个例子。本文后面将一直使用这个类表示通过阻塞连接执行的非阻塞操作。

清单 6. 模拟层的类模板

public class nbChannel implements ByteChannel { Socket s; InputStream is; OutputStream os; ReadableByteChannel rbc; WritableByteChannel wbc; public nbChannel(Socket socket); public int read(ByteBuffer dest); public int write(ByteBuffer src); public void close(); protected int checkConnection(); }

使用模拟层创建套接字

使用新建的模拟层创建套接字非常简单。只要像通常那样创建 Socket 对象，然后创建 nbChannel 对象就可以了，如清单 7 所示：

清单 7. 使用模拟层

Socket s = new Socket("www.ibm.com", 80); nbChannel socketChannel = new nbChannel(s); ReadableByteChannel rbc = (ReadableByteChannel)socketChannel; WritableByteChannel wbc = (WritableByteChannel)socketChannel;

回页首

创建传统的非阻塞服务器套接字

服务器端的非阻塞套接字和客户端上的没有很大差别。稍微麻烦一点的只是建立接受输入连接的套接字。套接字必须通过从服务器套接字通道派生一个阻塞的服务器套接字绑定到阻塞模式。清单 8 列出了需要做的步骤。

清单 8. 创建非阻塞的服务器套接字（SocketChannel）

ServerSocketChannel ssc = ServerSocketChannel.open(); ServerSocket ss = ssc.socket(); ss.bind(new InetSocketAddress(port)); SocketChannel sc = ssc.accept();

与客户机套接字通道相似，服务器套接字通道也必须打开而不是使用 new 操作符或者构造函数。在打开之后，必须派生服务器套接字对象以便把套接字通道绑定到一个端口。一旦套接字被绑定，服务器套接字对象就可以丢弃了。

通道使用 accept() 方法接收到来的连接并把它们转给套接字通道。一旦接收了到来的连接并转给套接字通道对象，通信就可以通过 read() 和 write() 方法开始进行了。

回页首

创建替代的非阻塞服务器套接字

实际上，并非真正的替代。因为服务器套接字通道必须使用服务器套接字对象绑定，为何不完全绕开服务器套接字通道而仅使用服务器套接字对象呢？不过这里的通信不使用 SocketChannel ，而要使用模拟层 nbChannel。

清单 9. 建立服务器套接字的另一种方法

ServerSocket ss = new ServerSocket(port); Socket s = ss.accept(); nbChannel socketChannel = new nbChannel(s); ReadableByteChannel rbc = (ReadableByteChannel)socketChannel; WritableByteChannel wbc = (WritableByteChannel)socketChannel;

回页首

创建 SSL 连接

创建SSL连接，我们要分别从客户端和服务器端考察。

从客户端

创建 SS L连接的传统方法涉及到使用套接字工厂和其他一些东西。我将不会详细讨论如何创建SSL连接，不过有一本很好的教程，“Secure your sockets with JSSE”（请参阅 参考资料），从中您可以了解到更多的信息。

创建 SSL 套接字的默认方法非常简单，只包括几个很短的步骤：

1. 创建套接字工厂。
2. 创建连接的套接字。
3. 开始握手。
4. 派生流。
5. 通信。

清单 10 说明了这些步骤：

清单 10. 创建安全的客户机套接字

SSLSocketFactory sslFactory = (SSLSocketFactory)SSLSocketFactory.getDefault(); SSLSocket ssl = (SSLSocket)sslFactory.createSocket(host, port); ssl.startHandshake(); InputStream is = ssl.getInputStream(); OutputStream os = ssl.getOutputStream();

默认方法不包括客户验证、用户证书和其他特定连接可能需要的东西。

从服务器端

建立SSL服务器连接的传统方法稍微麻烦一点，需要加上一些类型转换。因为这些超出了本文的范围，我将不再进一步介绍，而是说说支持SSL服务器连接的默认方法。

创建默认的 SSL 服务器套接字也包括几个很短的步骤：

1. 创建服务器套接字工厂。
2. 创建并绑定服务器套接字。
3. 接受传入的连接。
4. 开始握手。
5. 派生流。
6. 通信。

尽管看起来似乎与客户端的步骤相似，要注意这里去掉了很多安全选项，比如客户验证。

清单 11 说明这些步骤：

清单 11. 创建安全的服务器套接字

SSLServerSocketFactory sslssf = (SSLServerSocketFactory)SSLServerSocketFactory.getDefault(); SSLServerSocket sslss = (SSLServerSocket)sslssf.createServerSocket(port); SSLSocket ssls = (SSLSocket)sslss.accept(); ssls.startHandshake(); InputStream is = ssls.getInputStream(); OutputStream os = ssls.getOutputStream();

回页首

创建安全的非阻塞连接

要精心实现安全的非阻塞连接，也需要分别从客户端和服务器端来看。

从客户端

在客户端建立安全的非阻塞连接非常简单：

1. 创建并连接 Socket 对象。
2. 把 Socket 对象添加到模拟层上。
3. 通过模拟层通信。

清单 12 说明了这些步骤：

清单 12. 创建安全的客户机连接

/* Create the factory, then the secure socket */ SSLSocketFactory sslFactory = (SSLSocketFactory)SSLSocketFactory.getDefault(); SSLSocket ssl = (SSLSocket)sslFactory.createSocket(host, port); /* Start the handshake. Should be done before deriving channels */ ssl.startHandshake(); /* Put it into the emulation layer and create separate channels */ nbChannel socketChannel = new nbChannel(ssl); ReadableByteChannel rbc = (ReadableByteChannel)socketChannel; WritableByteChannel wbc = (WritableByteChannel)socketChannel;

利用前面给出的 模拟层类 就可以实现非阻塞的安全连接。因为安全套接字通道不能使用 SocketChannel 类打开，而 Java API 中又没有完成这项工作的类，所以创建了一个模拟类。模拟类可以实现非阻塞通信，无论使用安全套接字连接还是非安全套接字连接。

列出的步骤包括默认的安全设置。对于更高级的安全性，比如用户证书和客户验证， 参考资料 部分提供了说明如何实现的文章。

从服务器端

在服务器端建立套接字需要对默认安全稍加设置。但是一旦套接字被接收和路由，设置必须与客户端的设置完全相同，如清单 13 所示：

清单 13. 创建安全的非阻塞服务器套接字

/* Create the factory, then the socket, and put it into listening mode */ SSLServerSocketFactory sslssf = (SSLServerSocketFactory)SSLServerSocketFactory.getDefault(); SSLServerSocket sslss = (SSLServerSocket)sslssf.createServerSocket(port); SSLSocket ssls = (SSLSocket)sslss.accept(); /* Start the handshake on the new socket */ ssls.startHandshake(); /* Put it into the emulation layer and create separate channels */ nbChannel socketChannel = new nbChannel(ssls); ReadableByteChannel rbc = (ReadableByteChannel)socketChannel; WritableByteChannel wbc = (WritableByteChannel)socketChannel;

同样，要记住这些步骤使用的是默认安全设置。

回页首

集成安全的和非安全的客户机连接

多数 Internet 客户机应用程序，无论使用 Java 语言还是其他语言编写，都需要提供安全和非安全连接。Java Secure Socket Extensions 库使得这项工作非常容易，我最近在编写一个 HTTP 客户库时就使用了这种方法。

SSLSocket 类派生自 Socket。 您可能已经猜到我要怎么做了。所需要的只是该对象的一个 Socket 指针。如果套接字连接不使用SSL，则可以像通常那样创建套接字。如果要使用 SSL，就稍微麻烦一点，但此后的代码就很简单了。清单 14 给出了一个例子：

清单 14. 集成安全的和非安全的客户机连接

Socket s; ReadableByteChannel rbc; WritableByteChannel wbc; nbChannel socketChannel; if(!useSSL) s = new Socket(host, port); else { SSLSocketFactory sslsf = SSLSocketFactory.getDefault(); SSLSocket ssls = (SSLSocket)SSLSocketFactory.createSocket(host, port); ssls.startHandshake(); s = ssls; } socketChannel = new nbChannel(s); rbc = (ReadableByteChannel)socketChannel; wbc = (WritableByteChannel)socketChannel; ... s.close();

创建通道之后，如果套接字使用了SSL，那么就是安全通信，否则就是普通通信。如果使用了 SSL，关闭套接字将导致握手中止。

这种设置的一种可能是使用两个单独的类。一个类负责处理通过套接字沿着与非安全套接字的连接进行的所有通信。一个单独的类应该负责创建安全的连接，包括安全连接的所有必要设置，无论是否是默认的。安全类应该直接插入通信类，只有在使用安全连接时被调用。

使用J2SEAPI读取Properties文件的六种方法



　　1。使用java.util.Properties类的load()方法示例：InputStreamin=lnewBufferedInputStream(newFileInputStream(name));Propertiesp=newProperties();p.load(in);

　　2。使用java.util.ResourceBundle类的getBundle()方法示例：ResourceBundlerb=ResourceBundle.getBundle(name,Locale.getDefault());

　　3。使用java.util.PropertyResourceBundle类的构造函数示例：InputStreamin=newBufferedInputStream(newFileInputStream(name));ResourceBundlerb=newPropertyResourceBundle(in);

　　4。使用class变量的getResourceAsStream()方法示例：InputStreamin=JProperties.class.getResourceAsStream(name);Propertiesp=newProperties();p.load(in);

　　5。使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法示例：InputStreamin=JProperties.class.getClassLoader().getResourceAsStream(name);Propertiesp=newProperties();p.load(in);

　　6。使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法示例：InputStreamin=ClassLoader.getSystemResourceAsStream(name);Propertiesp=newProperties();p.load(in);

　　补充

　　Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法示例：InputStreamin=context.getResourceAsStream(path);Propertiesp=newProperties();p.load(in);

class ThreadB extends Thread
{
  int total;
  public void run()
  {
    synchronized(this)
    {
      System.out.println("ThreadB is running..");
      for (int i=0;i<100;i++ )
      {
        total +=i;
        System.out.println("total is "+total);
      }
      notify();
    }
  }
}

要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

 再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.

按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态，同时又“积极”地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."

  我们来解释一下这句话.
  "wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?

   区别在于"(wait)同时又“积极”地等待条件发生改变",这一点很关键,sleep和suspend无法做到.因为我们有时候需要通过同步（synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着,等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.
   而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.
   但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！
   好,那怎么把对象锁收回来呢?
   第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.
   第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?靠!当然用完了就收回了,还管我设的是多长时间啊.

   那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.
   因此,我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().

   这个时候我们来解释上面的程序,简直是易如反掌了.

   synchronized(b){...}；的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.

Introduction

This article describes how you can create a run and debug configuration in IntelliJ IDEA 5.1 (or higher) to allow your Web modules with JSP files to be remotely debugged under WebSphere 5.1 and WebSphere 6.0 application servers. It also describes how to configure these application servers to enable integration with IntelliJ IDEA, and provides you with step-by-step instructions for application deployment.

Requirements

Before making any settings, make sure that the following requirements are met:

1. WebSphere 5.1 or 6.0 application server is installed (full or express version). IntelliJ IDEA does not have any bundled servers, so you need to install them yourself.
2. JDK (Sun Java2^TM Standard Edition SDK) 1.4 or less is installed. Although IntelliJ IDEA supports JDK 5.0, WebSphere application servers require JDK 1.4 or less.
3. WebSphere application server is started.

You can find the full documentation on how to install, start, and initially configure the server at http://www-306.ibm.com/software/websphere/.

Configuring WebSphere Application Server

To enable remote debugging on the server, perform the following steps:

1. Start the server's Administrative Console.
2. Expand Servers > Application Servers.
   
   
   

   ---

   Note:

   WebSphere Application Server V6.0: Administrative Console

3. Click the server name and clic the Configuration tab
4. Navigate to the Additional Properties group and click the Debugging Service link.
5. Make sure that the debugging service is enabled at server startup.
   • For the WebSphere 5.1 application server, select the Startup check box.
     
     
     

     ---

     Note:

     WebSphere Application Server - Express 5.1: enabling debugging

   • For the WebSphere 6.0 application server, select the Enable service at server startup check box.

     To the JVM Debug arguments field add the following line before the existing set of arguments: -Dwas.debug.mode=true

     
     
     

     ---

     Note:

     WebSphere Application Server 6.0: enabling debugging

6. Click the Apply button. Then save the settings (for example, using the notification message)
   
   
   

   ---

   Note:

   WebSphere Application Server 6.0: notification message

7. Restart the server using WebSphere's or operating system's administration tools.

Generating the Application Archive File

IntelliJ IDEA can generate the WAR, EAR, or JAR file for your application automatically. For this purpose, you need to configure your module (Web, J2EE Application, or EJB).

1. In IntelliJ IDEA, click File > Settings (Ctrl + Alt + S), and then select Modules.
2. In the Modules list, click the module for which you need to generate the archive file.
3. Click the J2EE Build Settings tab.
4. Select the Create web module war/ear/jar file check box, and specify the location of the file. This path will be required later, on the application deployment stage.

Apply the changes, and make the project (click the Build > Make Project menu or press Ctrl + F9).

The application is now ready for deployment.

Deploying Application

You deploy the application using the WebSphere application server's tools.

1. Start the server's Administrative Console.
2. Click Applications > Install New Application, and then click your server.
3. Select Local file system or Remote file system depending on your server installation, and then specify the path to your WAR, EAR, or JAR file (usually, it corresponds to the path you specified when generating the application archive file in IntelliJ IDEA).
4. In the Context Root text box, specify the context (e.g. "myContext").
   
   
   

   ---

   Note:

   WebSphere Application Server 6.0: enabling debugging

5. Click Next. Skip the next screen and click Next again. Note:

   The Security Warning may appear. It displays the content of the was.policy file. You can simply click Continue.

6. On the first step of the Install New Application wizard, select the Enable class reloading check box, and then click Next. This allows you to redeploy the application without reinstalling it
   
   
   

   ---

   Note:

   WebSphere Application Server 6.0: selecting installation options.

7. On the second step, select the check box next to your Web module to map it to the server. Then click Next.
8. On the third step, select the check box next to your Web module to map the virtual host to it, and then click Next.
9. On the last step, just click Finish. The deployment will start. Note:

   The server may not always notify you when the deployment is complete. If the operation takes too long, click Enterprise Applications. If your application is present in the enterprise applications list with the �Stopped� status (red cross icon), the deployment is complete, and you can move to the next step.

10. When the deployment is finished, the server console will show you the installation results page. Save the configuration, for example using the Save to Master Configuration link on this page.
11. Click Applications > Enterprise Applications. In the list of applications your application should be displayed with the �Stopped� status (red cross icon).
12. Select the check box next to your application, and then click Start.

WebSphere Application Server 6.0: starting the application

Creating Run/Debug Configuration

WebSphere 5.1/6.0 application servers are supported by means of the general IntelliJ IDEA integration with the JSR compatible servers and do not have a server-specific type of Run/Debug configuration. You need to create a configuration for a JSR45 compatible server and then modify it according to WebSphere application server's needs.

1. In IntelliJ IDEA, click the Run > Edit Configurations menu, and then click the JSR45 Compatible Server tab.
2. Click the plus sign or press Insert to add a new configuration, and then click Remote. Specify some configuration name.
3. Click the Configure button to add an application server.
4. In the Application Servers dialog box, click Add, and then specify some server name.
5. Click the Attach Classes button, and find the j2ee.jar file for your version of WebSphere Application server (<installation folder>\lib\j2ee.jar).
   
   
   

   ---

   Note:

   IntelliJ IDEA 5.1: configuring application servers

6. In the Application Servers dialog box, click Apply to save the changes, and then in the configuration, in the Application Server list, select the added server.
7. In the Startup page text box, specify the home page of your web application in the following format:
   • WebSphere Application Server 5.1
     http://localhost:7080/<ContextRoot>/<home page>
   • WebSphere Application Server 6.0
     http://localhost:9080/<ContextRoot>/<home page>

   "7080" and "9080" are default ports for the WebSphere 5.1 and 6.0 servers, respectively. If you have changed the default port, specify the actual port number instead.

   <ContextRoot> is name of web context used during application deployment, e.g. "myContext".
   <home page> can be any page from your Web module.

8. Optionally, you can configure the application server log to display its content in the IntelliJ IDEA's Run tool window, in the console.

   Click the Add button, and then in the Edit Log Files Aliases dialog specify some alias name (e.g. "activity"). In the Log File Location text box, specify the location of the activity.log file. By default, this file is located in the <home>\logs folder.

9. In the JSP package text box, enter one of the following:
   • WebSphere Application Server 5.1
     org.apache.jsp
   • WebSphere Application Server 6.0
     com.ibm._jsp
10. In the VM options variable text box, type DEBUG.
11. If you use WebSphere Application Server 5.1, select to use the specific JSP's line mapping model. For the WebSphere Application Server 6.0 this check box is ignored, but it is recommended to clear it.
12. In the Port text box, specify the port number of the corresponding application server (it should be the same as specified for the startup page).
    
    
    

    ---

    Note:

    IntelliJ IDEA 5.0: Run/Debug configuration for WebSphere Application Server 6.0

13. Click the Startup/Connection tab, and then click Debug. Check that the Socket option is selected, and the Port number is 7777.

Debugging Application

To start debugging the application in IntelliJ IDEA, just click Run > Debug or press Shift + F9. You can use all the power of the IntelliJ IDEA debugger for the JSP files running on the WebSphere Application Server, including breakpoints, stepping commands, watches, etc.

To apply any changes in the web module, you will need to redeploy the application as described earlier in this article. The "Build on frame deactivation" feature is not supported for remote debugging.

Troubleshooting

The server crashes during the debug session

Such problems may appear if you use the IBM's virtual machine supplied with the WebSphere server. Possible solutions in this case are:

• Run IntelliJ IDEA with the command line option:
  -Didea.debugger.keep.temp.objects=false
  In this case IntelliJ IDEA will avoid calling certain methods from debug API.
• Use Sun's JDK 1.4 or less

IntelliJ IDEA is unable to open the debugger port

In most cases, it is an internal WebSphere server error. Try to restart the WebSphere application server.

Conclusion

We hope that this article helped you to configure remote debugging successfully. If you have encountered any problems that are not described in the Troubleshooting section, don't hesitate to contact our technical support: support@jetbrains.com.

一：无返回值的存储过程

存储过程为：

CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2,PARA2 IN VARCHAR2) AS

BEGIN

   INSERT INTO HYQ.B_ID (I_ID,I_NAME) VALUES (PARA1, PARA2);

END TESTA;

然后呢，在java里调用时就用下面的代码：

package com.hyq.src;

import java.sql.*;

import java.sql.ResultSet;

public class TestProcedureOne {

 public TestProcedureOne() {

 }

 public static void main(String[] args ){

    String driver = "oracle.jdbc.driver.OracleDriver";

    String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521: hyq ";

    Statement stmt = null;

    ResultSet rs = null;

    Connection conn = null;

    CallableStatement cstmt = null;

    try {

      Class.forName(driver);

      conn = DriverManager.getConnection(strUrl, " hyq ", " hyq ");

      CallableStatement proc = null;

      proc = conn.prepareCall("{ call HYQ.TESTA(?,?) }");

      proc.setString(1, "100");

      proc.setString(2, "TestOne");

      proc.execute();

    }

    catch (SQLException ex2) {

      ex2.printStackTrace();

    }

    catch (Exception ex2) {

      ex2.printStackTrace();

    }

    finally{

      try {

        if(rs != null){

          rs.close();

          if(stmt!=null){

            stmt.close();

          }

          if(conn!=null){

            conn.close();

          }

        }

      }

      catch (SQLException ex1) {

      }

    }

 }

}

当然了，这就先要求要建张表TESTTB,里面两个字段（I_ID，I_NAME）。

二：有返回值的存储过程（非列表）

存储过程为：

CREATE OR REPLACE PROCEDURE TESTB(PARA1 IN VARCHAR2,PARA2 OUT VARCHAR2) AS

BEGIN

   SELECT INTO PARA2 FROM TESTTB WHERE I_ID= PARA1;

END TESTB;

在java里调用时就用下面的代码：

package com.hyq.src;

public class TestProcedureTWO {

 public TestProcedureTWO() {

 }

 public static void main(String[] args ){

    String driver = "oracle.jdbc.driver.OracleDriver";

    String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:hyq";

    Statement stmt = null;

    ResultSet rs = null;

    Connection conn = null;

    try {

      Class.forName(driver);

      conn = DriverManager.getConnection(strUrl, " hyq ", " hyq ");

      CallableStatement proc = null;

      proc = conn.prepareCall("{ call HYQ.TESTB(?,?) }");

      proc.setString(1, "100");

      proc.registerOutParameter(2, Types.VARCHAR);

      proc.execute();

      String testPrint = proc.getString(2);

      System.out.println("=testPrint=is="+testPrint);

    }

    catch (SQLException ex2) {

      ex2.printStackTrace();

    }

    catch (Exception ex2) {

      ex2.printStackTrace();

    }

    finally{

      try {

        if(rs != null){

          rs.close();

          if(stmt!=null){

            stmt.close();

          }

          if(conn!=null){

            conn.close();

          }

        }

      }

      catch (SQLException ex1) {

      }

    }

 }

}

}

注意，这里的proc.getString(2)中的数值2并非任意的，而是和存储过程中的out列对应的，如果out是在第一个位置，那就是proc.getString(1)，如果是第三个位置，就是proc.getString(3)，当然也可以同时有多个返回值，那就是再多加几个out参数了。

三：返回列表

由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用pagkage了.所以要分两部分，

1， 建一个程序包。如下：

CREATE OR REPLACE PACKAGE TESTPACKAGE  AS

 TYPE Test_CURSOR IS REF CURSOR;

end TESTPACKAGE;

2，建立存储过程，存储过程为：

CREATE OR REPLACE PROCEDURE TESTC(p_CURSOR out TESTPACKAGE.Test_CURSOR) IS

BEGIN

    OPEN p_CURSOR FOR SELECT * FROM HYQ.TESTTB;

END TESTC;

可以看到，它是把游标（可以理解为一个指针），作为一个out 参数来返回值的。

在java里调用时就用下面的代码：

package com.hyq.src;

import java.sql.*;

import java.io.OutputStream;

import java.io.Writer;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import oracle.jdbc.driver.*;

public class TestProcedureTHREE {

 public TestProcedureTHREE() {

 }

 public static void main(String[] args ){

    String driver = "oracle.jdbc.driver.OracleDriver";

    String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:hyq";

    Statement stmt = null;

    ResultSet rs = null;

    Connection conn = null;

    try {

      Class.forName(driver);

      conn = DriverManager.getConnection(strUrl, "hyq", "hyq");

      CallableStatement proc = null;

      proc = conn.prepareCall("{ call hyq.testc(?) }");

      proc.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR);

      proc.execute();

      rs = (ResultSet)proc.getObject(1);

      while(rs.next())

      {

          System.out.println("<tr><td>" + rs.getString(1) + "</td><td>"+rs.getString(2)+"</td></tr>");

      }

    }

    catch (SQLException ex2) {

      ex2.printStackTrace();

    }

    catch (Exception ex2) {

      ex2.printStackTrace();

    }

    finally{

      try {

        if(rs != null){

          rs.close();

          if(stmt!=null){

            stmt.close();

          }

          if(conn!=null){

            conn.close();

          }

        }

      }

      catch (SQLException ex1) {

      }

    }

 }

}

在这里要注意，在执行前一定要先把oracle的驱动包放到class路径里，否则会报错的。

的 SSO(single sign-on) 的服务(主要是2.0，到3.0为ja-sig)。

关键字

TGC(ticket-granting cookie)--------- 受权的票据证明

KDC( Key Distribution Center ) ---------- 密钥发放中心

Service ticket(ST) --------- 服务票据， 由 KDC 的 TGS 发放。 任何一台 Workstation 都需要拥有一张有效的 Service Ticket 才能访问域内部的应用 (Applications) 。 如果能正确接收 Service Ticket ，说明在 CASClient-CASServer 之间的信任关系已经被正确建立起来 , 通常为一张数字加密的证书

Ticket Granting tieckt(TGT) --------- 票据授权票据，由 KDC 的 AS 发放。即获取这样一张票据后，以后申请各种其他服务票据 (ST) 便不必再向 KDC 提交身份认证信息 ( 准确术语是 Credentials) 。

authentication service (AS) --------- 认证用服务，索取 Crendential ，发放 TGT

ticket-granting service (TGS) --------- 票据授权服务，索取 TGT ，发放 ST

CAS 单点服务器的认证过程，所有应用服务器收到应用请求后，检查 ST 和 TGT ，如果没有或不对，转到 CAS 认证服务器登陆页面，通过安全认证后得到 ST 和 TGT 再重定向到相关应用服务器，在会话生命周期之内如果再定向到别的应用，将出示

ST 和 TGT 进行认证 , 注意 , 取得 TGT 的过程是通过 SSL 安全协议的 ( 换句话说就是如果不用 ssl 协议 , 每访问一个应用服务，就得重新到认证服务中心认证一次 ) ，关于 SSL 的相关描述可以查看附录 .

白话描述 :

单点登陆 , 无非就是提供给用户一次登陆 , 多个系统共享用户信息的操作 .

这个是怎么操作的呢 ? 有简单的方法 , 当用户访问其他系统的时候 , 写个 URL 带上用户的 ID 和 PASS 提交到相应的系统就可以了 . 这也是一种方法

那 CAS 是怎么操作的呢 ? 或则是 KRB(Kerberos 是一个加密认证协议，允许网络用户不使用明文密码访问服务，一个普通
的协议实现包括 LOGIN 服务存在伪造欺骗对 Key Distribution Center 的响应 。

) 怎么操作的呢 ?

他并不是很复杂 , 他先是建立一个 专门认证用户的 服务 (SERVER) 这个服务只做一件事 , 负责验证用户的 ID 和 PASS 是否是正确 , 在正确的情况提供用户一个名为 TGT 的票据 ,

相当你要去游乐场玩 , 首先你要在门口检查你的身份 ( 即 CHECK 你的 ID 和 PASS), 如果你通过验证 , 游乐场的门卫 (AS) 即提供给你一张门卡 (TGT).

这张卡片的用处就是告诉 游乐场的各个场所 , 你是通过正门进来 , 而不是后门偷爬进来的 , 并且也是获取进入场所一把钥匙 .

好的 , 现在你有张卡 , 但是这对你来不重要 , 因为你来游乐场不是为了拿这张卡的 , 好的 , 我们向你的目的出发 , 恩 , 你来到一个摩天楼 , 你想进入玩玩 ,

这时摩天轮的服务员 (client) 拦下你 , 向你要求摩天轮的 (ST) 票据 , 你说你只有一个门卡 (TGT), 好的 , 那你只要把 TGT 放在一旁的票据授权机 (TGS) 上刷一下 ,

票据授权机 (TGS) 就根据你现在所在的摩天轮 , 给你一张摩天轮的票据 (ST), 哈 , 你有摩天轮的票据 , 现在你可以畅通无阻的进入摩天轮里游玩了 .

当然如果你玩完摩天轮后 , 想去游乐园的咖啡厅休息下 , 那你一样只要带着那张门卡 (TGT). 到相应的咖啡厅的票据授权机 (TGS) 刷一下 , 得到咖啡厅的票据 (ST) 就可以进入咖啡厅

当你离开游乐场后 , 想用这张 TGT 去刷打的回家的费用 , 呵呵 , 对不起 , 你的 TGT 已经过期了 , 在你离开游乐场那刻开始 , 你的 TGT 就已经销毁了 ~

Yale CAS Server 的配置过程

CAS (Central Authentication Service) 是 Yale 大学的 ITS 开发的一套 JAVA 实现的开源

的 SSO(single sign-on) 的服务。该服务是以一个 java web app(eg:cas.war) 来进行服务的，

使用时需要将 cas.war 发布到一个 servlet2.3 兼容的服务器上，并且服务器需要支持 SSL ，

在需要使用该服务的其他服务器（客户），只要进行简单的配置就可以实现 SSO 了。

CAS 的客户端可以有很多种，因为验证的结果是以 XML 的格式返回的， CAS 的客户端已

打包进去的有 java,perl,python,asp,apache module 等好几种客户端示例，你还可以根据

需要实现一个自己的客户端，非常简单 !~

下面我们以 tomcat 5.0 作为 CAS Server(server1) ，另外一台 tomcat5.0 为 client(client1)

为例进行说明。

1. 下载 cas-server 和 cas-client( 可选，建议使用）

http://www.ja-sig.org/downloads/cas/cas-server-3.0.5.zip

http://www.ja-sig.org/downloads/cas-clients/cas-client-java-2.1.1.zip

2. 将 cas-server-3.0.5.zip 解压，并将 lib/cas.war 拷贝到 server1 的 webapps 下

3. 产生 SERVER 的证书

PS: 参数与各系统本身一致

%JAVA_HOME%\bin\keytool -delete -alias tomcat -keypass changeit

%JAVA_HOME%\bin\keytool -genkey -alias tomcat -keypass changeit -keyalg RSA

%JAVA_HOME%\bin\keytool -export -alias tomcat -keypass changeit -file %FILE_NAME%

%JAVA_HOME%\bin\keytool -import -file server.crt -keypass changeit -keystore %JAVA_HOME%/jre/lib/security/cacerts

%JAVA_HOME%\bin\keytool -import -file server.crt -keystore %JAVA_HOME%\jre\lib\security\cacerts

4. 在 server1 配置 tomcat 使用 HTTPS

$CATALINA_HOME/conf/server.xml 里

<Connector className="org.apache.coyote.tomcat5.CoyoteConnector"

port="8443" minProcessors="5" maxProcessors="75"

enableLookups="true" disableUploadTimeout="true"

acceptCount="100" debug="0" scheme="https"

secure="true">

<Factory className="org.apache.coyote.tomcat5.CoyoteServerSocketFactory"

keystoreFile="/path/to/your/keystore-file"

keystorePass="your-password" clientAuth="false" protocol="TLS" />

</Connector>

5. 在要使用 CAS 的客户端 client1 里设置（以 servlets-examples 这个 APP 为例），我们使用

ServletFilter(CAS client 里提供的 ) 来实现 SSO 的检查。

修改 servlets-examples/WEB-INF/web.xml

<filter>

<filter-name>CASFilter</filter-name>

<filter-class>edu.yale.its.tp.cas.client.filter.CASFilter</filter-class>

<init-param>

<param-name>edu.yale.its.tp.cas.client.filter.loginUrl</param-name>

<param-value>https://your.cas.server.name(eg:server1):port/cas/login</param-value>

</init-param>

<init-param>

<param-name>edu.yale.its.tp.cas.client.filter.validateUrl</param-name>

<param-value>https://your.cas.server.name(eg:server1):port/cas/proxyValidate</param-value>

</init-param>

<init-param>

<param-name>edu.yale.its.tp.cas.client.filter.serviceUrl</param-name>

<param-value>your.client.server.ip(eg:127.0.0.1):port</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>CASFilter</filter-name>

<url-pattern>/servlet/*</url-pattern>

</filter-mapping>

PS: 在 client 端配置 filter 时 , 需要将 CAS 的 filter 放在 web.xml 最上端 ,. 如果在你的 web.xml 有类似 encodingFilter 的 filter 也需要将这个 filter 放在 CAS filter 下面 , 否则你会发现每次访问时都需要你进行验证 .

6. 将 cas-client-java-2.1.1.zip 解压，把 java/lib/casclient.jar 拷贝到 client1 服务器上的

webapps/servlets-examples/WEB-INF/lib 目录下（如果没有就建一个）

7. 导出 SERVER 的证书，用来给所有需要用到的客户端导入

keytool -export -file server.crt -alias my-alias-name -keystore keystore-file

8. 在客户端的 JVM 里导入信任的 SERVER 的证书 ( 根据情况有可能需要管理员权限 )

keytool -import -keystore $JAVA_HOME/jre/lib/security/cacerts -file server.crt -alias my-alias-name

9.test & done.

把 server1 和 client1 分别起来，检查启动的 LOG 是否正常，如果一切 OK ，就访问

http://client1:8080/servlets-examples/servlet/HelloWorldExample

系统会自动跳转到一个验证页面，随便输入一个相同的账号 , 密码，严正通过之后就会访问

到真正的 HelloWorldExample 这个 servlet 了

实现自已的认证代码 (java 代码和相关注释 , 需要 cas-server-3.0.5.jar 包 )

package com.mcm.sso;

import org.jasig.cas.authentication.handler.support.AbstractUsernamePasswordAuthenticationHandler;

import org.jasig.cas.authentication.principal.UsernamePasswordCredentials;

import org.springframework.util.StringUtils;

public class MyUsernamePasswordAuthenticationHandler extends

AbstractUsernamePasswordAuthenticationHandler {

public boolean authenticateUsernamePasswordInternal(

final UsernamePasswordCredentials credentials) {

final String username = credentials.getUsername();

final String password = credentials.getPassword();

// 此处实现你的登陆验证代码

if (StringUtils.hasText(username) && StringUtils.hasText(password) ) {

getLog().debug(

" User [ " + username + " ] was successfully authenticated with ucix. " );

return true ;

}

getLog().debug( " User [ " + username + " ] failed authentication " );

return false ;

}

protected void afterPropertiesSetInternal() throws Exception {

super .afterPropertiesSetInternal();

}

}

然后将这个类配置到 deployerConfigContext.xml 文件里 , 替代 <bean class="org.jasig.cas.authentication.handler.support.SimpleTestUsernamePasswordAuthenticationHandler" />

可能要用到数据库连接之类的配置，具体可参照 spring framework 相关文档

在 client 端取到登陆相关信息及登出系统

1. 取得用用户 ID

以下两种方式都可以

session.getAttribute(CASFilter.CAS_FILTER_USER);

session.getAttribute("edu.yale.its.tp.cas.client.filter.user");

也可以直接取得认证 java 对象

session.getAttribute(CASFilter.CAS_FILTER_RECEIPT);

session.getAttribute("edu.yale.its.tp.cas.client.filter.receipt");

JSP2.0 标准写法

<c:out value="${sessionScope['edu.yale.its.tp.cas.client.filter.user']}"/>

在 jsp 中使用 CAS Tag Library 标签

除实现以上功能完还可以实现登出之类的相关功能，具体参照 cas 官方文档

http://www.ja-sig.org/products/cas/client/jsp/index.html

附录

1 ． SSL(Server Socket Layer) 简介

在网络上信息在源 - 宿的传递过程中会经过其它的计算机。一般情况下，中间的计算机不会监听路过的信息。但在使用网上银行或者进行信用卡交易的时候有可能被监视，从而导致个人隐私的泄露。由于 Internet 和 Intranet 体系结构的原因，总有某些人能够读取并替换用户发出的信息。随着网上支付的不断发展，人们对信息安全的要求越来越高。因此 Netscape 公司提出了 SSL 协议，旨在达到在开放网络 (Internet) 上安全保密地传输信息的目的，这种协议在 WEB 上获得了广泛的应用。 之后 IETF(ietf.org) 对 SSL 作了标准化，即 RFC2246 ，并将其称为 TLS （ Transport Layer Security ），从技术上讲， TLS1.0 与 SSL3.0 的差别非常微小。

2 ． SSL 工作原理

SSL 协议使用不对称加密技术实现会话双方之间信息的安全传递。可以实现信息传递的保密性、完整性，并且会话双方能鉴别对方身份。不同于常用的 http 协议，我们在与网站建立 SSL 安全连接时使用 https 协议，即采用 https://ip:port/ 的方式来访问。当我们与一个网站建立 https 连接时，我们的浏览器与 Web Server 之间要经过一个握手的过程来完成身份鉴定与密钥交换，从而建立安全连接。具体过程如下：

用户浏览器将其 SSL 版本号、加密设置参数、与 session 有关的数据以及其它一些必要信息发送到服务器。

服务器将其 SSL 版本号、加密设置参数、与 session 有关的数据以及其它一些必要信息发送给浏览器，同时发给浏览器的还有服务器的证书。如果配置服务器的 SSL 需要验证用户身份，还要发出请求要求浏览器提供用户证书。

客户端检查服务器证书，如果检查失败，提示不能建立 SSL 连接。如果成功，那么继续。客户端浏览器为本次会话生成 pre-master secret ，并将其用服务器公钥加密后发送给服务器。如果服务器要求鉴别客户身份，客户端还要再对另外一些数据签名后并将其与客户端证书一起发送给服务器。

如果服务器要求鉴别客户身份，则检查签署客户证书的 CA 是否可信。如果不在信任列表中，结束本次会话。如果检查通过，服务器用自己的私钥解密收到的 pre-master secret ，并用它通过某些算法生成本次会话的 master secret 。

客户端与服务器均使用此 master secret 生成本次会话的会话密钥 ( 对称密钥 ) 。在双方 SSL 握手结束后传递任何消息均使用此会话密钥。这样做的主要原因是对称加密比非对称加密的运算量低一个数量级以上，能够显著提高双方会话时的运算速度。

客户端通知服务器此后发送的消息都使用这个会话密钥进行加密。并通知服务器客户端已经完成本次 SSL 握手。

服务器通知客户端此后发送的消息都使用这个会话密钥进行加密。并通知客户端服务器已经完成本次 SSL 握手。

本次握手过程结束，会话已经建立。双方使用同一个会话密钥分别对发送以及接受的信息进行加、解密。

Portlet 的形态直白的说，就是 portlet 功能的表现形式。通常， portlet 根据他们自己功能的不同，执行不同的任务以及生成不同的内容。 Portlet 形态直接预示着他们担任什么样的功能并且将会显示什么样的内容。当 portlet 被调用的时候， portlet 容器会为其提供的一个的当前 portal 形态。 Portlet 可以很方便的在处理一个 action 请求的时候改变它的形态。

       Portal 规范定义了 3 个 portlet 形态。他们分别是 VIEW ， EDIT 以及 HELP 。 PortletMode 类定义了这些形态的常量。

       Portal 形态还用于对用户的权限功能控制，比方说一个未认证用户只能察看 portlet 的 VIEW 以及 HELP 形态，而认证用户则能访问 portlet 的 EDIT 形态。

8.1 Portlet 的 VIEW 形态

       Portlet 的 VIEW 形态的主要功能是通过生成标记语言来显示 portlet 的当前状态。比方说，一个 portlet 的 VIEW 形态可能包含一到两个页面，用户可以浏览或者做某些操作。它也可能仅仅是一张静态页面而不做任何事情。

       开发者可以简单的通过重载 GenericPortlet 的 doView() 方法来获得这项功能

       Portlet 必须支持 VIEW 形态

8.2 EDIT 形态

       在 EDIT 形态下面， portlet 应该提供相关的内容以及逻辑给用户，以便能够让用户可以自定义 portlet 行为。一个 EDIT 形态的 portlet 应该有 1 到多个窗口，这样用户就能从这些窗口进入他们自己自定义的数据了。

       通常， EDIT 形态的 portlet 会设置或者更新 Portlet 参数。参考 portlet 参数一节获得更多的细节。

开发者可以简单的通过重载 GenericPortlet 的 doEdit() 方法来获得这项功能

Portlet 不必支持 EDIT 形态

8.3 HELP 形态

       在 help 形态下面， portlet 应该提供 portlet 本身的相关帮助信息。一个 portlet 的帮助信息可以是介绍 portlet 的完整帮助或者是内容相关的帮助文本。

开发者可以简单的通过重载 GenericPortlet 的 doHelp() 方法来获得这项功能

Portlet 不必支持 HELP 形态

8.4 portlet 自定义形态

       Portlal 的提供者可以自定义 portlet 形态用来提供自己指定的功能

       要使用自定义 Portlet 形态，首先需要在部署描述器中添加 custom-portlet-mode 元素 ，其次需要在运行期找到该形态的 portal 实现。如果在运行期间找不到该自定义形态的 portal 实现，这个 portlet 就不应该被调用

       打个比方， portlet 应用需要支持 clipsboard 以及 config 形态的 portlet ，那么部署描述器里面可能这么写：

<portlet-app>

...

<custom-portlet-mode>

<description>Creates content for Cut and Paste</description>

<name>clipboard</name>

</custom-portlet-mode>

<custom-portlet-mode>

<description>Provides administration functions</description>

<name>config</name>

</custom-portlet-mode>

...

</portlet-app>

在《扩展 Portlet 形态》附录中列出了建议的 portlet 形态的命名参考以及他们的使用参考。如果 portlet 在部署描述器中定义了一个自定义的形态，并且 portal 容器实现了这种形态的话，那么 Portal 容器可以立即自动地映射这种支持形态。

8.5 GenericPorlet 渲染方法的处理

       GenericPorlet 通过 render 方法来分发用户的请求给 doView , doEdit , doHelp 方法。这个指定形态分发的动作在 doDispatch 里面都会指明。如果 portal 容器提供者需要支持一种新的形态，那么必须重载 doDispatch 方法。

8.6     定义 portlet 形态

Portlet 通过在它的部署描述器内配置 portlet 形态来获得它能使用的 portal 容器支持的形态。每个 Portlet 都必须支持 VIEW 形态，而且 VIEW 形态无需特别指定。

下面的例子显示了一个配置 Portlet 形态的样本：

...

<supports>

<mime-type>text/html</mime-type>

<portlet-mode>edit</portlet-mode>

<portlet-mode>help</portlet-mode>

...

</supports>

<supports>

<mime-type>text/vnd.wap.wml</mime-type>

<portlet-mode>help</portlet-mode>

...

</supports>

...

以上的配置说明了，该 portlet 在 html 标记语言下支持 edit ,help 形态，当然还支持默认的 view 形态。在 wml 语言环境下，支持 help 以及 view 形态。

 ===

以上是翻译节选，以后会陆续刊出其它章节
欢迎转载共同交流

 

检查应用路径 %App_path%/WEB-INF/lib ，把下面 log4j.jar以及 commons-logging.jar 均删除，问题解决

原理解释文章在以下位置

http://www.qos.ch/logging/thinkAgain.jsp

以前也遇到类似问题

如果是tomcat 5.x 版本，需要这样处理

删除tomcat/webapps/%apps%/WEB-INF/lib/下面的
commons-logging-api-1.0.4.jar 包
然后换成

log4j.jar以及 commons-logging.jar

一、JDOM 简介
JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。
JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念以及映射），把SAX和DOM的功能有效地结合起来。
在使用设计上尽可能地隐藏原来使用XML过程中的复杂性。利用JDOM处理XML文档将是一件轻松、简单的事。
JDOM 在2000年的春天被Brett McLaughlin和Jason Hunter开发出来，以弥补DOM及SAX在实际应用当中的不足之处。
这些不足之处主要在于SAX没有文档修改、随机访问以及输出的功能，而对于DOM来说，JAVA程序员在使用时来用起来总觉得不太方便。
DOM的缺点主要是来自于由于Dom是一个接口定义语言（IDL）,它的任务是在不同语言实现中的一个最低的通用标准，并不是为JAVA特别设计的。JDOM的最新版本为JDOM Beta 9。最近JDOM被收录到JSR-102内，这标志着JDOM成为了JAVA平台组成的一部分。

二、JDOM 包概览
JDOM是由以下几个包组成的
org.JDOM
org.JDOM.input
org.JDOM.output
org.JDOM.adapters
org.JDOM.transform

三、JDOM 类说明

org.JDOM
这个包里的类是你解析xml文件后所要用到的所有数据类型。
Attribute
CDATA
Coment
DocType
Document
Element
EntityRef
Namespace
ProscessingInstruction
Text

org.JDOM.transform
在涉及xslt格式转换时应使用下面的2个类
JDOMSource
JDOMResult

org.JDOM.input
输入类，一般用于文档的创建工作
SAXBuilder
DOMBuilder
ResultSetBuilder

org.JDOM.output
输出类，用于文档转换输出
XMLOutputter
SAXOutputter
DomOutputter
JTreeOutputter

使用前注意事项：
1.JDOM对于JAXP 以及 TRax 的支持
JDOM 支持JAXP1.1：你可以在程序中使用任何的parser工具类,默认情况下是JAXP的parser。
制定特别的parser可用如下形式
SAXBuilder parser
  = new SAXBuilder("org.apache.crimson.parser.XMLReaderImpl");
 Document doc = parser.build("http://www.cafeconleche.org/");
 // work with the document...
JDOM也支持TRaX：XSLT可通过JDOMSource以及JDOMResult类来转换（参见以后章节）
2.注意在JDOM里文档（Document）类由org.JDOM.Document 来表示。这要与org.w3c.dom中的Document区别开，这2种格式如何转换在后面会说明。
以下如无特指均指JDOM里的Document。

四、JDOM主要使用方法
1.Ducument类
(1)Document的操作方法：
Element root = new Element("GREETING");
Document doc = new Document(root);
root.setText("Hello JDOM!");
或者简单的使用Document doc = new Document(new Element("GREETING").setText("Hello JDOM!t"));

这点和DOM不同。Dom则需要更为复杂的代码，如下：
DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();
DocumentBuilder builder =factory.newDocumentBuilder();
Document doc = builder.newDocument();
Element root =doc.createElement("root");
Text text = doc.createText("This is the root");
root.appendChild(text);
doc.appendChild(root);

注意事项：JDOM不允许同一个节点同时被2个或多个文档相关联，要在第2个文档中使用原来老文档中的节点的话。首先需要使用detach()把这个节点分开来。

(2)从文件、流、系统ID、URL得到Document对象：
DOMBuilder builder = new DOMBuilder();
Document doc = builder.build(new File("jdom_test.xml"));

SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(url);
在新版本中DOMBuilder 已经Deprecated掉 DOMBuilder.builder(url)，用SAX效率会比较快。

这里举一个小例子，为了简单起见，使用String对象直接作为xml数据源：

 public jdomTest() {
    String textXml = null;
    textXml = "<note>";
    textXml = textXml +
        "<to>aaa</to><from>bbb</from><heading>ccc</heading><body>ddd</body>";
    textXml = textXml + "</note>";
    SAXBuilder builder = new SAXBuilder();
    Document doc = null;
    Reader in= new StringReader(textXml);
    try {
      doc = builder.build(in);
      Element root = doc.getRootElement();
      List ls = root.getChildren();//注意此处取出的是root节点下面的一层的Element集合
      for (Iterator iter = ls.iterator(); iter.hasNext(); ) {
        Element el = (Element) iter.next();
        if(el.getName().equals("to")){
         System.out.println(el.getText());
        }
      }
    }
    catch (IOException ex) {
      ex.printStackTrace();
    }
    catch (JDOMException ex) {
      ex.printStackTrace();
    }
  }

很简单把。

(3)DOM的document和JDOM的Document之间的相互转换使用方法，简单！
DOMBuilder builder = new DOMBuilder();
org.jdom.Document jdomDocument = builder.build(domDocument);
// work with the JDOM document…

DOMOutputter converter = new DOMOutputter();
org.w3c.dom.Document domDocument = converter.output(jdomDocument);
// work with the DOM document…

2.XML文档输出
XMLOutPutter类：
JDOM的输出非常灵活,支持很多种io格式以及风格的输出
Document doc = new Document(...);
XMLOutputter outp = new XMLOutputter();
// Raw output
outp.output(doc, fileOutputStream);
// Compressed output
outp.setTextTrim(true);
outp.output(doc, socket.getOutputStream());
// Pretty output
outp.setIndent(" ");
outp.setNewlines(true);
outp.output(doc, System.out);
......
详细请参阅最新的JDOM API手册

3.Element 类：
(1)浏览Element树
//获得根元素element
Element root = doc.getRootElement();
// 获得所有子元素的一个list
List allChildren = root.getChildren();
// 获得指定名称子元素的list
List namedChildren = root.getChildren("name");
//获得指定名称的第一个子元素
Element child = root.getChild("name");
（这里的List是java.util.List）

JDOM给了我们很多很灵活的使用方法来管理子元素
List allChildren = root.getChildren();
// 删除第四个子元素
allChildren.remove(3);
// 删除叫“jack”的子元素
allChildren.removeAll(root.getChildren("jack"));

root.removeChildren("jack"); // 便捷写法
// 加入
allChildren.add(new Element("jane"));

root.addContent(new Element("jane")); // 便捷写法
allChildren.add(0, new Element("first"));

(2)移动Elements:
在JDOM里很简单
Element movable = new Element("movable");
parent1.addContent(movable); // place
parent1.removeContent(movable); // remove
parent2.addContent(movable); // add

在Dom里
Element movable = doc1.createElement("movable");
parent1.appendChild(movable); // place
parent1.removeChild(movable); // remove
parent2.appendChild(movable); // 出错!

补充：
纠错性
JDOM的Element构造函数（以及它的其他函数）会检查element是否合法。
而它的add/remove方法会检查树结构，检查内容如下：
1.在任何树中是否有回环节点
2.是否只有一个根节点
3.是否有一致的命名空间（Namespaces）

(3)Element的text内容读取
<description>
A cool demo
</description>

// The text is directly available
// Returns "\n A cool demo\n"
String desc = element.getText();

// There's a convenient shortcut
// Returns "A cool demo"
String desc = element.getTextTrim();

(4)Elment内容修改
element.setText("A new description");
3.可正确解释特殊字符
element.setText("<xml> content");
4.CDATA的数据写入、读出
element.addContent(new CDATA("<xml> content"));
String noDifference = element.getText();

混合内容
element可能包含很多种内容，比如说

<table>
<!-- Some comment -->
Some text
<tr>Some child element</tr>
</table>

取table的子元素tr
String text = table.getTextTrim();
Element tr = table.getChild("tr");

也可使用另外一个比较简单的方法
List mixedCo = table.getContent();
Iterator itr = mixedCo.iterator();
while (itr.hasNext()) {
Object o = i.next();
if (o instanceof Comment) {
...
}
// 这里可以写成Comment, Element, Text, CDATA,ProcessingInstruction, 或者是EntityRef的类型
}
// 现在移除Comment,注意这里游标应为1。这是由于回车键也被解析成Text类的缘故,所以Comment项应为1。
mixedCo.remove(1);

4.Attribute类
<table width="100%" border="0"> </table>
//获得attribute
String width = table.getAttributeValue("width");
int border = table.getAttribute("width").getIntValue();
//设置attribute
table.setAttribute("vspace", "0");
// 删除一个或全部attribute
table.removeAttribute("vspace");
table.getAttributes().clear();

5.处理指令(Processing Instructions)操作
一个Pls的例子
<?br?>
<?cocoon-process type="xslt"?>
          |        |
          |        |
        目标     数据

处理目标名称(Target)
String target = pi.getTarget();
获得所有数据（data），在目标（target）以后的所有数据都会被返回。
String data = pi.getData();
获得指定属性的数据
String type = pi.getValue("type");
获得所有属性的名称
List ls = pi.getNames();

6.命名空间操作
<xhtml:html
 xmlns:xhtml="http://www.w3.org/1999/xhtml">
<xhtml:title>Home Page</xhtml:title>
</xhtml:html>

Namespace xhtml = Namespace.getNamespace("xhtml", "http://www.w3.org/1999/xhtml");
List kids = html.getChildren("title", xhtml);
Element kid = html.getChild("title", xhtml);
kid.addContent(new Element("table", xhtml));

7.XSLT格式转换
使用以下函数可对XSLT转换
最后如果你需要使用w3c的Document则需要转换一下。
public static Document transform(String stylesheet，Document in)
                                        throws JDOMException {
     try {
       Transformer transformer = TransformerFactory.newInstance()
                             .newTransformer(new StreamSource(stylesheet));
       JDOMResult out = new JDOMResult();
       transformer.transform(new JDOMSource(in), out);
       return out.getDeocument();
     }
     catch (TransformerException e) {
       throw new JDOMException("XSLT Trandformation failed", e);
     }
   }

参考书目：

1.JDOM官方网站： http://www.jdom.org

2.<<Processing XML with Java>> Elliotte Rusty Harold 2002

3.JDOM API Documentation

4.<<JDOM Makes XML Easy>>Jason Hunter Co-Creator JDOM Project

5.WSDP Tutorial