Java回调机制在RPC框架中的应用示例

完整源码：

https://gitee.com/shiyanjun/x-callback-demo

应用场景描述：

服务提供者在项目启动时，创建并启动一个TCP服务器，然后将自己提供的所有服务注册到注册中心。

这里有3个角色：

1.服务提供者
2.TCP服务器
3.注册中心

引出回调：

服务提供者，要求TCP服务器启动成功之后，回调一下"注册服务"的逻辑。

开始撸码：

首先定义一个回调基类，这是一个抽象类，里面只有一个抽象的回调函数，是将来回调时要实现的方法

/**
 * 回调基类
 *
 * @author syj
 */
public abstract class BaseCallBack {
    /**
     * 回调执行逻辑
     *
     * @throws Exception
     */
    public abstract void run() throws Exception;
}

谁来调用这个回调函数呢，前面说了，TCP服务器启动之后要调用这个回调函数，所以回调的操作要在TCP服务器中完成。

TCP服务器是一个具体的服务实现，我们可能会有多种服务器的实现，所以先定义一个抽象的服务类：

/**
 * 服务抽象
 *
 * @author syj
 */
public abstract class Server {

    // 服务启动后回调
    private BaseCallBack startedCallBack;

    // 服务停止后回调
    private BaseCallBack stopedCallBack;

    /**
     * 设置服务启动后的回调逻辑
     *
     * @param startedCallBack
     */
    public void setStartedCallBack(BaseCallBack startedCallBack) {
        this.startedCallBack = startedCallBack;
    }

    /**
     * 设置服务停止后的回调逻辑
     *
     * @param stopedCallBack
     */
    public void setStopedCallBack(BaseCallBack stopedCallBack) {
        this.stopedCallBack = stopedCallBack;
    }

