1. module Demo{  
2. interface test{  
3.  string   execute(string mth,string cmd);  
4. };  
5. };  

1. //TestImp.java  
2. package Demo;  
3.   
4. import Ice.Current;  
5.   
6.   
7. public class TestImp extends _testDisp{  
8.   
9.     public String execute(String mth, String cmd, Current __current) {  
10.         // TODO Auto-generated method stub  
11.         return mth+cmd;  
12.     }  
13.   
14.   
15.   
16. }  

1. //Server.java  
2. package Demo;  
3.   
4. public class Server {  
5.     public static void main(String[] args) {  
6.         int status = 0;  
7.         Ice.Communicator ic = null;  
8.         try {  
9.             ic = Ice.Util.initialize(args);  
10.             Ice.ObjectAdapter adapter = ic.createObjectAdapterWithEndpoints(  
11.                     "TestAdapter", "default -p 10000");  
12.             Ice.Object object = new TestImp();  
13.             adapter.add(object, ic.stringToIdentity("TestAdapter"));  
14.             adapter.activate();  
15.             ic.waitForShutdown();  
16.         } catch (Ice.LocalException e) {  
17.             e.printStackTrace();  
18.             status = 1;  
19.         } catch (Exception e) {  
20.             System.err.println(e.getMessage());  
21.             status = 1;  
22.         }  
23.         if (ic != null) {  
24.             // Clean up  
25.             //  
26.             try {  
27.                 ic.destroy();  
28.             } catch (Exception e) {  
29.                 System.err.println(e.getMessage());  
30.                 status = 1;  
31.             }  
32.         }  
33.         System.exit(status);  
34.     }  
35. }  

1. package Demo;  
2.   
3. public class Client {  
4.     public static void main(String[] args) {  
5.         int status = 0;  
6.         Ice.Communicator ic = null;  
7.         try {  
8.             ic = Ice.Util.initialize(args);  
9. //          Ice.ObjectPrx base = ic  
10. //                  .stringToProxy("SimplePrinter:tcp -h 172.17.12.101 -p 10000");  
11.             Ice.ObjectPrx base = ic  
12.             .stringToProxy("TestAdapter:default -p 10000");  
13.   
14.             testPrx test = testPrxHelper.checkedCast(base);  
15.             if (test == null)  
16.                 throw new Error("Invalid proxy");  
17.             System.out.println(test.execute("My first Ice ", "demo"));  
18.             //System.out.println("ok");  
19.         } catch (Ice.LocalException e) {  
20.             e.printStackTrace();  
21.             status = 1;  
22.         } catch (Exception e) {  
23.             System.err.println(e.getMessage());  
24.             status = 1;  
25.         }  
26.         if (ic != null) {  
27.             // Clean up  
28.             //  
29.             try {  
30.                 ic.destroy();  
31.             } catch (Exception e) {  
32.                 System.err.println(e.getMessage());  
33.                 status = 1;  
34.             }  
35.         }  
36.         System.exit(status);  
37.     }  
38. }  

1. System.out.println(test.execute("my first Ice ", "demo"));  

 Slice是在ICE所特有的特殊语言，ICE 提供基于Ice语言的多语言映射工具。Slice主要针对程序所涉及到的接口和类型进行定义。不涉及到具体实现和具体语言的特征。 
   既然ICE支持跨语言的调用，那么是不是Slice支持每种的特有数据类型呢？ 
   当然不是，ICE只是保留各种具体语言数据类型的最小交集。 
提供： 


string 采用Unicode编码，具有很好的国际化语言支持。 

下面主要在介绍一下Slice的特性和约束： 
1. Slice文件必须以.ice结尾，其他结尾方案的文件会被编译器拒绝。 
2. Slice 文件格式实际就是text文本描述，由于Slice形式自由，可以用任何文本编辑器进行编辑。 
3. Slice 支持#ifndef,#define,#endif,#include 
例如： 

在include 要避免使用双引号"",以及"",而要使用"/" 
例如: 
#include "Clock.ice" // 不推荐采用； 
#include <SliceDefs/Clock.ice> // 正确 
#include <SliceDefs\Clock.ice> // 非法 
4.Slice 中文件的结构,模块，接口，类型出现的顺序，，可以按照你的喜好而自由定义。 
5.Slice 的词法规则很多来源于C++和Java，只有少量的差异。 
6.可以采用c++的注释规则。// 或  
7.Slice 的关键词需要区分大小写： 
关键词： 
8.在接口定义的时候也避免使用非Slice关键字，但是C++ 或 Java关键字的标识符。 

