CORBA规范和CORBA中间件&CORBA中间件的开发过程

最新推荐文章于 2025-07-18 13:11:25 发布

原创最新推荐文章于 2025-07-18 13:11:25 发布 · 2.8k 阅读

11 ·

CC 4.0 BY-SA版权

DEV 专栏收录该内容

35 篇文章

订阅专栏

CORBA规范和CORBA中间件

本篇博客我们介绍一种流行的集成中间件：基于OMG的CORBA中间件以及CORBA规范。

一、OMG：对象管理组织，该组织发布了最有影响的两套规范，一个是UML统一建模语言，另一个就是CORBA规范。OMG的技术规范主要用来支持分布式、异构环境的软件开发项目。这些规范覆盖了从分析、设计到编码、部署、运行和管理的整个软件的开发过程。

二、OMA：对象体系结构，描述了一个基于CORBA的应用系统的基本结构与构成系统的构件的特性。其参考模型为：

在上面的图中我们可以看出，ORB类似于一条系统总线，为其提供互操作的基本支持，同时，我们把系统中的很多对象都划分到不同的组中，根据这些对象的共性按照其基础性分别抽象并标准化为对象服务、通用设计和领域接口。

三、ORB：对象请求代理，在上面的参考模型中所有的系统对象都会附着在一条类似系统总线的东西上，这就是OMA参考模型的核心，负责完成查找请求的对象实现，让对象实现准备好接收请求、传递构成请求的数据等完成远程调用时底层通信任务所需的全部机制。

ORB的体系结构如下：

从上图中可以看到ORB同样采用了Stub/Skeleton结构开支持客户端与分布式对象的交互，这种体系结构不仅提供了动态调用的方式，还支持用不同的程序设计语言实现来实现对象。其中ORB内核是ORB最核心的东西，负责请求的通信设施，每一个ORB产品供应商都有一个自己特有的ORB内核。

四、CORBA的可互操作性：CORBA中间件最大的优势就是对可互操作性具有良好的支持。CORBA支持可互操作性主要包括如下几个层次：

1、不同平台与语言之间的可互操作性：CORBA对于这种互操作性的解决方法包括制定IDL标准及IDL到程序设计语言的映射。

2、不同厂商ORB产品之间的可互操作性：在CORBA2.0版本中引入了GIOP和IIOP，实现了不同供应商的ORB产品之间的可互操作性。

3、不同体型结构之间的可互操作性：一个CORBA对象可通过协议桥接操作一个DCOM对象。OMG通过引入了ESIOP来解决了这一问题。

OMG对象管理组织提供了一系列的标准和规范，本篇中的CORBA规范就是其中的一个，我们根据这种规范来开发中间件，这就是我们今天提到的CORBA中间件，基于CORBA的体系结构就是上面提到了OMA，这种体系结构的核心就是ORB，下篇博客我们介绍CORBA中间件的开发过程。

原文链接：https://blog.youkuaiyun.com/xh921/article/details/44066779

CORBA中间件的开发过程

一、开发前的准备：

虽然CORBA中间件对于异类环境下的可互操作性提高了很好的支持，但是对于不同平台之间的系统移植来说还是一个难题，所以在开发过程中我们还是要尽量避免使用与平台有关的操作系统等。

在CORBA中间件中，分布式对象提供的服务的调用方式分为三种：

1、同步方式：调用时调用者会阻塞直接被调用的服务完成并返回。

2、异步方式：调用者发起调用后不会阻塞，等待服务完成期间可以执行其他操作，调用者通过轮询方式或者服务者发送的事件检测调用完成，服务完成后调用者检查并处理结果，异步方式通常依靠异步消息来实现。

3、单向方式：调用者只是发出调用请求，并不关心调用什么时候完成。

不同的方式适用不同的应用场合，我们根据客户程序的请求选择使用的调用方式。

在分布式系统环境下，我们采用Stub/Skeleton机制，开发者不需要自己编写底层通信，可以把精力集中在业务逻辑方面的开发。

二、CORBA开发过程：

尽管使用不同的ORB产品的具体操作差异很大，但程序员开发一个CORBA应用程序通过会遵循一定的框架，如果所示：

开发步骤如下：

1、编写对象接口：利用OMG的IDL编写对象的规格说明。

2、编译IDL文件：IDL文件的编译是通过IDL编译器将IDL映射到具体程序设计语言，产生客户程序使用的桩代码以及编写对象实现所需的框架代码。

