ICE java实现helloworld

目录

一 前言

二 实现

1、目录结构

2、java实现

3、spring实现（spring启动ice）

三 项目git  https://github.com/HandsomeMars/springboot-ice-demo

---

一 前言

1、基于上篇slice2java编译，本文接着使用slice2java实现简单的客户端和服务端

2、本文列举两种实现：

• java main方法调用
• 结合spring IOC容器管理

二 实现

1、目录结构

src
├─main
│  ├─java
│  │  ├─com
│  │  │  └─zyj
│  │  │      │  SpringbootIceApplication.java
│  │  │      │
│  │  │      ├─ice
│  │  │      │  ├─java     ##java实现
│  │  │      │  │  ├─client
│  │  │      │  │  │      IceClient.java
│  │  │      │  │  │
│  │  │      │  │  └─server
│  │  │      │  │          HelloServant.java
│  │  │      │  │          IceService.java
│  │  │      │  │
│  │  │      │  └─spring   ##spring结合
│  │  │      │      ├─client
│  │  │      │      │      IceClient.java
│  │  │      │      │
│  │  │      │      └─server
│  │  │      │              HelloServant.java
│  │  │      │              IceService.java
│  │  │      │
│  │  │      └─util
│  │  │              SpringContextUtil.java
│  │  │
│  │  └─slice2java        ##slice生成文件
│  │          Callback_HelloI_hello.java
│  │          HelloI.java
│  │          HelloIHolder.java
│  │          HelloIPrx.java
│  │          HelloIPrxHelper.java
│  │          HelloIPrxHolder.java
│  │          _Callback_HelloI_hello.java
│  │          _HelloIDisp.java
│  │          _HelloIOperations.java
│  │          _HelloIOperationsNC.java
│  │
│  └─resources
│      │  application.properties
│      │
│      └─slice
│              slice.bat
│              test.ice
│
└─test
    └─java
        └─com
            └─zyj
                    SpringbootIceApplicationTests.java

2、java实现

step1: HelloServant 实现服务端  _xxxDisp抽象类

package com.zyj.ice.java.server;

import Ice.Current;
import Ice.StringHolder;
import slice2java._HelloIDisp;

/**
 * @author by zyj
 * @version V1.0
 * @Description:
 * @Date 2019/8/6 21:13
 */
public class HelloServant extends _HelloIDisp {
    @Override
    public int hello(String instr, StringHolder outstr, Current __current) {
        System.out.println("server接受："+instr+" 时间："+System.currentTimeMillis());
        outstr.value="hello client";
        return 0;
    }
}

setp2:配置server 

package com.zyj.ice.java.server;

/**
 * @author by zyj
 * @version V1.0
 * @Description:
 * @Date 2019/8/6 21:13
 */
public class IceService {
    /**服务名*/
    private static final String SERVER_NAME="Hello";
    /**服务端点*/
    private static final String SERVER_ENDPOINT="tcp -p 10006";


    public static void main(String[] args) {
        //获取实现类 SpringContextUtil.getBean(helloServant)
        HelloServant helloServant=new HelloServant();

        //ice通信器
        Ice.Communicator communicator = null;
        try {
            //初始化ice通信器communicator,可以使用args传入一下ice初始化的参数如超时时间，线程池大小等
            communicator = Ice.Util.initialize(args);

            //创建一个名为queryEmployeeAdapter的适配器并且默认使用tcp协议  服务部署在10.4.30.81机器上 服务开启10006监听端口

            Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints(SERVER_NAME,SERVER_ENDPOINT);

            // 将servant与ice对象标识符建立映射关系，并添加到ice对象适配器中
            adapter.add(helloServant, Ice.Util.stringToIdentity(SERVER_NAME));

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

            System.out.println("服务启动");
            // 服务在退出之前一直保持监听状态
            communicator.waitForShutdown();

        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            //异常销毁通信器
            if(communicator != null){
                communicator.destroy();
            }
        }
    }


}

step3:IceClient 使用 xxxPrxHelper 获取 xxxPrx

package com.zyj.ice.java.client;

import Ice.StringHolder;
import slice2java.HelloIPrx;
import slice2java.HelloIPrxHelper;

/**
 * @author by zyj
 * @version V1.0
 * @Description:
 * @Date 2019/8/6 21:13
 */
public class IceClient {

    /**服务名*/
    private static final String SERVER_NAME="Hello";
    /**服务端点*/
    private static final String SERVER_ENDPOINT="tcp -h 127.0.0.1 -p 10006";


    public static void main(String[] args) {
        //ice通信器
        Ice.Communicator communicator = null;
        try {
            //初始化ice通信器communicator,可以使用args传入一下ice初始化的参数如超时时间，线程池大小等
            communicator = Ice.Util.initialize(args);

            //构建服务端的代理对象  服务端对象标识以 SERVER_NAME:SERVER_ENDPOINT 格式
            Ice.ObjectPrx op = communicator.stringToProxy(SERVER_NAME+":"+SERVER_ENDPOINT);

            //检查通用客户端代理op 是不是queryServer对象标识符所关联的ice对象的代理
            HelloIPrx qp = HelloIPrxHelper.checkedCast(op);

            if(qp == null){
                throw new Exception("qp == null");
            }

            //测试发送信息到户无端
            StringHolder holder=new StringHolder();
            int result = qp.hello("hello",holder);

            // 输出服务端返回结果
            System.out.println("client接受："+holder.value+" 时间："+System.currentTimeMillis());

        } catch (Exception e) {
            e.printStackTrace();

        }
    }

}