例如:switch 

9.Ice保留了所有以"ice"作为开始标识符。保留以"Helper","Holder","Prx","Ptr"结尾的标识符。所以大家定义的时候最好避免一些不必要的麻烦。 

10.Ice可以通过module嵌套的方式，类似于c++的namespace和java的包的概念。 


11.除了刚才提到的Slice支持的基础类型外，还支持用户自定义类型：enumerations, structures, sequences, and dictionaries. 

enumerations:枚举就不要介绍了，采用C++的语法形式 
enum Fruit { Apple, Pear, Orange }; 

Structures:结构，也是采用C++的语法形式，避免，结构中定义结构 

sequence:序列号类型，映射到java采用的数组方式实现，而不是所谓的集合容器类型对象存储。映射到C++中则采用STL容器存储。 
sequence<int> values; 
dictionary:字典类型,映射到java采用Map 进行存储,映射到C++采用map进行存储. 
dictionary<int,string> myValues; 
12.常量定义可以直接使用,但常量的定义必须是基本类型或枚举类型.定义形式也是采用C++定义方式. 
13.方法的定义,形式类型java的方法定义,方法返回可以使void或对象类型. 
14.Slice支持方法异常的定义,以及异常的继承.关于异常机制,我想java开发者可能更加熟悉, 
例如: 

Ice的错误机制也是异常强大,吸取了很多Java关于异常机制的特点. 


Slice还包括很多良好的特性,在这里就不一一列举,对于支持自定义类型,基本类型,异常支持,对于一般的网络通讯应用已经足够了,更多Slice语言的介绍参阅其帮助. 

Ice为我们提供了强大而又丰富的Slice,可以利用Slice,结合我们应用的特点，定义间接的Slice描述。 

btw: 

    虽然Slice提供给我们丰富的功能和特性,在此我还是建议大家尽量采用基本类型和非异常机制.这样会对系统性能会带有一定的帮助。 
    另外接口的定义我想大家能够保持KISS(Keep it It Simple)设计原则，会使我们的应用看起来更美丽。 
    不要过度的使用Slice,否则会给我们带来无尽的烦恼。 

ce的服务端可以采用C++/Java/Python/C#等实现,客户端可以采用C++/Java/Python/C#/VB/PHP/Ruby来实现,就是说我的一个服务端采用C++实现,客户端可以采用java/php/vb/c# 等其他语言实现。 

这个特性也是Ice的很重要的优势之一. 

Ice的多语言之间如何确保对象的正确传输,每种语言都有各自的特点,数据类型,Ice是如何达到各种语言之间的互通互联的呢？ 
那么就一定提到Slice语言.Slice是保证各种语言的互通互联的关键,它是独立于其它任何语言,Ice可以通过把Slice代码片断转化为各自的 

语言描述. 



赫赫够多！ 

Slice的全称:Specification Language for Ice,是Ice自己的特殊语言,一种用于使对象接口与其实现相分离的基础性抽象机制。Slice 建立在客户与服务器之间的合约，用以描述应用所使用的类型和对象接口。Slice描述独立于实现语言，所以客户实现语言是否与编写服务器所用的语言相同没有任何关系。 

slice语言片段可以被编译为任何所支持语言的实现。目前Ice Slice可以支持映射到到C++, Java, C#, Python,Ruby, and PHP。 
因为Slice主要对接口和类型的定义和描述，没有实现部分。 

到底如何实现不同语言的互通互联的呢？我们已Java,C++作为Ice例子原形，实际上我们仅仅做少量修改，就可以实现 

C++的服务端，Java的客户端。Server和Client还是保持在同一台机器上运行。注意我们基于同一个demo.ice的事例。 

首先运行./Server,再运行Client，看到结果了么？赫赫，是不是出现了正常结果。 

到目前没有我们所有实例都是基于同一台机器的，实际情况Server,Client会分布在不同机器上。这种情况下，我们需要如何处理呢？ 


这个很简单，在Server少量修改 


