About neohope

一直在努力,还没想过要放弃...

使用Avro实现RPC简单示例02

接第01部分,本节用来说明C#语言的代码实现。

使用avro生成cs代码之后,会生成三个cs文件,Client与Server需要分别包含这三个文件。

首先是Server端:
1、新建一个Console项目,引用Avro程序集中以下几个dll文件
Avro.dll
Avro.ipc.dll
Castle.Core.dll
log4net.dll
Newtonsoft.Json.dll

2、项目中添加生成的以下几个cs文件
JustATest.cs
Person.cs

3、新建一个类MyAvroServer,实现JustATest接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using com.neohope.avro.test;

namespace TestAvro.com.neohope.avro.test
{
    class MyAvroServer : JustATest
    {
        public override string SayHelloTo(Person person)
        {
            return "Hello " + person.name;
        }

        public override int Add(int a, int b)
        {
            return a + b;
        }
    }
}

4、修改Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using Avro.ipc;
using Avro.ipc.Specific;
using com.neohope.avro.test;
using TestAvro.com.neohope.avro.test;

namespace TestAvro
{
    class Program
    {
        static void Main(string[] args)
        {
            SpecificResponder<JustATest> responder = new SpecificResponder<JustATest>(new MyAvroServer());
            SocketServer server = new SocketServer("localhost", 1900, responder);
            server.Start();

            Console.ReadLine();

            server.Stop();
        }
    }
}

5、编译运行

然后是Client端:
1、新建一个Console项目,引用Avro程序集中以下几个dll文件
Avro.dll
Avro.ipc.dll
Castle.Core.dll
log4net.dll
Newtonsoft.Json.dll

2、项目中添加生成的以下几个cs文件
JustATestCallback.cs
JustATest.cs
Person.cs

3、修改Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Avro.ipc;
using Avro.ipc.Specific;
using com.neohope.avro.test;

namespace TestAvroClient
{
    class Program
    {
        static void Main(string[] args)
        {
            SocketTransceiver transceiver = new SocketTransceiver("localhost", 1900);
            JustATestCallback proxy = SpecificRequestor.CreateClient<JustATestCallback>(transceiver);
            
            Person person = new Person();
            person.sex = "male";
            person.name = "neohope";
            person.address = "shanghai";
            Console.WriteLine(proxy.SayHelloTo(person));
            Console.WriteLine(proxy.Add(1, 2));

            transceiver.Close();
        }
    }
}

4、编译运行

使用Avro实现RPC简单示例01

Avro也是典型CS架构,与ICE、CORBA、Thrift相同,但大家一般不太用其做RPC框架,而多是使用其强大的序列化功能。即使如此,我们也可以将Avro用于RPC通讯,也只需要告诉Avro服务在哪里,需要哪个服务,调用参数是什么,然后就坐等处理结果就好咯。

使用Avro的时候,首先要先下载Avro的开发包,每种序言需要单独下载,都自带编译工具及语言支持包,本例主要用到C#和Java。
Avro

使用新版本Avro的时候,一般显示用IDL语言,定义一个接口描述文件,比如我自己写了一个很简单的接口。
JustATest.avdl

@namespace("com.neohope.avro.test")
protocol JustATest{
  record Person {
    string name;
    int age;
    string sex;
    string address;
  }

  string SayHelloTo(Person person);
  int Add(int a,int b);
}

然后用Avro自带工具,将其翻译为protocol文件
JustATest.avpr

set AVRO_HOME=D:\Build\Avro\avro-java-1.8.0
java -jar %AVRO_HOME%\avro-tools-1.8.0.jar idl JustATest.avdl JustATest.avpr

翻译得到的JustATest.avpr文件如下:

{
  "protocol" : "JustATest",
  "namespace" : "com.neohope.avro.test",
  "types" : [ {
    "type" : "record",
    "name" : "Person",
    "fields" : [ {
      "name" : "name",
      "type" : "string"
    }, {
      "name" : "age",
      "type" : "int"
    }, {
      "name" : "sex",
      "type" : "string"
    }, {
      "name" : "address",
      "type" : "string"
    } ]
  } ],
  "messages" : {
    "SayHelloTo" : {
      "request" : [ {
        "name" : "person",
        "type" : "Person"
      } ],
      "response" : "string"
    },
    "Add" : {
      "request" : [ {
        "name" : "a",
        "type" : "int"
      }, {
        "name" : "b",
        "type" : "int"
      } ],
      "response" : "int"
    }
  }
}

