一、前言
 
在进行应用开发时，不同模块之间存在着相互调用的关系。调用的方式分为以下几种：
 
 
同步调用
 fun(a)调用fun(b)，fun(a)等待fun(b)执行完后再进行下一步。
 同步调用会引起代码的阻塞。
 
 
异步调用
 fun(a)调用fun(b), fun(a)不等待fun(b)执行完便进行下一步。
 常见的有Thread、Task等。
 
 
回调
 回调的机制是：
 a) 类A的a()方法调用类B的b()方法
 b) 类B的b()方法执行完毕主动调用类A的callback()方法
 
 
二、例子简介
 
实现一个最常见的功能：文件下载。当然这儿的下载不是真正的下载。
 在下载的过程中，服务端可以返回给我们一些信息，比如：下载进度、下载状态、查看下载URL等。
 
三、代码实现
 
1. 接口定义
 
首先定义一个IDownloadStatusCallBack 接口，接口里面包含用户需要得知的信息，即：开始下载、结束下载、显示下载的URL、显示下载的进度。
 
package com.example.test.callback;

public interface IDownloadStatusCallBack {
	
	public void startDownload();
	public void stopDownload();
	public void showDownloadURL(String url);
	public void showDownloadProgress(int progress);
}

 
2. 客户端定义
 
定义一个Client客户端，并实现这些接口并打印相应的信息。
 
package com.example.test.callback;

public class Client implements IDownloadStatusCallBack {
	
	private Server mServer = null;
	
	public Client() {
		// TODO Auto-generated constructor stub
	}
	
	public void download(String url) {
		mServer = new Server(Client.this, url);
		mServer.Run();
	}

	@Override
	public void startDownload() {
		// TODO Auto-generated method stub
		System.out.println("startDownload");
	}

	@Override
	public void stopDownload() {
		// TODO Auto-generated method stub
		System.out.println("stopDownload");
	}
	
	@Override
	public void showDownloadURL(String url) {
		// TODO Auto-generated method stub
		System.out.println("Download URL: " + url);
	}

	@Override
	public void showDownloadProgress(int progress) {
		// TODO Auto-generated method stub
		System.out.println("DownloadProgress: " + progress + "%");
	}

}

 
3. 服务端定义
 
定义一个Server服务端，Server是对模拟下载过程的具体实现。
 Server里面用定时器模拟下载进度，每隔1秒下载进度增长百分之十，到百分之百下载结束。
 在执行过程中，通过IDownloadStatusCallBack 回调通知客户端下载进度等信息。
 
package com.example.test.callback;

import java.util.Timer;
import java.util.TimerTask;

public class Server {

	private IDownloadStatusCallBack iCallBack;
	private String mDownloadUrl = null;
	
	private Timer mTimer = null;
	
	private int mProgress = 0;
	
	public Server(IDownloadStatusCallBack iCallBack, String url) {
		this.iCallBack = iCallBack;
		this.mDownloadUrl = url;
		mProgress = 0;
	}

	public void Run() {
		iCallBack.showDownloadURL(mDownloadUrl); // 回调下载URL
		iCallBack.startDownload();               // 回调开始下载
		
		mTimer = new Timer();
		mTimer.schedule(new TimerTask() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				iCallBack.showDownloadProgress(mProgress); // 回调下载进度
				if (mProgress == 100) {                    // 下载进度至100%
					iCallBack.stopDownload();              // 回调下载结束
					mTimer.cancel();
				}
				mProgress += 10;
			}
		}, 0, 1000);
	}
}

 
4. 用户调用
 
最后建立一个User用户，用户通过调用Client里面的download()方法来执行下载任务。
 
package com.example.test.callback;

public class User {
	
	private static final String URL = "https://www.baidu.com";

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Client client = new Client();
		client.download(URL);
	}

}

 
5. 数据打印
 
执行代码看到打印：
 
Download URL: https://www.baidu.com
startDownload
DownloadProgress: 0%
DownloadProgress: 10%
DownloadProgress: 20%
DownloadProgress: 30%
DownloadProgress: 40%
DownloadProgress: 50%
DownloadProgress: 60%
DownloadProgress: 70%
DownloadProgress: 80%
DownloadProgress: 90%
DownloadProgress: 100%
stopDownload
 
四、后语
 
在执行一些通知类的操作时，采用回调比较方便。

前言
 
