封装ICE客户端

待我称王封你为后i 2022-05-12 01:08 181阅读 0赞

来自《ICE权威指南》一书中的Ice的一个工具类。

IceClientUtil.java:

package com.lucky.interf.util;
    import Ice.Communicator;
    import Ice.ObjectPrx;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Locale;
    import java.util.Map;
    import java.util.ResourceBundle;
    import java.util.concurrent.TimeUnit;
     /** * @Author j.tommy * @Date 2016/7/3 0003 下午 9:50 */
     public class IceClientUtil { 
         private static final Map<Class, ObjectPrx> cls2PrxMap = new HashMap<Class, ObjectPrx>();
         private static volatile Ice.Communicator ic = null;
         private static volatile long lastAccessTime = 0L;
         private static volatile MonitorThread monitorThread;
         private static int idleTimeoutSeconds = 300;
         private static final String locatorKey = "--Ice.Default.Locator";
         private static String iceLocator = null;
     // private static final String clientConfigFile = "iceconfig/iceclient.conf";
         /** * 获取代理对象 * @param clazz * @return */
         public static ObjectPrx getServicePrx(Class clazz) {
             ObjectPrx prx = cls2PrxMap.get(clazz);
             if (prx != null) {
                 lastAccessTime = System.currentTimeMillis();
                 return prx;
             }
             prx = createServicePrx(getIceCommunicator(),clazz);
             cls2PrxMap.put(clazz,prx);
             lastAccessTime = System.currentTimeMillis();
             return prx;
         }
         // 创建守护线程，关闭长时间不使用的连接
         private static void createMonitorThread() {
             monitorThread = new MonitorThread();
             monitorThread.setDaemon(true);
             monitorThread.start();
         }
         private static Ice.Communicator getIceCommunicator() {
             if (ic == null) {
                 synchronized (IceClientUtil.class) {
                     if (ic == null) {
                         if (iceLocator == null) {
                             ResourceBundle rb = ResourceBundle.getBundle("iceclient", Locale.ENGLISH);
                             iceLocator = rb.getString(locatorKey);
                             idleTimeoutSeconds = Integer.parseInt(rb.getString("idleTimeoutSeconds"));
                             String[] initParams = new String[]{locatorKey + "=" + iceLocator};
                             ic = Ice.Util.initialize(initParams);
                             createMonitorThread();
                         }
                         // 另外一种创建Ice.Communicator的方式
                         /*Ice.InitializationData initData = new InitializationData(); initData.properties = Ice.Util.createProperties(); initData.properties.load(clientConfigFile); ic = Ice.Util.initialize(initData);*/
                     }
                 }
             }
             return ic;
         }
         /** * 使用反射方式创建ice代理对象 * @param ic * @param clazz * @return */
         private static ObjectPrx createServicePrx(Communicator ic, Class clazz) {
             ObjectPrx prx = null;
             String className = clazz.getName();
             String serviceName = clazz.getSimpleName();
             int pos = serviceName.lastIndexOf("Prx");
             if (pos <= 0) {
                 throw new IllegalArgumentException("Invalid ObjectPrx class,class name must end with Prx.");
             }
             String realServiceName = serviceName.substring(0, pos);
             try {
                 Ice.ObjectPrx base = ic.stringToProxy(realServiceName);
                 prx = (ObjectPrx) Class.forName(className + "Helper").newInstance();
                 Method method = prx.getClass().getDeclaredMethod("uncheckedCast",Ice.ObjectPrx.class);
                 prx = (ObjectPrx) method.invoke(prx,base);
             } catch (Exception e) {
                 e.printStackTrace();
                 throw new RuntimeException(e);
             }
             return prx;
         }
         static class MonitorThread extends Thread {
             public void run() {
                 while (!monitorThread.isInterrupted()) {
                     try {
                         TimeUnit.SECONDS.sleep(5);
                         if (lastAccessTime + idleTimeoutSeconds < System.currentTimeMillis()) {
                             closeCommunicator(true);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        private void closeCommunicator(boolean removeServicesCache) {
            synchronized (IceClientUtil.class) {
                if (ic != null) {
                    safeShutdown();
                    monitorThread.interrupt();
                    if (removeServicesCache && !cls2PrxMap.isEmpty()) {
                        cls2PrxMap.clear();
                    }
                }
            }
        }
        private void safeShutdown() {
            try {
                ic.shutdown();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                ic.destroy();
                ic = null;
            }
        }
    }

iceclient.properties文件：

--Ice.Default.Locator=DemoGrid/Locator:tcp -h 127.0.0.1 -p 4061:tcp -h 127.0.0.1 -p 4062 idleTimeoutSeconds = 300

调用：

import com.lucky.interf.generated.CalcServiceIcePrx;
    import com.lucky.interf.generated.MessageServiceIcePrx;
    import com.lucky.interf.util.IceClientUtil;
    /** * @Author j.tommy * @Date 2016/7/2 0002 下午 12:34 */
    public class Test { 
        public static void main(String[] args) {
             MessageServiceIcePrx msip = (MessageServiceIcePrx) IceClientUtil.getServicePrx(MessageServiceIcePrx.class);
             String result = msip.sendMessage("IceBox msg");
             System.out.println("result->" + result);
             CalcServiceIcePrx csip = (CalcServiceIcePrx) IceClientUtil.getServicePrx(CalcServiceIcePrx.class);
             double sum = csip.calc(0.999, 0.001);
             System.out.println("sum->" + sum);
         }
     }