Spring实现Ice回调实例

Spring实现Ice回调实例

原理

当客户端除了主动调用服务端方法之外，还需要被动获取服务端的数据时，就需要通过回调机制实现。

回调机制下，客户端接收服务端数据的频率完全由服务端的回调频率决定。

这种情况下，如果使用客户端主动调用服务端方法获取数据的方式，会存在服务端上报数据频率与客户端接收数据频率不一致的情况。

但如果服务端上报数据的频率可以同步客户端调用方法获取数据的频率（客户端调用一次服务端方法，服务端上报一次数据），那可以不使用回调机制。

image

初始化

引入gradle依赖

新建包ice

包ice下目录
/client
/clientServant
/server
/serverServant
/slice
/slice2java

slice下Callback.ice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#pragma once

module Demo
{
    interface CallbackReceiver
    {
        void callback();
    };
    
    interface CallbackSender
    {
        void initiateCallback(CallbackReceiver* proxy);
        void shutdown();
    };
};

slice2java生成通用类到slice2java下

clientServant下ClientHandler实现

1
2
3
4
5
6
7
public class ClientHandler implements CallbackReceiver {

    @Override
    public void callback(Current current) {
        System.out.println("received callback");
    }
}

serverServant下ServerHandler实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class ServerHandler implements CallbackSender {

    @Override
    public void initiateCallback(CallbackReceiverPrx proxy, Current current) {
        System.out.println("initiating callback");
        try
        {
            // 执行回调函数
            proxy.callback();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void shutdown(Current current) {
        System.out.println("Shutting down...");
        try
        {
            current.adapter.getCommunicator().shutdown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

server下Server实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Server {

    public static void main(String[] args)
    {

        int status = 0;
        List<String> extraArgs = new ArrayList<String>();

        //
        // Try with resources block - communicator is automatically destroyed
        // at the end of this try block
        //
        try(Communicator communicator = initialize(args, "src/main/resources/config.server", extraArgs))
        {
            // com.ice.slice2java为通用文件类包
            communicator.getProperties().setProperty("Ice.Default.Package", "com.ice.slice2java");
            //
            // Install shutdown hook to (also) destroy communicator during JVM shutdown.
            // This ensures the communicator gets destroyed when the user interrupts the application with Ctrl-C.
            //
            Runtime.getRuntime().addShutdownHook(new Thread(() -> communicator.destroy()));

            if(!extraArgs.isEmpty())
            {
                System.err.println("too many arguments");
                status = 1;
            }
            else
            {
                ObjectAdapter adapter = communicator.createObjectAdapter("Callback.Server");
                adapter.add(new CallbackServerServant(), stringToIdentity("callbackSender"));
                adapter.activate();

                communicator.waitForShutdown();
            }
        }

        System.exit(status);
    }
}

client下Client实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class Client {

    public static void main(String[] args)
    {
        int status = 0;
        List<String> extraArgs = new ArrayList<>();

        //
        // Try with resources block - communicator is automatically destroyed
        // at the end of this try block
        //
        try(Communicator communicator = initialize(args, "src/main/resources/config.client", extraArgs))
        {
            // com.ice.slice2java为通用文件类包
            communicator.getProperties().setProperty("Ice.Default.Package", "com.ice.slice2java");

            if(!extraArgs.isEmpty())
            {
                System.err.println("too many arguments");
                status = 1;
            }
            else
            {
                status = run(communicator);
            }
        }

        System.exit(status);
    }

    private static int run(Communicator communicator)
    {
        CallbackSenderPrx sender = CallbackSenderPrx.checkedCast(
                communicator.propertyToProxy("CallbackSender.Proxy")).ice_twoway().ice_timeout(-1).ice_secure(false);
        if(sender == null)
        {
            System.err.println("invalid proxy");
            return 1;
        }

        ObjectAdapter adapter = communicator.createObjectAdapter("Callback.Client");
        adapter.add(new CallbackClientServant(), stringToIdentity("callbackReceiver"));
        adapter.activate();

        CallbackReceiverPrx receiver =
                CallbackReceiverPrx.uncheckedCast(adapter.createProxy(
                        stringToIdentity("callbackReceiver")));

        // 初始化回调
        sender.initiateCallback(receiver);

        // 关闭回调
        sender.shutdown();

        return 0;
    }
}

src/main/resources/config.server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#
# The server creates one single object adapter with the name
# "Callback.Server". The following line sets the endpoints for this
# adapter.
#
Callback.Server.Endpoints=default -h localhost -p 10000

#
# Warn about connection exceptions
#
Ice.Warn.Connections=1

#
# Network Tracing
#
# 0 = no network tracing
# 1 = trace connection establishment and closure
# 2 = like 1, but more detailed
# 3 = like 2, but also trace data transfer
#
#Ice.Trace.Network=1

#
# Protocol Tracing
#
# 0 = no protocol tracing
# 1 = trace protocol messages
#
#Ice.Trace.Protocol=1

#
# Security Tracing
#
# 0 = no security tracing
# 1 = trace messages
#
#IceSSL.Trace.Security=1

#
# SSL Configuration
#
# Ice.Plugin.IceSSL=com.zeroc.IceSSL.PluginFactory
# IceSSL.DefaultDir=../../../certs
# IceSSL.Keystore=server.jks
# IceSSL.Password=password

src/main/resources/config.client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#
# The client reads this property to create the reference to the
# "CallbackSender" object in the server.
#
CallbackSender.Proxy=callbackSender:default -h localhost -p 10000

#
# The client creates one single object adapter with the name
# "Callback.Client". The following line sets the endpoints for this
# adapter.
#
Callback.Client.Endpoints=default -h localhost

#
# Warn about connection exceptions
#
Ice.Warn.Connections=1

#
# Network Tracing
#
# 0 = no network tracing
# 1 = trace connection establishment and closure
# 2 = like 1, but more detailed
# 3 = like 2, but also trace data transfer
#
#Ice.Trace.Network=1

#
# Protocol Tracing
#
# 0 = no protocol tracing
# 1 = trace protocol messages
#
#Ice.Trace.Protocol=1

#
# Security Tracing
#
# 0 = no security tracing
# 1 = trace messages
#
#IceSSL.Trace.Security=1

#
# SSL Configuration
#
# Ice.Plugin.IceSSL=com.zeroc.IceSSL.PluginFactory
# IceSSL.DefaultDir=../../../certs
# IceSSL.Keystore=client.jks
# IceSSL.Password=password

Run

先运行服务端

再运行客户端

客户端回调函数打印：received callback

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>