然后,用工具分别编译为java及c#语言

#java
set AVRO_HOME=D:\Build\Avro\avro-java-1.8.0
java -jar %AVRO_HOME%\avro-tools-1.8.0.jar compile protocol JustATest.avpr avpr

#c#
avrogen -p JustATest.avpr avpr-cs

使用Thrift实现RPC简单示例03

接第01部分,本节用来说明Java语言的代码实现。

使用thrift生成java代码之后,会生成两个java文件,无论是Client还是Server都要包含这个文件。

首先是Server端:
1、新建一个java项目,引用libthrift.jar,项目中添加生成的两个java文件。
2、新建一个类MyThriftServer,实现JustATest.Iface接口

package com.neohope.thrift.test;

import org.apache.thrift.TException;

public class MyThriftServer implements JustATest.Iface {
    @Override
    public String SayHelloTo(Person person) throws TException {
        return "Hello "+ person.getName();
    }

    @Override
    public int Add(int a, int b) throws TException {
        return a+b;
    }
}

3、修改TestServer.java

package com.neohope.thrift.test;

import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.transport.TServerSocket;
import org.apache.thrift.transport.TTransportException;

public class TestServer {
    public static void main(String[] args) {
        try {
            TServerSocket serverTransport = new TServerSocket(1900);
            JustATest.Processor process = new JustATest.Processor(new MyThriftServer());
            TBinaryProtocol.Factory portFactory = new TBinaryProtocol.Factory(true, true);
            TThreadPoolServer.Args thriftArgs = new TThreadPoolServer.Args(serverTransport);
            thriftArgs.processor(process);
            thriftArgs.protocolFactory(portFactory);
            TServer server = new TThreadPoolServer(thriftArgs);
            server.serve();
        } catch (TTransportException e) {
            e.printStackTrace();
        }
    }
}

4、编译运行

然后是Client端:
1、新建一个java项目,引用libthrift.jar,项目中添加生成的两个java文件。
2、修改TestClient.java

package com.neohope.thrift.test;

import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

public class TestClient {

    public static void main(String[] args) {
        TTransport transport;
        try {
            transport = new TSocket("localhost", 1900);
            TProtocol protocol = new TBinaryProtocol(transport);
            JustATest.Client client = new JustATest.Client(protocol);
            transport.open();

            Person p = new Person();
            p.setName("neohope");
            System.out.println(client.SayHelloTo(p));
            System.out.println(client.Add(1, 2));
            transport.close();
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        }
    }
}

3、编译运行

使用Thrift实现RPC简单示例02

接第01部分,本节用来说明C#语言的代码实现。

使用thrift生成cs代码之后,会生成两个cs文件,无论是Client还是Server都要包含这个文件。

首先是Server端:
1、新建一个Console项目,引用Thrift程序集中的Thrift.dll,项目中添加生成的两个cs文件。
2、新建一个类MyThriftServer,实现JustATest.Iface接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestThrift
{
    class MyThriftServer : JustATest.Iface
    {
        public string SayHelloTo(Person person)
        {
            return "Hello " + person.Name;
        }

        public int Add(int a, int b)
        {
            return a + b;
        }
    }
}

3、修改Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Thrift.Protocol;
using Thrift.Server;
using Thrift.Transport;

namespace TestThrift
{
    class Program
    {
        static void Main(string[] args)
        {
            TServerSocket serverTransport = new TServerSocket(1900, 0, false);
            JustATest.Processor processor = new JustATest.Processor(new MyThriftServer());
            TServer server = new TSimpleServer(processor, serverTransport);
            server.Serve(); 
        }
    }
}

4、编译运行