3、编写客户程序：客户程序的编写分为三个步骤：

无论是客户程序还是服务程序，都必须利用ORB进行通信之前初始化ORB，其作用一个是让ORB了解有新的成员加入，以便后继为其提供服务，另一个作用就是获取ORB伪对象的引用，以备将来调用ORB内核提供的操作。所谓伪对象专指在CORBA基础设施中的一个对象。

1、编写对象实现：CORBA的应用程序对象实现采用的方式是继承。

2、编写服务程序：CORBA中有几种典型的服务。服务程序利用可移植对象适配器（POA）激活伺服对象共客户程序使用。服务程序通常是一个循环执行的进程，不断监听客户程序请求并为之服务。

编写服务程序的基本步骤如下：

1）初始化对象请求代理（ORB）

2）用所需策略创建一个可移植对象适配器（POA）。在程序中我们为POA起一个名字，客户程序必须使用相同的POA名字。

3）创建一个提供服务的伺服对象、伺服对象是服务端的本地对象，当伺服对象通过对象适配器注册到ORB后，就成为了一个可供远程调用的CORBA对象。

4）激活新创建的伺服对象。

5）激活POA管理器。

6）等待客户程序发来请求。

如下所示是一个服务程序的编写：

本篇博客整体介绍一下如何开发一个CORBA中间件，客户端与服务端程序应该以怎样的步骤编写。下一篇博客我们讲解在开发过程中关于对象接口的程序编写。

原文链接：https://blog.youkuaiyun.com/xh921/article/details/44138303

CORBA程序的工作流程

工作流程的一些细节

1. Server启动，等待来自Client的请求

Server启动后，它首先生成一个POA(potable object adapter)。然后告诉POA他所能提供的服务，即Servant(Server按照IDL定义所实现的每个对象)。
Server从POA处得到每个Servant的引用OR(Object Reference，类似于句柄)。
Server把自己提供的服务公布出来，这里有两个办法：
将OR转换为一个字符串并输出；
将这个OR绑定到一个简单易理解的名字上，这通过Naming Service完成。
如图所示：

图1：Server启动并注册服务

2. Client调用你定义的对象方法

Client通过象Naming Service查询获得要访问的对象的引用OR(object reference)，或通过一个IOR字符串获得；
Client通过这个引用调用对象的方法，因为OR中有足够的信息来定位一个对象；
这个调用被传递给ORB。
如图所示：

图2：一个Client发出请求

3. 调用的完成

Client端的调用请求通过ORB被传递给正确的Server端的ORB，定位是根据OR实现的；
这个ORB把调用请求交给真正的Server进行处理;
Server又根据OR定位产生这个OR的POA，并把请求传给它；
POA又把请求传给最后真正的Servant，完成调用并返回。

如图所示：

图2：Server对请求进行服务

原文链接：https://blog.youkuaiyun.com/c_spark/article/details/3091863

JAVA&CORBA详解

Java IDL技术在Java平台上添加了CORBA(Common Object Request Broker Architecture)功能，提供了基于标准的互操作能力和连接性。Java IDL技术使得分布式的Java Web应用能够通过使用工业标准的IDL和IIOP(Internet Inter-ORB Protocol)来透明地调用远程网络服务的操作。运行时组件(Runtime Components)包括了一个用于分布式计算且使用IIOP通信的Java ORB.

可移植对象适配器（Portable Object Adapter，POA）
CORBA对象的负责分隔服务器端远程调用句柄（handler）到远程对象和它的服务者（servant）。对象由远程调用所暴露，而服务者包含实际处理这些请求的方法。每个对象都可以选择服务者为静态的（一次）或动态的（每个远程调用），在这两种情况下，都允许调用转移到另一台服务器。
在服务器端，POA形成了类似树状的结构，每个POA都负责一到多个服务的对象。树的分支可以是独立活动的、或钝化的，服务者调用有不同的代码和不同的请求处理策略。

API规范
    * org.omg.CORBA 包 - 提供了OMG CORBA APIs到Java编程语言的映射
    * org.omg.CosNaming 包 - 为Java IDL提供命名服务
    * org.omg.PortableServer 包 - 为建立服务器端的可移植的、跨越多ORB的应用程序提供类和接口
    * org.omg.PortableInterceptor 包 - 提供了注册ORB钩子的机制，此钩子通过ORB服务能截取正常的ORB执行流
    * org.omg.DynamicAny 包 - 提供了使得任何值都能被动态解释（或遍历）和通过DynAny对象构造出来的类和接口
    * org.omg.CORBA.ORB - 为CORBA ORB功能的API

