observerActions = registry.getMatchedObserverActions(event);
+
+ for (ObserverAction observerAction : observerActions) {
+ executor.execute(new Runnable() {
+ @Override
+ public void run() {
+ observerAction.execute(event);
+ }
+ });
+ }
+ }
+}
+```
+
+
+
+#### AsyncEventBus
+
+有了 EventBus，AsyncEventBus 的实现就非常简单了。为了实现异步非阻塞的观察者模式，它就不能再继续使用 MoreExecutors.directExecutor() 了，而是需要在构造函数中，由调用者注入线程池。
+
+```java
+public class AsyncEventBus extends EventBus {
+
+ public AsyncEventBus(Executor executor) {
+ super(executor);
+ }
+}
+```
+
+至此，我们用了不到 200 行代码，就实现了一个还算凑活能用的 EventBus，从功能上来讲，它跟 Google Guava EventBus 几乎一样。不过，如果去查看Google Guava EventBus的源码，你会发现，在实现细节方面，相比我们现在的实现，它其实做了很多优化，比如优化了在注册表中查找消息可匹配函数的算法。如果有时间的话，建议你去读一下它的源码。
+
+
+
+
+
+
+
+# 模板模式【常用】
+
+我们再学习另外一种行为型设计模式，模板模式。我们多次强调，绝大部分设计模式的原理和实现，都非常简单，难的是掌握应用场景，搞清楚能解决什么问题。模板模式也不例外。模板模式主要是用来解决复用和扩展两个问题。我们今天会结合 Java Servlet、JUnit TestCase、Java InputStream、Java AbstractList 四个例子来具体讲解这两个作用。
+
+
+
+
+
+
+
+
+
+## 模板模式的原理与实现
+
+1. 模板模式，全称是模板方法设计模式，英文是 Template Method Design Pattern。在 GoF 的《设计模式》一书中，它是这么定义的：
+
+> Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.
+
+2. 翻译成中文就是：模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。
+3. 这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。
+4. 原理很简单，代码实现就更加简单，我写了一个示例代码，如下所示。templateMethod() 函数定义为 final，是为了避免子类重写它。method1() 和 method2() 定义为 abstract，是为了强迫子类去实现。不过，这些都不是必须的，在实际的项目开发中，模板模式的代码实现比较灵活，待会儿讲到应用场景的时候，我们会有具体的体现。
+
+
+
+```java
+public abstract class AbstractClass {
+ public final void templateMethod() {
+ //...
+ method1();
+ //...
+ method2();
+ //...
+ }
+
+ protected abstract void method1();
+ protected abstract void method2();
+}
+
+public class ConcreteClass1 extends AbstractClass {
+
+ @Override
+ protected void method1() {
+ //...
+ }
+
+ @Override
+ protected void method2() {
+ //...
+ }
+}
+
+public class ConcreteClass2 extends AbstractClass {
+
+ @Override
+ protected void method1() {
+ //...
+ }
+
+ @Override
+ protected void method2() {
+ //...
+ }
+}
+
+AbstractClass demo = ConcreteClass1();
+demo.templateMethod();
+```
+
+
+
+## Demo案例-制作豆浆
+
+编写制作豆浆的程序，说明如下:
+
+1. 制作豆浆的流程 选材--->添加配料--->浸泡--->放到豆浆机打碎
+2. 通过添加不同的配料，可以制作出不同口味的豆浆
+3. 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
+4. 请使用 模板方法模式 完成 (说明：因为模板方法模式，比较简单，很容易就想到这个方案，因此就直接使用，
+
+不再使用传统的方案来引出模板方法模式
+
+### SoyaMilk【抽象类】
+
+```java
+//抽象类，表示豆浆
+public abstract class SoyaMilk {
+
+ //模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
+ final void make() {
+
+ select();
+ if(customerWantCondiments()) {
+ addCondiments();
+ }
+ soak();
+ beat();
+
+ }
+
+ //选材料
+ void select() {
+ System.out.println("第一步：选择好的新鲜黄豆 ");
+ }
+
+ //添加不同的配料， 抽象方法, 子类具体实现
+ abstract void addCondiments();
+
+ //浸泡
+ void soak() {
+ System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");
+ }
+
+ void beat() {
+ System.out.println("第四步：黄豆和配料放到豆浆机去打碎 ");
+ }
+
+ //钩子方法，决定是否需要添加配料
+ boolean customerWantCondiments() {
+ return true;
+ }
+}
+```
+
+### RedBeanSoyaMilk
+
+```java
+public class RedBeanSoyaMilk extends SoyaMilk {
+
+ @Override
+ void addCondiments() {
+ // TODO Auto-generated method stub
+ System.out.println(" 加入上好的红豆 ");
+ }
+}
+```
+
+### PureSoyaMilk
+
+```java
+// 纯豆浆
+public class PureSoyaMilk extends SoyaMilk {
+
+ @Override
+ void addCondiments() {
+ // TODO Auto-generated method stub
+ // 空实现
+ }
+
+ @Override
+ boolean customerWantCondiments() {
+ // TODO Auto-generated method stub
+ return false;
+ }
+}
+```
+
+### PeanutSoyaMilk
+
+```java
+public class PeanutSoyaMilk extends SoyaMilk {
+
+ @Override
+ void addCondiments() {
+ // TODO Auto-generated method stub
+ System.out.println(" 加入上好的花生 ");
+ }
+}
+```
+
+### Client
+
+```java
+public class Client {
+
+ public static void main(String[] args) {
+ System.out.println("----制作红豆豆浆----");
+ SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
+ redBeanSoyaMilk.make();
+
+ System.out.println("----制作花生豆浆----");
+ SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
+ peanutSoyaMilk.make();
+
+ System.out.println("----制作纯豆浆----");
+ SoyaMilk pureSoyaMilk = new PureSoyaMilk();
+ pureSoyaMilk.make();
+ }
+}
+```
+
+
+
+## 模板模式作用一：复用
+
+开篇的时候，我们讲到模板模式有两大作用：复用和扩展。我们先来看它的第一个作用：复用。模板模式把一个算法中不变的流程抽象到父类的模板方法 templateMethod() 中，将可变的部分 method1()、method2() 留给子类 ContreteClass1 和 ContreteClass2 来实现。所有的子类都可以复用父类中模板方法定义的流程代码。我们通过两个小例子来更直观地体会一下。
+
+
+
+### Java InputStream
+
+1. Java IO 类库中，有很多类的设计用到了模板模式，比如 InputStream、OutputStream、Reader、Writer。我们拿 InputStream 来举例说明一下。
+2. 我把 InputStream 部分相关代码贴在了下面。在代码中，read() 函数是一个模板方法，定义了读取数据的整个流程，并且暴露了一个可以由子类来定制的抽象方法。不过这个方法也被命名为了 read()，只是参数跟模板方法不同。
+
+
+
+```java
+import java.io.IOException;
+
+public abstract class InputStream implements Closeable {
+ //...省略其他代码...
+
+ public int read(byte b[], int off, int len) throws IOException {
+ if (b == null) {
+ throw new NullPointerException();
+ } else if (off < 0 || len < 0 || len > b.length - off) {
+ throw new IndexOutOfBoundsException();
+ } else if (len == 0) {
+ return 0;
+ }
+ int c = read();
+ if (c == -1) {
+ return -1;
+ }
+ b[off] = (byte) c;
+ int i = 1;
+ try {
+ for (; i < len; i++) {
+ c = read();
+ if (c == -1) {
+ break;
+ }
+ b[off + i] = (byte) c;
+ }
+ } catch (IOException ee) {
+ }
+ return i;
+
+ }
+ public abstract int read() throws IOException;
+}
+
+public class ByteArrayInputStream extends InputStream {
+ //...省略其他代码...
+
+ @Override
+ public synchronized int read() {
+ return (pos < count) ? (buf[pos++] & 0xff) : -1;
+ }
+}
+```
+
+
+
+
+
+### Java AbstractList
+
+在 Java AbstractList 类中，addAll() 函数可以看作模板方法，add() 是子类需要重写的方法，尽管没有声明为 abstract 的，但函数实现直接抛出了 UnsupportedOperationException 异常。前提是，如果子类不重写是不能使用的。
+
+```java
+public boolean addAll(int index,Collection c){
+ rangeCheckForAdd(index);
+ boolean modified=false;
+
+ for(E e:c){
+ add(index++,e);
+ modified=true;
+ }
+ return modified;
+}
+
+public void add(int index,E element){
+ throw new UnsupportedOperationException();
+}
+```
+
+
+
+
+
+## 模板模式作用二：扩展
+
+模板模式的第二大作用的是扩展。这里所说的扩展，并不是指代码的扩展性，而是指框架的扩展性，有点类似我们之前讲到的控制反转。基于这个作用，模板模式常用在框架的开发中，让框架用户可以在不修改框架源码的情况下，定制化框架的功能。我们通过 Junit TestCase、Java Servlet 两个例子来解释一下。
+
+
+
+### Java Servlet
+
+对于 Java Web 项目开发来说，常用的开发框架是 SpringMVC。利用它，我们只需要关注业务代码的编写，底层的原理几乎不会涉及。但是，如果我们抛开这些高级框架来开发 Web 项目，必然会用到 Servlet。实际上，使用比较底层的 Servlet 来开发 Web 项目也不难。我们只需要定义一个继承 HttpServlet 的类，并且重写其中的 doGet() 或 doPost() 方法，来分别处理 get 和 post 请求。具体的代码示例如下所示：
+
+```java
+public class HelloServlet extends HttpServlet {
+
+ @Override
+ protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ this.doPost(req, resp);
+ }
+
+ @Override
+ protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+ resp.getWriter().write("Hello World.");
+ }
+}
+```
+
+除此之外，我们还需要在配置文件 web.xml 中做如下配置。Tomcat、Jetty 等 Servlet 容器在启动的时候，会自动加载这个配置文件中的 URL 和 Servlet 之间的映射关系。
+
+```xml
+
+ HelloServlet
+ com.xzg.cd.HelloServlet
+
+
+
+ HelloServlet
+ /hello
+
+```
+
+当我们在浏览器中输入网址（比如，http://127.0.0.1:8080/hello ）的时候，Servlet 容器会接收到相应的请求，并且根据 URL 和 Servlet 之间的映射关系，找到相应的 Servlet（HelloServlet），然后执行它的 service() 方法。service() 方法定义在父类 HttpServlet 中，它会调用 doGet() 或 doPost() 方法，然后输出数据（“Hello world”）到网页。
+
+
+
+我们现在来看，HttpServlet 的 service() 函数长什么样子。
+
+```java
+public void service(ServletRequest req, ServletResponse res)
+ throws ServletException, IOException {
+ HttpServletRequest request;
+ HttpServletResponse response;
+ if (!(req instanceof HttpServletRequest && res instanceof HttpServletResponse)) {
+ throw new ServletException("non-HTTP request or response");
+ }
+ request = (HttpServletRequest) req;
+ response = (HttpServletResponse) res;
+ service(request, response);
+ }
+
+ protected void service(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException {
+ String method = req.getMethod();
+ if (method.equals(METHOD_GET)) {
+ long lastModified = getLastModified(req);
+ if (lastModified == -1) {
+ // servlet doesn't support if-modified-since, no reason
+ // to go through further expensive logic
+ doGet(req, resp);
+ } else {
+ long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
+ if (ifModifiedSince < lastModified) {
+ // If the servlet mod time is later, call doGet()
+ // Round down to the nearest second for a proper compare
+ // A ifModifiedSince of -1 will always be less
+ maybeSetLastModified(resp, lastModified);
+ doGet(req, resp);
+ } else {
+ resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
+ }
+ }
+ } else if (method.equals(METHOD_HEAD)) {
+ long lastModified = getLastModified(req);
+ maybeSetLastModified(resp, lastModified);
+ doHead(req, resp);
+ } else if (method.equals(METHOD_POST)) {
+ doPost(req, resp);
+ } else if (method.equals(METHOD_PUT)) {
+ doPut(req, resp);
+ } else if (method.equals(METHOD_DELETE)) {
+ doDelete(req, resp);
+ } else if (method.equals(METHOD_OPTIONS)) {
+ doOptions(req, resp);
+ } else if (method.equals(METHOD_TRACE)) {
+ doTrace(req, resp);
+ } else {
+ String errMsg = lStrings.getString("http.method_not_implemented");
+ Object[] errArgs = new Object[1];
+ errArgs[0] = method;
+ errMsg = MessageFormat.format(errMsg, errArgs);
+ resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
+ }
+ }
+```
+
+从上面的代码中我们可以看出，HttpServlet 的 service() 方法就是一个模板方法，它实现了整个 HTTP 请求的执行流程，doGet()、doPost() 是模板中可以由子类来定制的部分。实际上，这就相当于 Servlet 框架提供了一个扩展点（doGet()、doPost() 方法），让框架用户在不用修改 Servlet 框架源码的情况下，将业务代码通过扩展点镶嵌到框架中执行。
+
+
+
+### JUnit TestCase
+
+1. 跟 Java Servlet 类似，JUnit 框架也通过模板模式提供了一些功能扩展点（setUp()、tearDown() 等），让框架用户可以在这些扩展点上扩展功能。
+2. 在使用 JUnit 测试框架来编写单元测试的时候，我们编写的测试类都要继承框架提供的 TestCase 类。在 TestCase 类中，runBare() 函数是模板方法，它定义了执行测试用例的整体流程：先执行 setUp() 做些准备工作，然后执行 runTest() 运行真正的测试代码，最后执行 tearDown() 做扫尾工作。
+3. TestCase 类的具体代码如下所示。尽管 setUp()、tearDown() 并不是抽象函数，还提供了默认的实现，不强制子类去重新实现，但这部分也是可以在子类中定制的，所以也符合模板模式的定义。
+
+```java
+public abstract class TestCase extends Assert implements Test {
+
+ public void runBare() throws Throwable {
+ Throwable exception = null;
+ setUp();
+ try {
+ runTest();
+ } catch (Throwable running) {
+ exception = running;
+ } finally {
+ try {
+ tearDown();
+ } catch (Throwable tearingDown) {
+ if (exception == null) exception = tearingDown;
+ }
+ }
+ if (exception != null) throw exception;
+ }
+
+ /**
+ * * Sets up the fixture, for example, open a network connection.
+ *
+ * * This method is called before a test is executed.
+ */
+ protected void setUp() throws Exception {}
+
+ /**
+ * * Tears down the fixture, for example, close a network connection.
+ *
+ *
* This method is called after a test is executed.
+ */
+ protected void tearDown() throws Exception {}
+}
+```
+
+
+
+
+
+## 回调的原理解析
+
+复用和扩展是模板模式的两大作用，实际上，还有另外一个技术概念，也能起到跟模板模式相同的作用，那就是**回调**（Callback）。今天我们今天就来看一下，回调的原理、实现和应用，以及它跟模板模式的区别和联系。
+
+
+
+1. 相对于普通的函数调用来说，回调是一种双向调用关系。A 类事先注册某个函数 F 到 B 类，A 类在调用 B 类的 P 函数的时候，B 类反过来调用 A 类注册给它的 F 函数。这里的 F 函数就是“回调函数”。A 调用 B，B 反过来又调用 A，这种调用机制就叫作“回调”。
+2. A 类如何将回调函数传递给 B 类呢？不同的编程语言，有不同的实现方法。C 语言可以使用函数指针，Java 则需要使用包裹了回调函数的类对象，我们简称为回调对象。这里我用 Java 语言举例说明一下。代码如下所示：
+
+```java
+public interface ICallback {
+ void methodToCallback();
+}
+
+public class BClass {
+
+ public void process(ICallback callback) {
+ // ...
+ callback.methodToCallback();
+ // ...
+ }
+}
+
+public class AClass {
+
+ public static void main(String[] args) {
+ BClass b = new BClass();
+ b.process(
+ new ICallback() { // 回调对象
+ @Override
+ public void methodToCallback() {
+ System.out.println("Call back me.");
+ }
+ });
+ }
+}
+
+```
+
+1. 上面就是 Java 语言中回调的典型代码实现。从代码实现中，我们可以看出，回调跟模板模式一样，也具有复用和扩展的功能。除了回调函数之外，BClass 类的 process() 函数中的逻辑都可以复用。如果 ICallback、BClass 类是框架代码，AClass 是使用框架的客户端代码，我们可以通过 ICallback 定制 process() 函数，也就是说，框架因此具有了扩展的能力。
+2. 实际上，回调不仅可以应用在代码设计上，在更高层次的架构设计上也比较常用。比如，通过三方支付系统来实现支付功能，用户在发起支付请求之后，一般不会一直阻塞到支付结果返回，而是注册回调接口（类似回调函数，一般是一个回调用的 URL）给三方支付系统，等三方支付系统执行完成之后，将结果通过回调接口返回给用户。
+3. 回调可以分为同步回调和异步回调（或者延迟回调）。同步回调指在函数返回之前执行回调函数；异步回调指的是在函数返回之后执行回调函数。上面的代码实际上是同步回调的实现方式，在 process() 函数返回之前，执行完回调函数 methodToCallback()。而上面支付的例子是异步回调的实现方式，发起支付之后不需要等待回调接口被调用就直接返回。从应用场景上来看，同步回调看起来更像模板模式，异步回调看起来更像观察者模式。
+
+
+
+### 应用举例一：JdbcTemplate
+
+1. Spring 提供了很多 Template 类，比如，JdbcTemplate、RedisTemplate、RestTemplate。尽管都叫作 xxxTemplate，但它们并非基于模板模式来实现的，而是基于回调来实现的，确切地说应该是同步回调。而同步回调从应用场景上很像模板模式，所以，在命名上，这些类使用 Template（模板）这个单词作为后缀。
+2. 这些 Template 类的设计思路都很相近，所以，我们只拿其中的 JdbcTemplate 来举例分析一下。对于其他 Template 类，你可以阅读源码自行分析。
+3. 在前面的章节中，我们也多次提到，Java 提供了 JDBC 类库来封装不同类型的数据库操作。不过，直接使用 JDBC 来编写操作数据库的代码，还是有点复杂的。比如，下面这段是使用 JDBC 来查询用户信息的代码。
+
+```java
+public class JdbcDemo {
+ public User queryUser(long id) {
+ Connection conn = null;
+ Statement stmt = null;
+ try {
+ // 1.加载驱动
+ Class.forName("com.mysql.jdbc.Driver");
+ conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/demo", "xzg", "xzg");
+ // 2.创建statement类对象，用来执行SQL语句
+ stmt = conn.createStatement();
+ // 3.ResultSet类，用来存放获取的结果集
+ String sql = "select * from user where id=" + id;
+ ResultSet resultSet = stmt.executeQuery(sql);
+ String eid = null, ename = null, price = null;
+ while (resultSet.next()) {
+ User user = new User();
+ user.setId(resultSet.getLong("id"));
+ user.setName(resultSet.getString("name"));
+ user.setTelephone(resultSet.getString("telephone"));
+ return user;
+ }
+ } catch (ClassNotFoundException e) {
+ // TODO: log...
+ } catch (SQLException e) {
+ // TODO: log...
+ } finally {
+ if (conn != null)
+ try {
+ conn.close();
+ } catch (SQLException e) {
+ // TODO: log...
+ }
+ if (stmt != null)
+ try {
+ stmt.close();
+ } catch (SQLException e) {
+ // TODO: log...
+ }
+ }
+ return null;
+ }
+}
+
+```
+
+
+
+4. queryUser() 函数包含很多流程性质的代码，跟业务无关，比如，加载驱动、创建数据库连接、创建 statement、关闭连接、关闭 statement、处理异常。针对不同的 SQL 执行请求，这些流程性质的代码是相同的、可以复用的，我们不需要每次都重新敲一遍。
+5. 针对这个问题，Spring 提供了 JdbcTemplate，对 JDBC 进一步封装，来简化数据库编程。使用 JdbcTemplate 查询用户信息，我们只需要编写跟这个业务有关的代码，其中包括，查询用户的 SQL 语句、查询结果与 User 对象之间的映射关系。其他流程性质的代码都封装在了 JdbcTemplate 类中，不需要我们每次都重新编写。我用 JdbcTemplate 重写了上面的例子，代码简单了很多，如下所示：
+
+```java
+public class JdbcTemplateDemo {
+ private JdbcTemplate jdbcTemplate;
+
+ public User queryUser(long id) {
+ String sql = "select * from user where id=" + id;
+ return jdbcTemplate.query(sql, new UserRowMapper()).get(0);
+ }
+
+ class UserRowMapper implements RowMapper {
+ public User mapRow(ResultSet rs, int rowNum) throws SQLException {
+ User user = new User();
+ user.setId(rs.getLong("id"));
+ user.setName(rs.getString("name"));
+ user.setTelephone(rs.getString("telephone"));
+ return user;
+ }
+ }
+}
+
+```
+
+
+
+6. 那 JdbcTemplate 底层具体是如何实现的呢？我们来看一下它的源码。因为 JdbcTemplate 代码比较多，我只摘抄了部分相关代码，贴到了下面。其中，JdbcTemplate 通过回调的机制，将不变的执行流程抽离出来，放到模板方法 execute() 中，将可变的部分设计成回调 StatementCallback，由用户来定制。query() 函数是对 execute() 函数的二次封装，让接口用起来更加方便。
+
+```java
+@Override
+ public List query(String sql, RowMapper rowMapper) throws DataAccessException {
+ return query(sql, new RowMapperResultSetExtractor(rowMapper));
+ }
+
+ @Override
+ public T query(final String sql, final ResultSetExtractor 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, 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);
+ }
+ return rse.extractData(rsToUse);
+ } finally {
+ JdbcUtils.closeResultSet(rs);
+ }
+ }
+
+ @Override
+ public String getSql() {
+ return sql;
+ }
+ }
+ return execute(new QueryStatementCallback());
+ }
+
+ @Override
+ public T execute(StatementCallback 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());
+ }
+ }
+```
+
+
+
+### 应用举例二：setClickListener(）
+
+在客户端开发中，我们经常给控件注册事件监听器，比如下面这段代码，就是在 Android 应用开发中，给 Button 控件的点击事件注册监听器。
+
+```java
+ Button button = (Button)findViewById(R.id.button);
+ button.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ System.out.println("I am clicked.");
+ }
+ });
+```
+
+1. 从代码结构上来看，事件监听器很像回调，即传递一个包含回调函数（onClick()）的对象给另一个函数。从应用场景上来看，它又很像观察者模式，即事先注册观察者（OnClickListener），当用户点击按钮的时候，发送点击事件给观察者，并且执行相应的 onClick() 函数。
+2. 我们前面讲到，回调分为同步回调和异步回调。这里的回调算是异步回调，我们往 setOnClickListener() 函数中注册好回调函数之后，并不需要等待回调函数执行。这也印证了我们前面讲的，异步回调比较像观察者模式。
+
+
+
+### 应用举例三：addShutdownHook()
+
+1. Hook 可以翻译成“钩子”，那它跟 Callback 有什么区别呢？
+2. 网上有人认为 Hook 就是 Callback，两者说的是一回事儿，只是表达不同而已。而有人觉得 Hook 是 Callback 的一种应用。Callback 更侧重语法机制的描述，Hook 更加侧重应用场景的描述。我个人比较认可后面一种说法。不过，这个也不重要，我们只需要见了代码能认识，遇到场景会用就可以了。
+3. Hook 比较经典的应用场景是 Tomcat 和 JVM 的 shutdown hook。接下来，我们拿 JVM 来举例说明一下。JVM 提供了 Runtime.addShutdownHook(Thread hook) 方法，可以注册一个 JVM 关闭的 Hook。当应用程序关闭的时候，JVM 会自动调用 Hook 代码。代码示例如下所示：
+
+```JAVA
+public class ShutdownHookDemo {
+ private static class ShutdownHook extends Thread {
+ public void run() {
+ System.out.println("I am called during shutting down.");
+ }
+ }
+
+ public static void main(String[] args) {
+ Runtime.getRuntime().addShutdownHook(new ShutdownHook());
+ }
+}
+```
+
+我们再来看 addShutdownHook() 的代码实现，如下所示。这里我只给出了部分相关代码。
+
+```java
+public class Runtime {
+ public void addShutdownHook(Thread hook) {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null) {
+ sm.checkPermission(new RuntimePermission("shutdownHooks"));
+ }
+ ApplicationShutdownHooks.add(hook);
+ }
+}
+
+class ApplicationShutdownHooks {
+ /* The set of registered hooks */
+ private static IdentityHashMap hooks;
+ static {
+ try {
+ Shutdown.add(1 /* shutdown hook invocation order */,
+ false /* not registered if shutdown in progress */,
+ new Runnable() {
+ public void run() {
+ runHooks();
+ }
+ }
+ );
+ hooks = new IdentityHashMap<>();
+ } catch (IllegalStateException e) {
+ // application shutdown hooks cannot be added if
+ // shutdown is in progress.
+ hooks = null;
+ }
+ }
+
+
+ private ApplicationShutdownHooks() {}
+
+ /* Add a new shutdown hook. Checks the shutdown state and the hook itself,
+ * but does not do any security checks.
+ */
+ static synchronized void add(Thread hook) {
+ if(hooks == null)
+ throw new IllegalStateException("Shutdown in progress");
+
+ if (hook.isAlive())
+ throw new IllegalArgumentException("Hook already running");
+
+ if (hooks.containsKey(hook))
+ throw new IllegalArgumentException("Hook previously registered");
+
+ hooks.put(hook, hook);
+ }
+
+ /* Remove a previously-registered hook. Like the add method, this method
+ * does not do any security checks.
+ */
+ static synchronized boolean remove(Thread hook) {
+ if(hooks == null)
+ throw new IllegalStateException("Shutdown in progress");
+
+ if (hook == null)
+ throw new NullPointerException();
+
+ return hooks.remove(hook) != null;
+ }
+
+ /* Iterates over all application hooks creating a new thread for each
+ * to run in. Hooks are run concurrently and this method waits for
+ * them to finish.
+ */
+ static void runHooks() {
+ Collection threads;
+ synchronized(ApplicationShutdownHooks.class) {
+ threads = hooks.keySet();
+ hooks = null;
+ }
+
+ for (Thread hook : threads) {
+ hook.start();
+ }
+ for (Thread hook : threads) {
+ while (true) {
+ try {
+ hook.join();
+ break;
+ } catch (InterruptedException ignored) {
+ }
+ }
+ }
+ }
+}
+```
+
+从代码中我们可以发现，有关 Hook 的逻辑都被封装到 ApplicationShutdownHooks 类中了。当应用程序关闭的时候，JVM 会调用这个类的 runHooks() 方法，创建多个线程，并发地执行多个 Hook。我们在注册完 Hook 之后，并不需要等待 Hook 执行完成，所以，这也算是一种异步回调。
+
+
+
+
+
+## 模板模式 VS 回调
+
+1. 回调的原理、实现和应用到此就都讲完了。接下来，我们从应用场景和代码实现两个角度，来对比一下模板模式和回调。
+2. 从应用场景上来看，同步回调跟模板模式几乎一致。它们都是在一个大的算法骨架中，自由替换其中的某个步骤，起到代码复用和扩展的目的。而异步回调跟模板模式有较大差别，更像是观察者模式。
+3. 从代码实现上来看，回调和模板模式完全不同。回调基于组合关系来实现，把一个对象传递给另一个对象，是一种对象之间的关系；模板模式基于继承关系来实现，子类重写父类的抽象方法，是一种类之间的关系。
+4. 前面我们也讲到，组合优于继承。实际上，这里也不例外。在代码实现上，回调相对于模板模式会更加灵活，主要体现在下面几点。
+
+- 像 Java 这种只支持单继承的语言，基于模板模式编写的子类，已经继承了一个父类，不再具有继承的能力。
+- 回调可以使用匿名类来创建回调对象，可以不用事先定义类；而模板模式针对不同的实现都要定义不同的子类。
+- 如果某个类中定义了多个模板方法，每个方法都有对应的抽象方法，那即便我们只用到其中的一个模板方法，子类也必须实现所有的抽象方法。而回调就更加灵活，我们只需要往用到的模板方法中注入回调对象即可。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#### WeatherData
+
+```java
+/**
+ * 类是核心
+ * 1. 包含最新的天气情况信息
+ * 2. 含有 CurrentConditions 对象
+ * 3. 当数据有更新时，就主动的调用 CurrentConditions对象update方法(含 display), 这样他们（接入方）就看到最新的信息
+ *
+ */
+public class WeatherData {
+ private float temperatrue;
+ private float pressure;
+ private float humidity;
+ private CurrentConditions currentConditions;
+ //加入新的第三方
+
+ public WeatherData(CurrentConditions currentConditions) {
+ this.currentConditions = currentConditions;
+ }
+
+ public float getTemperature() {
+ return temperatrue;
+ }
+
+ public float getPressure() {
+ return pressure;
+ }
+
+ public float getHumidity() {
+ return humidity;
+ }
+
+ public void dataChange() {
+ //调用 接入方的 update
+ currentConditions.update(getTemperature(), getPressure(), getHumidity());
+ }
+
+ //当数据有更新时，就调用 setData
+ public void setData(float temperature, float pressure, float humidity) {
+ this.temperatrue = temperature;
+ this.pressure = pressure;
+ this.humidity = humidity;
+ //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
+ dataChange();
+ }
+}
+```
+
+#### CurrentConditions
+
+```java
+/**
+ * 显示当前天气情况（可以理解成是气象站自己的网站）
+ *
+ */
+public class CurrentConditions {
+ // 温度，气压，湿度
+ private float temperature;
+ private float pressure;
+ private float humidity;
+
+ //更新 天气情况，是由 WeatherData 来调用，我使用推送模式
+ public void update(float temperature, float pressure, float humidity) {
+ this.temperature = temperature;
+ this.pressure = pressure;
+ this.humidity = humidity;
+ display();
+ }
+
+ //显示
+ public void display() {
+ System.out.println("***Today mTemperature: " + temperature + "***");
+ System.out.println("***Today mPressure: " + pressure + "***");
+ System.out.println("***Today mHumidity: " + humidity + "***");
+ }
+}
+```
+
+#### Client
+
+```java
+public class Client {
+ public static void main(String[] args) {
+ // 创建接入方 currentConditions
+ CurrentConditions currentConditions = new CurrentConditions();
+ // 创建 WeatherData 并将 接入方 currentConditions 传递到 WeatherData中
+ WeatherData weatherData = new WeatherData(currentConditions);
+
+ // 更新天气情况
+ weatherData.setData(30, 150, 40);
+
+ // 天气情况变化
+ System.out.println("============天气情况变化=============");
+ weatherData.setData(40, 160, 20);
+ }
+}
+```
+
+#### 问题分析
+
+1. 其他第三方接入气象站获取数据的问题，无法在运行时动态的添加第三方 (新浪网站)
+2. 违反 ocp 原则，当加入第三方时，需要修改WeatherData代码，不利于维护。
+
+
+
+### 观察者模式方案
+
+#### Subject【接口】
+
+```java
+//接口, 让WeatherData 来实现
+public interface Subject {
+
+ public void registerObserver(Observer o);
+ public void removeObserver(Observer o);
+ public void notifyObservers();
+}
+```
+
+#### Observer【接口】
+
+```java
+//观察者接口，有观察者来实现
+public interface Observer {
+
+ public void update(float temperature, float pressure, float humidity);
+}
+```
+
+#### WeatherData
+
+```java
+public class WeatherData implements Subject {
+ private float temperatrue;
+ private float pressure;
+ private float humidity;
+ //观察者集合
+ private ArrayList