今天有个小兄弟问到了回调函数，讲解了一番以后觉得不能白讲，得把这些东西记下来，虽然很基础。。。
 
介绍
 
首先从英文介绍开始
 
A callback is a function that is passed as an argument to another function and is executed after its parent function has completed.
 
这里只是js里的解释。
 
开始
 
字面上理解下来就是，回调就是一个函数的调用过程。那么就从理解这个调用过程开始吧。函数a有一个参数，这个参数是个函数b，当函数a执行完以后执行函数b。那么这个过程就叫回调。
 
其实中文也很好理解：回调，回调，就是回头调用的意思。函数a的事先干完，回头再调用函数b。
 
举个现实的例子：约会结束后你送你女朋友回家，离别时，你肯定会说：“到家了给我发条信息，我很担心你。”对不，然后你女朋友回家以后还真给你发了条信息。小伙子，你有戏了。
 
其实这就是一个回调的过程。你留了个函数b（要求女朋友给你发条信息）给你女朋友，然后你女朋友回家，回家的动作是函数a。她必须先回到家以后，函数a的内容执行完了，再执行函数b，然后你就收到一条信息了。
 
这里必须清楚一点：函数b是你以参数形式传给函数a的，那么函数b就叫回调函数。
 
 也许有人有疑问了:一定要以参数形式传过去吗，我不可以直接在函数a里面调用函数b吗？确实可以。求解中。
 
解惑:如果你直接在函数a里调用的话，那么这个回调函数就被限制死了。但是使用函数做参数就有下面的好处：当你a(b)的时候函数b就成了回调函数，而你还可以a(c)这个时候，函数c就成了回调函数。如果你写成了function a(){...;b();}就失去了变量的灵活性。
 
上一段代码大家可以跑一下：
 
function a(callback)
{   
    alert("我是parent函数a！");
    alert("调用回调函数");
    callback();
}
function b(){
alert("我是回调函数b");
  
}
function c(){
alert("我是回调函数c");
  
}
  
function test()
{
    a(b);
   a(c);
}
 
根据代码示例加深理解
 
问题：
 
现在有函数如下定义：
 function A(a,callback){
 ....
 }
 function B(){
 ....
 }
 则可以有如下调用
 A(a,B);来实现回调。
 现在我希望传给B一个参数c，即实现类似于:  A(a,B(c)); 的效果，应该如何实现？
 
function A(a,callback){ 
var b=callback; 
alert(a+b); 
} 
function B(c){ 
return (-c); 
} 
A(4,B(3))
 
根据jquery的ajax请求常见的场景再去写一个示例：
 
我包装了jQuery的ajax方法：
 
function doAjax(u,param,callback){
      $.ajax({
            type:'POST',
            url:u,
            data:param,
            success:callback
      });
}
 
function showAlert(data){
     alert(data);
}
 
 
比如这样调用 doAjax("url","id=1",showAlert);
 $.ajax 在success后,会返回一个data到showAlert中,显示出来 ,没有问题.
 可是,当我想多传一个参数给showAlert时怎么写?
 写成doAjax("server.php","id=12&type=1",showAlert("hi",data))、或者把上面的success:callback 写成success:callback(msg,data)显然都不行,如之奈何?
 
其实很简单，很多方法都定义了回调函数,回调函数也是函数,就是说不管怎么传，只需要是个函数类型即可。写法如下：
 
方式1，
doAjax(参数1,参数2,function(request,opts){
         callback(request,opts,agrs);
 });
function callback(request,opts,args){
               
};
方式2，
var args=N;
doAjax(参数1,参数2,function(request,opts){
       var X=N;
       回调函数代码块..
       和以上几乎一样，看个人编码方式选择。     
});
 
再看一个从父函数传递给回调函数的示例
 
function e(m,n,Callback){  
    var d = m+n;  
    alert("一个从父函数e 产生的参数将要被传递给回调函数 ，这个参数是:"+d);  
     
    //这里才写你想调用的函数---参数要正确  
    Callback(d);   
}  
function callback(data){  
        alert("我是回调函数，我的名字叫:callback ,我接收到来自父函数的参数，参数是:"+data);   
}
e(1,2,callback)  
 
最后
 
感谢各位的阅读，如有问题麻烦及时指正出来。
 
 