分布式对象之间的关系有两方面：客户端和服务器。
服务器提供远程接口，客户端调用远程接口。
在客户端，应用程序包括远程对象的引用。该对象引用有stub方法，它是独立的远程方法。stub方法实际连接到ORB，因此调用它实际上转发调用到服务器。
在服务器端，ORB使用skeleton代码翻译远程调用为本地对象的方法调用。Skeleton把调用转换成指定实现的格式，并在方法中调用。当方法返回时，Skeleton代码转换方法调用的结果或错误，经ORB送回客户端。

Java IDL开发过程
1）定义远程接口
使用IDL语言为远程对象定义接口。
【Billing.idl源代码】如下：

[java] view plaincopy
// 声明CORBA IDL模块  
module BillingApp{  
 // 声明接口  
 interface Billing{  
  string successBilling();  
  oneway void shutdown();  
 };  
};

2）编译远程接口
使用idlj编译器生成Java语言的stub和skeleton源文件。
idlj编译器缺省只生成客户端的binding代码。如果同时需要客户端的bindings和服务器端的skeletons，必须加上-fall选项。
使用POA(Portable Object Adaptor)的优点：
· 允许编程者构建对象在不同ORB产品之间的可移植实现
· 支持带持久化标识的对象
· 对对象的透明活动提供支持
· 允许单个servant支持多种对象同时标识
注意：确定jdk/bin目录下有：idlj、java、javac、orbd
命令：
idlj -fall Billing.idl
在当前目录下生成BillingApp目录，包含如下六个文件：

Billing.java ————> 此接口包含IDL接口的Java版本。它继承自org.omg.CORBA.Object，提供标准的CORBA对象功能。
BillingHelper.java ————> 此类提供辅助功能，Helper类负责读写数据类型到CORBA流，以及插入和提取数据类型。
BillingHolder.java ————> This final class holds a public instance member of type Billing.
BillingOperations.java ————> 此接口包含successBilling()和shutdown()方法。
BillingPOA.java ————> 此抽象类是基于流的服务器Skeleton，为服务器提供基本的CORBA功能。它继承org.omg.PortableServer.Servant，实现了InvokeHandler接口和BillingOperations接口。服务器类BillingServant继承BillingPOA。
_BillingStub.java ————> 此类是客户端stub，为客户端提供CORBA功能。它继承org.omg.CORBA.Object，提供标准CORBA对象功能。还扩展了BillingOperations接口和org.omg.CORBA.portable.IDLEntity接口。

3）实现服务器端
一旦使用idlj编译器后，就可以使用它产生的Skeleton装配服务器应用程序了。另外要实现远程接口方法，服务器代码应包含启动ORB和等待远程客户端调用的机制。
服务器端由两个类组成，一个是servant，另一个是Server。
servant是BillingImpl类，是Billing IDL接口的实现，每个Billing实例均由BillingImpl实例实现。servant是BillingPOA的子类。
servant包含了IDL定义的所有方法，与通常的Java方法类似。
server类含服务器的main()方法，它：
· 创建和初始化ORB实例
· 获得根POA的引用并激活POAManager
· 创建一个Servant实例（CORBA的Billing对象的实现）并通知ORB
· 获得根命名上下文
· 在命名上下文用“Billing”名注册新对象
· 等待客户端调用此新对象

【BillingImpl.java源码】：

[java] view plaincopy
01.import org.omg.CORBA.ORB;     
02.import BillingApp.*;     
03.class BillingImpl extends BillingPOA{     
04. private ORB orb;     
05. public void setORB(ORB orb_val){     
06.  this.orb = orb_val;     
07. }     
08. /**   
09.  * 实现successBilling()方法   
10.  */    
11. public String successBilling() {     
12.  return "/nBilling success!!/n";     
13. }     
14. /**   
15.  * 实现shutdown()方法   
16.  */    
17. public void shutdown(){     
18.  orb.shutdown(false);     
19. }     
20.}    
import org.omg.CORBA.ORB;  
import BillingApp.*;  
class BillingImpl extends BillingPOA{  
 private ORB orb;  
 public void setORB(ORB orb_val){  
  this.orb = orb_val;  
 }  
 /** 
  * 实现successBilling()方法 
  */  
 public String successBilling() {  
  return "/nBilling success!!/n";  
 }  
 /** 
  * 实现shutdown()方法 
  */  
 public void shutdown(){  
  orb.shutdown(false);  
 }  
}