然后是Client端:
1、新建一个Console项目,引用Thrift程序集中的Thrift.dll,项目中添加生成的两个cs文件。
2、修改Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Thrift.Protocol;
using Thrift.Transport;

namespace TestThriftClient
{
    class Program
    {
        static void Main(string[] args)
        {
            TTransport transport = new TSocket("localhost", 1900); 
            TProtocol protocol = new TBinaryProtocol(transport);
            JustATest.Client client = new JustATest.Client(protocol); 
            transport.Open(); 
 
            Person p = new Person();
            p.Name="neohope";
            Console.WriteLine(client.SayHelloTo(p));
            Console.WriteLine(client.Add(1, 2));
            
            transport.Close();
        }
    }
}

3、编译运行

使用Thrift实现RPC简单示例01

看一眼下面的框架,你就会发现,Thrift框架其实与CORBA、ICE很相似。对使用者来说,最大的不同,估计是Thrift用一个可执行文件,生成各种各样的代码咯(别告诉我你信了)。

Thrift Arch

Thrift是典型CS架构,与ICE、CORBA相同,Thrift帮我们处理的底层的网络通信及服务定位,我们只需要告诉Thrift服务在哪里,需要哪个服务,调用参数是什么,然后就坐等处理结果就好咯。

使用Thrift的时候,首先要先下载Thrift的开发包,分两部分。
Thrift
一个是一个EXE文件,适用于从IDL描述文件,生成各类语言代码的。
第二个是源码压缩包,用于编译自己所需语言的支持包。

受用Thrift之前,要先编译需要的语言支持包,我这里用到了C#和Java。
Java包,直接到路径lib/java下,执行ant命令就好了
C#包,直接到路径lib/csharp/src下,用VS编译Thrift.sln就好了

使用Thrift的时候,首先要用IDL语言,定义一个接口描述文件,比如我自己写了一个很简单的接口。
JustATest.thrift

struct Person {
1: string name
2: i32 age
3: string sex
4: string address
}

service JustATest {
  string SayHelloTo(1:Person person);
  i32 Add(1:i32 a,2:i32 b);
}

然后用语言的转化工具,将接口描述文件,转化为对应语言。

#生成java代码,会有两个文件
thrift -gen java JustATest.thrift

#生成C#代码,会有两个文件
thrift -gen csharp JustATest.thrift

在对应的项目中包含这些文件及所需要的库文件(jar、dll),就可以开工了。

如何向外行解释产品经理频繁更改需求为什么会令程序员烦恼?读后感

前几天在微信朋友圈中看到了这篇文章,立即就转发了,看完后感触还是很多的。

作者“猫爱吃鱼不吃耗子”,以餐馆点餐为例,说明了定制化产品在研发过程中遇到的种种问题,这些问题,在实际过程中都或多或少的遇到过,但如果在一个产品中,全部遇到,那真是“我日了狗啊”。

这篇文章主要描述的是,一个不懂开发、没有产品经验的需求管理人员(产品经理),在遇到奇葩客户的时候,虽然积极应对需求变更,但忽略了客户的实际需求,没有了解需求后真正的原因,最终产出了看似达到用户需求的产品,但用户各种不满意,开发人员不满意,产品经理各种挫败感。

neohope原创(www.neohope.com)

如果换一个有经验的产品经理,差不多是这个样子的:

你去饭店,坐下来。
“服务员,给我来份宫保鸡丁!”
“好的!我们店的宫保鸡丁做法是。。。”
——————根据客户实际情况,介绍自己的产品,客户越不了解自己的需求,这里越重要,要明白客户要什么,要知道,不少时候客户其实是想要鱼香肉丝。引导用户,搞清楚真正的需求。

服务员:“您是否有其他要求?咸淡?是否加辣?”
“最近没食欲,加点儿辣椒”
“微辣,中辣,还是重辣?”
“中辣好了”
。。。。。。
——————逐步细化用户需求,开工前一定要确认。有经验的产品经理+有经验的用户,这里是最快的,比如用户很可能直接说(“来个宫保鸡丁盖浇饭,只要一半饭,中辣,打包”)。用户没有经验时,这里是要下工夫搞清楚的。

