什么是回调方法
个人理解的回调是指在解决某个问题时需要两步操作，此时第一步操作可以看作是为了解决问题，第二步操作是在第一步操作结果的基础上完善或补充操作。此处的第二步操作一般就是回调方法。为什么这么说呢，常规来说为了解决一个问题，我们可能需要调用某些耗时不确定的方法，若让主线程一直等待调用结果很容易造成程序无响应而卡死，影响用户体验。此时就可以用到回调方法来解决问题，将耗时不确定的方法设计为带有回调参数的方法，在耗时方法执行结束时候，继续做后续操作。这里被封装起来的这些操作就是回调方法。
怎么使用回调方法
此处以spring封装的jdbctemplate在查询数据库后可以得到不同类型的数据为例。众所周知，从数据库中查询数据得到的肯定是一个resultset，但这在开发过程中并不能满足实际的需求。我们一般希望得到的是实体对象，或是一个集合等。那么此时有两种选择，一是先进行数据查询，得到result，然后再通过第二个方法对result进行封装。第二种则是在进行数据查询的同时，调用者告诉spring，查询结束后得到result，顺便去执行封装的方法。然后再把封装结果给我。两种方法其实都可行，但是常用的确是第二种。这是为什么呢？一般来说使用回调都是为了避免耗时较长的方法。但更重要的原因是面向对象设计的封装性，模块间要解耦，模块内要内聚。使用回调可以降低模块间的耦合性。另外，在上例中，因为常规关系型数据库并不是面向对象的，所以我们得到的结果并不是能够满足oop的要求，故通过封装，直接得到对应实体或实体集合更符合面向对象的思想。而在平时使用的过程中，通过sql查询并直接返回封装对象更方便，也更符合面向对象的思想。
通过如下代码再来理解回调的使用:
假设数据库中有如下数据：
Person实体类如下
package com.af.study.spring.bean;
/**
* person实体
* Created by zyb on 2017/06/05.
*/
public class Person {
String id;
String name;
Integer sex;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
}
** PersonDao，在封装数据时使用了回调。**
package com.af.study.spring.jdbc;
import com.af.study.spring.bean.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcDaoSupport;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* personDao
* Created by zyb on 2017/07/17.
*/
@Component
public class PersonDao extends NamedParameterJdbcDaoSupport {
@Autowired
public PersonDao(JdbcTemplate jdbcTemplate) {
setJdbcTemplate(jdbcTemplate);
}
List<Person> getBeans(){
return this.getJdbcTemplate().query("select * from t_person", BeanPropertyRowMapper.newInstance(Person.class));
}
}
测试类
package com.af.study.spring.jdbc;
import com.af.study.spring.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
/**
* Created by zyb on 2017/07/17.
*/
public class PersonDaoTest {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
PersonDao personDao = ctx.getBean("personDao", PersonDao.class);
List<Person> personList = personDao.getBeans();
for (Person person : personList) {
System.out.println(person.getId() + " --- " + person.getName() + " --- " + person.getSex());
}
}
}
运行后结果是：
1 --- lx --- 0
2 --- yh --- 1
从上面简单示例可以看到，查询数据库之后直接得到了Person对象集合，而并不是常规的resultSet。spring通过传递一个row mapper参数进去，自动实现一个回掉方法，在得到result set之后进行对象的封装。
通过查看spring源码可以看到如下代码：
public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException {
Assert.notNull(sql, "SQL must not be null");
Assert.notNull(rse, "ResultSetExtractor must not be null");
if (logger.isDebugEnabled()) {
logger.debug("Executing SQL query [" + sql + "]");
}
class QueryStatementCallback implements StatementCallback<T>, SqlProvider {
@Override
public T doInStatement(Statement stmt) throws SQLException {
ResultSet rs = null;
try {
rs = stmt.executeQuery(sql);
ResultSet rsToUse = rs;
if (nativeJdbcExtractor != null) {
rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
}
// 此处调用了回调方法，前面的代码得到result set，通过如下方法，实现封装并返回
return rse.extractData(rsToUse);
}
finally {
JdbcUtils.closeResultSet(rs);
}
}
@Override
public String getSql() {
return sql;
}
}
return execute(new QueryStatementCallback());
}
此处用了内部类来封装操作，将耗时操作（即数据库查询）和后续操作（即封装对象）组合成了新的方法，再将内部类作为参数传递给execute方法，在execute方法中可以看到，直接调用了组合后的方法，将两步操作结果合并并返回。
public <T> T execute(StatementCallback<T> action) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
Connection con = DataSourceUtils.getConnection(getDataSource());
Statement stmt = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements()) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
stmt = conToUse.createStatement();
applyStatementSettings(stmt);
Statement stmtToUse = stmt;
if (this.nativeJdbcExtractor != null) {
stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
}
T result = action.doInStatement(stmtToUse);
handleWarnings(stmt);
return result;
}
catch (SQLException ex) {
// Release Connection early, to avoid potential connection pool deadlock
// in the case when the exception translator hasn't been initialized yet.
JdbcUtils.closeStatement(stmt);
stmt = null;
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
}
finally {
JdbcUtils.closeStatement(stmt);
DataSourceUtils.releaseConnection(con, getDataSource());
}
}
继续跟进extractData方法，可以看到实际上就是遍历了result set，将每一行记录进行封装。
public List<T> extractData(ResultSet rs) throws SQLException {
List<T> results = (this.rowsExpected > 0 ? new ArrayList<T>(this.rowsExpected) : new ArrayList<T>());
int rowNum = 0;
while (rs.next()) {
results.add(this.rowMapper.mapRow(rs, rowNum++));
}
return results;
}
到这里，对于回调方法的演示基本就结束了。下面来说说如何设计、使用回调。
如何设计自己的回调方法
如文章开头所说，回调方法实际上是将耗时操作之后的行为封装，作为参数传递给耗时的方法。通常是使用接口配合内部类的方法来实现，之所以使用内部类+接口，我的理解是结合了代理的思想来实现，通过接口来限定需要代理的方法，在通过内部类来实现接口，不会产生额外的类，也不会对其他地方造成影响。总之，理解了回调就是将操作组合成新的方法作为参数传递，相信在代码中运用回调并不是难事。
写在最后
并不是一定要使用回调，回调并不会对功能造成影响，只是提供了一种提升效率，减少因为等待时间等因素造成bug等问题的解决方案。所有回调都可以将两步操作分开。要做到深入理解回调使用的场景，不要为了使用而强行使用，反而造成了效率问题等。同样也适用于设计模式的学习中。
本文也仅仅是个人的理解，在表述不清或理解不到位的地方，欢迎各位大神指正，也求各位轻拍，刚开始写博客，可能有些地方也表述的不够清晰，望大家能多多包涵。