【BillingServer.java源码】：

[java] view plaincopy
view plaincopy to clipboardprint?  
01.import org.omg.CORBA.ORB;     
02.import org.omg.CosNaming.NameComponent;     
03.import org.omg.CosNaming.NamingContextExt;     
04.import org.omg.CosNaming.NamingContextExtHelper;     
05.import org.omg.PortableServer.POA;     
06.import BillingApp.*;     
07.public class BillingServer {     
08. public static void main(String args[]){     
09.  try{     
10.   // 创建和初始化ORB     
11.   ORB orb = ORB.init(args, null);     
12.   // 获得根POA的引用并激活POAManager     
13.   POA rootpoa = (POA)orb.resolve_initial_references("RootPOA");     
14.   rootpoa.the_POAManager().activate();     
15.   // 创建servant并注册到ORB     
16.   BillingImpl billingImpl = new BillingImpl();     
17.   billingImpl.setORB(orb);     
18.   // 从servant获得对象引用     
19.   org.omg.CORBA.Object ref = rootpoa.servant_to_reference(billingImpl);     
20.   Billing href = BillingHelper.narrow(ref);     
21.   // 得到根命名上下文     
22.   org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");     
23.   // 使用命名上下文，它是互操作命名服务规范的一部分     
24.   NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);     
25.   // 在命名中绑定对象引用     
26.   String name = "Billing";     
27.   NameComponent path[] = ncRef.to_name(name);     
28.   ncRef.rebind(path, href);     
29.   System.out.println("BillingServer is ready and waiting...");     
30.   // 等待客户端调用     
31.   orb.run();     
32.  }catch(Exception e){     
33.   System.err.println("ERROR:"+e);     
34.   e.printStackTrace(System.out);     
35.  }     
36.  System.out.println("BillingServer Exiting ...");     
37. }     
38.}    
import org.omg.CORBA.ORB;  
import org.omg.CosNaming.NameComponent;  
import org.omg.CosNaming.NamingContextExt;  
import org.omg.CosNaming.NamingContextExtHelper;  
import org.omg.PortableServer.POA;  
import BillingApp.*;  
public class BillingServer {  
 public static void main(String args[]){  
  try{  
   // 创建和初始化ORB  
   ORB orb = ORB.init(args, null);  
   // 获得根POA的引用并激活POAManager  
   POA rootpoa = (POA)orb.resolve_initial_references("RootPOA");  
   rootpoa.the_POAManager().activate();  
   // 创建servant并注册到ORB  
   BillingImpl billingImpl = new BillingImpl();  
   billingImpl.setORB(orb);  
   // 从servant获得对象引用  
   org.omg.CORBA.Object ref = rootpoa.servant_to_reference(billingImpl);  
   Billing href = BillingHelper.narrow(ref);  
   // 得到根命名上下文  
   org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");  
   // 使用命名上下文，它是互操作命名服务规范的一部分  
   NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);  
   // 在命名中绑定对象引用  
   String name = "Billing";  
   NameComponent path[] = ncRef.to_name(name);  
   ncRef.rebind(path, href);  
   System.out.println("BillingServer is ready and waiting...");  
   // 等待客户端调用  
   orb.run();  
  }catch(Exception e){  
   System.err.println("ERROR:"+e);  
   e.printStackTrace(System.out);  
  }  
  System.out.println("BillingServer Exiting ...");  
 }  
}

4）实现客户端
与第三步类似，可以使用idlj产生的stub作为客户端应用程序的基础。客户端代码建立于stub之上，启动ORB，使用服务器提供的命名服务查询，获得远程对象的引用，调用其方法。
【BillingClient.java源码】：