服务员:“要米饭吗?来点儿啤酒不?”
“来两碗米饭,要开车不能喝酒”
。。。。。。
——————了解自己有哪些产品,可以一起卖给客户,组合套餐全家桶

服务员:“现在用餐高峰期,根据您的要求,30分钟之内上齐,加米饭共30元”(其实会预估为20分钟)
“不能快点儿吗,饿了”
“好的,尽量给您催”
——————与用户沟通工期,给自己留余地,取得用户理解(客户催促时,告诉他已经沟通过工期,而且你自己还有一点儿余地可以退让)

厨房:
“宫保鸡丁一份,中辣,不要花椒,米饭两碗,客户要20分钟上齐”
厨师:“好滴”
——————要描述清楚需求,多多沟通

餐厅:
“服务员,我想在菜里加腐竹”
“以前也有客户加腐竹来自,我自己尝过,难吃的要死,要不您来份本店的凉拌腐竹,小碟免费”
“那好啊”
——————要清楚自己的产品线及成本,通过其他案例的经验教训,引导用户到正确的道路上来,提出合理的解决方案。腐竹这类凉菜,相当与公司成熟的小应用,解决具体的实际问题。但要考虑成本的,成本低没问题,但如果客户要个肘子,不好意思,加钱。

餐厅:
“服务员,我要在菜里加花生,去皮的,必须加”
“那我问下厨房”
——————总有新需求无法拒绝,自己清楚的可以许诺,但不清楚的要和研发沟通

厨房:
大厨:“花生去皮要先泡,先吃不上,要不换腰果,但口感不一样,而且要加钱咯”
服务员:“我去问问看,你先别下锅”
——————多方沟通,获取可行解决方案,并进行评估

餐厅:
“花生去皮的话,要多等半小时,我们厨师建议你换腰果试试,就是贵点儿”
“腰果就腰果,还没吃过这样的呢”
“好的,我去说一下”
——————与客户沟通可行方案,但要有主有次,有引导性

餐厅:
“要不我还是要带皮的花生吧”
“对不起,菜已经下锅了,我们大厨说了保证好吃”
“那好吧”
——————客户在某一功能点摇摆不定时,帮助他坚定信念

餐厅:
“上菜咯,外加米饭两碗”
“还不错,上菜挺快,腰果也不错吗”
——————尽量在约定时间内给客户解决问题

在实际做项目的时候,首先要了解清楚用户的实际需求,然后多方进行沟通,避免返工及重复劳动,完成自己对客户的承诺。这才是向合格的产品经理迈进了一大步呢。

其实,真正做项目的时候,都有无法预知的问题,但产品经理就要见招拆招,知道自己的底线在哪里,沟通沟通再沟通,这样才能保证事情顺利进行。

如果任务不可行的时候,那就应该说不可行,宁可不做,也不要把团队带入需求的泥潭。长期在泥潭里,士气会很快低落,人心散了,队伍就没法呆了。

加油吧!

===============================================================
上面说的是定制化产品开发,但大家有没有考虑过成熟产品是如何处理的呢。

你去KFC点餐。
“服务员,给我来个香辣鸡腿堡套餐,打包!”
“好的!”
——————成熟的产品,都是定位特定人群,通过配置而不是开发来达到用户的目的的。其通用性会很高,一半通过搭配,可以解决绝大多数客户的问题。但对于少数用户的奇葩需求并不会处理。而这些也是通过长期的积累,把经验变成了需求,变成了产品的一部分来做到的。

在这里,实施人员成了KFC的配餐员,产品经理是KFC新产品的需求采集人员,研发人员是设计出这些产品的幕后工作者,销售人员是新产品的推广者。

具体情况,大家可以看看Google、MS、亚马逊、阿里的一些开发流程,会发现不少好玩的事情呢。

好啦,先写到这里啦。

如何向外行解释产品经理频繁更改需求为什么会令程序员烦恼?


如何向外行解释产品经理频繁更改需求为什么会令程序员烦恼?
作者:猫爱吃鱼不吃耗子(转自知乎)

