Java中的回调机制使用方式_Java

什么是回调机制

回调机制(callback)是一种常见的编程模式，它允许一个类或对象在特定事件发生时通知另一个类或对象。简单来说，就是"a调用b，b在执行完成后又调用a"的过程。

回调的核心思想是反向调用，这与传统的正向调用（直接调用方法）不同。回调机制在事件处理、异步编程、框架设计中有着广泛应用。

在 java 中，回调最常见的实现方式是：

定义一个回调接口（callback interface）。
调用方持有该接口的引用，并将其传递给被调用方。
被调用方在合适的时机反过来调用接口方法，把结果或事件通知给调用方。

回调的基本实现方式

1. 基于接口的回调

这是java中最常用的回调实现方式。我们定义一个回调接口，然后让调用方实现这个接口，最后将实现类的实例传递给被调用方。

示例：按钮点击事件

// 定义回调接口
interface clicklistener {
    void onclick();
}

// 按钮类
class button {
    private clicklistener listener;
    
    // 设置回调监听器
    public void setclicklistener(clicklistener listener) {
        this.listener = listener;
    }
    
    // 模拟按钮被点击
    public void click() {
        system.out.println("按钮被点击了");
        if (listener != null) {
            listener.onclick(); // 触发回调
        }
    }
}

public class interfacecallbackdemo {
    public static void main(string[] args) {
        button button = new button();
        
        // 设置回调实现
        button.setclicklistener(new clicklistener() {
            @override
            public void onclick() {
                system.out.println("回调执行：按钮点击事件处理");
                system.out.println("回调执行了~");
            }
        });
        
        button.click(); // 触发点击事件
    }
}

说明：

定义clicklistener回调接口
button类持有接口引用，并在适当时机调用接口方法
主程序通过匿名类实现接口，完成回调设置
当click()方法被调用时，会触发回调

执行结果：

按钮被点击了
回调执行：按钮点击事件处理
回调执行了~

2. 抽象类回调

示例：任务处理器

// 定义抽象回调类
abstract class taskhandler {
    // 抽象回调方法
    public abstract void oncomplete(string result);
    
    // 可以有具体实现方法
    public void onstart() {
        system.out.println("任务开始处理");
    }
}

// 任务执行类
class taskexecutor {
    public void execute(taskhandler handler) {
        handler.onstart();
        
        // 模拟任务执行
        try {
            thread.sleep(1000);
            handler.oncomplete("任务完成");
        } catch (interruptedexception e) {
            thread.currentthread().interrupt();
        }
    }
}

public class abstractclasscallbackdemo {
    public static void main(string[] args) {
        taskexecutor executor = new taskexecutor();
        
        // 使用匿名类实现抽象回调类
        executor.execute(new taskhandler() {
            @override
            public void oncomplete(string result) {
                system.out.println("回调结果: " + result);
            }
        });
    }
}

说明：

定义taskhandler抽象类，包含抽象回调方法
抽象类可以包含具体实现方法（如onstart()）
taskexecutor接收抽象类作为参数，调用其方法
主程序通过匿名类实现抽象类，完成回调设置

执行结果：

任务开始处理
回调结果: 任务完成

3. 函数式接口与lambda表达式（java 8+）

示例：简单计算器

import java.util.function.bifunction;

public class lambdacallbackdemo {
    public static void main(string[] args) {
        // 使用bifunction作为回调接口
        calculate(5, 3, (a, b) -> a + b);  // 加法
        calculate(5, 3, (a, b) -> a * b);  // 乘法
        
        // 更复杂的示例，数据处理回调
        processdata("hello", 
            data -> {
                string result = data + " world!";
                system.out.println("处理结果: " + result);
                return result;
            },
            error -> system.err.println("错误: " + error)
            );
        // 
        processdata(null,
                data -> data + " world!",
                error -> system.err.println("捕获到错误: " + error)
                );
    }
    
    // 计算方法，接收操作回调
    public static void calculate(int a, int b, bifunction<integer, integer, integer> operation) {
        int result = operation.apply(a, b);
        system.out.println("计算结果: " + result);
    }
    
