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:
>>>> setStartedCallBack:[orderService, productService, userService]:127.0.0.1:
>>>> 注册中心创建成功
>>>> 服务注册成功
>>>> stop!
>>>> setStopedCallBack:192.168.11.23:
>>>> 服务移除成功

总结：

A类调用B类的某个方法，B类的该方法中又调用了A类的某个方法，这就是回调。
这仅是一个形象的描述，具体的回调机制在实际应用时会很灵活。
 
比如这个例子中，Provider类的start方法调用啦Server类的start方法，而Server类的start方法中又调用了onStarted方法，
虽然这个onStarted方法不是Provider中的方法，但其执行的回调逻辑是在Provider中通过setStartedCallBack()来设置的。