转帖请注明本文出自xiaanming的博客(http://blog.csdn.net/xiaanming/article/details/17483273),请尊重他人的辛勤劳动成果,谢谢
回调函数:
所谓回调,就是客户程序C调用服务程序S中的某个函数A,然后S又在某个时候反过来调用C中的某个函数B,对于C来说,这个B便叫做回调函数。回调函数只是一个功能片段,由用户按照回调函数调用约定来实现的一个函数。回调函数是一个工作流的一部分,由工作流来决定函数的调用(回调)时机。一般说来,C不会自己调用B,C提供B的目的就是让S来调用它,而且是C不得不提供。由于S并不知道C提供的B姓甚名谁,所以S会约定B的接口规范(函数原型),然后由C提前通过S的一个函数R告诉S自己将要使用B函数,这个过程称为回调函数的注册,R称为注册函数。Web Service以及Java 的RMI都用到回调机制,可以访问远程服务器程序。回调函数包含下面几个特性:
1、属于工作流的一个部分;
2、必须按照工作流指定的调用约定来申明(定义);
3、他的调用时机由工作流决定,回调函数的实现者不能直接调用回调函数来实现工作流的功能;
回调机制:
回调机制是一种常见的设计模型,他把工作流内的某个功能,按照约定的接口暴露给外部使用者,为外部使用者提供数据,或要求外部使用者提供数据。
java回调机制:
软件模块之间总是存在着一定的接口,从调用方式上,可以把他们分为三类:同步调用、回调和异步调用。
同步调用:一种阻塞式调用,调用方要等待对方执行完毕才返回,它是一种单向调用;
回 调:一种双向调用模式,也就是说,被调用方在接口被调用时也会调用对方的接口;
异步调用:一种类似消息或事件的机制,不过它的调用方向刚好相反,接口的服务在收到某种讯息或发生某种事件时,会主动通知客户方(即调用客户方的接口)。
回调和异步调用的关系非常紧密:使用回调来实现异步消息的注册,通过异步调用来实现消息的通知。
回调实例
1、回调接口
1
2
3
4
|
public
interface
Callback {
String callBack();
}
|
2、调用者
1
2
3
4
5
6
7
8
9
10
11
|
public
class
Another {
private
Callback callback;
//调用实现类的方法
public
void
setCallback(Callback callback) {
this
.callback = callback;
}
//业务需要的时候,通过委派,来调用实现类的具体方法
public
void
doCallback(){
System.out.println(callback.callBack());
}
}
|
3、测试回调函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
class
TestCallcack {
public
static
void
main(String[] args) {
//创建调用者的实现类
Another another =
new
Another();
//将回掉接口注册到实现类中
another.setCallback(
new
Callback() {
@Override
public
String callBack() {
return
"you are a pig"
;
}
});
//执行回调函数
another.doCallback();
}
}
|
回调方法的使用通常发生在“java接口”和“抽象类”的使用过程中。模板方法设计模式就使用方法回调的机制,该模式首先定义特定的步骤的算法骨架,而将一些步骤延迟到子类中去实现的设计模式。模板方法设计模式使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。
模板方式设计模式的适用性:
1、一次性实现一个算法的不变部分,并将可变的算法留给子类来实现。
2、各子类中公共的行为应该被提取出来并集中一个公共父类中以避免代码重复。
3、可以控制子类扩展。
模板实例:
抽象模板方法类:
1
2
3
4
5
6
7
8
9
10
11
|
public
abstract
class
AbstractSup {
//需要子类实现的方法
public
abstract
void
print();
//模板方法
public
void
doPrint(){
System.out.println(
"执行模板方法"
);
for
(
int
i =
0
; i <
3
; i++) {
print();
}
}
}
|
子类实现模板方式类:
1
2
3
4
5
6
7
|
public
class
SubClass
extends
AbstractSup{
@Override
public
void
print() {
System.out.println(
"子类的实现方法"
);
}
}
|
模板方法测试类:
1
2
3
4
5
6
7
|
public
class
TempleteTest {
public
static
void
main(String[] args) {
SubClass subClass =
new
SubClass();
subClass.print();
subClass.doPrint();
}
}
|
下面深入介绍下spring模板方法的使用,以JdbcTemplete为例,详细说明模板模式和回调机制的使用。
首先看一下经典的JDBC编程的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
public
List<User> query() {
List<User> userList =
new
ArrayList<User>();
String sql =
"select * from User"
;
Connection con =
null
;
PreparedStatement pst =
null
;
ResultSet rs =
null
;
try
{
con = HsqldbUtil.getConnection();
pst = con.prepareStatement(sql);
rs = pst.executeQuery();
User user =
null
;
while
(rs.next()) {
user =
new
User();
user.setId(rs.getInt(
"id"
));
user.setUserName(rs.getString(
"user_name"
));
user.setBirth(rs.getDate(
"birth"
));
user.setCreateDate(rs.getDate(
"create_date"
));
userList.add(user);
}
}
catch
(SQLException e) {
e.printStackTrace();
}
finally
{
if
(rs !=
null
){
try
{
rs.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
}
try
{
pst.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
try
{
if
(!con.isClosed()){
try
{
con.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
}
}
catch
(SQLException e) {
e.printStackTrace();
}
}
return
userList;
}
|
一个简单的查询,就要做这么一大堆事情,而且还要处理异常,我们不防来梳理一下:
1、获取connection
2、获取statement
3、获取resultset
4、遍历resultset并封装成集合
5、依次关闭connection,statement,resultset,而且还要考虑各种异常等等。
如果是多个查询会产生较多的重复代码,这时候就可以使用模板机制,通过观察我们发现上面步骤中大多数都是重复的,可复用的,只有在遍历ResultSet并封装成集合的这一步骤是可定制的,因为每张表都映射不同的java bean。这部分代码是没有办法复用的,只能定制。
抽象类代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
public
abstract
class
JdbcTemplate {
//模板方法
public
final
Object execute(String sql)
throws
SQLException{
Connection con = HsqldbUtil.getConnection();
Statement stmt =
null
;
try
{
stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
Object result = doInStatement(rs);
//抽象方法(定制方法,需要子类实现)
return
result;
}
catch
(SQLException ex) {
ex.printStackTrace();
throw
ex;
}
finally
{
try
{
stmt.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
try
{
if
(!con.isClosed()){
try
{
con.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
}
}
catch
(SQLException e) {
e.printStackTrace();
}
}
}
//抽象方法(定制方法)
protected
abstract
Object doInStatement(ResultSet rs);
}
|
这个抽象类中,封装了SUN JDBC API的主要流程,而遍历ResultSet这一步骤则放到抽象方法doInStatement()中,由子类负责实现。
子类实现代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public
class
JdbcTemplateUserImpl
extends
JdbcTemplate {
@Override
protected
Object doInStatement(ResultSet rs) {
List<User> userList =
new
ArrayList<User>();
try
{
User user =
null
;
while
(rs.next()) {
user =
new
User();
user.setId(rs.getInt(
"id"
));
user.setUserName(rs.getString(
"user_name"
));
user.setBirth(rs.getDate(
"birth"
));
user.setCreateDate(rs.getDate(
"create_date"
));
userList.add(user);
}
return
userList;
}
catch
(SQLException e) {
e.printStackTrace();
return
null
;
}
}
}
|
我们在doInStatement()方法中,对ResultSet进行了遍历,最后并返回。
测试代码:
1
2
3
|
String sql =
"select * from User"
;
JdbcTemplate jt =
new
JdbcTemplateUserImpl();
List<User> userList = (List<User>) jt.execute(sql);
|
模板机制的使用到此为止,但是如果每次调用jdbcTemplate时,都要继承一下上面的父类,这样挺不方便的,这样回调机制就可以发挥作用了。
所谓回调,就是方法参数中传递一个接口,父类在调用此方法时,必须调用方法中传递的接口的实现类。
回调加模板模式实现
回调接口:
1
2
3
|
public
interface
StatementCallback {
Object doInStatement(Statement stmt)
throws
SQLException;
}
|
模板方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
public
class
JdbcTemplate {
//模板方法
public
final
Object execute(StatementCallback action)
throws
SQLException{
Connection con = HsqldbUtil.getConnection();
Statement stmt =
null
;
try
{
stmt = con.createStatement();
Object result = action.doInStatement(rs);
//回调方法
return
result;
}
catch
(SQLException ex) {
ex.printStackTrace();
throw
ex;
}
finally
{
try
{
stmt.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
try
{
if
(!con.isClosed()){
try
{
con.close();
}
catch
(SQLException e) {
e.printStackTrace();
}
}
}
catch
(SQLException e) {
e.printStackTrace();
}
}
}
}
public
Object query(StatementCallback stmt)
throws
SQLException{
return
execute(stmt);
}
}
|
测试的类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public
Object query(
final
String sql)
throws
SQLException {
class
QueryStatementCallback
implements
StatementCallback {
public
Object doInStatement(Statement stmt)
throws
SQLException {
ResultSet rs = stmt.executeQuery(sql);
List<User> userList =
new
ArrayList<User>();
User user =
null
;
while
(rs.next()) {
user =
new
User();
user.setId(rs.getInt(
"id"
));
user.setUserName(rs.getString(
"user_name"
));
user.setBirth(rs.getDate(
"birth"
));
user.setCreateDate(rs.getDate(
"create_date"
));
userList.add(user);
}
return
userList;
}
}
JdbcTemplate jt =
new
JdbcTemplate();
return
jt.query(
new
QueryStatementCallback());
}
|
为什么spring不用传统的模板方法,而加之以Callback进行配合呢?
试想,如果父类中有10个抽象方法,而继承它的所有子类则要将这10个抽象方法全部实现,子类显得非常臃肿。而有时候某个子类只需要定制父类中的某一个方法该怎么办呢?这个时候就要用到Callback回调了。
另外,上面这种方式基本上实现了模板方法+回调模式。但离spring的jdbcTemplate还有些距离。 我们上面虽然实现了模板方法+回调模式,但相对于Spring的JdbcTemplate则显得有些“丑陋”。Spring引入了RowMapper和ResultSetExtractor的概念。 RowMapper接口负责处理某一行的数据,例如,我们可以在mapRow方法里对某一行记录进行操作,或封装成entity。 ResultSetExtractor是数据集抽取器,负责遍历ResultSet并根据RowMapper里的规则对数据进行处理。 RowMapper和ResultSetExtractor区别是,RowMapper是处理某一行数据,返回一个实体对象。而ResultSetExtractor是处理一个数据集合,返回一个对象集合。
当然,上面所述仅仅是Spring JdbcTemplte实现的基本原理,Spring JdbcTemplate内部还做了更多的事情,比如,把所有的基本操作都封装到JdbcOperations接口内,以及采用JdbcAccessor来管理DataSource和转换异常等。
以上就是本文的全部内容,希望对大家的学习有所帮助。
以前不理解什么叫回调,天天听人家说加一个回调方法啥的,心里想我草,什么叫回调方法啊?然后自己就在网上找啊找啊找,找了很多也不是很明白,现在知道了,所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法,这样子说你是不是有点晕晕的,其实我刚开始也是这样不理解,看了人家说比较经典的回调方式:
- Class A实现接口CallBack callback——背景1
- class A中包含一个class B的引用b ——背景2
- class B有一个参数为callback的方法f(CallBack callback) ——背景3
- A的对象a调用B的方法 f(CallBack callback) ——A类调用B类的某个方法 C
- 然后b就可以在f(CallBack callback)方法中调用A的方法 ——B类调用A类的某个方法D
大家都喜欢用打电话的例子,好吧,为了跟上时代,我也用这个例子好了,我这个例子采用异步加回调
有一天小王遇到一个很难的问题,问题是“1 + 1 = ?”,就打电话问小李,小李一下子也不知道,就跟小王说,等我办完手上的事情,就去想想答案,小王也不会傻傻的拿着电话去等小李的答案吧,于是小王就对小李说,我还要去逛街,你知道了答案就打我电话告诉我,于是挂了电话,自己办自己的事情,过了一个小时,小李打了小王的电话,告诉他答案是2
- /**
- * 这是一个回调接口
- * @author xiaanming
- *
- */
- public interface CallBack {
- /**
- * 这个是小李知道答案时要调用的函数告诉小王,也就是回调函数
- * @param result 是答案
- */
- public void solve(String result);
- }
- /**
- * 这个是小王
- * @author xiaanming
- * 实现了一个回调接口CallBack,相当于----->背景一
- */
- public class Wang implements CallBack {
- /**
- * 小李对象的引用
- * 相当于----->背景二
- */
- private Li li;
- /**
- * 小王的构造方法,持有小李的引用
- * @param li
- */
- public Wang(Li li){
- this.li = li;
- }
- /**
- * 小王通过这个方法去问小李的问题
- * @param question 就是小王要问的问题,1 + 1 = ?
- */
- public void askQuestion(final String question){
- //这里用一个线程就是异步,
- new Thread(new Runnable() {
- @Override
- public void run() {
- /**
- * 小王调用小李中的方法,在这里注册回调接口
- * 这就相当于A类调用B的方法C
- */
- li.executeMessage(Wang.this, question);
- }
- }).start();
- //小网问完问题挂掉电话就去干其他的事情了,诳街去了
- play();
- }
- public void play(){
- System.out.println("我要逛街去了");
- }
- /**
- * 小李知道答案后调用此方法告诉小王,就是所谓的小王的回调方法
- */
- @Override
- public void solve(String result) {
- System.out.println("小李告诉小王的答案是--->" + result);
- }
- }
- /**
- * 这个就是小李啦
- * @author xiaanming
- *
- */
- public class Li {
- /**
- * 相当于B类有参数为CallBack callBack的f()---->背景三
- * @param callBack
- * @param question 小王问的问题
- */
- public void executeMessage(CallBack callBack, String question){
- System.out.println("小王问的问题--->" + question);
- //模拟小李办自己的事情需要很长时间
- for(int i=0; i<10000;i++){
- }
- /**
- * 小李办完自己的事情之后想到了答案是2
- */
- String result = "答案是2";
- /**
- * 于是就打电话告诉小王,调用小王中的方法
- * 这就相当于B类反过来调用A的方法D
- */
- callBack.solve(result);
- }
- }
- /**
- * 测试类
- * @author xiaanming
- *
- */
- public class Test {
- public static void main(String[]args){
- /**
- * new 一个小李
- */
- Li li = new Li();
- /**
- * new 一个小王
- */
- Wang wang = new Wang(li);
- /**
- * 小王问小李问题
- */
- wang.askQuestion("1 + 1 = ?");
- }
- }
通过上面的那个例子你是不是差不多明白了回调机制呢,上面是一个异步回调,我们看看同步回调吧,onClick()方法
现在来分析分析下Android View的点击方法onclick();我们知道onclick()是一个回调方法,当用户点击View就执行这个方法,我们用Button来举例好了
- //这个是View的一个回调接口
- /**
- * Interface definition for a callback to be invoked when a view is clicked.
- */
- public interface OnClickListener {
- /**
- * Called when a view has been clicked.
- *
- * @param v The view that was clicked.
- */
- void onClick(View v);
- }
- package com.example.demoactivity;
- import android.app.Activity;
- import android.os.Bundle;
- import android.view.View;
- import android.view.View.OnClickListener;
- import android.widget.Button;
- import android.widget.Toast;
- /**
- * 这个就相当于Class A
- * @author xiaanming
- * 实现了 OnClickListener接口---->背景一
- */
- public class MainActivity extends Activity implements OnClickListener{
- /**
- * Class A 包含Class B的引用----->背景二
- */
- private Button button;
- @Override
- public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.activity_main);
- button = (Button)findViewById(R.id.button1);
- /**
- * Class A 调用View的方法,而Button extends View----->A类调用B类的某个方法 C
- */
- button.setOnClickListener(this);
- }
- /**
- * 用户点击Button时调用的回调函数,你可以做你要做的事
- * 这里我做的是用Toast提示OnClick
- */
- @Override
- public void onClick(View v) {
- Toast.makeText(getApplication(), "OnClick", Toast.LENGTH_LONG).show();
- }
- }
下面是View类的setOnClickListener方法,就相当于B类咯,只把关键代码贴出来
- /**
- * 这个View就相当于B类
- * @author xiaanming
- *
- */
- public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {
- /**
- * Listener used to dispatch click events.
- * This field should be made private, so it is hidden from the SDK.
- * {@hide}
- */
- protected OnClickListener mOnClickListener;
- /**
- * setOnClickListener()的参数是OnClickListener接口------>背景三
- * Register a callback to be invoked when this view is clicked. If this view is not
- * clickable, it becomes clickable.
- *
- * @param l The callback that will run
- *
- * @see #setClickable(boolean)
- */
- public void setOnClickListener(OnClickListener l) {
- if (!isClickable()) {
- setClickable(true);
- }
- mOnClickListener = l;
- }
- /**
- * Call this view's OnClickListener, if it is defined.
- *
- * @return True there was an assigned OnClickListener that was called, false
- * otherwise is returned.
- */
- public boolean performClick() {
- sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
- if (mOnClickListener != null) {
- playSoundEffect(SoundEffectConstants.CLICK);
- //这个不就是相当于B类调用A类的某个方法D,这个D就是所谓的回调方法咯
- mOnClickListener.onClick(this);
- return true;
- }
- return false;
- }
- }
这个例子就是Android典型的回调机制,看完这个你是不是更进一步的理解了回调机制呢? 线程run()也是一个回调方法,当执行Thread的start()方法就会回调这个run()方法,还有处理消息都比较经典等等
Java回调机制解析
模块之间总是存在这一定的接口,从调用方式上看,可以分为三类:同步调用、回调和异步调用。同步调用是一种阻塞式调用,也是我们在写程序中经常使用的;回调是一种双向的调用模式,也就是说,被调用的接口被调用时也会调用对方的接口,这句话可能有点绕,等文章后面举例说明;异步调用是一种类似消息或事件的机制,解决了同步阻塞的问题,举例来讲:A通知B后,他们各走各的路,互不影响,不用像同步调用那样,A通知B后,非得等到B走完后,A才继续走。回调是异步的基本,因此下面着重说回调机制。
首先创建一个回调接口,让老板得告知干完活如何找到他的方式:留下老板办公室地址:
- package net.easyway.test;
- /**
- * 此接口为联系的方式,不论是电话号码还是联系地址,作为
- * 老板都必须要实现此接口
- * @author Administrator
- *
- */
- public interface CallBackInterface {
- public void execute();
- }
创建回调对象,就是老板本人,因为员工干完活后要给他打电话,因此老板必须实现回调接口,不然员工去哪里找老板?
- package net.easyway.test;
- /**
- * 老板是作为上层应用身份出现的,下层应用(员工)是不知道
- * 有哪些方法,因此他想被下层应用(员工)调用必须实现此接口
- * @author Administrator
- *
- */
- public class Boss implements CallBackInterface {
- @Override
- public void execute() {
- System.out.println("收到了!!" + System.currentTimeMillis());
- }
- }
创建控制类,也就是员工对象,他必须持有老板的地址(回调接口),即使老板换了一茬又一茬,办公室不变,总能找到对应的老板。
- package net.easyway.test;
- /**
- * 员工类,必须要记住,这是一个底层类,底层是不了解上层服务的
- * @author Administrator
- *
- */
- public class Employee {
- private CallBackInterface callBack = null;
- //告诉老板的联系方式,也就是注册
- public void setCallBack(CallBackInterface callBack){
- this.callBack = callBack;
- }
- //工人干活
- public void doSome(){
- //1.开始干活了
- for(int i=0;i<10;i++){
- System.out.println("第【" + i + "】事情干完了!");
- }
- //2.告诉老板干完了
- callBack.execute();
- }
- }
测试类代码:
- package net.easyway.test;
- public class Client {
- public static void main(String[] args) {
- Employee emp = new Employee();
- //将回调对象(上层对象)传入,注册
- emp.setCallBack(new Boss());
- //开启控制器对象运行
- emp.doSome();
- }
- }
上面这个例子,大家可以和程序员A和程序员B的那个例子结合对照下。
看了上面的例子,有的人可能认为,这不是面向接口的编程吗?怎么会是回调,你再好好想想,咱们面向接口的编程的调用关系?在三层中,当业务层调用数据层时,是不需要把业务层自身传递到数据层的,并且这是一种上层调用下层的关系,比如我们在用框架的时候,一般直接调用框架提供的API就可以了,但回调不同,当框架不能满足需求,我们想让框架来调用自己的类方法,怎么做呢?总不至于去修改框架吧。许多优秀的框架提几乎都供了相关的接口,我们只需要实现相关接口,即可完成了注册,然后在合适的时候让框架来调用我们自己的类,还记不记得我们在使用Struts时,当我们编写Action时,就需要继承Action类,然后实现execute()方法,在execute()方法中写咱们自己的业务逻辑代码,完成对用户请求的处理。由此可以猜测,框架和容器中会提供大量的回调接口,以满足个性化的定制。
不知道上面这个例子懂了没有?我们现在可以想象Filter和Interceptor的区别了,这两者其中最大的一个区别是Filter是基于回调函数,需要容器的支持,没有容器是无法回调doFilter()方法,而Interceptor是基于Java的反射机制的,和容器无关。那到此是否又将反射和回调搞混了呢?请见我讲Java动态代理的博客《以此之长,补彼之短----AOP(代理模式)》。
总之,要明确的一点是,首先要搞清回调函数出现的原因,也就是适用场景,才能搞清楚回调机制,不然事倍功半。
最后,再举一例,为了使我们写的函数接近完美,就把一部分功能外包给别人,让别人个性化定制,至于别人怎么实现不管,我唯一要做的就是定义好相关接口,这一设计允许了底层代码调用高层定义的子程序,增强程序灵活性,和反射有着异曲同工之妙,我觉得这才是回调的真正原因,以上是我个人一些理解,望讨论!
注:本文不想扯很多拗口的话来充场面,我的目的是希望以最简明扼要的语言将Java回调的大概机制说清楚。好了,言归正传。
一句话, 回调是一种双向调用模式,什么意思呢,就是说,被调用方在被调用时也会调用对方,这就叫回调。“If you call me, i will call back”。
不理解?没关系,先看看这个可以说比较 经典的使用回调的方式:
- class A实现接口InA ——背景1
- class A中包含一个class B的引用b ——背景2
- class B有一个参数为InA的方法test(InA a) ——背景3
- A的对象a调用B的方法传入自己,test(a) ——这一步相当于you call me
- 然后b就可以在test方法中调用InA的方法 ——这一步相当于i call you back
是不是清晰一点了?下面再来看一个完全符合这个方式模板的例子
(PS:这个例子来源于网络,由于这个例子表现的功能极度拉风,令我感觉想想出一个超越它的例子确实比较困难,所以直接搬过来)
- //相当于接口InA
- public interface BoomWTC{
- //获得拉登的决定
- public benLaDengDecide();
- // 执行轰炸世贸
- public void boom();
- }
- //相当于class A
- public class At$911 implements BoomWTC{//相当于【背景1】
- private boolean decide;
- private TerroristAttack ta;//相当于【背景2】
- public At$911(){
- Date now=new Date();
- SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");
- this.dicede= myFmt.format(dt).equals("01/09/11 09:44");
- this.ta=new TerroristAttack();
- }
- //获得拉登的决定
- public boolean benLaDengDecide(){
- return decide;
- }
- // 执行轰炸世贸
- public void boom(){
- ta.attack(new At$911);//class A调用class B的方法传入自己的对象,相当于【you call me】
- }
- }
- //相当于class B
- public class TerroristAttack{
- public TerroristAttack(){
- }
- public attack(BoomWTC bmw){——这相当于【背景3】
- if(bmw.benLaDengDecide()){//class B在方法中回调class A的方法,相当于【i call you back】
- //let's go.........
- }
- }
- }
现在应该对回调有一点概念了吧。
可是问题来了,对于上面这个例子来说,看不出用回调有什么好处,直接在调用方法不就可以了, 为什么要使用回调呢?
事实上,很多需要进行回调的操作是比较费时的,被调用者进行费时操作,然后操作完之后将结果回调给调用者。看这样一个例子:
- //模拟Spring中HibernateTemplate回调机制的代码
- interface CallBack{
- public void doCRUD();
- }
- public class HibernateTemplate {
- public void execute(CallBack action){
- getConnection();
- action.doCRUD();
- releaseConnection();
- }
- public void add(){
- execute(new CallBack(){
- public void doCRUD(){
- System.out.println("执行add操作...");
- }
- });
- }
- public void getConnection(){
- System.out.println("获得连接...");
- }
- public void releaseConnection(){
- System.out.println("释放连接...");
- }
- }
可能上面这个例子你不能一眼看出个所以然来,因为其实这里A是作为一个内部匿名类存在的。好,不要急,让我们把这个例子来重构一下:
- interface CallBack{ //相当于接口InA
- public void doCRUD();
- }
- public class A implements CallBack{//【背景1】
- private B b;//【背景2】
- public void doCRUD(){
- System.out.println("执行add操作...");
- }
- public void add(){
- b.execute(new A());//【you call me】
- }
- }
- public class B{
- public void execute(CallBack action){ //【背景3】
- getConnection();
- action.doCRUD(); //【i call you back】
- releaseConnection();
- }
- public void getConnection(){
- System.out.println("获得连接...");
- }
- public void releaseConnection(){
- System.out.println("释放连接...");
- }
- }
好了,现在就明白多了吧,完全可以转化为上面所说的回调使用方式的模板。
现在在来看看为什么要使用回调,取得连接getConnection();是费时操作,A希望由B来进行这个费时的操作,执行完了之后通知A即可(即所谓的i call you back)。这就是这里使用回调的原因。
在网上看到了一个比喻,觉得很形象,这里借用一下:
你有一个复杂的问题解决不了,打电话给你的同学,你的同学说可以解决这个问题,但是需要一些时间,那么你不可能一直拿着电话在那里等,你会把你的电话号码告诉他,让他解决之后打电话通知你。回调就是体现在你的同学又反过来拨打你的号码。
结合到前面所分析的,你打电话给你同学就是【you call me】,你同学解决完之后打电话给你就是【i call you back】。
怎么样,现在理解了吧?
---------------------------------以下为更新----------------------------------
看了有些朋友的回帖,我又思考了一下,感觉自己之前对回调作用的理解的确存在偏差。
下面把自己整理之后的想法共享一下,如果有错误希望指出!多谢!
先说上面这段代码,本来完全可以用模板模式来进行实现:
- public abstract class B{
- public void execute(){
- getConnection();
- doCRUD();
- releaseConnection();
- }
- public abstract void doCRUD();
- public void getConnection(){
- System.out.println("获得连接...");
- }
- public void releaseConnection(){
- System.out.println("释放连接...");
- }
- }
- public class A extends B{
- public void doCRUD(){
- System.out.println("执行add操作...");
- }
- public void add(){
- doCRUD();
- }
- }
- public class C extends B{
- public void doCRUD(){
- System.out.println("执行delete操作...");
- }
- public void delete(){
- doCRUD();
- }
- }
如果改为回调实现是这样的:
- interface CallBack{
- public void doCRUD();
- }
- public class HibernateTemplate {
- public void execute(CallBack action){
- getConnection();
- action.doCRUD();
- releaseConnection();
- }
- public void add(){
- execute(new CallBack(){
- public void doCRUD(){
- System.out.println("执行add操作...");
- }
- });
- }
- public void delete(){
- execute(new CallBack(){
- public void doCRUD(){
- System.out.println("执行delete操作...");
- }
- });
- }
- public void getConnection(){
- System.out.println("获得连接...");
- }
- public void releaseConnection(){
- System.out.println("释放连接...");
- }
- }
可见 摒弃了继承抽象类方式的回调方式更加简便灵活。不需要为了实现抽象方法而总是继承抽象类,而是只需要通过回调来增加一个方法即可,更加的直观简洁灵活。这算是回调的好处之一。
下面再给出一个关于 利用回调配合异步调用的很不错的例子,来源于 http://kt8668.iteye.com/blog/205739
回调接口:
- public interface CallBack {
- /**
- * 执行回调方法
- * @param objects 将处理后的结果作为参数返回给回调方法
- */
- public void execute(Object... objects );
- }
消息的发送者:
- /**
- * 这个类相当于你自己
- */
- public class Local implements CallBack,Runnable{
- private Remote remote;
- /**
- * 发送出去的消息
- */
- private String message;
- public Local(Remote remote, String message) {
- super();
- this.remote = remote;
- this.message = message;
- }
- /**
- * 发送消息
- */
- public void sendMessage()
- {
- /**当前线程的名称**/
- System.out.println(Thread.currentThread().getName());
- /**创建一个新的线程发送消息**/
- Thread thread = new Thread(this);
- thread.start();
- /**当前线程继续执行**/
- System.out.println("Message has been sent by Local~!");
- }
- /**
- * 发送消息后的回调函数
- */
- public void execute(Object... objects ) {
- /**打印返回的消息**/
- System.out.println(objects[0]);
- /**打印发送消息的线程名称**/
- System.out.println(Thread.currentThread().getName());
- /**中断发送消息的线程**/
- Thread.interrupted();
- }
- public static void main(String[] args)
- {
- Local local = new Local(new Remote(),"Hello");
- local.sendMessage();
- }
- public void run() {
- remote.executeMessage(message, this); //这相当于给同学打电话,打完电话之后,这个线程就可以去做其他事情了,只不过等到你的同学打回电话给你的时候你要做出响应
- }
- }
消息的接收者:
- /**
- * 这个类相当于你的同学
- */
- public class Remote {
- /**
- * 处理消息
- * @param msg 接收的消息
- * @param callBack 回调函数处理类
- */
- public void executeMessage(String msg,CallBack callBack)
- {
- /**模拟远程类正在处理其他事情,可能需要花费许多时间**/
- for(int i=0;i<1000000000;i++)
- {
- }
- /**处理完其他事情,现在来处理消息**/
- System.out.println(msg);
- System.out.println("I hava executed the message by Local");
- /**执行回调**/
- callBack.execute(new String[]{"Nice to meet you~!"}); //这相当于同学执行完之后打电话给你
- }
- }
由上面这个例子可见,回调可以作为异步调用的基础来实现异步调用。