class myclass {
static public void main(String args[]) {
    print_a_file();
    manipulate_another_file();
    access_database();
    draw_picture_on_screen();
    }
}

import java.util.*;

class TimePrinter extends Thread {
    int pauseTime;
    String name;
    public TimePrinter(int x, String n) {
        pauseTime = x;
        name = n;
    }

    public void run() {
        while(true) {
            try {
                System.out.println(name + ":" + new
                    Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            } catch(Exception e) {
                System.out.println(e);
            }
        }
    }

    static public void main(String args[]) {
        TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
        tp1.start();
        TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
        tp2.start();

    }
}

import java.util.*;

class TimePrinter implements Runnable {
    int pauseTime;
    String name;
    public TimePrinter(int x, String n) {
        pauseTime = x;
        name = n;
    }

    public void run() {
        while(true) {
            try {
                System.out.println(name + ":" + new
                    Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            } catch(Exception e) {
                System.out.println(e);
            }
        }
    }

    static public void main(String args[]) {
        Thread t1 = new Thread(new TimePrinter(1000, "Fast Guy"));
        t1.start();
        Thread t2 = new Thread(new TimePrinter(3000, "Slow Guy"));
        t2.start();

    }
}

public class Account {
    String holderName;
    float amount;
    public Account(String name, float amt) {
        holderName = name;
        amount = amt;
    }

    public void deposit(float amt) {
        amount += amt;
    }

    public void withdraw(float amt) {
        amount -= amt;
    }

    public float checkBalance() {
        return amount;
    }
}

public class Account {
    String holderName;
    float amount;
    public Account(String name, float amt) {
        holderName = name;
        amount = amt;
    }

    public synchronized void deposit(float amt) {
        amount += amt;
    }

    public synchronized void withdraw(float amt) {
        amount -= amt;
    }