    // 数据处理方法，接收成功和失败回调
    public static void processdata(string input, 
                                  java.util.function.function<string, string> successhandler,
                                  java.util.function.consumer<exception> errorhandler) {
        try {
            if (input == null) {
                throw new illegalargumentexception("输入不能为null");
            }
            string result = successhandler.apply(input);
        } catch (exception e) {
            errorhandler.accept(e);
        }
    }
}

说明：

使用java内置的bifunction函数式接口作为回调
lambda表达式简化了回调的实现
calculate方法接收操作逻辑作为参数
processdata方法用了更复杂的回调场景，包含成功和错误处理

执行结果：

计算结果: 8
计算结果: 15
处理结果: hello world!
捕获到错误: java.lang.illegalargumentexception: 输入不能为null

回调的同步与异步特性

回调本身只是一种编程模式，它既可以是同步的也可以是异步的，这取决于具体的实现方式

同步回调

特点：回调方法在调用者方法返回前执行
执行流程：a调用b → b执行 → b调用a的回调方法 → b返回 → a继续执行

如：集合排序时传入的comparator

同步回调实现示例

// 同步回调接口
interface synccallback {
    void oncomplete(string result);
}

class syncprocessor {
    public void process(string input, synccallback callback) {
        system.out.println("处理线程: " + thread.currentthread().getname());
        // 同步处理
        string result = input.touppercase();
        // 同步调用回调
        callback.oncomplete(result);
    }
}

public class synccallbackdemo {
    public static void main(string[] args) {
        syncprocessor processor = new syncprocessor();
        
        system.out.println("主线程: " + thread.currentthread().getname());
        
        processor.process("hello", result -> {
            system.out.println("回调线程: " + thread.currentthread().getname());
            system.out.println("同步结果: " + result);
        });
        
        system.out.println("主线程继续执行...");
    }
}

执行结果

主线程: main
处理线程: main
回调线程: main
同步结果: hello
主线程继续执行...

异步回调

特点：回调方法在另一个线程执行
执行流程：a调用b → b立即返回 → b启动新线程执行任务 → 任务完成后在新线程调用a的回调方法

如：网络请求的响应回调

异步回调实现示例

// 异步回调接口
interface asynccallback {
    void oncomplete(string result);
}

class asyncprocessor {
    public void process(string input, asynccallback callback) {
        system.out.println("调用线程: " + thread.currentthread().getname());
        
        // 启动新线程异步处理
        new thread(() -> {
            system.out.println("处理线程: " + thread.currentthread().getname());
            try {
                thread.sleep(1000); // 模拟耗时操作
                string result = input.touppercase();
                callback.oncomplete(result);
            } catch (interruptedexception e) {
                thread.currentthread().interrupt();
            }
        }).start();
    }
}

public class asynccallbackdemo {
    public static void main(string[] args) {
        asyncprocessor processor = new asyncprocessor();
        
        system.out.println("主线程: " + thread.currentthread().getname());
        
        processor.process("hello", result -> {
            system.out.println("回调线程: " + thread.currentthread().getname());
            system.out.println("异步结果: " + result);
        });
        
        system.out.println("主线程继续执行...");
        
        // 防止主线程过早退出
        try { thread.sleep(1500); } catch (interruptedexception e) {}
    }
}

执行结果

主线程: main
调用线程: main
主线程继续执行...
处理线程: thread-0
回调线程: thread-0
异步结果: hello

回调的一些应用实例

场景	回调接口	说明
jdbc 驱动	rowcallbackhandler	spring jdbctemplate 每查出一行就回调一次
gui 事件	actionlistener	swing/awt 点击按钮触发
servlet 3.0	asynclistener	异步 servlet 完成/超时/错误时回调
netty	channelfuturelistener	io 操作完成后回调
spring 生命周期	initializingbean, disposablebean	容器启动/销毁时回调
guava	listenablefuture + futures.addcallback	早于 completablefuture 的回调方案