    /**
     * 服务启动后回调
     */
    public void onStarted() {
        if (startedCallBack != null) {
            try {
                startedCallBack.run();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 服务停止后回调
     */
    public void onStoped() {
        if (stopedCallBack != null) {
            try {
                stopedCallBack.run();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 启动服务
     *
     * @param provider
     * @throws Exception
     */
    public abstract void start(Provider provider) throws Exception;

    /**
     * 停止服务
     *
     * @throws Exception
     */
    public abstract void stop() throws Exception;

}

这个服务器抽象类，主要有启动服务和停止服务的方法，还持有两个回调对象，一个是服务器启动后的回调对象，一个是服务器停止后的回调对象。并有两个方法分别去调用这两个回调对象的run方法。

下面定义一个TCP服务器类，它是上面服务器抽象类的一个具体实现类：

/**
 * 服务实现类
 *
 * @author syj
 */
public class TcpServerImpl extends Server {


    /**
     * 启动服务
     *
     * @param provider
     */
    @Override
    public void start(Provider provider) {
        System.out.println(">>>> start! " + provider.getTcpSrvAddr() + ":" + provider.getTcpSrvPort());
        // 启动后回调
        onStarted();

    }

    /**
     * 停止服务
     *
     */
    @Override
    public void stop() {
        System.out.println(">>>> stop!");
        // 停止后回调
        onStoped();
    }
}

该类主要有两个功能，一个是启动TCP服务，一个是停止TCP服务，这两个方法的最后都需要触发回调逻辑的执行；

关于具体回调逻辑的定义写在哪里呢？自然是服务的提供者最清楚，所以写在服务提供者类中最合适：

import java.util.TreeSet;

/**
 * 服务操作
 *
 * @author syj
 */
public class Provider {

    // 模拟要注册的服务列表
    public static TreeSet<String> serviceKeys = new TreeSet<String>() {{
        add("userService");
        add("productService");
        add("orderService");
    }};

    // 模拟本机http服务使用的ip和端口
    public static String localAddress = "127.0.0.1:8081";

    // TCP服务器地址
    private String tcpSrvAddr;

    // TCP服务器端口
    private int tcpSrvPort;

    public String getTcpSrvAddr() {
        return tcpSrvAddr;
    }

    public int getTcpSrvPort() {
        return tcpSrvPort;
    }

    private Server server;
    private Registry registry;

    public Provider() {
    }

    /**
     * 初始化配置
     *
     * @param tcpSrvAddr
     * @param tcpSrvPort
     */
    public void initConfig(String tcpSrvAddr, int tcpSrvPort) {
        this.tcpSrvAddr = tcpSrvAddr;
        this.tcpSrvPort = tcpSrvPort;
    }

    /**
     * 启动服务
     */
    public void start() {
        try {
            registry = Registry.class.newInstance();
            server = TcpServerImpl.class.newInstance();
            // 设置服务启动后回调逻辑
            server.setStartedCallBack(new BaseCallBack() {
                @Override
                public void run() {
                    System.out.println(">>>> setStartedCallBack:" + serviceKeys + ":" + localAddress);
                    // 注册服务
                    registry.start();
                    registry.registry(serviceKeys, localAddress);
                }
            });

            // 设置服务停止后回调逻辑
            server.setStopedCallBack(new BaseCallBack() {
                @Override
                public void run() {
                    System.out.println(">>>> setStopedCallBack:" + tcpSrvAddr + ":" + tcpSrvPort);
                    registry.remove(serviceKeys, localAddress);
                }
            });

            // 启动服务
            server.start(this);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 停止服务
     */
    public void stop() {
        try {
            server.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

由于服务提供者需要启动TCP服务器，所以它依赖一个Server对象，在他的start方法中，启动TCP服务之前，先给这个TCP服务设置两个回调回调具体逻辑，就是前面说的一个是TCP服务器启动之后要执行的逻辑，一个是TCP服务器停止之后要执行的逻辑。

TCP服务器启动成功之后，要将服务提供者的所有服务注册到注册中心，TCP服务器停止之后要从注册中心移除自己的所有服务。

下面是注册中心类，它只负责服务的注册和移除，别的事不管：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * 服务注册中心
 *
 * @author syj
 */
public class Registry {

    private Map<String, TreeSet<String>> registryData;


    public void start() {
        registryData = new HashMap<String, TreeSet<String>>();
        System.out.println(">>>> 注册中心创建成功");
    }

    public void stop() {
        registryData.clear();
    }


    public boolean registry(Set<String> keys, String value) {
        if (keys==null || keys.size()==0 || value==null || value.trim().length()==0) {
            return false;
        }
        for (String key : keys) {
            TreeSet<String> values = registryData.get(key);
            if (values == null) {
                values = new TreeSet<>();
                registryData.put(key, values);
            }
            values.add(value);
        }
        System.out.println(">>>> 服务注册成功");
        return true;
    }

    public boolean remove(Set<String> keys, String value) {
        if (keys==null || keys.size()==0 || value==null || value.trim().length()==0) {
            return false;
        }
        for (String key : keys) {
            TreeSet<String> values = registryData.get(key);
            if (values != null) {
                values.remove(value);
            }
        }
        System.out.println(">>>> 服务移除成功");
        return true;
    }
}

写个测试类测试一下：

/**
 * 测试类
 *
 * @author syj
 */
public class App {
    // TCP 服务器IP
    public static String tcpSrvAddr = "192.168.11.23";
    // TCP 服务端口
    public static int tcpSrvPort = 9090;

    public static void main(String[] args) {
        Provider provider = new Provider();
        provider.initConfig(tcpSrvAddr, tcpSrvPort);
        provider.start();
        provider.stop();
    }
}

输出结果：

>>>> start! 192.168.11.23:9090
>>>> setStartedCallBack:[orderService, productService, userService]:127.0.0.1:8081
>>>> 注册中心创建成功
>>>> 服务注册成功
>>>> stop!
>>>> setStopedCallBack:192.168.11.23:9090
>>>> 服务移除成功

总结：

A类调用B类的某个方法，B类的该方法中又调用了A类的某个方法，这就是回调。
这仅是一个形象的描述，具体的回调机制在实际应用时会很灵活。

比如这个例子中，Provider类的start方法调用啦Server类的start方法，而Server类的start方法中又调用了onStarted方法，
虽然这个onStarted方法不是Provider中的方法，但其执行的回调逻辑是在Provider中通过setStartedCallBack()来设置的。