/**
     * kotlin文件中 Java类使用Java的callback
     */
    //第一种写法
    JavaManager().setJavaCallback(JavaCallback {
        println(it)
    })
    //第一种方法取别名
    JavaManager().setJavaCallback(JavaCallback { aaa ->
        println(aaa)
    })
    //第二种写法
    JavaManager().setJavaCallback(object : JavaCallback {
        override fun show(info: String?) {
            println(info)
        }
    })
    //第二种写法的简写
    JavaManager().setJavaCallback { info -> println(info) }
    //第二种写法的再简单写法
    JavaManager().setJavaCallback { it -> println(it) }
    JavaManager().setJavaCallback { println(it) }

    //第三种写法，第一种写法的，先声明java callback
    val callback = JavaCallback {
        println(it)
    }
    JavaManager().setJavaCallback(callback)

    //第四中写法，第二种写法的，先声明kt callback写法
    val callback2 = object : JavaCallback {
        override fun show(info: String?) {
            println(info)
        }
    }
    JavaManager().setJavaCallback(callback2)

    /**
     * kotlin文件中 Java类使用Kt的callback
     */
    JavaManager().setKtCallback(object :KTCallback{
        override fun show(name: String) {
            println(name)
        }
    })

    val ktCallback1 = object :KTCallback{
        override fun show(name: String) {
            println(name)
        }
    }
    JavaManager().setKtCallback(ktCallback1)

    /**
     * kotlin文件中kotlin使用kotlin 的callback
     */
    //写法1,kotlin中只能使用这种方式，先object ： XXXCallback
    KtManager().setKtCallback(object : KTCallback {
        override fun show(name: String) {

        }
    })

    //写法1 ，先声明kt的callback
    val callback1 = object : KTCallback {
        override fun show(name: String) {
            println(name)
        }
    }
    KtManager().setKtCallback(callback1)

    //kotlin不能像Java一样的写法，kotlin的callback一定是object：XXCallback
    /*KtManager().setCallback(KTCallback {

    })*/

    /**
     * kotlin使用java 的callback
     */
    KtManager().setJavaCallback(JavaCallback {
        println(it)
    })

    KtManager().setJavaCallback(object : JavaCallback {
        override fun show(info: String?) {
            println(info)
        }
    })
    KtManager().setJavaCallback(JavaCallback { it -> println(it) })
    KtManager().setJavaCallback(JavaCallback { println(it) })
 
 
 
 
 

   
 
 

开启 callback 功能，在callback_whitelist 中添加
 
vim ansible.cfg
 
 
callback_plugins   = plugins/callback

# by default callbacks are not loaded for /bin/ansible, enable this if you
# want, for example, a notification or logging callback to also apply to
# /bin/ansible runs
bin_ansible_callbacks = Ture 

# Uncomment below to profile an anible run i.e. how long tasks take
#callback_whitelist = profile_tasks
callback_whitelist = XXX, XXX, XXX
 
ansible 自带哪些 callback 功能。
 
 
actionable – shows only items that need attention
aws_resource_actions – summarizes all “resource:actions” completed
cgroup_memory_recap – Profiles maximum memory usage of tasks and full execution using cgroups
cgroup_perf_recap – Profiles system activity of tasks and full execution using cgroups
context_demo – demo callback that adds play/task context
counter_enabled – adds counters to the output items (tasks and hosts/task)
debug – formatted stdout/stderr display
default – default Ansible screen output
dense – minimal stdout output
foreman – Sends events to Foreman
full_skip – suppresses tasks if all hosts skipped
grafana_annotations – send ansible events as annotations on charts to grafana over http api
hipchat – post task events to hipchat
jabber – post task events to a jabber server
json – Ansible screen output as JSON
junit – write playbook output to a JUnit file
log_plays – write playbook output to log file
logdna – Sends playbook logs to LogDNA
logentries – Sends events to Logentries
logstash – Sends events to Logstash
mail – Sends failure events via email
minimal – minimal Ansible screen output
nrdp – post task result to a nagios server through nrdp
null – Don’t display stuff to screen
oneline – oneline Ansible screen output
osx_say – notify using software speech synthesizer
profile_roles – adds timing information to roles
profile_tasks – adds time information to tasks
say – notify using software speech synthesizer
selective – only print certain tasks
skippy – Ansible screen output that ignores skipped status
slack – Sends play events to a Slack channel
splunk – Sends task result events to Splunk HTTP Event Collector
stderr – Splits output, sending failed tasks to stderr
sumologic – Sends task result events to Sumologic
syslog_json – sends JSON events to syslog
timer – Adds time to play stats
tree – Save host events to files
unixy – condensed Ansible output
yaml – yaml-ized Ansible screen output
 