你去饭店,坐下来。
“服务员,给我来份宫保鸡丁!”
“好嘞!”
——————这叫原始需求

大厨做到一半。
“服务员,菜里不要放肉。”
“不放肉怎么做啊?”
“不放肉就行了,其它按正常程序做,不就行了,难吗?”
“好的您稍等”
——————中途需求变更

厨房:
大厨:“你大爷,我肉都回锅了”
服务员:“顾客非要要求的嘛,你把肉挑出来不就行了吗”
大厨:“行你大爷”
然而还是一点点挑出来了
——————改动太大,部分重构

餐厅:
“服务员,菜里能给我加点腐竹吗?”
“行,这个应该简单。”
——————低估改动成本

厨房:
大厨:“你TMD,不知道腐竹得提前泡水?炒到一半才说?跟他说,想吃腐竹就多等半天”
服务员:“啊你怎么不早说?”
大厨:“早说你MLGB我怎么知道他要往宫保鸡丁里放腐竹”
然而还是去泡腐竹了
——————新需求引入了新研发成本

餐厅:
“服务员,还是把肉加回去吧”
“您不是刚说不要肉吗”
“现在又想要了”
“…好的您稍等”
——————某一功能点摇摆不定

厨房:
大厨:“日你啊,菜都炒过火了你让我放肉?还好肉我没扔”
服务员:“客户提的要求你日我干嘛?”
大厨:“你就不能拒绝他啊?啊?”
服务员:“人家是客户嘛。”
——————甲方是大爷

餐厅:
“服务员!服务员!”
“来了来了,你好?”
“怎么这么半天啊?”
“稍等我给您催催啊”
——————改动开始导致工期延误

厨房:
大厨:“催你M催,腐竹没泡好,我还得重新放油,他要想吃老的也行,没法保质保量”
——————开发者请求重新排期

餐厅:
服务员:“抱歉,加腐竹的话得多等半天,您别着急哈”
“我靠要等那么久?我现在就要吃,你们能快点吗?”
“行…您稍等”
——————甲方催活

厨房:
大厨:“我日他仙人板板,中途改需求又想按期交付,逗我玩呢?”
服务员:“那我问问,要不让他们换个菜?”
大厨:“再换我就死了”
——————开发者开始和中间人pk

餐厅:
“服务员,这样吧,腐竹不要了,换成蒜毫能快点吗?对了,顺便加点番茄酱”
——————因工期过长再次改动需求

厨房:
大厨:“我日了狗啊,你TM不知道蒜毫也得焯水啊?还有你让我怎么往热菜里放番茄酱啊??”
服务员:“焯水也比等腐竹强吧,番茄酱往里一倒不就行了吗?很难吗?”
大厨:“草。腐竹我还得接着泡,万一这孙子一会又想要了呢。”
——————频繁改动开始导致大量冗余

餐厅:“服务员,菜里加茄丁了没有?我去其它饭店吃可都是有茄丁的”
“好好好您稍等您稍等”
——————奇葩需求

厨房:
大厨:“我去他二大爷他吃的是斯里兰卡三流技校炒的宫保鸡丁吗?宫保鸡丁里放茄丁??”
服务员:“茄丁抄好了扔里边不就行了吗?”
大厨:“那TM还能叫菜吗?哪个系的?”
服务员:“客户要,你就给炒了吧。”
大厨:“MB你顺道问问他腐竹还要不要,我这盆腐竹还占着地方呢不要我就扔了”
——————奇葩你也得做

餐厅:
“服务员,还要多久能好啊”
“很快,很快…”
“再给我来杯西瓜汁。”
“…好”
“我再等10分钟,还不好我就走了,反正还没给钱。”
“很快,很快…”
——————黑暗前的最后黎明10分钟后

“咦,我上次吃的不是这个味啊?”
从厨房杀出来的大厨:“我TM就日了你的狗…”
——————最终决战

——————
你=客户
服务员=客户经理+产品经理
大厨=码农
请自行转换…
——————
注:以上场景已极度夸张,实际生产生活中码农和PM是和睦友好的相亲相爱的一家人
——————
注:对于做2C产品的公司,你=公司大boss

