因为对CORBA分析的需要，这里写一个简单的CORBA例子。从JDK1.2开始，JDK中集成了ORB的实现，本例子使用了JDK1.7，对于JDK1.2+应该都没有问题。这个例子实现一个简单的加减乘除的功能的计算器，客户端将参数和请求的方法名传送到服务端，服务端处理这个请求并将结果返回给客户端。
我们知道不同编程语言中的类型的表达，内存模型是不一样的，为此CORBA发明了一套中间描述语言IDL，不同语言平台的ORB实现负责将IDL中的类型映射到本地类型中。因此IDL是我们编写CORBA程序的出发点，首先，我们用IDL来描述我们的接口/对象：
module com{
module bes{
module corba{
module test{
interface Calc{
void add(in long a,in long b,out long c);
void sub(in long a,in long b,out long c);
void multi(in long a,in long b,out long c);
void div(in long a,in long b,out long c);
};
};
};
};
};
当然接口Calc中的方法的返回值不一定为void，这里将返回值放到了out类型的参数c中，方法可以带有多个out类型的参数。然后我们用idlj工具（jdk自带）将Calc.idl转换为对应java的描述，并生成Stub和POA等类：
idlj给我们生成很多文件，首先我们来看一下UML图：
上面的图不涉及工具类CalcHelper和CalcHolder，这两个类的作用在后而阐述。
package com.bes.corba.test; /**
* com/bes/corba/test/_CalcStub.java .
* 由IDL-to-Java 编译器 (可移植), 版本 "3.2"生成
* 从Hello.idl
* 2016年2月15日 星期一 下午09时08分34秒 CST
*/ public class _CalcStub extends org.omg.CORBA.portable.ObjectImpl implements com.bes.corba.test.Calc
{ public void add (int a, int b, org.omg.CORBA.IntHolder c)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("add", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
c.value = $in.read_long ();
return;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
add (a, b, c );
} finally {
_releaseReply ($in);
}
} // add public void sub (int a, int b, org.omg.CORBA.IntHolder c)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("sub", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
c.value = $in.read_long ();
return;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
sub (a, b, c );
} finally {
_releaseReply ($in);
}
} // sub public void multi (int a, int b, org.omg.CORBA.IntHolder c)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("multi", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
c.value = $in.read_long ();
return;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
multi (a, b, c );
} finally {
_releaseReply ($in);
}
} // multi public void div (int a, int b, org.omg.CORBA.IntHolder c)
{
org.omg.CORBA.portable.InputStream $in = null;
try {
org.omg.CORBA.portable.OutputStream $out = _request ("div", true);
$out.write_long (a);
$out.write_long (b);
$in = _invoke ($out);
c.value = $in.read_long ();
return;
} catch (org.omg.CORBA.portable.ApplicationException $ex) {
$in = $ex.getInputStream ();
String _id = $ex.getId ();
throw new org.omg.CORBA.MARSHAL (_id);
} catch (org.omg.CORBA.portable.RemarshalException $rm) {
div (a, b, c );
} finally {
_releaseReply ($in);
}
} // div // Type-specific CORBA::Object operations
private static String[] __ids = {
"IDL:com/bes/corba/test/Calc:1.0"}; public String[] _ids ()
{
return (String[])__ids.clone ();
} private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
{
String str = s.readUTF ();
String[] args = null;
java.util.Properties props = null;
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init (args, props);
try {
org.omg.CORBA.Object obj = orb.string_to_object (str);
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
_set_delegate (delegate);
} finally {
orb.destroy() ;
}
} private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException
{
String[] args = null;
java.util.Properties props = null;
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init (args, props);
try {
String str = orb.object_to_string (this);
s.writeUTF (str);
} finally {
orb.destroy() ;
}
}
} // class _CalcStub
_CalcStub是存根类，有过远程调用编程经验的读者应该对这个词比较熟悉，它是远程对象在本地的一个代理（Proxy）。从业务划分角度来说，CORBA这些底层的东西不应该太多地污染到我们的应用，比如这个_CalcStub是我们不希望在业务代码中出现的，我们只需要看到我们需要的Calc。客户端从ORB中拿到的Calc接口实现其实是一个_CalcStub，客户程序对Calc接口中的方法进行调用时，_CalcStub将相应方法的调用转发到服务端，然后将服务器的响应返回给客户端，从而成功从欺骗客户端程序。
_CalcStub继承了ObjectImpl类，这使得_CalcStub能够关联到ORB环境中，从而完成远程调用。
idlj工具并没有直接在Calc.java中定义idlj方法的java语言描述，而是在CalcOperation.java中。Calc接口继承了IDLEntity，org.omg.CORBA.Object和CalcOperation三个接口：
IDLEntity是一个标记接口，表明Calc接口是一种IDL接口，这个与org.omg.CORBA.Object有点相类似，但实现了org.omg.CORBA.Object接口的对象不一定是IDL描述的，因此这里单独把IDLEntity拎出来。
org.omg.CORBA.Object接口定义了一些CORBA相关的方法，因为客户端所使用的是Calc，参数传递到ORB中语义上也是 Calc类型，当然我们不能将非IDL的对象传递到ORB中，ORB无法完成那样子的操作；Calc接口继承 org.omg.CORBA.Object（ORB层面使用的是org.omg.CORBA.Object），那就意味了通过编译器来保证类型安全（避免 强制转换，ClassCastException之类的异常）。
package com.bes.corba.test; /**
* com/bes/corba/test/CalcOperations.java .
* 由IDL-to-Java 编译器 (可移植), 版本 "3.2"生成
* 从Hello.idl
* 2016年2月15日 星期一 下午09时08分34秒 CST
*/ public interface CalcOperations
{
void add (int a, int b, org.omg.CORBA.IntHolder c);
void sub (int a, int b, org.omg.CORBA.IntHolder c);
void multi (int a, int b, org.omg.CORBA.IntHolder c);
void div (int a, int b, org.omg.CORBA.IntHolder c);
} // interface CalcOperations
CalcOperation是相对应的IDL映射。
package com.bes.corba.test; /**
* com/bes/corba/test/CalcPOA.java .
* 由IDL-to-Java 编译器 (可移植), 版本 "3.2"生成
* 从Hello.idl
* 2016年2月15日 星期一 下午09时08分34秒 CST
*/ public abstract class CalcPOA extends org.omg.PortableServer.Servant
implements com.bes.corba.test.CalcOperations, org.omg.CORBA.portable.InvokeHandler
{ // Constructors private static java.util.Hashtable _methods = new java.util.Hashtable ();
static
{
_methods.put ("add", new java.lang.Integer (0));
_methods.put ("sub", new java.lang.Integer (1));
_methods.put ("multi", new java.lang.Integer (2));
_methods.put ("div", new java.lang.Integer (3));
} public org.omg.CORBA.portable.OutputStream _invoke (String $method,
org.omg.CORBA.portable.InputStream in,
org.omg.CORBA.portable.ResponseHandler $rh)
{
org.omg.CORBA.portable.OutputStream out = null;
java.lang.Integer __method = (java.lang.Integer)_methods.get ($method);
if (__method == null)
throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE); switch (__method.intValue ())
{
case 0: // com/bes/corba/test/Calc/add
{
int a = in.read_long ();
int b = in.read_long ();
org.omg.CORBA.IntHolder c = new org.omg.CORBA.IntHolder ();
this.add (a, b, c);
out = $rh.createReply();
out.write_long (c.value);
break;
} case 1: // com/bes/corba/test/Calc/sub
{
int a = in.read_long ();
int b = in.read_long ();
org.omg.CORBA.IntHolder c = new org.omg.CORBA.IntHolder ();
this.sub (a, b, c);
out = $rh.createReply();
out.write_long (c.value);
break;
} case 2: // com/bes/corba/test/Calc/multi
{
int a = in.read_long ();
int b = in.read_long ();
org.omg.CORBA.IntHolder c = new org.omg.CORBA.IntHolder ();
this.multi (a, b, c);
out = $rh.createReply();
out.write_long (c.value);
break;
} case 3: // com/bes/corba/test/Calc/div
{
int a = in.read_long ();
int b = in.read_long ();
org.omg.CORBA.IntHolder c = new org.omg.CORBA.IntHolder ();
this.div (a, b, c);
out = $rh.createReply();
out.write_long (c.value);
break;
} default:
throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);
} return out;
} // _invoke // Type-specific CORBA::Object operations
private static String[] __ids = {
"IDL:com/bes/corba/test/Calc:1.0"}; public String[] _all_interfaces (org.omg.PortableServer.POA poa, byte[] objectId)
{
return (String[])__ids.clone ();
} public Calc _this()
{
return CalcHelper.narrow(
super._this_object());
} public Calc _this(org.omg.CORBA.ORB orb)
{
return CalcHelper.narrow(
super._this_object(orb));
} } // class CalcPOA
CalcPOA：它工作在服务端，POA是Portable Object Adapter的缩写，这里Adapter（适配器）的语义是指适配相应的编程语言中的对象（比如在java中那意思就是指 Java对象的适配器），适配器的作用有三点：
1：接受客户端发过来的调用请求，反序列化（Unmarshalling）参数，方法名等，然后将请求分发给对应的Servant。POA和Servant之间的关系如下图。
2：将对象引用（Object Reference）和相应的Servant起来（可以看到Servant._object_id方法），比如我们在EJB中的有状态会话Bean。
3：负责Servant的生命周期管理（如创建，钝化，销毁等），这里又让我联想到了EJB的生命周期。到这里这里我们可以清楚Home接口存在的理由。
好吧，我们要实现的例子确实很简单，在这个例子中，读者只需要了解到第一点即可（CORBA水很深，很容易死里面去的）。idlj为我们生成的POA中，集Servant，CalcOperation和InvocationHandler于一身，有越殂代疱的嫌疑，当然这并不影响程序的正常执行，当然如果服务端比较关注2，3两点的话，自己实现POA还是很有必要的，但这已经超出了本文的范围。
同样地ORB的东西不应该玷污到我们服务端的业务逻辑 ，Servant和InvocationHandler将POA关联到ORB中去。注意Servant和InvocationHandler是两接口是分开的，这一点还不是太清楚（也许是为了特性的划分吧）。
package com.bes.corba.test; /**
* com/bes/corba/test/CalcHelper.java .
* 由IDL-to-Java 编译器 (可移植), 版本 "3.2"生成
* 从Hello.idl
* 2016年2月15日 星期一 下午09时08分34秒 CST
*/ abstract public class CalcHelper
{
private static String _id = "IDL:com/bes/corba/test/Calc:1.0"; public static void insert (org.omg.CORBA.Any a, com.bes.corba.test.Calc that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
} public static com.bes.corba.test.Calc extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
} private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().create_interface_tc (com.bes.corba.test.CalcHelper.id (), "Calc");
}
return __typeCode;
} public static String id ()
{
return _id;
} public static com.bes.corba.test.Calc read (org.omg.CORBA.portable.InputStream istream)
{
return narrow (istream.read_Object (_CalcStub.class));
} public static void write (org.omg.CORBA.portable.OutputStream ostream, com.bes.corba.test.Calc value)
{
ostream.write_Object ((org.omg.CORBA.Object) value);
} public static com.bes.corba.test.Calc narrow (org.omg.CORBA.Object obj)
{
if (obj == null)
return null;
else if (obj instanceof com.bes.corba.test.Calc)
return (com.bes.corba.test.Calc)obj;
else if (!obj._is_a (id ()))
throw new org.omg.CORBA.BAD_PARAM ();
else
{
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl)obj)._get_delegate ();
com.bes.corba.test._CalcStub stub = new com.bes.corba.test._CalcStub ();
stub._set_delegate(delegate);
return stub;
}
} public static com.bes.corba.test.Calc unchecked_narrow (org.omg.CORBA.Object obj)
{
if (obj == null)
return null;
else if (obj instanceof com.bes.corba.test.Calc)
return (com.bes.corba.test.Calc)obj;
else
{
org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl)obj)._get_delegate ();
com.bes.corba.test._CalcStub stub = new com.bes.corba.test._CalcStub ();
stub._set_delegate(delegate);
return stub;
}
} }
CalcHelper：从名字上可以看出，它是一个工具类，它的职责在有：
1、通过提供narrow方法和RepositoryId等信息来实现类型安全。
2、与Any类型之间的进行转换。
3、从InputStream中读出Calc（对象引用），将Calc写出到OutputStream中。
我们的例子中将只用到第一点。
package com.bes.corba.test; /**
* com/bes/corba/test/CalcHolder.java .
* 由IDL-to-Java 编译器 (可移植), 版本 "3.2"生成
* 从Hello.idl
* 2016年2月15日 星期一 下午09时08分34秒 CST
*/ public final class CalcHolder implements org.omg.CORBA.portable.Streamable
{
public com.bes.corba.test.Calc value = null; public CalcHolder ()
{
} public CalcHolder (com.bes.corba.test.Calc initialValue)
{
value = initialValue;
} public void _read (org.omg.CORBA.portable.InputStream i)
{
value = com.bes.corba.test.CalcHelper.read (i);
} public void _write (org.omg.CORBA.portable.OutputStream o)
{
com.bes.corba.test.CalcHelper.write (o, value);
} public org.omg.CORBA.TypeCode _type ()
{
return com.bes.corba.test.CalcHelper.type ();
} }
CalcHolder：这个类在Calc被作为out或者inout类型的参数传递时候被使用，如果我们在另一个IDL方法中使用Calc作为参数，那么生成的代码将会是这样子的：
void test(int a, int b, CalcHolder calc)
CalcHolder负责从InputStream或者OuputStream分别读出和写入Calc，从CalcHolder生成的代码中我们可以看出，CalcHolder的_read和_write方法将相应的操作委托给了CalcHelper。
哆嗦了这么多，是时候拿出我们的客户端和服务端了。
服务端代码：
CalculatorImpl是Servant的实现，它继承了CalcPOA类。
package com.bes.corba.impl;
import org.omg.CORBA.IntHolder;
import com.bes.corba.test.CalcPOA;
public class CalculatorImpl extends CalcPOA{
@Override
public void add(int a, int b, IntHolder c) {
c.value=a+b;
}
@Override
public void sub(int a, int b, IntHolder c) {
c.value=a-b;
}
@Override
public void multi(int a, int b, IntHolder c) {
c.value=a*b;
}
@Override
public void div(int a, int b, IntHolder c) {
c.value=a/b;
}
}
Server类:
package com.bes.corba.test; 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 org.omg.PortableServer.POAHelper; import com.bes.corba.test.Calc;
import com.bes.corba.test.CalcHelper;
import com.bes.corba.impl.CalculatorImpl; public class Server {
public static void main(String[] args) throws Exception{
/*
* ORB 初始化。
*/
ORB orb=ORB.init(args,null); /*
* 获取根POA并初始化。
*/
POA rootPoa=POAHelper.narrow(orb.resolve_initial_references("RootPOA") );
rootPoa.the_POAManager().activate(); /*
* 构建一个CalculatorImpl。
*/
CalculatorImpl calculatorImpl=new CalculatorImpl(); /*
* 将Servant注册到RootPOA中，建立Servant到Object Reference的相互映射，
* 注意这里具体行为跟RootPOA的POA Policy有关。
*/
org.omg.CORBA.Object ref=rootPoa.servant_to_reference(calculatorImpl);
Calc iref=CalcHelper.narrow(ref); /*
* 获取命名服务。
*/
org.omg.CORBA.Object objRef=orb.resolve_initial_references("NameService");
NamingContextExt ncRef= NamingContextExtHelper.narrow(objRef); /*
* 将对象引用以相应的名字发布到命名服务中。
*/
String name="Calc";
NameComponent path[] = ncRef.to_name(name);
ncRef.rebind(path,iref); System.out.println("Calculator server ready..."); /*
* 阻塞直到ORB关闭。
*/
orb.run();
}
}
客户端代码Client
package com.bes.corba.test; import org.omg.CORBA.IntHolder;
import org.omg.CORBA.ORB;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper; import com.bes.corba.test.Calc;
import com.bes.corba.test.CalcHelper; public class Client {
public static void main(String[] args) throws Exception{
/*
* ORB 初始化。
*/
ORB orb=ORB.init(args,null); /*
* 获取命名服务。
*/
org.omg.CORBA.Object objRef=orb.resolve_initial_references("NameService");
NamingContextExt ncRef=NamingContextExtHelper.narrow(objRef); /*
* 从命名服务中查找相应的对象引用，并进行类型转型。
*/ String name="Calc";
Calc calc=CalcHelper.narrow(ncRef.resolve_str(name)); /*
* 调用对象的方法。
*/
IntHolder result=new IntHolder(); calc.add(1,2,result);
System.out.printf("1+2=%d\n",result.value);
}
}
启动命名服务，命名服务器不一定运行在对象服务器的进程中，尤其是在一个分布式的环境中，命名服务器与对象服务器通常是一对多的关系。
orbd -ORBInitialPort 1050 -ORBInitialHost localhost&
启动服务端：
java HelloServer -ORBInitialPort 1050 -ORBInitialHost localhost
ORBInitialPort和ORBInitialHost参数指定了命名服务器的主机名和端口号。
启动客户端：
java com.bes.corba.test.Client -ORBInitialPort 1050 -ORBInitialHost localhost