[java] view plaincopy
01.import org.omg.CORBA.ORB;     
02.import org.omg.CosNaming.NamingContextExt;     
03.import org.omg.CosNaming.NamingContextExtHelper;     
04.import BillingApp.*;     
05.public class BillingClient {     
06. static Billing billingImpl;     
07. public static void main(String args[]){     
08.  try{     
09.   // 创建和初始化ORB     
10.   ORB orb = ORB.init(args, null);     
11.   System.out.println("ORB initialised");     
12.   // 获得根命名上下文     
13.   org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");     
14.   // 使用NamingContextExt代替命名上下文，它是互操作命名服务的一部分     
15.   NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);     
16.   // 在命名中解析对象引用     
17.   String name = "Billing";     
18.   billingImpl = BillingHelper.narrow(ncRef.resolve_str(name));     
19.        
20.   System.out.println("Obtained a handle on server object: "+billingImpl);     
21.   System.out.println(billingImpl.successBilling());     
22.   billingImpl.shutdown();     
23.  }catch(Exception e){     
24.   System.out.println("ERROR: "+e);     
25.   e.printStackTrace(System.out);     
26.  }     
27. }     
28.}    
import org.omg.CORBA.ORB;  
import org.omg.CosNaming.NamingContextExt;  
import org.omg.CosNaming.NamingContextExtHelper;  
import BillingApp.*;  
public class BillingClient {  
 static Billing billingImpl;  
 public static void main(String args[]){  
  try{  
   // 创建和初始化ORB  
   ORB orb = ORB.init(args, null);  
   System.out.println("ORB initialised");  
   // 获得根命名上下文  
   org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");  
   // 使用NamingContextExt代替命名上下文，它是互操作命名服务的一部分  
   NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);  
   // 在命名中解析对象引用  
   String name = "Billing";  
   billingImpl = BillingHelper.narrow(ncRef.resolve_str(name));  
     
   System.out.println("Obtained a handle on server object: "+billingImpl);  
   System.out.println(billingImpl.successBilling());  
   billingImpl.shutdown();  
  }catch(Exception e){  
   System.out.println("ERROR: "+e);  
   e.printStackTrace(System.out);  
  }  
 }  
}

5）启动应用程序
要运行服务器和客户端，必须先启动命名服务，再启动服务器，最后运行客户端。
此例用到命名服务，它使得servant对象的操作对客户端有效。服务器需要命名服务的对象引用，命名服务可以发布对象引用实现各种接口。客户端使用对象引用来调用方法。
Java SE 1.4以上提供了两种可选的命名服务：
· tnameserv
一种透明的命名服务
· orbd
包含自启动服务、透明的命名服务、持久化命名服务和命名管理器的后台处理进程。
本例使用orbd。

5.1）启动orbd
注意：Solaris系统运行要求root权限并以1024端口开始进程。因此，对所有OS，可以选用大于或等于1024的端口以实现统一。
-ORBInitialPort选项用于指定端口（非缺省状态）。
例如：假定使用1050端口的Java ORB Daemon（orbd），命令如下：
start orbd -ORBInitialPort 1050 -ORBInitialHost localhost

5.2）开始Billing服务器
java BillingServer -ORBInitialPort 1050 -ORBInitialHost localhost
注：如在同一台主机上运行，可省略-ORBInitialHost localhost

5.3）运行客户端应用程序
java BillingClient -ORBInitialPort 1050 -ORBInitialHost localhost

原文链接：https://blog.youkuaiyun.com/zacklin/article/details/8207673

分布式技术比较(RPC,CORBA,WebService)

1、RPC（Remote Procedure Call Protocol）

RPC是由Sun发明的远程过程调用协议，是第一种真正的分布式应用模型。面向过程

2、CORBA（Common Object Request Broker Architecture）

CORBA从概念上扩展了RPC。用RPC开发的分布式应用是面向过程的，而CORBA是完全面向对象的，企业级的

3、Web Service

使用XML来描述所有数据，具有通用、可交互的优势，因为使用HTTP协议来传输数据，具有跨平台、跨网络的特点

4、选择方式

最简单的通信，可以直接用Socket编程来实现；

对分布式要求较高的应用，可以考虑使用RPC；

在面向对象（双方语言都是面向对象的）的环境下，可以选用CORBA或DCOM；

当我们要在不同的网络和平台之间搭建开放的分布式应用系统时，Web Service就是最好的选择了

RPC(remote produce calL)
RPC是远程过程调用协议，它是基于C/S模型调用的机制，客户机向服务器端发送调用请求等待服务器应答，是一种典型的请求应答机制，大致过程可以理解为本地分布式对象向本机发请求，不用自己编写底层通信本机会通过网络向服务器发送请求，服务器对象接受参数后，经过处理再把处理后的结果发送回客户端。