    public float checkBalance() {
        return amount;
    }
}

• 使用多线程不会增加 CPU 的能力。但是如果使用 JVM 的本地线程实现，则不同的线程可以在不同的处理器上同时运行（在多 CPU 的机器中），从而使多 CPU 机器得到充分利用。
• 如果应用程序是计算密集型的，并受 CPU 功能的制约，则只有多 CPU 机器能够从更多的线程中受益。
• 当应用程序必须等待缓慢的资源（如网络连接或数据库连接）时，或者当应用程序是非交互式的时，多线程通常是有利的。

基于 Internet 的软件有必要是多线程的；否则，用户将感觉应用程序反映迟钝。例如，当开发要支持大量客户机的服务器时，多线程可以使编程较为容易。在这种情况下，每个线程可以为不同的客户或客户组服务，从而缩短了响应时间。

某些程序员可能在 C 和其他语言中使用过线程，在那些语言中对线程没有语言支持。这些程序员可能通常都被搞得对线程失去了信心。

参考资料

• 请阅读 Scott Oaks 和 Henry Wong 所著的

　　内容简介

　　STEVEN GOULD在文中介绍了JAVA2平台企业版（J2EE）的13种核心技术：JDBC, JNDI, EJBS, RMI, JSP, JAVA SERVLETS, XML, JMS, JAVA IDL, JTS, JTA, JAVAMAIL 和 JAF。为了联系实际，GOULD基于WEBLOGIC应用服务器—来自BEA SYSTEMS公司的一种广为应用的产品—环境来介绍J2EE的这些技术。

　　JAVA最初是在浏览器和客户端机器中粉墨登场的。当时，很多人质疑它是否适合做服务器端的开发。现在，随着对JAVA2平台企业版（J2EE）第三方支持的增多，JAVA被广泛接纳为开发企业级服务器端解决方案的首选平台之一。

　　J2EE平台由一整套服务（SERVICES）、应用程序接口（APIS）和协议构成，它对开发基于WEB的多层应用提供了功能支持。

　　在本文中我将解释支撑J2EE的13种核心技术：JDBC, JNDI, EJBS, RMI, JSP, JAVA SERVLETS, XML, JMS, JAVA IDL, JTS, JTA, JAVAMAIL 和 JAF，同时还将描述在何时、何处需要使用这些技术。当然，我还要介绍这些不同的技术之间是如何交互的。

　　此外，为了让您更好地感受J2EE的真实应用，我将在WEBLOGIC应用服务器—来自BEA SYSTEMS公司的一种广为应用的产品—环境下来介绍这些技术。不论对于WEBLOGIC应用服务器和J2EE的新手，还是那些想了解J2EE能带来什么好处的项目管理者和系统分析员，相信本文一定很有参考价值。

　　宏观印象: 分布式结构和J2EE

　　过去，二层化应用 -- 通常被称为CLIENT/SERVER应用 -- 是大家谈论的最多的。图1刻画了典型的二层化结构。在很多情况下，服务器提供的唯一服务就是数据库服务。在这种解决方案中，客户端程序负责数据访问、实现业务逻辑、用合适的样式显示结果、弹出预设的用户界面、接受用户输入等。CLIENT/SERVER结构通常在第一次部署的时候比较容易，但难于升级或改进，而且经常基于某种专有的协议—通常是某种数据库协议。它使得重用业务逻辑和界面逻辑非常困难。更重要的是，在WEB时代，二层化应用通常不能体现出很好的伸缩性，因而很难适应INTERNET的要求。

　　图1. 二层化应用结构

　　SUN设计J2EE的部分起因就是想解决二层化结构的缺陷。于是，J2EE定义了一套标准来简化N层企业级应用的开发。它定义了一套标准化的组件，并为这些组件提供了完整的服务。J2EE还自动为应用程序处理了很多实现细节，如安全、多线程等。

　　用J2EE开发N层应用包括将二层化结构中的不同层面切分成许多层。一个N层化应用A能够为以下的每种服务提供一个分开的层：

　　显示：在一个典型的WEB应用中，客户端机器上运行的浏览器负责实现用户界面。

　　动态生成显示: 尽管浏览器可以完成某些动态内容显示，但为了兼容不同的浏览器，这些动态生成工作应该放在WEB服务器端进行，使用JSP、SERVLETS，或者XML（可扩展标记语言）和（可扩展样式表语言）。

　　业务逻辑：业务逻辑适合用SESSION EJBS（后面将介绍）来实现。

　　数据访问：数据访问适合用ENTITY EJBS（后面将介绍）和JDBC来实现。

　　后台系统集成: 同后台系统的集成可能需要用到许多不同的技术，至于何种最佳需要根据后台系统的特征而定。

　　您可能开始诧异：为什么有这么多的层？事实上，多层方式可以使企业级应用具有很强的伸缩性，它允许每层专注于特定的角色。例如，让WEB服务器负责提供页面，应用服务器处理应用逻辑，而数据库服务器提供数据库服务。

　　由于J2EE建立在JAVA2平台标准版（J2SE）的基础上，所以具备了J2SE的所有优点和功能。包括“编写一次，到处可用”的可移植性、通过JDBC访问数据库、同原有企业资源进行交互的CORBA技术，以及一个经过验证的安全模型。在这些基础上，J2EE又增加了对EJB（企业级JAVA组件）、JAVA SERVLETS、JAVA服务器页面（JSPS）和XML技术的支持。

　　分布式结构与WEBLOGIC应用服务器

　　J2EE提供了一个框架--一套标准API--用于开发分布式结构的应用，这个框架的实际实现留给了第三方厂商。部分厂商只是专注于整个J2EE架构中的的特定组件，例如APACHE的TOMCAT提供了对JSP和SERVLETS的支持，BEA系统公司则通过其WEBLOGIC应用服务器产品为整个J2EE规范提供了一个较为完整的实现。

　　WEBLOGIC服务器已使建立和部署伸缩性较好的分布式应用的过程大为简化。WEBLOGIC和J2EE代你处理了大量常规的编程任务，包括提供事务服务、安全领域、可靠的消息、名字和目录服务、数据库访问和连接池、线程池、负载平衡和容错处理等。

　　通过以一种标准、易用的方式提供这些公共服务，象WEBLOGIC服务器这样的产品造就了具有更好伸缩性和可维护性的应用系统，使其为大量的用户提供了增长的可用性。

　　J2EE技术

　　在接下来的部分里，我们将描述构成J2EE的各种技术，并且了解WEBLOGIC服务器是如何在一个分布式应用中对它们进行支持的。最常用的J2EE技术应该是JDBC、JNDI、EJB、JSP和SERVLETS，对这些我们将作更仔细的考察。

　　图2表示了在一个分布式应用中，J2EE技术的各个方面通常在何处发挥作用。

　　图2. 一个N层应用结构的例子

　　JAVA DATABASE CONNECTIVITY (JDBC)

　　JDBC API以一种统一的方式来对各种各样的数据库进行存取。和ODBC一样，JDBC为开发人员隐藏了不同数据库的不同特性。另外，由于JDBC建立在JAVA的基础上,因此还提供了数据库存取的平台独立性。

　　JDBC定义了4种不同的驱动程序，现分述如下：

　　类型 1: JDBC-ODBC BRIDGE

　　在JDBC出现的初期，JDBC-ODBC桥显然是非常有实用意义的，通过JDBC-ODBC桥，开发人员可以使用JDBC来存取ODBC数据源。不足的是，他需要在客户端安装ODBC驱动程序，换句话说，必须安装MICROSOFT WINDOWS的某个版本。使用这一类型你需要牺牲JDBC的平台独立性。另外，ODBC驱动程序还需要具有客户端的控制权限。

　　类型 2: JDBC-NATIVE DRIVER BRIDGE

　　JDBC本地驱动程序桥提供了一种JDBC接口，它建立在本地数据库驱动程序的顶层，而不需要使用ODBC。 JDBC驱动程序将对数据库的API从标准的JDBC调用转换为本地调用。使用此类型需要牺牲JDBC的平台独立性，还要求在客户端安装一些本地代码。

　　类型 3: JDBC-NETWORK BRIDGE

　　JDBC网络桥驱动程序不再需要客户端数据库驱动程序。它使用网络上的中间服务器来存取数据库。这种应用使得以下技术的实现有了可能，这些技术包括负载均衡、连接缓冲池和数据缓存等。由于第3种类型往往只需要相对更少的下载时间，具有平台独立性，而且不需要在客户端安装并取得控制权，所以很适合于INTERNET上的应用。

　　类型 4: PURE JAVA DRIVER

　　第4种类型通过使用一个纯JAVA数据库驱动程序来执行数据库的直接访问。此类型实际上在客户端实现了2层结构。要在N-层结构中应用，一个更好的做法是编写一个EJB，让它包含存取代码并提供一个对客户端具有数据库独立性的服务。

　　WEBLOGIC服务器为一些通常的数据库提供了JDBC驱动程序，包括ORACLE, SYBASE, MICROSOFT SQL SERVER以及INFORMIX。它也带有一种JDBC驱动程序用于CLOUDSCAPE，这是一种纯JAVA的DBMS，WEBLOGIC服务器中带有该数据库的评估版本。

　　以下让我们看一个实例。

　　JDBC实例

　　在这个例子中我们假定你已经在CLOUDSCAPE中建立了一个PHONEBOOK数据库，并且包含一个表，名为 CONTACT_TABLE ，它带有2个字段：NAME 和 PHONE。 开始的时候先装载CLOUDSCAPE JDBC DRIVER，并请求 DRIVER MANAGER得到一个对PHONEBOOK CLOUDSCAPE数据库的连接。通过这一连接，我们可以构造一个 STATEMENT 对象并用它来执行一个简单的SQL查询。最后，用循环来遍历结果集的所有数据，并用标准输出将NAME和PHONE字段的内容进行输出。

IMPORT JAVA.SQL.*;

PUBLIC CLASS JDBCEXAMPLE
{
PUBLIC STATIC VOID MAIN( STRING ARGS[] )
{
TRY
{
CLASS.FORNAME("COM.CLOUDSCAPE.CORE.JDBCDRIVER");
CONNECTION CONN = DRIVERMANAGER.GETCONNECTION("JDBC:CLOUDSCAPE:PHONEBOOK");
STATEMENT STMT = CONN.CREATESTATEMENT();
STRING SQL = "SELECT NAME, PHONE FROM CONTACT_TABLE ORDER BY NAME";
RESULTSET RESULTSET = STMT.EXECUTEQUERY( SQL );

STRING NAME;
STRING PHONE;
WHILE ( RESULTSET.NEXT() )
{
NAME = RESULTSET.GETSTRING(1).TRIM();
PHONE = RESULTSET.GETSTRING(2).TRIM();
SYSTEM.OUT.PRINTLN( NAME + ", " + PHONE );
}
}
CATCH ( EXCEPTION E )
{
// HANDLE EXCEPTION HERE
E.PRINTSTACKTRACE();
}
}
}

　　OK。接着我们来看一看JDBC是如何在企业应用中的进行使用。

　　JDBC在企业级应用中的应用

　　以上实例其实是很基本的，可能有些微不足道。它假定了一个2层结构。在一个多层的企业级应用中，更大的可能是在客户端和一个EJB进行通信，该EJB将建立数据库连接。为了实现和改进可伸缩性和系统性能， WEBLOGIC服务器提供了对连接缓冲池CONNECTION POOL的支持。

　　CONNECTION POOL减少了建立和释放数据库连接的消耗。在系统启动以后即可建立这样的缓冲池，此后如故再有对数据库的请求，WEBLOGIC服务器可以很简单地从缓冲池中取出数据。数据缓冲池可以在WEBLOGIC服务器的 WEBLOGIC.PROPERTIES 文件中进行定义。(可参考 WEBLOGIC.PROPERTIES 文件中的例子，WEBLOGIC服务器的文档中还有更详细的参考信息)

　　在企业级应用的另一个常见的数据库特性是事务处理。事务是一组申明STATEMENT，它们必须做为同一个STATEMENT来处理以保证数据完整性。缺省情况下JDBC使用 AUTO-COMMIT 事务模式。这可以通过使用CONNECTION类的 SETAUTOCOMMIT() 方法来实现。

　　现在我们已经对JDBC有了一些认识，下面该转向JNDI了。

　　JAVA NAMING AND DIRECTORY INTERFACE (JNDI)

　　JNDI API被用于执行名字和目录服务。它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件系统，后者在应用服务器中的对象。

　　在JNDI中，在目录结构中的每一个结点称为CONTEXT。每一个JNDI名字都是相对于CONTEXT的。这里没有绝对名字的概念存在。对一个应用来说，它可以通过使用 INITIALCONTEXT 类来得到其第一个CONTEXT:

　　CONTEXT CTX = NEW INITIALCONTEXT();

　　应用可以通过这个初始化的CONTEXT经有这个目录树来定位它所需要的资源或对象。例如，假设你在WEBLOGIC服务器中展开了一个EJB并将HOME接口绑定到名字 MYAPP.MYEJB ，那么该EJB的某个客户在取得一个初始化CONTEXT以后，可以通过以下语句定位HOME接口：

　　MYEJBHOME HOME = CTX.LOOKUP( "MYAPP.MYEJB" );

　　在这个例子中，一旦你有了对被请求对象的参考，EJB的HOME接口就可以在它上面调用方法。我们将在下面的"ENTERPRISE JAVA BEANS"章节中做更多的介绍。

　　以上关于JNDI的讨论只是冰山之一角而已。如果要更进一步地在CONTEXT中查找对象，JNDI也提供了一些方法来进行以下操作：　

　　将一个对象插入或绑定到CONTEXT。这在你展开一个EJB的时候是很有效的。

　　从CONTEXT中移去对象。

　　列出CONTEXT中的所有对象。

　　创建或删除子一级的CONTEXT。

　　接下来，我们要开始关注EJB了。

　　ENTERPRISE JAVA BEANS (EJB)

　　J2EE技术之所以赢得某体广泛重视的原因之一就是EJB。它们提供了一个框架来开发和实施分布式商务逻辑，由此很显著地简化了具有可伸缩性和高度复杂的企业级应用的开发。EJB规范定义了EJB组件在何时如何与它们的容器进行交互作用。容器负责提供公用的服务，例如目录服务、事务管理、安全性、资源缓冲池以及容错性。

　　EJB规范定义了3中基本的BEAN类型:

　　STATELESS SESSION BEANS: 提供某种单一的服务，不维持任何状态，在服务器故障发生时无法继续存在，生命期相对较短。例如，一个STATELESS SESSION BEAN可能被用于执行温度转换计算。

　　STATEFUL SESSION BEAN: T提供了与客户端的会话交互，可以存储状态从而代表一个客户。典型例子是购物车。STATEFUL SESSION BEAN在服务器故障时无法继续生存，生命气相对较短。每一个实例只用于一个单个的线程。

　　ENTITY BEANS: 提供了一致性数据的表示-- 通常存放在数据库中 -- 在服务器故障发生后能继续存在。多用户情况下可以使用EJB来表示相同的数据。ENTITY EJB的一个典型例子是客户的帐号信息。

　　尽管有以上的区别，所有的EJB还是有许多的共同之处。它们都处理HOME INTERFACE。它定义了一个客户端是如何创建与消亡EJB的。可以在BEAN中对定义了客户端方法的远程接口进行调用；BEAN类则执行了主要的商务逻辑。

　　描述EJB的开发已经超出了本文的范围。但是，如果一个EJB已经被开发了或者从第三方进行了购买，它就必须在应用服务器中进行发布。WEBLOGIC SERVER 5.1带有一个EJB DEPLOYER TOOL来协助处理EJB的发布。当你使用EJB DEPLOYER TOOL的时候，你要定义客户端所用的JNDI名字来定位EJB。DEPLOYER TOOL将生成WRAPPER类来处理和容器的通信以及在一个JAR文件中把被请求的JAVA类绑定在一起。

　　一旦EJB被发布，客户端就可以使用它的JNDI名字来定位EJB。首先，它必须得到一个到HOME接口的REFERENCE。然后，客户端可以使用该接口，调用一个 CREATE() 方法来得到服务器上运行的某个BEAN实例的句柄；最后，客户端可以使用该句柄在BEAN中调用方法。

　　了解 EJB后，让我们再来看JSP。

　　JAVASERVER PAGES (JSPS)

　　我们中间可能已经有许多人已经熟悉MICROSOFT的ACTIVE SERVER PAGES (ASP)技术了。JSP和ASP相对应的，但更具有平台对立性。他们被设计用以帮助WEB内容开发人员创建动态网页，并且只需要相对较少的代码。 即使WEB设计师不懂得如何编程也可以使用JSP，因为JSP应用是很方便的。 JSP页面由HTML代码和嵌入其中的JAVA代码所组成。服务器在页面被客户端所请求以后对这些JAVA代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。

　　下面我们来看一个JSP的简单实例。它只显示了服务器的当前日期和时间。虽然，对语法的具体解释已经超出了本文的范围，但我们还是可以很直观地看到，JAVA代码被放在<%和%>的中间，而JAVA的表达式则放在<%=和%>之间。

<html>
<head>
<title>Sample JSP Page</title>
</head>
<body>
<h1>Date JSP sample</h1>

<h2>
<% response.setHeader("Refresh", 5); %>
The current date is <%= new Date()  %>.
</h2>

</body>
</html>

　　您可能有时候听说过JHTML。这是JSP以前的一种较老的标准。WEBLOGIC服务器既可支持JSP，又可支持JHTML。请注意，在缺省状况下，JSP在WEBLOGIC服务器中并没有处于有效状态。要使之有效，你可以编辑WEBLOGIC.PROPERTIES文件。如果WEB服务器还没有处于有效状态，则要先使之有效。SERVLET的情况和JSP是一样的。

　　下面是: JAVA SERVLETS

　　JAVA SERVLETS

　　SERVLET提供的功能大多与JSP类似，不过实现的方式不同。JSP通常是大多数HTML代码中嵌入少量的JAVA代码，而SERVLETS全部由JAVA写成并且生成HTML。

　　SERVLET是一种小型的JAVA程序，它扩展了WEB服务器的功能。作为一种服务器端的应用，当被请求时开始执行，这和CGI PERL脚本很相似。SERVLETS和CGI脚本的一个很大的区别是：每一个CGI在开始的时候都要求开始一个新的进程 -- 而SERVLETS是在SERVLET引擎中以分离的线程来运行的。因此SERVLETS在可伸缩性上提供了很好的改进。

　　在开发SERVLETS的时候，您常常需要扩展JAVAX.SERVLET.HTTP.HTTPSERVLET 类，并且OVERRIDE一些它的方法，其中包括：

　　SERVICE(): 作为DISPATCHER来实现命令-定义方法

　　DOGET(): 处理客户端的HTTP GET请求。

　　DOPOST(): 进行HTTP POST操作

　　其它的方法还包括处理不同类型的HTTP请求 -- 可以参考HTTPSERVLET API文档。

　　以上描述的是标准J2EE SERVLET API的各种方法。WEBLOGIC服务器提供了一个该API完整的实现途径。一旦你开发了一个SERVLET，你就可以在WEBLOGIC.PROPERTIES 中加以注册并由此可以在WEBLOGIC服务器中对它进行配置。

　　通过JAVA SERVLETS,我们已经到达了J2EE主要技术的末尾了。但J2EE所提供的并不止于这些。下面的段落中我们将简要地看一下现存的一些技术，包括RMI, JAVA IDL和CORBA, JTA, 以及XML，等等。

　　REMOTE METHOD INVOCATION (RMI)

　　正如其名字所表示的那样，RMI协议是在远程对象上调用一些方法。它使用了连续序列方式在客户端和服务器端传递数据。RMI是一种被EJB使用的更下层的协议。

　　JAVA IDL/CORBA

　　在JAVA IDL的支持下，开发人员可以将JAVA和CORBA集成在一起。 他们可以创建JAVA对象并使之可在CORBA ORB中展开, 或者他们还可以创建JAVA类并作为和其它ORB一起展开的CORBA对象的客户。后一种方法提供了另外一种途径，通过它JAVA可以被用于将你的新的应用和LEGACY系统相集成。

　　JAVA TRANSACTION ARCHITECTURE (JTA)/JAVA TRANSACTION SERVICE (JTS)

　　JTA定义了一种标准的API，应用系统由此可以存取各种事务监控。

　　JTS是CORBA OTS事务监控的基本的实现。JTS规定了事务管理器的实现方式。该事务管理器是在高层支持JAVA TRANSACTION API (JTA)规范，并且在较底层实现OMG OTS SPECIFICATION的JAVA映像。JTS事务管理器为应用服务器、资源管理器、独立的应用以及通信资源管理器提供了事务服务。

　　JAVAMAIL AND JAVABEANS ACTIVATION FRAMEWORK

　　JAVAMAIL是用于存取邮件服务器的API，它提供了一套邮件服务器的抽象类。不仅支持SMTP服务器，也支持IMAP服务器。

　　JAVAMAIL利用JAVABEANS ACTIVATION FRAMEWORK (JAF)来处理MIME-编码的邮件附件。MIME的字节流可以被转换成JAVA对象，或者转换自JAVA对象。由此大多数应用都可以不需要直接使用JAF。

　　JAVA MESSAGING SERVICE (JMS)

　　JMS是用于和面向消息的中间件相互通信的应用程序接口(API)。它既支持点对点的域，有支持发布/订阅(PUBLISH/SUBSCRIBE)类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支持。JMS还提供了另一种方式来对您的应用与LEGACY BACKEND系统相集成。

　　EXTENSIBLE MARKUP LANGUAGE (XML)

　　XML是一种可以用来定义其它标记语言的语言。它被用来在不同的商务过程中共享数据。XML的发展和JAVA是相互独立的，但是，它和JAVA具有的相同目标正是平台独立性。通过将JAVA和XML的组合，您可以得到一个完美的具有平台独立性的解决方案。目前正有许多不同的公司在为JAVA和XML的组合而努力。如果要了解更多的这方面的信息，可以访问SUN的JAVA-XML页面，或者IBM DEVELOPERWORKS的XML ZONE。

　　总结

　　在本文中，我们介绍了建立在J2EE上的分布式应用结构，并且描述了WEBLOGIC服务器对J2EE的各种支持。 然而，我们所揭示的仅仅是冰山之一角而已，要以一篇数千字的文章来展示J2EE潜在的对您的企业级应用的影响可是很不公平的。

　　我们已经关注了在您开始用J2EE进行工作时最有可能遇到的各类技术：JDBC, JNDI, EJB, JSP和SERVLET。我们也为您提供了一些尚未常见的J2EE技术的背景知识。不管您是一名开发人员，商务应用分析师，或者项目经理，都应该对J2EE和WEBLOGIC服务器所能提供给我们，给我们的企业以及我们的企业级应用所带来的意义有一个更好的认识。

　　常见的边线方式

　　常见的通讯方式是三线式，这种方式是将两个RS232设备的发送端(TXD)和接收端(RXD)及接地端(GND)互相连接，也是许多读者所知道的连接方式：

　　这种方式分别将两端的RS232接口的2--3,3---2,5(7)---5(7)针脚连接起来。其中2是数据接收线(RXD)，3是数据发送线(TXD)，5(7)是接地(RND)。如果有一台式PC，和一部NoteBook电脑，就可以用这种方式连线了。用三线式可以将大多数的RS232设备连接起来。但如果你认死了2--3,3--2,5(7)--5(7)对接这个理，会发现在连某些RS232设备时并不奏效。这是因为有些设备在电路内部已将2和3线调换过来了，你只要2,3,5(7)针一一对应就行了。

小技巧：如何辨别TXD和RXD端口？ 　　搞电子的人手边应该常备一个电表，用来测测电压，电阻什么的会很有用。你只要分别测一下RS232端口的2--5或3--5针脚之间的电压，通常TXD针脚与GND之间会有3~15V左右的负电压，表示它是TXD针脚。

安装Java Communications API

　　Sun的J2SE中并没有直接提供以上提到的任何一种串行通讯协议的开发包，而是以独立的jar包形式发布在java.sun.com网站上(从这里下载)----即comm.jar，称之为Javatm Communications API，它是J2SE的标准扩展。comm.jar并不是最近才有，早在1998年时，sun就已经发布了这个开发包。comm.jar分别提供了对常用的RS232串行端口和IEEE1284并行端口通讯的支持。目前sun发布的comm.jar只有Windows和Solaris平台两个版本，如果你需要Linux平台下的，可以在http://www.geeksville.com/~kevinh/linuxcomm.html找到。

　　在使用comm.jar之前，必须知道如何安装它。这也是困扰许多初学java RS232通讯者的一个难题。如果我们电脑上安装了JDK, 它将同时为我们安装一份JRE(Java Runtime Entironment)，通常我们运行程序时都是以JRE来运行的。所以以下的安装适用于JRE。如果你是用JDK来运行程序的，请将相应的<JRE_HOME>改成<JDK_HOME>。

　　下载了comm.jar开发包后，与之一起的还有两个重要的文件，win32com.dll和javax.comm.properties。 comm.jar提供了通讯用的java API，而win32com.dll提供了供comm.jar调用的本地驱动接口。而javax.comm.properties是这个驱动的类配置文件。首先将comm.jar复制到<JRE_HOME>\lib\ext目录。再将win21com.dll复制到你的RS232应用程序运行的目录，即user.dir。然后将javax.comm.properties复制到<JRE_HOME>\lib目录。

　　通讯前的准备

　　如果你手头上没有现成的提供了标准RS232串口的设备，你可以将自己的电脑模拟成两台不同的串口设备。通常电脑主机后面的面板提供了两个9针的串口，请将这两个串口的2,3,5脚按前面介绍的方法连接。电子市场都有现成的连接头卖，请不要买那种封装的严严实实的接头，而要买用螺丝封装可以拆开的连接头，这样可以方便自己根据需要连接各个针脚。

　　Comm API基础

　　我无意于在此详细描述Comm API每个类和接口的用法，但我会介绍Comm API的类结构和几个重要的API用法。

　　所有的comm API位于javax.comm包下面。从Comm API的javadoc来看，它介绍给我们的只有区区以下13个类或接口：

javax.comm.CommDriver javax.comm.CommPort javax.comm.ParallelPort javax.comm.SerialPort javax.comm.CommPortIdentifier javax.comm.CommPortOwnershipListener javax.comm.ParallelPortEvent javax.comm.SerialPortEvent javax.comm.ParallelPortEventListener (extends java.util.EventListener) javax.comm.SerialPortEventListener (extends java.util.EventListener) javax.comm.NoSuchPortException javax.comm.PortInUseException javax.comm.UnsupportedCommOperationException

下面讲解一下几个主要类或接口。

　　1.枚举出系统所有的RS232端口

　　在开始使用RS232端口通讯之前，我们想知道系统有哪些端口是可用的，以下代码列出系统中所有可用的RS232端口:

Enumeration en = CommPortIdentifier.getPortIdentifiers(); CommPortIdentifier portId; while (en.hasMoreElements()) { portId = (CommPortIdentifier) en.nextElement(); /*如果端口类型是串口，则打印出其端口信息*/ if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) { System.out.println(portId.getName()); } }

　　在我的电脑上以上程序输出以下结果：

　　COM1
　　COM2

　　CommPortIdentifier类的getPortIdentifiers方法可以找到系统所有的串口，每个串口对应一个CommPortIdentifier类的实例。

　　2.打开端口

　　如果你使用端口，必须先打开它。

try{ CommPort serialPort = portId.open("My App", 60); /* 从端口中读取数据*/ InputStream input = serialPort.getInputStream(); input.read(...); /* 往端口中写数据*/ OutputStream output = serialPort.getOutputStream(); output.write(...) ... }catch(PortInUseException ex) { ... }

　　通过CommPortIdentifier的open方法可以返回一个CommPort对象。open方法有两个参数，第一个是String，通常设置为你的应用程序的名字。第二个参数是时间，即开启端口超时的毫秒数。当端口被另外的应用程序占用时，将抛出PortInUseException异常。

　　在这里CommPortIdentifier类和CommPort类有什么区别呢？其实它们两者是一一对应的关系。CommPortIdentifier主要负责端口的初始化和开启，以及管理它们的占有权。而CommPort则是跟实际的输入和输出功能有关的。通过CommPort的getInputStream()可以取得端口的输入流，它是java.io.InputStream接口的一个实例。我们可以用标准的InputStream的操作接口来读取流中的数据，就像通过FileInputSteam读取文件的内容一样。相应的，CommPort的getOutputStream可以获得端口的输出流，这样就可以往串口输出数据了。

　　3. 关闭端口

　　使用完的端口，必须记得将其关闭，这样可以让其它的程序有机会使用它，不然其它程序使用该端口时可能会抛出端口正在使用中的错误。很奇怪的是，CommPortIdentifier类只提供了开启端口的方法，而要关闭端口，则要调用CommPort类的close()方法。

通讯方式

　　CommPort的输入流的读取方式与文件的输入流有些不一样，那就是你可能永远不知这个InputStream何时结束，除非对方的OutputStream向你发送了一个特定数据表示发送结束，你收到这个特定字符后，再行关闭你的InputStream。而comm.jar提供了两种灵活的方式让你读取数据。
1. 轮询方式(Polling)

　　举个例子，你同GF相约一起出门去看电影，但你的GF好打扮，这一打扮可能就是半小时甚至一小时以上。这时你就耐不住了，每两分钟就催问一次“好了没？”，如此这样，直到你的GF说OK了才算完。这个就叫轮询(Polling)。

　　在程序中，轮询通常设计成一个封闭的循环，当满足某个条件时即结束循环。刚才那个例子中，你的GF说“OK了！”，这个就是结束你轮询的条件。在单线程的程序中，当循环一直执行某项任务而又无法预知它何时结束时，此时你的程序看起来可能就像死机一样。在VB程序中，这个问题可以用在循环结构中插入一个doEvent语句来解决。而Java中，最好的方式是使用线程，就像以下代码片断一样。

public TestPort extend Thread { ... InputStream input = serialPort.getInputStream(); StringBuffer buf = new StringBuffer(); boolean stopped = false; ... public void run() { try { while( !stopped ) int ch = input.read(); if ( ch=='q' || ch=='Q' ) { /* 结束读取，关闭端口...*/ stopped = true; ... } else { buf.append((char)ch); ... } }catch (InterruptedException e) { } } }

　　2. 监听方式(listening)

　　Comm API支持标准的Java Bean型的事件模型。也就是说，你可以使用类似AddXXXListener这样的方法为一个串口注册自己的监听器，以监听方式进行数据读取。

　　如要对端口监听，你必须先取得CommPortIdentifier类的一个实例，
CommPort serialPort = portId.open("My App", 60);

　　从而取得SerialPort，再调用它的addEventListener方法为它添加监听器，
serialPort.addEventListener(new MyPortListener());

　　SerialPort的监听器必须继承于SerialPortEventListener接口。当有任何SerialPort的事件发生时，将自动调用监听器中的serialEvent方法。Serial Event有以下几种类型：

　　BI - 通讯中断.
　　CD - 载波检测.
　　CTS - 清除发送.
　　DATA_AVAILABLE - 有数据到达.
　　DSR - 数据设备准备好.
　　FE - 帧错误.
　　OE - 溢位错误.
　　OUTPUT_BUFFER_EMPTY - 输出缓冲区已清空.
　　PE - 奇偶校验错.
　　RI - 　振铃指示.
　
　　下面是一个监听器的示例：

public void MyPortListener implements SerialPortEventListener { 　public void serialEvent(SerialPortEvent evt) 　{ 　　switch (evt.getEventType()) 　　{ 　　　case SerialPortEvent.CTS : 　　　　System.out.println("CTS event occured."); 　　　　break; 　　　case SerialPortEvent.CD : 　　　　System.out.println("CD event occured."); 　　　　break; 　　　case SerialPortEvent.BI : 　　　　System.out.println("BI event occured."); 　　　　break; 　　　case SerialPortEvent.DSR : 　　　　System.out.println("DSR event occured."); 　　　　break; 　　　case SerialPortEvent.FE : 　　　　System.out.println("FE event occured."); 　　　　break; 　　　case SerialPortEvent.OE : 　　　　System.out.println("OE event occured."); 　　　　break; 　　　case SerialPortEvent.PE : 　　　　System.out.println("PE event occured."); 　　　　break; 　　　case SerialPortEvent.RI : 　　　　System.out.println("RI event occured."); 　　　　break; 　　　case SerialPortEvent.OUTPUT_BUFFER_EMPTY : 　　　　System.out.println("OUTPUT_BUFFER_EMPTY event occured."); 　　　　break; 　　　case SerialPortEvent.DATA_AVAILABLE : 　　　　System.out.println("DATA_AVAILABLE event occured."); 　　　　int ch; 　　　　StringBuffer buf = new StringBuffer(); 　　　　InputStream input = serialPort.getInputStream 　　　　try {　 　　　　　while ( (ch=input.read()) > 0) { 　　　　　　buf.append((char)ch); 　　　　　} 　　　　　System.out.print(buf); 　　　　} catch (IOException e) {} 　　　　break;　 　　　} }

　　这个监听器只是简单打印每个发生的事件名称。而对于大多数应用程序来说，通常关心是DATA_AVAILABLE事件，当数据从外部设备传送到端口上来时将触发此事件。此时就可以使用前面提到过的方法，serialPort.getInputStream()来从InputStream中读取数据了。