转自知乎,原文链接

使用ICE实现RPC简单示例03

接第01部分,本节用来说明Java语言的代码实现。

使用slice2java之后,会生成10个文件,Client与Server需要分别包含多个文件。

首先是Server端:
1、新建一个java项目,引用ice-3.6.1.jar
2、copy以下几个文件
_iIceTestDisp.java
_iIceTestOperations.java
_iIceTestOperationsNC.java
iIceTest.java
iIceTestHolder.java
3、新建一个类MyICETest,实现iIceTestDisp_接口

package com.neohope.ice.test;

import Ice.Current;

public class MyIceTest extends _iIceTestDisp {
    @Override
    public String SayHelloTo(String s, Current __current) {
        return "Hello " + s;
    }

    @Override
    public int Add(int a, int b, Current __current) {
        return a+b;
    }
}

4、新建测试类TestServer

package com.neohope.ice.test;

public class TestServer {

    public static void main(String[] args) {
        Ice.Communicator ic = null;

        //初使化
        ic = Ice.Util.initialize(args);

        //创建适配器,并指定监听端口
        Ice.ObjectAdapter adapter = ic.createObjectAdapterWithEndpoints("NeoTestAdapter", "default -p 1900");

        //绑定
        Ice.Object obj = new MyIceTest();
        adapter.add(obj, Ice.Util.stringToIdentity("NeoICETest"));

        //激活适配器
        adapter.activate();

        //持续监听,直到服务关闭
        ic.waitForShutdown();

        //清理
        if (ic != null) {
            try {
                ic.destroy();
            } catch (Exception e) {
                System.err.println(e.getMessage());
            }
        }
    }
}

5、编译运行

然后是Client端:
1、新建一个java项目,引用ice-3.6.1.jar
2、copy以下几个文件
Callback_iIceTest_Add.java
Callback_iIceTest_SayHelloTo.java
iIceTestPrx.java
iIceTestPrxHelper.java
iIceTestPrxHolder.java
3、新建测试类TestClient

package com.neohope.ice.test;

public class TestClient {
    public static void main(String[] args) {
        Ice.Communicator ic = null;

        //初使化
        ic = Ice.Util.initialize(args);
        Ice.ObjectPrx obj = ic.stringToProxy("NeoICETest:default -p 1900");

        //查找并获取代理接口
        iIceTestPrx client = iIceTestPrxHelper.checkedCast(obj);
        if (client == null) throw new Error("Invalid proxy");

        //调用服务端方法
        System.out.println(client.SayHelloTo("neohope"));
        System.out.println(client.Add(1, 2));

        //清理
        if (ic != null) {
            try {
                ic.destroy();
            } catch (Exception e) {
                System.err.println(e.getMessage());
            }
        }
    }
}

4、编译运行

PS:
1、不要乱修改id,如果要修改,必须全部修改
2、我调整了包名,不调整也可以

使用ICE实现RPC简单示例02

接第01部分,本节用来说明C#语言的代码实现。

使用slice2cs之后,会生成一个文件JustATest.cs,无论是Client还是Server都要包含这个文件。

首先是Server端:
1、新建一个Console项目,引用ICE程序集中的Ice.dll,项目中添加JustATest.cs文件。
2、新建一个类MyICETest,实现iIceTestDisp_接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Ice;
using com.neohope.ice.test;

namespace TestICEServer
{
    class MyICETest : iIceTestDisp_
    {
        public override string SayHelloTo(string s, Current current__)
        {
            return "Hello " + s;
        }

        public override int Add(int a, int b, Current current__)
        {
            return a + b;
        }
    }
}

3、修改Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestICEServer
{
    class Program
    {
        static void Main(string[] args)
        {
            Ice.Communicator ic = null;

            //初使化
            ic = Ice.Util.initialize(ref args);

            //创建适配器,并指定监听端口
            Ice.ObjectAdapter adapter = ic.createObjectAdapterWithEndpoints("NeoTestAdapter", "default -p 1900");

            //绑定
            Ice.Object obj = new MyICETest();
            adapter.add(obj,Ice.Util.stringToIdentity("NeoICETest"));

            //激活适配器
            adapter.activate();

            //持续监听,直到服务关闭
            ic.waitForShutdown();

            //清理
            if (ic != null)
            {
                try
                {
                    ic.destroy();
                }
                catch (Exception e)
                {
                }
            }
        }
    }
}