它是早期的支持分布式一些，缺点rpc是面向过程的远程调用，不支持面向对象，所以现在用的人就少了。

不支持异步调用
RMI(remote method invocation)
rmi也是远程方法调用，似乎和RPC一样都是调用远程的方法，我们可以把RMI看作是用java语言实现了RPC协议，由于RPC不支持对象通信，这也是RMI比RPC的优越之处，支持对象传输。

它遵循的不是SOAP协议，而是JRMP（java remote message protocol）转为java对象所制定的一个协议，可以运行在任何用java语言写的系统上，具有跨平台特性，它不能跨语言。

既然用只支持java那么它也有了java对象的很多特性，如果垃圾回收、面向对象等。

RMI 采用stubs (客户机)和 skeletons (框架)来进行远程对象(remote object)的通讯。stub 充当远程对象的客户端代理，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端代理对象stub来完成的，效果和调用本地对象一样。

传输的数据一般是java对象，而不是XML格式的数据。

优点：支持分布式对象、跨平台，stubs/skeletons机制；缺点：不能跨语言。

JMS(java remote service)
jms是在各个java类（包括ejb类）之间传递消息的中间件，好比给我们送信的邮递员，在各个人之间收发信件。

支持两种消息模型P2P和pub/stub，即点对点和发布订阅模型。

传输的是一种消息移植机制，将消息从一个客户机移动到另一个终端。

优点：支持异步通信、消息produce和recept松耦合。

EJB(enterprise java bean)
ejb是java EE 中的一个规范，该规范描述了分布式应用程序需要解决的问题，例如事务处理、安全、日志、分布式等，而同时呢，sun公司也实现了自己定义的这一个标准，相当于自己颁布一个标准然后，又给出了实现供别人使用，实现以很多API的方式提供给用的人。

ejb是按照java服务器接口定义的java类，可以理解为一个特殊的java类，放在容器里容器可以帮助该类管理事务、分布式、安全等，一般小的程序不会用到，只有大型分布式系统才会用到ejb，既然ejb是一个java类或是一个组件，颗粒较小，这也是与Webservice的区别之一，下面会说到，它就可以被其它一个或多个模块调用。

包含了三种类型的Bean，可以通过注释JPA一个规范来标记,其中有一种Bean，叫MDB消息驱动bean，它的通信机制涉及到了JMS协议。

ejb可以进行远程调用，但是不能够跨语言，ejb是同步调用，而平时我们说的的ejb异步调用指的是ejb的MDB异步通信。

Web Service
Web service是一种网络间跨平台、跨语言的分布式系统间通信的标准。传输的数据位XML、json等格式的数据，应用范围广。

Web Service大体上分为5个层次:

1. Http传输信道

2. XML的数据格式

3. SOAP封装格式

4. WSDL的描述方式

5. UDDI UDDI是一种目录服务，企业可以使用它对Webservices进行注册和搜索

EJB与JMS的关系
它们其实是没有多大关系的，它们都是java EE的规范，ejb的一种类MDB实现了JMS规范，当然是先JMS规范的不止有ejb的mdb，比如apache ActiveMQ也实现了JMS规范，我们平时用的是实现了JMS的产品，而不是JMS规范。

Web service与EJB
对这两个常常有点迷惑人，因为他们都实现了分布式应用调用，虽然他们很相似但是还是有很多区别的，首先通信协议是不一样的，ejb采用rmi-iiop协议，Web service利用http协议传输数据，优点常识的都知道http协议支持的较广泛，从这点来看Web Service层次要高一些、俗话说站得高看得远。

Webservice主要关注于解决异构系统、不同语言系统通信，其关注的是分布式服务开发、着手点要高、站的角度高，而ejb可以看做是分布式编程平台，通过容器和组件，简化了程序开发、调试和部署等它关注的是分布式组件开发，粒度小。

Web service可以看做是异构系统、异构语言系统间通信的一个标准，而ejb只属于J2EE规范的一部分。

ejb底层用rmi-iiop协议进行通信，防火墙会阻止；web service是基于http协议进行通信，防火墙不会阻止。

SOA与Web Service
SOA 是面向服务体系架构，是一种编程思想，SOA不是Web Service，WebService是目前最适合实现SOA的技术。

小结
这些通信标准或实现各有个的优点和缺点，在实际使用中根据具体情况合理选择。

原文链接：https://blog.youkuaiyun.com/xls51314202005/article/details/84696499