EJB进行开发项目
何谓EJB的角色？具体有哪些角色？
EJB的全称是Enterprise Java bean。是JAVA中的商业应用组件技术。EJB结构中的角色 EJB 组件结构是基于组件的分布式计算结构，是分布式应用系统中的组件。
一个完整的基于EJB的分布式计算结构由六个角色组成，这六个角色可以由不同的开发商提供，每个角色所作的工作必须遵循Sun公司提供的EJB规范，以保证彼此之间的兼容性。这六个角色分别是EJB组件开发者（Enterprise Bean Provider）、应用组合者（Application Assembler）、部署者（Deployer）、EJB服务器提供者（EJB Server Provider）、EJB 容器提供者（EJB Container Provider）、系统管理员（System Administrator）：
1.EJB中各角色的分析
（1）EJB组件开发者（Enterprise Bean Provider）
EJB组件开发者负责开发执行商业逻辑规则的EJB组件，开发出的EJB组件打包成ejb-jar文件。EJB组件开发者负责定义EJB的remote和home接口，编写执行商业逻辑的EJB class，提供部署EJB的部署文件（deployment descriptor）。部署文件包含EJB的名字，EJB用到的资源配置，如JDBC等。EJB组件开发者是典型的商业应用开发领域专家。
EJB组件开发者不需要精通系统级的编程，因此，不需要知道一些系统级的处理细节，如事务、同步、安全、分布式计算等。
（2）应用组合者（Application Assembler）
应用组合者负责利用各种EJB组合一个完整的应用系统。应用组合者有时需要提供一些相关的程序，如在一个电子商务系统里，应用组合者需要提供JSP（Java Server Page）程序。
应用组合者必须掌握所用的EJB的home和remote接口，但不需要知道这些接口的实现。
（3）部署者（Deployer）
部署者负责将ejb-jar文件部署到用户的系统环境中。系统环境包含某种EJB Server和EJB Container。部署者必须保证所有由EJB组件开发者在部署文件中声明的资源可用，例如，部署者必须配置好EJB所需的数据库资源。
部署过程分两步：部署者首先利用EJB Container提供的工具生成一些类和接口，使EJB Container能够利用这些类和接口在运行状态管理EJB。 部署者安装EJB组件和其他在上一步生成的类到EJB Container中。部署者是某个EJB运行环境的专家。
某些情况下，部署者在部署时还需要了解EJB包含的业务方法，以便在部署完成后，写一些简单的程序测试。
（4）EJB服务器提供者（EJB Server Provider）
EJB 服务器提供者是系统领域的专家，精通分布式交易管理，分布式对象管理及其它系统级的服务。EJB 服务器提供者一般由操作系统开发商、中间件开发商或数据库开发商提供。
在目前的EJB规范中，假定EJB 服务器提供者和EJB 容器提供者来自同一个开发商，所以，没有定义EJB 服务器提供者和EJB容器提供者之间的接口标准。
（5）EJB 容器提供者（EJB Container Provider）
EJB 容器提供者提供EJB部署工具为部署好的EJB组件提供运行环境 。EJB容器负责为EJB提供交易管理，安全管理等服务。
EJB 容器提供者必须是系统级的编程专家，还要具备一些应用领域的经验。EJB 容器提供者的工作主要集中在开发一个可伸缩的，具有交易管理功能的集成在EJB 服务器中的容器。EJB 容器提供者为EJB组件开发者提供了一组标准的、易用的API访问EJB 容器，使EJB组件开发者不需要了解EJB服务器中的各种技术细节。
EJB容器提供者负责提供系统监测工具用来实时监测EJB容器和运行在容器中的EJB组件状态。
（6）系统管理员（System Administrator）
系统管理员负责为EJB服务器和容器提供一个企业级的计算和网络环境。
系统管理员负责利用EJB 服务器和容器提供的监测管理工具监测EJB组件的运行情况。
2.EJB的体系结构：
EJB分布式应用程序是基于对象组件模型的，低层的事务服务用了API技术。EJB技术简化了用JAVA语言编写的企业应用系统的开发，配置。EJB技术定义了一组可重用的组件：Enterprise Beans。你可以利用这些组件，象搭积木一样的建立你的分布式应用程序。当你把代码写好之后，这些组件就被组合到特定的文件中去。每个文件有一个或多个Enterprise Beans，在加上一些配置参数。最后，这些Enterprise Beans被配置到一个装了EJB容器的平台上。客户能够通过这些Beans的home接口，定位到某个beans，并产生这个beans的一个实例。这样，客户就能够调用Beans的应用方法和远程接口。
EJB服务器作为容器和低层平台的桥梁管理着EJB容器和函数。它向EJB容器提供了访问系统服务的能力。例如：数据库的管理和事务的管理，或者对于其它的Enterprise的应用服务器。所有的EJB 实例都运行在EJB容器中。
容器提供了系统级的服务，控制了EJB的生命周期。EJB中的有一些易于使用的管理工具如：
Security－配置描述器（The Deployment descriptor）定义了客户能够访问的不同的应用函数。容器通过允许授权的客户访问这些函数来达到这个效果。
Remote Connectivity－容器为远程链接管理着低层的通信issues，而且对Enterprise Beas的开发者和客户都隐藏了通信细节。EJB的开发者在编写应用方法的时候，就象是在条用本地的平台一样的。客户也不清楚他们调用的方法可能是在远程被处理的。
Life Cycle managment－客户简单的创建一个Enterprise beans的实例，并通常取消一个实例。而容器管理着Enterprise Beans的实例，使Enterprise Beans实现最大的效能和内存利用率。容器能够这样来激活和使Enterprise Beans失效，保持众多客户共享的实例池。等等。
Trasction management－配置描述器定义了Enterprise beans 的事务处理的需求。容器管理着那些管理分布式事务处理的复杂的issues。这些事务可能要在不同的平台之间更新数据库。容器使这些事务之间互相独立，互不干扰。保证所有的更新数据库都是成功发生的，否者，就回滚到事务处理之前的状态。
EJB组件是基于分布式事务处理的企业级应用程序的组件。所有的EJB都有如下的特点：
EJB包含了处理企业数据的应用逻辑，定义了EJB的客户界面。这样的界面不受容器和服务器的影响。于是，当一个EJB被集合到一个应用程序中去时，不用更改代码和重新编译。
EJB能够被定制。各种系统级的服务，例如安全和事务处理的特性，都不是属于EJB类的。而是由配置和组装应用程序的工具来实现。
有两种类型的EJB： Session beans 和 entity beans。Session beans是一种作为单用户执行的对象。作为对远程的任务请求的相应，容器产生一个Session beans 的实例。一个Session beans有一个用户。从某种程度上来说，一个Session bean 对于服务器来说就代表了它的那个用户。Session beans 也能用于事务，它能够更新共享的数据，但它不直接描绘这些共享的数据。Session beans 的生命周期是相对较短的。典型的是，只有当用户保持会话的时候，Session beans 才是活着的。一旦用户退出了，Session beans 就不再与用户相联系了。Session beans被看成是瞬时的，因为如果容器崩溃了，那么用户必须重新建立一个新的Session对象来继续会话。
Session bean典型的声明了与用户的互操作或者会话。也就是说，Session bean在客户会话期间，通过方法的调用，掌握用户的信息。一个具有状态的Session bean称为有状态的Session bean。当用户终止与Session beans互操作的时候。会话终止了，而且，bean 也不再拥有状态值。Session bean也可能是一个无状态的 session bean。无状态的Session beans并不掌握它的客户的信息或者状态。用户能够调用beans的方法来完成一些操作。但是，beans只是在方法调用的时候才知道用户的参数变量。当方法调用完成以后，beans并不继续保持这些参数变量。这样，所有的无状态的session beans的实例都是相同的，除非它正在方法调用期间。这样，无状态的Session beans就能够支持多个用户。容器能够声明一个无状态的Session beans。能够将任何Session beans指定给任何用户。
Entity Beans对数据库中的数据提供了一种对象的视图。例如：一个Entity bean能够模拟数据库表中一行相关的数据。多个client能够共享访问同一个Entity bean。多个client也能够同时的访问同一个Entity bean。Entity beans通过事务的上下文来访问或更新下层的数据。这样，数据的完整性就能够被保证。Entity Beans能存活相对教长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。如果由容器控制着保证 Entity beans持续的issus。如果由Beans自己管理，就必须写Entity beans的代码，包括访问数据库的调用。
Entity Beans是由主键（primary key 一种唯一的对象标识符）标识的。通常，主键与标识数据库中的一块数据，例如一个表中的一行，的主键是相同的。主键是client能够定位特定的数据块。
利用EJB进行开发有哪些步骤？
开发EJB的主要步骤一般来说，整个的开发步骤（开发，配置，组装）包括如下几个方面。
·开发：首先要定义三个类：Bean类本身，Bean的本地和远程接口类。
·配置：配置包括产生配置描述器－这是一个XML文件、声明了Enterprise Bean的属性、绑定了bean的class文件（包括stub文件和skeleton文件）。最后将这些配置都放到一个jar文件中。还需要在配置器中定义环境属性。
·组装应用程序：包括将Enterprise beans安装到Server服务器中，测试各层的连接情况。程序组装器将若干个Enterprise Beans与其它的组件结合起来，组合成一个完整的应用程序；或者将若干个Enterprise beans组合成一个复杂的Enterprise Bean。
·管理Enterprise Bean
必须定义和编写一些EJB中的基本类。如Enterprise bean类：这是Enterprise bean内部应用逻辑的实现。编写Enterprise bean的远程接口类。编写Enterprise bean的本地接口类。说明主键类，主键类只是对于Entity bean才需要的。在Enterprise bean的配置描述器中指定主键的名字。Enterprise beans提供者定义了远程接口和本地接口，实现了EJB类本身。Remote接口中提供了客户调用EJB实现的应用逻辑函数的接口。而home接口提供了产生和定位remote接口实例的方法。
在Enterprise bean本身类的实现，本地home接口，远程remote接口之间并没有正式的联系（例如继承关系）。但是，在三个类里声明的方法却必须遵守EJB里面定义的规范。例如： 你在Enterprise bean里面声明了一个应用程序的方法或者说应用逻辑。也在beans的remote接口中声明了这个方法，那么，这两个地方必须要同样的名字。Bean的实现里面必须至少有一个Create()方法：ejbCreate()。但是可以有多个带有不同参数的create()方法。在home接口中，也必须有相同的方法定义（参数的个数相同）。EjbCreate()方法返回的一个容器管理的持久对象。它们都返回一个容器管理持久性的主键值。但是，在home的相应的Create()方法中返回值的类型是remote接口。
注意：实体bean的实现的ejbCreate方法有点不同。实体bean可以不定义ejbCreate方法。如果实体只是通过应用程序或通过数据库管理程序的途径被加到数据库中，实体bean就省略了ejbCreate方法。EjbCreate返回的值是主键类型。如果ejbCreate方法是容器管理持久性的实体bean的方法，它的返回值就是NULL类型。如果实体bean实现了Bean管理的持久性，ejbCreate方法就返回值类型就是主键类型。容器的任务是把各接口和Enterprise bean的实现类结合起来。保证在编译时和运行时，各接口和实现类是相对应的。
EJB的实现类，各接口要从不同的基类中继承下来。一个会话bean必须实现基类Javax.ejb.SessionBean。而实体bean必须实现基类Javax.ejb.EntiyBean。这些EJB的基类都是从Javax.ejb.EnterpriseBean继承而来。而Javax.ejb.EnterpriseBean又是从Java.io.Serializable继承而来。每一个Enterprise Bean都必须有一个remote接口。Remote接口定义了应用程序规定客户可以调用的逻辑操作。这些是一些可以由客户调用的公共的方法，通常由Enterprise beans类来实现。注意，Enterprise bean的客户并不直接访问Bean。而是通过remote接口来访问。Enterprise bean类的remote接口扩展了Javax.ejb.EJBObject类的公共Java接口。而Javax.ejb.EJBObject是所有remote接口的基类。其代码如下：
package Javax.ejb；
public interface EJBObject extends Java.rmi.Remote{
public EJBHome getEJBHome() throws Java.rmi.RemoteException；
public Object getPrimaryKey() throws Java.rmi.RemoteException；
public void Remove() throws Java.rmi.RemtoeException， Java.rmi.RemoveException
public Handle getHandle() throws Java.rmi.RemoteException；
boolean isIdentical (EJBObject p0) throws Java.rmi.RemoteException；
}
getEJBHome()方法允许你取得一个相关的Home接口。对于 实体Bean，用getPrimaryKey()方法获得实体Bean的主键值。Remove()可以删除一个Enterprise bean。具体的语义在各种不同类型的enterprise beans的生命周期中，由上下文中解释的。方法getHandle()返回了一个Enterprise bean实例的持久的句柄。IsIndentical()方法允许你去比较Enterprise beans是否相同。
所有的remote接口中的方法必须声明为公共（public）的，并必须抛出Java.rmi.RemotException异常。另外，所有的remote接口中的方法定义的参数和都必须是在RMI-IIOP中有效的。对每一个在remote接口中定义的方法，在Enterprise bean 类里面都要有相应的方法。相应的方法必须要有同样的名字，同样类型和数量的参数，同样的返回值，而且还要抛出同样的例外。 如下代码显示了一个ATM例子的会话bean的remote接口Atm。里面声明了一个应用方法transfer()。黑体部分表示EJB规范中必须要有的内容。Remote接口必须扩展Javax.ejb.EJBObject类。从客户端调用的Enterprise bean的每一个方法都必须在remote接口中声明。Transfer()方法抛出了两个意外。其中InSufficientFundsException例外是应用程序定义的意外。
Public interface Atm extends Javax.ejb.EJBObject{
Public void transfer(String Source， String Target， float amount)
Throws Java.rmi.RemoteException， InSufficientFundsException；
}
Home接口必须定义一个或多个的Create()方法。每一个这样的Create()方法都必须命名为Create。并且，它的参数，不管是类型还是数量都必须与bean类里面的ejbCreate()方法对应。注意，home接口中的Create()方法和bean类中ejbCreate()方法的返回值类型是不同的。实体bean的home接口还包含find()方法。 每一个Home接口都扩展了Javax.ejb.EJBHome接口。如下代码显示了Javax.ejb.EJBHome接口的定义：
package Javax.ejb；
public interface EJBHome extends Java.rmi.Remote() {
void remove(Handle handle) throws Java.rmi.RemoteException，RemoveException；
void remove(Object primarykey) throws Java.rmi.RemoteException，RemoveException；
EJBMetaData getEJBMetaData() throws RemoteException；
Homehandle getHomeHandle() throws RemoteException；
}
这里提供了两个remove()方法来删除Enterprise bean的实例。第一个remove方法是通过句柄来删除一个Enterprise bean的实例。第二个remove方法通过主键来删除一个Enterprise bean的实例。 在众多的Enterprise bean实例中，句柄唯一的标识一个实例。一个句柄与它引用的Enterprise bean有相同的生命期。考虑一个实体对象，客户可以通过一个句柄来重新获得相应的Enterprise bean的实例。一个句柄能够对应一个Enterprise bean对象的多个实例。例如，即使当Enterprise bean对象所在的主机崩溃了，或者Enterprise bean对象在不同的机器之间移动，句柄仍是有效的。这里的句柄是Serialized句柄，与CORBA中的字符串化的CORBA对象的引用是相似的概念。在EJBHome接口中的第二个remove操作通过其主键来决定要删除的Enterprise bean。主键可以是扩展了Java Object类的任何类型，但是，必须要实现Java的Serializable接口。主键是标识实体bean的主要的方法。通常，主键是数据库中的一个关键字，唯一的定义了由实体bean代表的数据。
方法getEJBMetaData()返回了Enterprise bean对象的metadata接口。这个接口允许客户获得Enterprise bean的metadata信息。当开发工具来编译链接应用程序的时候，或者配置工具来配置的时候，可能会用到metadata信息。 Javax.ejb.EJBMetadata接口提供了获得Javax.ejb.EJBHome接口，home类，remote接口，还有获得主键的方法。也提供了一个isSesson()的方法来确定在放这个home接口的对象是会话bean还是实体bean。
IsStatelessSession()方法指示这个会话bean是有状态还是无状态的。如下代码显示了Javax.ejb.EJBMetadata接口的定义部分的代码。
Public Javax.ejb； Public interface EJBMetaData{
EJBHome getEJBHome()；
Class getHomeInterfaceClass()；
Class getRemoteInterfaceClasss()；
Class getPrimaryKeyClass()；
Boolean isSession()；
Boolean isStatelesssSession()；
}
对每一个Create()方法，EJB规范定义了如下的命名约定。它的返回值是会话bean的remote接口的类型。方法的名字只能是Create()。对会话bean类中的每一个ejbCreate()方法都必须有一个Create()与之对应。 对于每一个Create()方法的参数的类型和数量都必须与会话bean类中的ejbCreate()方法相对应。方法必须抛出Java.rmi.RemoteException例外。 方法必须抛出Javax.rmi.CreateExeption例外。 Create()方法的参数是用来初始化新的会话bean对象的。如下代码显示了一个会话bean对象的不同的Create()方法，其中必须的部分用粗体显示：
public interface AtmHome extends Javax.ejb.EJBHome{
Atm create() throws Java.rmi.RemoteException，Javax.ejb.CreateException；
Atm create(Profile preferredProfile)
Throws Java.rmi.RemoteExeption，Javax.ehrows Java.rmi.RemoteException，RemoveException；
EJBMetaData getEJBMetaData() throws RemoteException；
Homehandle getHomeHandle() throws RemoteException；
}
这里提供了两个remove()方法来删除Enterprise bean的实例。第一个remove方法是通过句柄来删除一个Enterprise bean的实例。第二个remove方法通过主键来删除一个Enterprise bean的实例。在众多的Enterprise bean实例中，句柄唯一的标识一个实例。一个句柄与它引用的Enterprise bean有相同的生命期。考虑一个实体对象，客户可以通过一个句柄来重新获得相应的Enterprise bean的实例。一个句柄能够对应一个Enterprise bean对象的多个实例。例如，即使当Enterprise bean对象所在的主机崩溃了，或者Enterprise bean对象在不同的机器之间移动，句柄仍是有效的。这里的句柄是Serialized句柄，与CORBA中的字符串化的CORBA对象的引用是相似的概念。
在EJBHome接口中的第二个remove操作通过其主键来决定要删除的Enterprise bean。主键可以是扩展了Java Object类的任何类型，但是，必须要实现Java的Serializable接口。主键是标识实体bean的主要的方法。通常，主键是数据库中的一个关键字，唯一的定义了由实体bean代表的数据。方法getEJBMetaData()返回了Enterprise bean对象的metadata接口。这个接口允许客户获得Enterprise bean的metadata信息。当开发工具来编译链接应用程序的时候，或者配置工具来配置的时候，可能会用到metadata信息。Javax.ejb.EJBMetadata接口提供了获得Javax.ejb.EJBHome接口，home类，remote接口，还有获得主键的方法。也提供了一个isSesson()的方法来确定在放这个home接口的对象是会话bean还是实体bean。IsStatelessSession()方法指示这个会话bean是有状态还是无状态的。 如下代码显示了Javax.ejb.EJBMetadata接口的定义部分的代码。
Public Javax.ejb；
Public interface EJBMetaData{
EJBHome getEJBHome()；
Class getHomeInterfaceClass()；
Class getRemoteInterfaceClasss()；
Class getPrimaryKeyClass()；
Boolean isSession()；
Boolean isStatelesssSession()；
}
EJB的编程环境有哪些？
1. 使用Jbuilder
Jbuilder与EJB Container能够进行无缝连接。Jbuilder和Inprise的应用服务器包括了所有的开发和配置Enterprise Beans的工具以及所需要的库：运行和管理Enterprise Bean的容器、命名服务、 事务服务、Java数据库、开发Enterprise Beans所需要的API、一个增强的Java-to-iiop编译器，支持值类型和RMI信号等等。
Jbuilder还提供了一个快速开发应用程序Enterprise Beans的工具和向导。通过简单而且直观的步骤，向导帮助你建立一个Enterprise Bean。自己设定某些缺省值，产生了bean的模板，在上面，我们可以增加我们自己的应用逻辑。Jbuilder也提供了一个EJB的接口生成向导。向导在Enterprise Bean的公共方法基础上生成了Remote接口和Home接口。Jbuilder还提供一个配置器的向导帮助我们逐步的建立XML描述器文件。并将生成的Stubs集中到一个jar文件中。
2.使用Jbuilder之外的集成环境：
如果你使用其它的除了别的集成环境（IDE）。要确定使用了集成环境IDE所带的容器工具。也要验证IDE是否支持EJB规范的相应的版本，还要确定它是否正确的支持EJB的API。
要确定JD到所支持的EJB容器的版本。可以通过检查Inprise的安装说明来确定EJB容器所支持的支持JDK的版本。
在配置Enterprise Bean的时候，你必须使用Inprise的应用服务器所提供的工具。这些工具能够编辑和修改第三方的代理商提供的Inprise配置描述器。还能够验证配置描述器，能够验证bean的源代码。
附录：一个具体而微的EJB应用实例？
1.安装Apusic Application Server
Note：以下以Linux为例，来说明Apusic Application Server的安装过程。其他平台的安装，可参考Apusic Application Server安装手册。
下载JDK1.2，Apusic Application Server必须运行在JDK1.2以上环境中。可从以下站点下载最新JDK。
http：//Java.sun.com
下载Apusic Application Server
Apusic Application Server 试用版可从以下网址得到：
http：//www.apusic.com/download/enter.jsp
在下载完成后，你可以得到一个包裹文件apusic.zip，选定安装目录，假设安装到/usr下，则用以下命令：
cd /usr
jar xvf apusic.zip
/usr下会出现一个目录apusic，Apusic Application Server的所有程序都被解压到/usr/apusic下。
将以下路径加入到CLASSPATH中
/usr/apusic/lib/apusic.jar
$JAVA_HOME/lib/tools.jar
用以下命令运行Apusic Application Server
Java -Xms64m com.apusic.server.Main -root /usr/apusic
2.定义EJB远程接口（Remote Interface)
任何一个EJB都是通过Remote Interface被调用，EJB开发者首先要在Remote Interface中定义这个EJB可以被外界调用的所有方法。执行Remote Interface的类由EJB生成工具生成。以下是HelloBean的Remote Inteface程序：
package ejb.hello；
import Java.rmi.RemoteException；
import Java.rmi.Remote；
import Javax.ejb.*；
public interface Hello extends EJBObject， Remote {
// this method just get "Hello World" from HelloBean.
public String getHello() throws RemoteException；
}
3.定义Home Interface
EJB容器通过EJB的Home Interface来创建EJB实例，和Remote Interface一样，执行Home Interface的类由EJB生成工具生成。以下是HelloBean 的Home Interface程序：
package ejb.hello；
import Javax.ejb.*；
import Java.rmi.Remote；
import Java.rmi.RemoteException；
import Java.util.*；
/**
* This interface is extremely simple it declares only
* one create method.
*/
public interface HelloHome extends EJBHome {
public Hello create() throws CreateException，
RemoteException；
}
4.写EJB类
在EJB类中，编程者必须给出在Remote Interface中定义的远程方法的具体实现。EJB类中还包括一些 EJB规范中定义的必须实现的方法，这些方法都有比较统一的实现模版，编程者只需花费精力在具体业务方法的实现上。以下是HelloBean的代码：
package ejb.hello；
import Javax.ejb.*；
import Java.util.*；
import Java.rmi.*；
public class HelloBean implements SessionBean {
static final boolean verbose = true；
private transient SessionContext ctx； // Implement the methods in the SessionBean
// interface
public void ejbActivate() {
if (verbose)
System.out.println("ejbActivate called")；
}
public void ejbRemove() {
if (verbose)
System.out.println("ejbRemove called")；
}
public void ejbPassivate() {
if (verbose)
System.out.println("ejbPassivate called")；
}
/**
* Sets the session context.
*
* @param SessionContext
*/
public void setSessionContext(SessionContext ctx) {
if (verbose)
System.out.println("setSessionContext called")；
this.ctx = ctx；
}
/**
* This method corresponds to the create method in
* the home interface HelloHome.Java.
* The parameter sets of the two methods are
* identical. When the client calls
* HelloHome.create()， the container allocates an
* instance of the EJBean and calls ejbCreate().
*/
public void ejbCreate () {
if (verbose)
System.out.println("ejbCreate called")；
}
/**
* **** HERE IS THE BUSINESS LOGIC *****
* the getHello just return a "Hello World" string.
*/
public String getHello()
throws RemoteException
{
return("Hello World")；
}
}
5.创建ejb-jar.xml文件
ejb-jar.xml文件是EJB的部署描述文件，包含EJB的各种配置信息，如是有状态Bean（Stateful Bean） 还是无状态Bean（Stateless Bean），交易类型等。ejb-jar.xml文件的详细信息请参阅EJB规范。以下是HelloBean的配置文件：
Hello
ejb.hello.HelloHome
ejb.hello.Hello
ejb.hello.HelloBean
Stateless
Container
Hello
*
Required
6.编译和部署
编译Java源文件并将编译后class和ejb-jar.xml打包到Hello.jar
mkdir build
mkdir build/META-INF
cp ejb-jar.xml build/META-INF
Javac -d build *.Java
cd build
jar cvf Hello.jar META-INF ejb
cd ..
用EJB工具生成可部署到Apusic Application Server中运行的jar文件：
Java com.apusic.ejb.utils.EJBGen -d /usr/apusic/classes/Hello.jar build/Hello.jar
增加/usr/apusic/classes/Hello.jar到CLASSPATH中
将Hello.jar加入到Apusic Application Server配置文件中。在/usr/apusic/config/server.xml 加入以下几行：
classes/Hello.jar
Hello
HelloHome
启动服务器
Java -Xms64m com.apusic.server.Main -root /usr/apusic
7.写客户端调用程序
现在读者可以从Java Client，JSP，Servlet或别的EJB调用HelloBean。
调用EJB有以下几个步骤：
·通过JNDI（Java Naming Directory Interface）得到EJB Home Interface
·通过EJB Home Interface 创建EJB对象，并得到其Remote Interface
·通过Remote Interface调用EJB方法
以下是一个从Java Client中调用HelloBean的例子：
package ejb.hello；
import Javax.naming.Context；
import Javax.naming.InitialContext；
import Java.util.Hashtable；
import Javax.ejb.*；
import Java.rmi.RemoteException；
/**
* @author Copyright （c） 2000 by Apusic， Inc. All Rights Reserved.
*/
public class HelloClient{
public static void main(String args[]){
String url = "rmi：//localhost：6888"；
Context initCtx = null；
HelloHome hellohome = null；
try{
Hashtable env = new Hashtable()；
env.put(Context.INITIAL_CONTEXT_FACTORY，
"com.apusic.jndi.InitialContextFactory")；
env.put(Context.PROVIDER_URL， url)；
initCtx = new InitialContext(env)；
}catch(Exception e){
System.out.println("Cannot get initial context： " + e.getMessage())；
System.exit(1)；
}
try{
hellohome = (HelloHome)initCtx.lookup("HelloHome")；
Hello hello = hellohome.create()；
String s = hello.getHello()；
System.out.println(s)；
}catch(Exception e){
System.out.println(e.getMessage())；
System.exit(1)；
}
}
}
运行HelloClient，可得到以下输出：Hello World
引自<Herr Apfel>
2005年6月15日
岸上的船儿，如同海上的灯塔，无法移动。
---荷兰谚语
史前史中，没有别的场景比巨兽在焦油坑中垂死挣扎的场面更令人震撼。上帝见证着恐龙、猛犸象、剑齿虎在焦油中挣扎。它们挣扎得越是猛烈，焦油纠缠得越紧，没有任何猛兽足够强壮或具有足够的技巧，能够挣脱束缚，它们最后都沉到了坑底。
过去几十年的大型系统开发就犹如这样一个焦油坑，很多大型和强壮的动物在其中剧烈地挣扎。他们中大多数开发出了可运行的系统——不过，其中只有非常少数的项目满足了目标、时间进度和预算的要求。各种团队，大型的和小型的，庞杂的和精干的，一个接一个淹没在了焦油坑中。表面上看起来好像没有任何一个单独的问题会导致困难，每个都能被解决，但是当它们相互纠缠和累积在一起的时候，团队的行动就会变得越来越慢。对问题的麻烦程度，每个人似乎都会感到惊讶，并且很难看清问题的本质。不过，如果我们想解决问题，就必须试图先去理解它。
职业的乐趣
编程为什么有趣？作为回报，它的从业者期望着什么样的快乐？
首先是一种创建事物的纯粹的快乐。如同小孩从玩泥巴中感到愉快一样，成人喜欢创建事物，特别是自己的设计。我想这种快乐一定是对上帝创造世界的映射，一种呈现在每个独特、崭新的叶片和雪花的喜悦。
第二是创建对其他人有用东西的欢乐。内心深处，我们需要其他人使用我们的劳动成果并感到有所帮助。从这个方面，编程系统与小孩用粘土为“爸爸办公室”捏制铅笔盒没有本质的区别。
第三是将相互啮合的部分组装在一起，并看到它们精妙的工作，实现预先所内建的结果，所体现的魔力。程序化的计算机具有像弹珠游戏或点唱机所有的令人入迷的魅力。
第四是学习的乐趣，来自于该工作的非重复的特性。问题在某个或其它方面总不同，解决的人员可以学习新的事物：有时是实践上的，有时是理论上的，或者两者兼有。
最后，是在如此易于驾驭的介质上工作的乐趣。程序员，像诗人一样，几乎工作在纯粹的思考中。程序员凭空地通过实现想象来建造自己的城堡。很少有创造的媒介如此的灵活，如此容易的完善和重建，以及如此容易的实现概念上的构架。（如同我们将看到的，容易驾驭的特性具有它自己的问题）然而程序同诗歌不同，是实实在在可以移动和工作的，以及产生独立于程序的可见输出。它打印出结果，绘制图形，发出声音，移动支架等。神话和传说的魔术在我们的时代变成了现实。即在键盘上键入正确的咒语，显示屏幕活动起来，显示从来没有或者存在的事物。
编程非常有趣，因为它满足我们内部深处的创建渴望和愉悦了所有人共同的感受。职业的苦恼然而并不全部都是喜悦，了解一些固有的烦恼能使它们出现时，更容易忍受。
首先，必须追求完美。计算机也以这种方式来变戏法。如果咒语的一个字符、一个停顿没有与正确的形式严格一致，魔术不会出现。人类不习惯于完美，只有很少的人类活动需要它。我认为，向完美的方式进行调整是学习编程的最困难的部分。
其次，其它的人设定了目标，供给资源，提供信息。编程的人员很少控制工作的环境，甚至工作的目标。用管理的术语而言，某人的权威对他所承担的责任是不充分的。不过，看起来在所有的领域中，对完成的工作，很少能提供与责任一致的正式的权威。而现实情况中，工作推进的动力需要实际（相对于正式）的权威。对其他人的依赖的影响比较突出，这对系统编程人员尤其痛苦。他依赖者其他人的程序。通常这些程序设计得不合理，实现拙劣，发布不完整（没有源代码或测试用例），或者文档记录得很糟。所以系统编程人员必须花费时间研究和修改在理想情况下应该完整、可用和有用的东西。
下一个烦恼——设计概念是有趣的，但寻找琐碎的BUG 仅仅是一项工作。伴随着创造性活动的，往往是枯燥、沉闷的时间，艰苦的劳动；程序编制工作也不例外。
另外，人们发现调试查错具有线性的收敛，或者更糟的是具有二次方的复杂度。所以，测试一拖再拖，寻找最后一个错误比第一个错误花费更多的时间。
最后一个苦恼，有时也是一种无奈——当某人花费大量劳动的产品在完成以前或完成时，显得陈旧。可能同事和竞争对手已在追逐新的、更好的设想。可能替代的方案不仅仅在构思，而且已经在安排了。现实的情况通常比上述的好一些。当产品开发完成时，新的、更佳的产品通常并不可用；仅仅是被大家所谈论。另外，它同样需要数月的开发时间。事实上，仅现实需要时，才要求使用最新的设想。因为所实现系统的价值已能体现回报，满足要求。
诚然，产品开发所基于的技术不断在进步。一旦设计被冻结，在概念上就已经陈旧了。不过，实际产品的实现需要阶段化和进行度量。实现的落后情况需要根据其它现有的系统进行测量，而非未实现的概念。我们所面临的挑战和任务是在现实的时间、有效的资源范围内，寻找实际问题的切实可行的解决方案。
这，就是编程。一个许多人痛苦挣扎的焦油潭以及一个乐趣和苦恼共存的创造性活动。对于许多人而言，其中的乐趣远大于烦劳。<FREDERICK P.BROOKS,JR. 人月神化>
2005年6月12日
第一次发表BlogJava，所谓万事开头难，请大家多多见量。本人Blog的初衷并不是给大家介绍很多技术难题和精妙思想，只是希望可以给各位喜好JAVA的朋友带来一些轻松写意的文章，使大家对JAVA这种语言能够从其它层面上进行交流沟通。呵呵，轻松，轻松，轻松。
<特此申明>
蔡学镛老师的这篇文章从宏观的角度为变量的种类做了一个总整理，希望可以帮助大家学习和了解JAVA变量有所帮助。
根据声明方式来为变量分类
根据声明方式详细来区分，Java的变量有七种,下面的程序代码展示了这七种变量的声明方式：
Class Myclass {
static int a;
int b;
public static void myMethod(int c) {
try {
int d;
} catch(Exception e) {
}
}
MyClass(int f) {
int[]g = new int[100];
}
}
class variable:声明在class内，method之外，且使用static修饰的变量,例如上面程序代码的a.
instance variable:声明在class内，method之外，且未使用static修饰的变量，例如上面程序的b.
method parameter:声明在method小括号内的变量，例如上面程序代码的c.
狭义的局部变量(local variable):声明在method内的变量，例如上面程序代码的d和g.
exception-handler parameter:声明在catch小括号内的变量，例如上面程序代码的e.
constructor parameter:声明在constructor小括号内的变量，例如上面程序代码的f.
数组元素(array element):数组的元素值没有识别名称，必须透过数组和索引值(index)来识别.例如上面
程序代码的g[0].
根据变量内存来分类
根据变量内存位置来区分，Java的变量有两种，包括了:
heap variable:占用的内存在heap中，这类变量包括了class variable,instance variable,array component,
即前面程序的a,b,g[0].这类变量会自动被JVM初始化默认值.
stack variable:通常广义的局部变量(pan-local variable),其占的内存在stack中，这类变量包括了狭义的
局部变量，method parameter,exception-handler parameter,constructor parameter,即前面程序 的c,d,e,f.狭义 的局部变量不会被JVM初始化成默认值，使用者必须自行初始化该变量,但是parameter类(包括method parameter,exception-handler parameter,constructor parameter)会被JVM初始化成传入值.
根据使用方式来为变量分类
根据使用方式，只要分三类即可，分别是:
class variable:即上例的a.
instance variable:即上例的b.
广义的局部变量:包含上例的c,d,e,f.这四者的差别很小，直接归为一类.
至于"数组元素"(array component)则不在此三类中，但是"数组元素"并不常被注意到，为它多分出一类的用处不大.我通常将数组视为对象,将array component视为对象的instance variable. <蔡学镛>