回调函数的使用

- 日理万妓 2024-03-31 14:28 55阅读 0赞

## 概述 ##

回调函数，简称回调（Callback），是指通过函数参数传递到其他代码的，某一块可执行代码的引用。

1.  `询问问题(调用对方接口)，然后问题解决之后再告诉你(对方处理完再调用你，通知结果)，这一过程便是回调。`

其有四种实现方法

1.  反射：**Java 的反射机制允许我们获取类的信息，其中包括类的方法**
2.  直接调用；
3.  接口调用；
4.  Lambda表达式

## 实现 ##

### 反射 ###

**这种写法需要传递的参数十分繁琐，所以不推荐**

public class CallBack {
        
        public void processResponse() {
        
            System.out.println("收到，做相应的处理");
        }
    }

public class Request{
        
        public void send(Class clazz, Method method) throws Exception {
        
            // 模拟等待响应
            Thread.sleep(3000);
            System.out.println("开始请求");
            method.invoke(clazz.newInstance());
        }
    }

public class Main {
        
        public static void main(String[] args) throws Exception {
        
            Request request = new Request();
            System.out.println("主线程开个线程去异步发请求");
            new Thread(() -> {
        
                try {
        
                    request.send(CallBack.class, CallBack.class.getMethod("processResponse"));
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }).start();
            System.out.println("主线程请求发完了, 现在在执行其他的事情");
            Thread.sleep(100000);
        }
    }

运行结果

主线程开个线程去异步发请求
    主线程请求发完了, 现在在执行其他的事情
    开始请求
    收到，做相应的处理

### 直接调用 ###

与上面反射的区别：

1.  request的send方法里面，没有method这个参数。
    
        public class Request{
              
            public void send(Class clazz, Method method) throws Exception {
              
                // 模拟等待响应
                Thread.sleep(3000);
                System.out.println("开始请求");
                method.invoke(clazz.newInstance());
            }
        }
2.  在main方法里面，将callback参数new处理，放入send方法的参数里面
    
        public class Main {
              
            public static void main(String[] args) throws Exception {
              
                Request request = new Request();
                System.out.println("主线程开个线程去异步发请求");
                CallBack callBack = new CallBack();
                new Thread(() -> {
              
                    try {
              
                        request.send(callBack);
                    } catch (Exception e) {
              
                        e.printStackTrace();
                    }
                }).start();
                System.out.println("主线程请求发完了, 现在在执行其他的事情");
                Thread.sleep(100000);
            }
        }

**`不符合修改封闭原则`**：**我们想要换一种“处理响应”的方法时，将必须去修改 CallBack 类的 processRequest()方法**

### 接口调用 ###

这个方法便可以解决直接调用出现的问题

1.  将callback类改为接口
    
        public interface CallBack {
              
            public void processResponse();
        }
2.  增加一个实现类，实现该接口
    
        public class CallBackImpl implements CallBack {
              
            @Override
            public void processResponse() {
              
                System.out.println("收到，做相应的处理");
            }
        }
3.  main方法里面实例化第二步的callbackImpl实现类
    
        public class Main {
              
           public static void main(String[] args) throws Exception {
              
               Request request = new Request();
               System.out.println("主线程开个线程去异步发请求");
               CallBack callBack = new CallBackImpl();
               new Thread(() -> {
              
                   try {
              
                       request.send(callBack);
                   } catch (Exception e) {
              
                       e.printStackTrace();
                   }
               }).start();
               System.out.println("主线程请求发完了, 现在在执行其他的事情");
               Thread.sleep(100000);
           }
        }

按如上操作后，便可以实现与反射一样的结果

### Lambda表达式 ###

这个方法更加简洁，不需要新增callback接口的实现类

1.  将main方法改写如下
    
        public class Main {
              
            public static void main(String[] args) throws Exception {
              
                Request request = new Request();
                System.out.println("主线程开个线程去异步发请求");
                new Thread(() -> {
              
                    try {
              
                        request.send(()-> System.out.println("收到，做相应的处理"));
                    } catch (Exception e) {
              
                        e.printStackTrace();
                    }
                }).start();
                System.out.println("主线程请求发完了, 现在在执行其他的事情");
                Thread.sleep(100000);
            }
        }