如果使用系统自带的callback，需要将需要的参数写入 ansible.cfg。
 
 
 
 
自定义 callback
 
如果要编写自定义的callback，要将脚本写入到 plugins/callback，并将路径配置到 ansible.cfg
 
我们写一个当执行结束之后，将执行语句和结果记录到 PG 数据库中的 callback
 
 
1. 建文件，基本内容
 
vim plugins/callback/
 
# 版本
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
# 描述
DOCUMENTATION = """
---
    callback: 
    callback_type: notification
    requirements:
      - packages.
    short_description: short description for the callback plugin.
    description:
        - There is description for this callback plugin.
    author: "chuckchen1222@gmail.com"
"""
# 继承
from ansible.plugins.callback import CallbackBase
# 创建类，继承callbackbase 
# 开始
class CallbackModule(CallbackBase):
    CALLBACK_VERSION = 2.0
    CALLBACK_TYPE = 'notification' #TODO what's a callback type, setting to notification for now because why not I guess? change in DOCUMENTATION as well
    CALLBACK_NAME = 'ta_host_locking'

    def __init__(self):
        super(CallbackModule, self).__init__()
        self.lock_results = None
 
2. 操作执行
 
接下来是我们要做什么，比如我们要在执行之后，将信息添加到数据库中。
 
    def logging_to_db(self, stat):
        sql = 'INSERT INTO test(col1, col2, ctime) VALUES (\'%s\', \'%s\', now());' % (self.cmd , stat)
        conn = psycopg2.connect(database='mytest', user='mytest', host='dbwtest03bc.daodao.com')
        cursor = conn.cursor()
        cursor.execute(sql)
        conn.commit()
        cursor.close()
        conn.close()
 
3. 什么情况下做
 
v2_on_any(self, *args, **kwargs):
v2_runner_on_failed(self, result, ignore_errors=False):
v2_runner_on_ok(self, result):
v2_runner_on_skipped(self, result):
v2_runner_on_unreachable(self, result):
v2_runner_on_async_poll(self, result):
v2_runner_on_async_ok(self, result):
v2_runner_on_async_failed(self, result):
v2_playbook_on_start(self, playbook):
v2_playbook_on_notify(self, handler, host):
v2_playbook_on_no_hosts_matched(self):
v2_playbook_on_no_hosts_remaining(self):
v2_playbook_on_task_start(self, task, is_conditional):
v2_playbook_on_cleanup_task_start(self, task):
v2_playbook_on_handler_task_start(self, task):
v2_playbook_on_vars_prompt(self, varname, private=True, prompt=None, encrypt=None, confirm=False, salt_size=None, salt=None, default=None, unsafe=None):
v2_playbook_on_import_for_host(self, result, imported_file):
v2_playbook_on_not_import_for_host(self, result, missing_file):
v2_playbook_on_play_start(self, play):
v2_playbook_on_stats(self, stats):
v2_on_file_diff(self, result):
v2_playbook_on_include(self, included_file):
v2_runner_item_on_ok(self, result):
v2_runner_item_on_failed(self, result):
v2_runner_item_on_skipped(self, result):
v2_runner_retry(self, result):
v2_runner_on_start(self, host, task):
 
在源码 plugins/callback/__init__.py 中，有这些触发事件。
 
我们可以在这里 overwrite ，控制事件的触发。
 
    def v2_runner_on_ok(self, result):
        print (result.__dict__.items())
        self.logging_to_db(result=result, stat='ok')


    def playbook_on_stats(self, stats):
        if stats:
            print (stats.__dict__.items())
            hosts = sorted(stats.processed.keys())
            for h in hosts:
                s = stats.summarize(h)
                print (s)
            print (stats.custom.key())
 
 
 
4. 可以获取的信息
 
4.1. result
 
result._host: 主机名
 
result._task：任务名
 
result._result：结果
 
result._task_fields：执行信息
 
 
 
4.2 stats
 
stats.__dict__.items()
 
[('processed', {'dbw21as': 1}), ('failures', {'dbw21as': 1}), ('ok', {'dbw21as': 3}), ('dark', {}), ('changed', {}), ('skipped', {}), ('rescued', {}), ('ignored', {}), ('custom', {})]
 
for h in hosts:
    t = stats.summarize(h)