EJB简谈

EJB,
是企业JAVA BEAN 的缩写,这里,
想跟大家谈谈一些实质的问题
================
为什么要使用EJB?
================
EJB 最大的诱人之处是她把应用程序和服务器分开了,
我们再也不用和那些服务器上的复杂的资源打交道了,
什么数据库,什么进程,线程,什么安全权限,什么套接字,
都见鬼去吧,我们只需要专著于我们的商业逻辑的实现了.
==========
EJB 的实质?
==========
EJB 实际上是SUN 的J2EE 中的一套规范,并且规定了一系列的
API 用来实现把EJB 概念转换成EJB 产品.
EJB 是BEANS,BEANS 是什么概念,那就是得有一个容纳她,
让她可劲造腾的地方,就是得有容器.EJB 必须生存在EJB 容器中.
这个容器可是功能强大之极!她首先要包装你BEAN,
EJB 的客户程序实际上从来就不和你编写的EJB 直接打交道,
他们之间是通过HOME/REMOTE 接口来发生关系的.
它负责你的BEAN 的所有的吃喝拉萨睡,
比如BEAN 的持续化,安全性,事务管理...
=============
EJB 服务器产品
=============
各个WEB 服务器开发商基本上都在他们WEB 服务器中
新捆绑了EJB 容器,或者叫EJB 服务器.
其中最简单也是最根本的是J2EE 开发环境带的J2EE 的EJB 容器,
它很好的和J2EE 的HTTP 服务器和Servlet 引擎一起构筑了
一个很好的运行环境,由于配置简单,功能强大,因此成为我的最爱.
另外象BEA 的Weblogical 是值得推荐的一个产品,它的WEB 服务器
功能相当强大,是当今很多网站构筑的理想WEB 服务器,
它也已经加入了EJB 的行列,在EJB 方面有着不俗的表现.
Inprise 的IAS 更是一个功能强大的WEB 服务器,同样,也嵌入了
EJB 容器,加之与本公司的JBuilder 的无接缝结合,更使它人气攀升.
还有象IBM 的WebSphere 也不错,
不过Apache 是否已经搭载了EJB 容器,我不太清楚.
另外,推荐一个EJBoss,是一个完全免费的EJB 服务器,而且是原代码公开的.
========================
EJB 容器如何包装你的BEAN.
========================
这年头没有天上掉馅饼的好事情,EJB 也不例外,
你想让EJB 容器替你管理你编写的EJB 的吃喝拉萨睡,凭什么?!
凭XML 描述子,你通过一个XML 文件告诉EJB 容器BEAN 的相关配置信息,
比如我的EJB 的HOME 接口和REMOTE 接口是哪一个类,
比如我的EJB 的别名(实际上是JNDI 名称)叫什么,
比如我的EJB 是否是实体类型的EJB 还是对话类型的EJB,
比如告诉容器替我管理我的实体EJB 中哪些自段,
......
总之,你得跟咱们的EJB 大总管----EJB 容器把所有都交代清楚.
这样,剩下的,就看EJB 容器的了!!!
你是不是总共写过3 个文件,BEAN 定义,HOME 接口定义,ROMOTE 接口定义,
当你DEPLOY 他们时,容器会
(1).首先根据HOME 和REMOTE 接口生成他们的实现代码,
我们不妨叫做HOME_IMPL 和REMOTE_IMPL,
(2).然后,利用RMIC 产生HOME_IMPL 和REMOTE_IMPL 的
STUB 和SKELETON 文件,2X2 一共生成4 个文件.
(STUB 和SKELETON 请参见RMI 的相关概念)
如此这般,最后,在服务器上,一共有
BEAN
HOME_IMPL
REMOTE_IMPL
HOME_STUB
HOME_SKELETON
REMOTE_STUB
REMOTE_SKELETON
7 文件,才能让EJB 工作起来.
(3).生成实体EJB 对应的数据库的库表
(4).注册你的EJB 到JNDI 服务
===============================================================
为什么除了写BEAN,还得写接口文件,而且干嘛要HOME 和REMOTE 两个接口.
===============================================================
我搅着吧,这两个接口完全是可以合并成一个接口的,
其实他们的作用都只是一个接口,为了让
那人家SUN 干吗还拆成两个呢?
我想,正如SUN 所说的,为了将一些容器相关操作和客户商业方法分开,
什么意思?说开了吧,HOME 用来规范容器相关的操作方法,
REMOTE 负责专心致志的定制商业方法,
而我们的BEAN 才是最终的逻辑实现者.
还是不明白?没关系,我在说的细些,
举例说明:
把我想象成一个BEAN,
HOME 接口就是我们家人的命令,
REMOTE 接口就是我们单位的领导的命令,
我们家人的命令决定了我如何吃喝拉萨睡,
领导的命令决定了我如何做一些真正的工作,
请注意这里我使用了"决定"这个字眼,
我并没有说我们家人,而是说了我们家人的命令,
这个命令的含义就是接口,不是类,
而我这个BEAN 却是个类!
还有,BEAN 类不实现REMOTE 和HOME 接口,
记住!记住!
=========
EJB 的分类
=========
EJB 分为实体(Entity)EJB 和对话(Session)EJB,
>>>>>>实体EJB:>>>>>>对话EJB<<<<<<<
对话EJB 根本根本不和数据库打交道,为什么,因为他根本不用序列化!
他只负责来完成一些逻辑操作,比如算个帐什么的.
为了和实体EJB 较劲,他也一口气生了两个儿子,
a.有状态(sessionful)对话EJB
他就跟servlet 中的session 对象似的,可以保存用户的session 相关信息,
而且他仅仅被一个用户的一次session 所使用,不和别人共享,
我管他叫对话,不过这"对话"翻出来
这是够难听的,还不如就叫他session 呢!
b.无状态(sessionless)对话EJB
这个东东是最简单的EJB,他是可以被多个用户共享,
注意!我所说的共享是指实例的共享!
======================================
一个BEAN 管理持续化的实体EJB(BMP)小例子
======================================
说了半天了,大家珍贵的脑资源恐怕被我消耗的差不多了,
好,让我们来剖析一个BEAN 管理持续化的实体EJB(BMP)吧.
-----------------------看看REMOTE 接口------------------------------
public interface Account extends EJBObject {//必须从EJBObject 继承
file://这些都是商业方法,而且这里写了的,必须在BEAN 中都实现
public void deposit(double amt) throws RemoteException;
public double withdraw(double amt) throws AccountException, RemoteException;
public double getBalance() throws RemoteException;
public String getOwnerName() throws RemoteException;
public void setOwnerName(String name)throws RemoteException;
}
-------------------------看看HOME 接口---------------------------------
public interface AccountHome extends EJBHome {
file://这声明了create 函数,由于是BMP,所以必须在BEAN 中实现一个叫ejbCreate 的对应函
数
Account create(String accountID, String ownerName) throws CreateException,
RemoteException;
file://按主键查询
file://由于是BMP,所以必须在BEAN 中实现一个叫ejbFindByPrimaryKey 的对应函数
public Account findByPrimaryKey(AccountPK key) throws FinderException,
RemoteException;
file://按其中的Name 字段查询
file://由于是BMP,所以必须在BEAN 中实现一个叫ejbFindByOwnerName 的对应函数
public Account findByOwnerName(String name) throws FinderException,
RemoteException;
}
---------------------------看看BEAN-----------------------------------
public class AccountBean implements EntityBean {
file://三个PUBLIC 字段,他们将来对应库表的三个字段
public String accountID
public String ownerName;
public double balance;
file://----HOME 中声明的create 方法的影射实现
file://由于是BMP,所以必须自己来负责实例创建时实例到数据库的影射
public AccountPK ejbCreate(String accountID, String ownerName) throws
CreateException, RemoteException {
PreparedStatement pstmt = null;
Connection conn = null;
try {
this.ownerName = ownerName;
this.balance = 0;
conn = getConnection();
pstmt = conn.prepareStatement("insert into accounts (id, ownerName, balance)
values (?, ?, ?)");
pstmt.setString(1, accountID);
pstmt.setString(2, ownerName);
pstmt.setDouble(3, balance);
file://看这里,看这里!插进去了...
pstmt.executeUpdate();
return new AccountPK(accountID);
}catch (Exception e) {
throw new CreateException(e.toString());
}finally {
try {
pstmt.close();
conn.close();
}catch (Exception e) { }
}
}
file://----HOME 中声明的findByOwnerName 方法的影射实现
file://由于是BMP,所以必须自己来完成按照Name 字段查找的工作
public AccountPK ejbFindByOwnerName(String name) throws FinderException,
RemoteException {
PreparedStatement pstmt = null;
Connection conn = null;
try {
conn = getConnection();
pstmt = conn.prepareStatement("select id from accounts where ownerName =
?");
pstmt.setString(1, name);
file://看看看!找上了,根据名称...
ResultSet rs = pstmt.executeQuery();
rs.next();
String id = rs.getString("id");
pstmt.close();
conn.close();
return new AccountPK(id);
}catch (Exception e) {
throw new FinderException(e.toString());
}finally {
try {
pstmt.close();
conn.close();
}catch (Exception e) { }
}
}
file://----REMOTE 中声明的一个方法的实现
file://这是一个商业方法,来完成帐户的存款查询
public double getBalance() {
System.out.println("[AccountEJB-getBalance]getBalance() called.");
return balance;
}
.......其他的方法,由于篇幅问题就不一一列出了,请大家参阅原代码!
}
使用EJB 你就不用你自己写支持分布式的对象的框架了
Java Beans 是个功能的部件，而不是一个可运行的程序， 不需要也不能发布它， 但它
又必须有一个可依赖的环境来运行
EJB 则是可发布的部件、发布到一个容器中， 装配成更大的系统
EJB 和Applet 和Servlet 相似， Applet 的容器是Browser, Servlet 的容器是
支持Java 的Web Server， 而EJB 的容器是Application Server
EJB1.1 (2.0 的规范已经发布了，请到sun 去download)
软件生产工业化
多层应用简单化
事务处理
并发安全
Enterprise beans 当前两个类型(2.0 中有新内容， 我自己还没理解，不多讲了)
Session Beans(又包括stateful 和stateless) 业务过程相关的逻辑，比如各种计算，
查询
entity beans 数据相关的逻辑， 比如修改帐号的余额
EJB 的规范定义了一些你的Bean 可以实现标准的接口。 这些接口强迫你实现其中特定方
法。EJB 的容器使用这些方法来管理你的Bean 以及传递事件
最基本的接口javax.ejb.EnterpriseBean
public interface javax.ejb.EnterpriseBean extends java.io.Serializable
{}
这个接口中没有方法，起到标示你的Bean 是个Enterprise bean.
sesssion beans 和entity beans 有许多接口都是从这个特定的接口继承来的（所以你
的bean 并不直接实现EnterpriseBean 接口）。所有的session beans 都从
javax.ejb.SessionBean 继承，同理所有的EntityBean 都从javax.ejb.EntityBean 继
承。
remote object 由MiddleSoftware 提供的工具生成
remote interface 远程接口---客户端的应用调用的接口
java.ejb.EJBObject
public interface EJBObject extends java.rmi.Remote {
public abstract javax.ejb.EJBHome getEJBHome() throws
java.rmi.RemoteException;
public abstract javax.ejb.Handle getHandle() throws
java.rmi.RemoteException;
file://一个EJB 的持续引用， 存储起来重新构造
public abstract java.lang.Object getPrimaryKey() throws
java.rmi.RemoteException;
file://只用在Entity Beans
public abstract boolean isIdentical(javax.ejb.EJBObject param1) throws
java.rmi.RemoteException;
public abstract void remove() throws java.rmi.RemoteException,
javax.ejb.RemoveException;
}
home object -- EJB object factory, 由工具生成，是EJB container 的一部分
创建EJB objects
发现已经存在的EJB objects (for entity beans)
删除EJB objects
home interface --本地接口,
定义创建的方法，查找的方法和析构的方法
package javax.ejb;
import java.rmi.Remote;
import java.rmi.RemoteException;
// Referenced classes of package javax.ejb:
// RemoveException, EJBMetaData, HomeHandle, Handle
public interface EJBHome
extends Remote
{
public abstract EJBMetaData getEJBMetaData()
throws RemoteException;
public abstract HomeHandle getHomeHandle()
throws RemoteException;
public abstract void remove(Object obj)
throws RemoteException, RemoveException;
public abstract void remove(Handle handle)
throws RemoteException, RemoveException;
}
session bean
package javax.ejb;
import java.rmi.RemoteException;
// Referenced classes of package javax.ejb:
// EJBException, EnterpriseBean, SessionContext
public interface SessionBean
extends EnterpriseBean
{
public abstract void ejbActivate()
throws EJBException, RemoteException;
public abstract void ejbPassivate()
throws EJBException, RemoteException;
public abstract void ejbRemove()
throws EJBException, RemoteException;
public abstract void setSessionContext(SessionContext sessioncontext)
throws EJBException, RemoteException;
}
setSessionContext(SessionContext sessioncontext)
session context 是session bean 和container 交互的通道， 通常的实现:
import javax.ejb.*;
public class MyBean implements SessionBean
{
private SessionBean sessiontext;
public void setSessionContext(SessionContext sessioncontext)
throws EJBException, RemoteException
{
this.sessiontext = sessiontext;
}
......
}
public void ejbCreate(...)
至少实现一个
home object 实现相应参数的一个create 方法
比如
你的bean 中有一个ejbCreate(int i)时
home object 中有
public void create(int i)
钝化和激活 ---仅用于stateful session bean
public abstract void ejbPassivate()
public abstract void ejbActivate()
当太多的session bean 被事例化时,container 做钝化和激活操作， 释放和打开资源
file://stateless session bean
对于所有的客户端是相同的，所有的信息通过参数传递或从数据库等外部得到
初始化的唯一方式是无参数的 ejbCreate()方法
home object 有相应的无参数create（）方法
客户端调用过程：
1、Look up a home object.
2、Use the home object to create an EJB object.
3、Call business methods on the EJB object.
4、Remove the EJB object.
Look up a home object
your client code must use the JNDI. J2EE products exploit directory services
to stroe location infromation for resources that your application code uses
in an enterprise deployment. These resources could be EJB home objects,
enterprise bean enviroment properties, database derivers, message service
drivers, and other resources. By using directory services, you can writer
application code that does not depend on specific machine names or
locations. This is all part of EJB's location transparency, and it keeps
your code portable. If later you decide thata resources should be located
elsewhere, your code will not need to be rebuilt because the directory
service can simply be updated to reflect the new resource locations. This
greatly enhances maintenance of a multi-tier deployment that may evolve over
time.
There are two common steps that must be taken to find any resource in a J2EE
deployment:
1. Associate the resource with a "nickname" in your deployment descriptor.
Your J2EE product will bind the nickname to the resource.
2. Clients of the resource can use the nickname with JNDI to look up the
resource across a deployment.
目前的主要的分布式应用框架
1、 Miscrosoft's Distribute interNet Appplications Architecture(DNA)
相关的平台和技术
NT
DCOM
MSMQ
MTS
Microsoft Wolfpack
Microsoft SQL Server
Microsoft Internet Information Server
Microsoft Management Console
2、SUN's J2EE
J2EE 是规范而不是产品， 不至于让用户绑定到一个卖家（Microsoft）
支持高端的Unix 平台
内置的CORBA 支持
3、The Object Management Group's CORBA Standard
Common Object Request Broker Architecture (CORBA)
Internet Inter-ORB Protocol (IIOP)
EJB 开发概述
1、EJB 的开发
先泛泛而论，讲一讲EJB 的开发步骤。
1.1 SessionBean 的开发
第一步， 写远程接口（remote interface）,
继承EJBObject 接口，把需要调用的public 方法写在里面(这些方法将在SessionBean 中
实现)，注意要声明throws java.rmi.RemoteException。
例如：
package jsper.ejb;
import java.rmi.*;
import javax.ejb.*;
public interface MyEJB extends EJBObject
{
public String sayHello() throws java.rmi.RemoteException;
}
第二步， 写Home 接口（生成EJBObject 引用的factory)
至少生成一个create 方法, 注意要声明throws java.rmi.RemoteException 和
javax.ejb.CreateException。
比如：
package jsper.ejb;
import java.rmi.*;
import javax.ejb.*;
public interface MyEJBHome extends EJBHome
{
MyEJB create() throws java.rmi.RemoteException, javax.ejb.CreateException;
}
第三步， 写真正的Session Bean 的实现(实现定义在远程接口中的方法)， 需要实现
javax.ejb.SessionBean 接口
注意：不能用implents MyEJB 的方式直接实现远程接口,此处不用抛出RemoteException
package jsper.ejb;
import java.rmi.RemoteException;
import javax.ejb.*;
public class MyEJBClass implements SessionBean {
public MyEJBClass() {
}
file://定义在SessionBean 中的方法
public void ejbCreate() throws RemoteException, CreateException {
}
public void ejbActivate() throws RemoteException {
}
public void ejbPassivate() throws RemoteException {
}
public void ejbRemove() throws RemoteException {
}
public void setSessionContext(SessionContext ctx)
throws RemoteException {
}
file://此处是具体的实现
public String sayHello()
{
System.out.println("Hello");
}
}
第四步，写一个发布用的配置文件ejb-jar.xml
需要提供的信息：
Bean Home name -- The nickname that clients use to lookup your bean's home
object.
Enterprise bean class name -- The fully qualified name of the enterprise
bean class.
Home interface class name
Remote interface class name
Re-entrant -- Whether the enterprise bean allow re-entrant calls. This
setting must be false for session beans(it applies to entity beans only)
stateful or stateless
Session timeout -- The length of time (in seconds) before a client
should time out when calling methods on your bean.
最后你还可以提供属于自己的配置信息供自己控制EJB 的工作方式。
例子：
helloEjb
com.jsper.ejb.MyEJBHome
com.jsper.ejb.MyEJB
com.jsper.ejb.MyEJBClass
Stateless
Container
第五步，将你的所有文件用jar 工具生成jar 文件
ejb-jar.xml 须在顶级的META-INF 子目录
这句话比较咬嘴， 举个例子
mylib----META-INF--*.XML
|
|com--coucouniu--ejb---EJBClass
|-EJBHome
|-EJB
在生成.jar 文件时
sh>cd mylib file://注意此处所在目录
sh>jar cv0f myejb.jar *
请注意： 到这一步我们做出的东西都是和和特定的EJB Server 是无关的， 只是和遵循
EJB 的标准有关
第六步，使用特定平台的发布工具生成发布使用的jar 文件。
不同的中间件产品此步骤非常不同， 产生的结果都是生成只有自己的EJB Server 能理
解的远程接口和Home 接口实现等等东西，打包在一个jar 文件中
一般是很简单的
第七步，把.jar 文件发布到EJB Server
根据不同的中间件产品此步骤非常不同， 可以分为启动时发布和运行时发布两种，一
般是很简单的, 以weblogic 为例：
1、在weblogic.properties 文件中配置使weblogic 启动时自动装载。
添加一个条目比如：
weblogic.ejb.deploy=C:/weblogic510/myserver/ejb_basic_beanManaged.jar，/
C:/weblogic510/myserver/ejb_basic_test.jar
2、使用deploy 或DeployerTool 动态装载/卸载/更新
第八步，写客户端的程序（我迄今为止的理解）
在我们使用发布工具把EJB 发布到EJB Container 的过程中，会绑定一个名字到
Container 的目录服务中，现在我们要调用时从这个目录服务中把EJBHome 对象取出，
这里分为从本地和外部两种情况：
一种是客户端本地调用EJB。 比如和EJB 引擎和Servlet 引擎是整合在同一个
Application Server 中， 这时当一个Servlet 要调用EJB 时无须验证，即可得到EJBHome
接口的实现
Context ic = new InitialContext();
System.out.println("Looking for the EJB published as 'hello'");
com.jsper.ejb.MyEJBHome homeInterface = (com.jsper.ejb.MyEJBHome)
ic.lookup(“hello”); file://发布时绑定的名字是hello
这样就可从目录服务中得到Home 接口的实现， 也是我们最常用的方式， 可移植性很
好
外部调用的话首先要经过身份验证，
比如Oracle8i ：
String ejbUrl = "sess_iiop://localhost:2481:ORCL/test/MyEJB";
String username = "scott";
String password = "tiger";
// Setup the environment
Hashtable environment = new Hashtable();
// Tell JNDI to speak sess_iiop
environment.put(javax.naming.Context.URL_PKG_PREFIXES,
"oracle.aurora.jndi");
// Tell sess_iiop who the user is
environment.put(Context.SECURITY_PRINCIPAL, username);
// Tell sess_iiop what the password is
environment.put(Context.SECURITY_CREDENTIALS, password);
// Tell sess_iiop to use credential authentication
environment.put(Context.SECURITY_AUTHENTICATION, ServiceCtx.NON_SSL_LOGIN);
// Lookup the URL
com.jsper.ejb.MyEJBHome homeInterface = null;
try {
System.out.println("Creating an initial context");
Context ic = new InitialContext(environment);
System.out.println("Looking for the EJB published as 'test/MyEJB'");
homeInterface = (com.jsper.ejb.MyEJBHome) ic.lookup(ejbUrl);
}
catch (ActivationException e) {
System.out.println("Unable to activate : " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
再比如weblogic 的调用方式：
try
{
// Get an InitialContext
String url="t3://localhost:7001";
Properties h = new Properties();
h.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.WLInitialContextFactory");
h.put(Context.PROVIDER_URL, url);
Context ctx = new InitialContext(h);
System.out.println("Getting the EJBHome object...");
com.jsper.ejb.EJBHome tmp= (com.jsper.ejb.EJBHome)ctx.lookup("hello");
file://create three element array of COUNT object
EJB ejb =tmp.create();
System.out.println(ejb.sayHello());
}
catch(Exception e)
{
e.printStackTrace();
}
由于和具体的目录服务、协议相关，为了达到可移植的目的，只好多做一些工作，幸好
一般不需要做这些工作。
附图
EJB 的调用模型
Passivation of stateful session bean
Activation of stateful session bean
EJB Context, 你和EJB Container 交换信息的通道
Home Object 和EJB Object 的信息
transaction
安全信息
环境的属性
EJB 中EJB Object 可以是别的Beans 的client 端，这样当你需要call 别的bean 和传引用
给自己的bean 时，不能用this 关键字， 而应该用SessionContext.getEJBObject()方
法
EJB 的安全机制
第一步、 client 端必须被验证。 证实他是本EJB 的用户。也许需要输入
username/password。 一般的中间件产品都能和成熟的目录服务集成。 当然也有很简
单粗糙的做法，比如weblogic 就有一种：
weblogic.password.employeeA=passwordA
第二步、必须被批准有相应的权限做相应的操作
两种方式：一种是叫declarstive authorization. 由Container 去代理一切。 只是在
deploy 时给相应的角色分配权限。
weblogic.security.group.emplyees=employeeA
weblogic.security.group.manager=employeeB
weblogic.security.group.administrators=AdminA
另一种自己在程序中去验证
这里讲讲如何使用jdeveloper 开发EJB。在此之前请先阅读 ‘EJB 开发概述.doc'
由于jDeveloper 中提供了一系列的向导（写起文档很麻烦）完成各种功能，兼之
jDeveloper 中的帮助说明得很详细，没有另写文档
jDeveloper 的文档在
Help->help topics->user's guaides->Developing Applications->Developing Java
Components->Developing and Deploying Enterprise JavaBeans
使用jDeveloper3.0 能够开发EJB1.0（可惜不支持EJB1.1）, 并能把EJB 发布到
Oracle8i(需要配置成多线/进程服务器)或Oracle Application server/iAs
开发EJB 的方式：
通过向导file->new...->Enterprise java bean
1、生成一个新的EJB 类框架和Remote interface, Home interface
2、把已经存在的类封装成EJB
3、把已经存在的EJB 的class 文件封装成EJB
注意：
根据jdeveloper 提供的这些功能，我们可以省去写Remote interface 和Home
interface 的工作。
而直接写EJB 实现文件甚至bean 文件， 但为了使开发的东西看起来干净一些，建议不
要使用包装bean 的方式。
生成Deployment descriptor 文件, jDevelper 提供一个向导做这件事情， 挺简单的
在生成EJB 的向导中选择可以生成Deplyment descriptor 文件， 以后双击生成的.prf 文
件向Oracle8i 或OAS 发布。
或者：
在项目文件夹右击鼠标->New Deployment Profile...
或者：
在EJB 文件夹右击鼠标->Create jServer/EJB deployment profile...或create
OAS/EJB deployment profile...
以后就是按照向导的提示一步步进行，不再赘述。
使用jDeveloper 开发EJB 的总体印象：
优点：
由于是和自己的产品（8i/OAS）整合在一起, jDeveloper 开发EJB 是一个好的思路， 速
度是很快的(不出错的情况下)， 隐藏了Deploy 的大部分细节，大大加快开发进度。根
据。
缺点：
1、8i 只支持EJB 的1.0 规范, 版本有点低。（根据Oracle 公司的iAS 白皮书， iAS 的版
本2 支持EJB1.1）。 而别的产品如weblogic, jrun 现在支持的时EJB1.1 规范，这样在向
这些平台发布时还有一定的工作量。（1.0 中deploy descriper 是java 类， 在1.1 中已
改为ejb-jar.xml 文件）
3、在8i 中没有和servlet 和jsp 的引擎在本地，这样在web server 访问EJB 时实际上是从
外部， JNDI 访问需要先验证身份， 给客户端servlet 程序的移植带来一定的工作量
（OAS 没有这个问题）。
2、在有的机器上jDeveloper3.0 的connection manager 有时连接8i 不能成功， 开发无
法进行。具体原因尚未查明。（在程序中能连接成功）
3、在向8i deploy 时出错时定位错误困难， 提示往往只是complie failed 或deploy
failed 给开发造成困难。
4、稳定性欠佳。较频繁地出现非法访问内存之类的错误
根据以上原因， 可以考虑使用支持EJB1.1 规范的iAS 作为将来程序开发的平台。在别的
平台做实施只需用相应平台的Deploy tools 重新发布EJB.