java 注册机制的实现_note/关于java中的回调机制和注册实现.md at master · hellmonky/note · GitHub...

关于java中回调机制和注册的实现：

在实现多种接口的具体实现和interface的接口调用的过程中，随着代码的编写，想实现类似于Spring中注册机制，Spring基于的IOC是其核心。

本文分析java的接口回调机制细节，然后结合Spring的IoC原理进行思考。

一 java中的接口回调机制

1.1 回调的概念：

模块之间都存在一定的调用关系，从调用方式上看，可以分为三类：同步调用、异步调用和回调。

同步调用是一种阻塞式调用，即在函数A的函数体里通过书写函数B的函数名来调用之，使内存中对应函数B的代码得以执行。

异步调用是一种类似消息或事件的机制解决了同步阻塞的问题，例如 A通知 B后，他们各走各的路，互不影响，不用像同步调用那样， A通知 B后，非得等到 B走完后， A才继续走 。

回调是一种双向的调用模式，也就是说，被调用的接口被调用时也会调用对方的接口，例如A要调用B，B在执行完又要调用A。

回调也包含为同步回调和异步回调：

异步回调一般使用多线程来进行，被回调的部分包含在线程中，在后台执行；

同步回调会一直等待被调用的返回结果，获取返回值之后再进行当前的程序。

1.2 回调的用处：

回调一般用于层间协作，上层将本层函数安装在下层，这个函数就是回调，而下层在一定条件下触发回调。例如作为一个驱动，是一个底层，他在收到一个数据时，除了完成本层的处理工作外，还将进行回调，将这个数据交给上层应用层来做进一步处理，这在分层的数据通信中很普遍。

1.3 java中的接口回调：

在C/C++中，要实现回调函数，被调用函数要告诉调用者自己的指针地址。但是Java没有指针地址，不能传递方法的地址，一般采用接口回调的方法来实现：

把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被调用类实现的接口的方法。

原理：首先创建一个回调对象，然后再创建一个控制器对象，将回调对象需要被调用的方法告诉控制器对象，控制器对象负责检查某个场景是否出现或某个条件是否满足，当满足时，自动调用回调对象的方法。

也就是说回调的双方需要协商好一个交互的接口，然后通过这个接口来实现相互之间的调用：

调用方：需要一个可以处理这个接口的函数；

被调用方：需要继承这个接口，然后在接口中实现处理方法。

1.4 基本回调的java实现样例代码：

首先定义一个接口：

public interface CallBack {

public void doEvent();

}

然后定义调用方，也就是所谓的控制类，主导什么时候进行回调：

public class Master {

CallBack callBack;

public Master(CallBack callBack) {

this.callBack=callBack;

}

public void process() {

System.out.println("主程序执行中");

callBack.doEvent();

}

}

接着定义被回调的类，用于响应回调发生的处理事件：

public class Slave implements CallBack {

@Override

public void doEvent() {

System.out.println("告知已经完成工作了");

}

}

这个被调用的类继承了协商好的接口，然后在其中实现被调用的方法，也就是接口中的doEvent方法。

最后就是完成整个回调的调用流程：

public static void main(String[] args) {

// 创建回调对象实例

Slave slave = new Slave();

//创建控制器对象，将提供给他的回调对象传入

Master master = new Master(slave);

//启动控制器对象运行

master.process();

}

1.5 异步回调的java实现样例代码：

在[上一节](### 1.4)中展示了基本的java中的接口回调方式，但是上述调用是同步的，控制器中需要等待回调对象中处理函数的返回。

但是在实际使用中，往往需要进行异步调用来继续执行控制器中的函数，直到回调对象返回处理结果通知控制器。本节主要展示异步的java代码。

主要修改控制类代码完成异步调用：

public class Master {

CallBack callBack;

public Master(CallBack callBack) {

this.callBack=callBack;

}

// 使用thread方式来完成异步调用封装，然后继续调用处理函数

public void asynchronousCall(){

// 开始请求异步调用

System.out.println("准备开始异步调用");

//这里用一个线程就是异步，

new Thread(new Runnable() {

@Override

public void run() {

callBack.doEvent();

}

}).start();

// 然后继续执行当前主程序，等待回调通知

System.out.println("完成异步调用，继续执行当前控制类代码");

process();

}

// 异步调用之后的控制程序需要继续执行的代码

public void process() {

System.out.println("控制类继续执行中");

}

}

其他的接口和实现都不变。这儿主要使用了new Thread来启动一个线程来进行异步调用，也可以使用其他方式来进行。

为了将整个过程模拟，改变被回调的类的定义，加入延时：

public class Slave implements CallBack {

@Override

public void doEvent() {

// 进入回调处理

System.out.println("进入回调调用");

// 模拟雕用处理需要很长时间

for(int i=0; i<10000;i++){

System.out.println("slave process : "+i);

//int j = i+1;

}

// 然后返回结果

System.out.println("回调执行完毕");

}

}

然后在主程序中执行调用：

public static void main(String[] args) {

// 创建回调对象实例

Slave slave = new Slave();

//创建控制器对象，将提供给他的回调对象传入

Master master = new Master(slave);

//启动控制器对象运行

master.asynchronousCall();

}

会返回如下执行结果：

准备开始异步调用

进入回调调用

slave process : 0

完成异步调用，继续执行当前控制类代码

slave process : 1

slave process : 2

控制类继续执行中

slave process : 3

slave process : 4

slave process : 5

slave process : 6

slave process : 7

...

slave process : 9999

回调执行完毕

可见当前的执行顺序为master在执行异步调用后，继续执行后续的process程序，然后异步处理的doEvent在后台进行处理，然后返回结果。

二 Spring的IoC原理：

所谓的IoC(Inversion of Control)，中文为：控制倒转。这是spring的核心，贯穿始终。这个概念的提出需要分析整理java开发中的类的使用情况：

java程序中的每个业务逻辑至少需要两个或以上的对象来协作完成，通常，每个对象在使用他的合作对象时，自己均要使用像new object() 这样的语法来完成合作对象的申请工作。你会发现：对象间的耦合度高了。而IOC的思想是：Spring容器来实现这些相互依赖对象的创建、协调工作。对象只需要关系业务逻辑本身就可以了。从这方面来说，对象如何得到他的协作对象的责任被反转了(IOC、DI)。

也就是说Ioc将对象的创建进行了统一的管理，

三 Spring的IoC的依赖注入和回调的关系：

Spring将组件的依赖关系由容器实现，那么容器如何知道一个组件依赖哪些其它的组件呢？例如用户注册的例子：容器如何得知UserRegister依赖于UserDao呢。

这样，我们的组件必须提供一系列所谓的回调方法(这个方法并不是具体的 Java 类的方法)，这些回调方法会告知容器它所依赖的组件。根据回调方法的不同，我们可以将 IoC 分为三种形式：

接口注入(Interface Injection)

设值方法注入(Setter Injection)

构造子注入(Constructor Injection)