step4:启动验证

启动server

 启动client

3、spring实现（spring启动ice）

step1：改造服务实现类（添加@Service注解）

package com.zyj.ice.spring.server;

import Ice.Current;
import Ice.StringHolder;
import org.springframework.stereotype.Service;
import slice2java._HelloIDisp;

/**
 * @author by zyj
 * @version V1.0
 * @Description:
 * @Date 2019/8/6 21:13
 */
@Service
public class HelloServant extends _HelloIDisp {
    @Override
    public int hello(String instr, StringHolder outstr, Current __current) {
        System.out.println("server接受："+instr+" 时间："+System.currentTimeMillis());
        outstr.value="hello client";
        return 0;
    }
}

 step2：改造server  主要防止ice阻塞，所以通过线程处理

package com.zyj.ice.spring.server;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author by zyj
 * @version V1.0
 * @Description:
 * @Date 2019/8/6 21:13
 */
@Service
public class IceService implements Runnable{

    /**服务名*/
    private static final String SERVER_NAME="Hello";
    /**服务端点*/
    private static final String SERVER_ENDPOINT="tcp -p 10006";

    @Autowired
    private HelloServant helloServant;

    @PostConstruct
    private void startIceServer() {
        //构造线程池启动当前任务
        LinkedBlockingQueue<Runnable> runnableList=new LinkedBlockingQueue<Runnable>();
        ThreadPoolExecutor threadPoolExecutor= new ThreadPoolExecutor(100,100,1L, TimeUnit.SECONDS,runnableList);
        threadPoolExecutor.execute(this);
    }


    @Override
    public void run() {
        //ice通信器
        Ice.Communicator communicator = null;
        try {
            //初始化ice通信器communicator,可以使用args传入一下ice初始化的参数如超时时间，线程池大小等
            communicator = Ice.Util.initialize();

            //创建一个名为queryEmployeeAdapter的适配器并且默认使用tcp协议  服务部署在10.4.30.81机器上 服务开启10006监听端口

            Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints(SERVER_NAME,SERVER_ENDPOINT);

            // 将servant与ice对象标识符建立映射关系，并添加到ice对象适配器中
            adapter.add(helloServant, Ice.Util.stringToIdentity(SERVER_NAME));

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

            System.out.println("服务启动");
            // 服务在退出之前一直保持监听状态
            communicator.waitForShutdown();

        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            //异常销毁通信器
            if(communicator != null){
                communicator.destroy();
            }
        }

    }
}

step3：改造客户端（客户端连接服务端后,可以保持服务端xxxPrx对象持续调用）

package com.zyj.ice.spring.client;

import Ice.StringHolder;
import org.springframework.stereotype.Service;
import slice2java.HelloIPrx;
import slice2java.HelloIPrxHelper;

import javax.annotation.PostConstruct;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author by zyj
 * @version V1.0
 * @Description:
 * @Date 2019/8/6 21:13
 */
@Service
public class IceClient implements Runnable{

    /**服务名*/
    private static final String SERVER_NAME="Hello";
    /**服务端点*/
    private static final String SERVER_ENDPOINT="tcp -h 127.0.0.1 -p 10006";


    @PostConstruct
    private void startIceClient() {
        //构造线程启动客户端
        LinkedBlockingQueue<Runnable> runnableList=new LinkedBlockingQueue<Runnable>();
        ThreadPoolExecutor threadPoolExecutor= new ThreadPoolExecutor(100,100,1L, TimeUnit.SECONDS,runnableList);
        threadPoolExecutor.execute(this);
    }


    @Override
    public void run() {
        //ice通信器
        Ice.Communicator communicator = null;
        try {
            //初始化ice通信器communicator,可以使用args传入一下ice初始化的参数如超时时间，线程池大小等
            communicator = Ice.Util.initialize();

            //构建服务端的代理对象  服务端对象标识以 SERVER_NAME:SERVER_ENDPOINT 格式
            Ice.ObjectPrx op = communicator.stringToProxy(SERVER_NAME+":"+SERVER_ENDPOINT);

            //检查通用客户端代理op 是不是queryServer对象标识符所关联的ice对象的代理
            HelloIPrx qp = HelloIPrxHelper.checkedCast(op);

            if(qp == null){
                throw new Exception("qp == null");
            }

            //测试发送信息到户无端
            StringHolder holder=new StringHolder();
            int result = qp.hello("hello",holder);

            // 输出服务端返回结果
            System.out.println("client请求结果："+holder.value+" 时间："+System.currentTimeMillis());

        } catch (Exception e) {
            e.printStackTrace();

        }
    }
}

step4 启动

三 项目git  https://github.com/HandsomeMars/springboot-ice-demo

https://github.com/HandsomeMars/springboot-ice-demo