完整源码：
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()来设置的。