4、编译运行

然后是Client端:
1、新建一个Console项目,引用ICE程序集中的Ice.dll,项目中添加JustATest.cs文件。
2、修改Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using com.neohope.ice.test;
//using JustATest;

namespace TestICE
{
    class Program
    {
        static void Main(string[] args)
        {
            Ice.Communicator ic = null;

            try
            {
                //初使化 
                ic = Ice.Util.initialize(ref args);
                Ice.ObjectPrx obj = ic.stringToProxy("NeoICETest:default -p 1900");

                //查找并获取代理接口
                iIceTestPrx client = iIceTestPrxHelper.checkedCast(obj);
                if (client == null)
                {
                    throw new ApplicationException("Invalid proxy");
                }

                //调用服务端方法
                Console.WriteLine(client.SayHelloTo("neohope"));
                Console.WriteLine(client.Add(1, 2));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                //清理
                if (ic != null)
                {
                    try
                    {
                        ic.destroy();
                    }
                    catch (Exception e)
                    {
                        Console.Error.WriteLine(e);
                    }
                }
            }
        }
    }
}

3、编译运行

PS:
1、不要乱修改id,如果要修改,必须全部修改
2、我调整了包名,不调整也可以

使用ICE实现RPC简单示例01

看一眼下面的框架,你就会发现,ICE框架其实与CORBA很相似。但ICE更加的简洁高效,并增加了很多现代框架的特性。同时,其开发组件更加易用,不需每种语言单独下载,学习成本相对较低。

Ice_Client_and_Server_Structure

ICE是典型CS架构,与CORBA相同,ICE帮我们处理的底层的网络通信及服务定位,我们只需要告诉ICE服务在哪里,需要哪个服务,调用参数是什么,然后就坐等处理结果就好咯。

使用ICE的时候,首先要先下载ICE的开发包,下载后直接解压就好了。
ICE下载地址

在使用ICE的时候,首先要用Slice语言,定义一个接口描述文件,比如我自己写了一个很简单的接口。
JustATest.ice

module JustATest
{ 
  interface iIceTest
  { 
    string SayHelloTo(string s);
    int Add(int a, int b);
  }; 
};

然后用对应语言的转化工具,将接口描述文件,转化为对应语言。

#设置环境变量
set ICE_HOME=C:\NeoArch\ZeroC\Ice-3.6.1
set PATH=%ICE_HOME%\bin;%PATH%

#转化为java
slice2java JustATest.ice

#转化为csharp
slice2cs JustATest.ice

那ICE的Client端,是如何找到Server,并告诉Server要调用哪个服务的呢?

//首先,Server在启动的时候,要指定Adapter的名称与端口
ic.createObjectAdapterWithEndpoints("NeoTestAdapter", "default -p 1900");
//然后,在Server端的Adapter上,要做一个类似于将服务名称与服务对象绑定的动作
adapter.add(obj,Ice.Util.stringToIdentity("NeoICETest"));

//当Client启动的时候,要指定端口及服务名称,这样就找到了
Ice.ObjectPrx obj = ic.stringToProxy("NeoICETest:default -p 1900");

那如果两个服务同名,只是端口不一致咋办呢?
你可以发现,无论是Client还是Server,无论是C#还是Java,都有类似的代码,你懂的。

        //C#
        public static readonly string[] ids__ =
        {
            "::Ice::Object",
            "::JustATest::iIceTest"
        };
    //java
    public static final String[] __ids =
    {
        "::Ice::Object",
        "::JustATest::iIceTest"
    };

在client段调用的时候,有checkedCast和uncheckedCast两种转换方式,说白了,checkedCast会先校验接口是否匹配,而uncheckedCast会直接强制转换不做任何校验。可以根据实际情况选用咯。