"default -p 10000" 采用 "tcp -h server1 -p port" 替代 

Server所在主机IP:172.17.12.101 ，端口:10000 

所以就修改为：tcp -h 172.17.12.101 -p 10000,再重新编译Server 


编译方式参见： 
http://masterkey.iteye.com/blog/183307 

下面我们需要对Client连接部分进行修改，同理： 



看到了么，就是这么简单，其他部分不用修改。 

好了，我们进行验证，首先启动./Server,再执行Client ,看到了 

"My first Ice 事例" 看到了么，祝贺你，跨语言的分布式调用例子你已经实现了。 


其实Ice的通讯机制极其强大，支持集群和容错技术。关于集群的事例会在日后的文章中介绍。 

BTW: 

注意，Server运行之后监听于10000端口，需要修改iptables，允许其他机器可以连接。 
编辑 iptables 
vi /etc/sysconfig/iptables 
追加： 

ZeroC ICE之旅------负载均衡及容错

Zero ICE我们已经掌握其基本运行原理。下面我们主要介绍一下ICe的多端口邦定的问题。 
ICE使用TCP/IP 和UDP协议，以及基于TCP/IP之上的SSL协议。SSL协议可以充分保障Server/Client数据传输的加密安全性问题。 
在这里，Server如何在同一台主机监听多个端口。 


关于TCP/IP还是UDP还是SSL协议的选择，还是要看具有应用的要求，通常情况下TCP/IP协议的ICE应用已经足够了。 

在同一个主机主机上，ICE服务支持多端口的监听。 

服务端注册： tcp -h host -p port1:tcp -h host -p port2形式， 

例如： 

IP：172.17.12.101，需要在10001和10000同时监听。 

就可以写成: 

tcp -h 172.17.12.101 -p 10000:tcp -h 172.17.12.101 -p 10001 


赫赫是不是很简单，运行之后，服务就监听于10000和10001端口，请注意：避免其他应用相冲突。 


客户端连接可以采用如下3种形式： 

1. tcp -h 172.17.12.101 -p 10000 
2. tcp -h 172.17.12.101 -p 10001 
3. tcp -h 172.17.12.101 -p 10000:tcp -h 172.17.12.101 -p 100001 

是不是很爽。 

无论Server监听在多个端口，还是只有唯一的一个Server在工作， 

对于Client较多的应用或负载要求很高的情况下，我们可以把Server程序运行于多台主机之上。通过集群方式合理有效的化解来自Client的压力。 

例如: 

ServerA 172.17.12.101 tcp -h 172.17.12.101 -p 10000 
ServerB 172.17.12.102 tcp -h 172.17.12.102 -p 10000 
ServerC 172.17.12.103 tcp -h 172.17.12.103 -p 10000 


Client可以如下的连接方式: 
tcp -h 172.17.12.101 -p 10000:tcp -h 172.17.12.102 -p 10000:tcp -h 172.17.12.103 -p 10000 

或是 
tcp -h 172.17.12.101 -p 10000:tcp -h 172.17.12.102 -p 10000 

等多种情况，可以根据应用的具体要求合理有效的构造所需连接主机的字符串。 


这种连接方式是不是很cool。 

其实这种连接方式可以有效地利用ICE提供的load balancing功能,把Client的每个请求合理的分配到每个Server。从而有效地避免了Client大量请求对同一台Server的巨大压力。 


ICE的load balancing主要采用round-robin算法,round-robin是一种非常有效的负载均衡算法. 



大家会问了,如果某个Server如果宕机,那么这个Client还能正常工作么? 

    这个问题问得好,其实ICE自身提供一种极其强大容错技术功能。 
    具体体现在如果当某个Server(假设是ServerA)宕机之后,来自Client的请求分配到ServerA服务器上,Client会自动记录ServerA失效状态,会把请求再分配给可正常工作的Server(ServerB,ServerC),对于用户的每次请求都能分配到正常的服务主机上(除非A,B,C都同时宕机).当ServerA回复正常之后,Client会自动感知ServerA工作状态.Client的请求又可以有效地分配到上述A,B,C主机上.这一切对于开发者都是透明的. 

ICE所提供的集群功能和容错功能是极其强大的. 



   Client状态感知的变化和更新完全不需要Client重新启动。