Java回调接口设计&&Lambda改造
设计之初
作为一名有技术情怀的程序员，在日常开发中，我们会遇到多种多样的场景，比如说在代码执行完成后进行的同步操作，亦或者是在代码执行过程中发生的异步操作，如果实现接口设计呢？老规矩，查资料，翻代码，找实现的API，而后进行扩展，做到举一反三。
Java对同步回调实现的支持
// 答案一：
// 顺序执行代码，实现不同方法的顺序压栈，通过利用java虚拟机栈的特性，实现代码顺序执行，而后执行回调函数
// 伪代码实现
public class TestByOrder{
public static void main(String[] args) throws ExecutionException, InterruptedException {
method1(); // 栈帧
method2(); // 栈帧
callBackMethod(); // 栈帧
}
public void method1(){
...
}
public void method2(){
...
}
}
// 答案二：
// 在java并发包中,可使用 java.util.concurrent.Future#get() 实现回调，使用 Executors#newSingleThreadExecutor()和ExecutorService#submit()实现同步
// 代码实现
public class TestFuture{
public static void main(String[] args) throws ExecutionException, InterruptedException {
// future 实现同步回调
futures();
}
private static void futures() throws ExecutionException, InterruptedException {
ExecutorService executorService =
Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
return "hello world future";
});
System.out.println(future.get());
executorService.shutdown();
System.out.println("future 同步回调...");
}
Java对异步回调实现的支持
// 答案一：
// 通过新起线程的方式实现异步处理，new Thread()#run，实现Runnable接口都可以
// 代码实现
public class TestRunnable{
public static void main(String[] args) throws ExecutionException, InterruptedException {
// runnable 实现异步回调
runnable();
}
private static void runnable() throws InterruptedException {
new Thread(() -> System.out.println("hello world runnable 1")).start();
new Thread(() -> {
try {
// 执行 RPC 或者 查询 DB 耗时操作
TimeUnit.SECONDS.sleep(1);
System.out.println("hello world runnable 2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
System.out.println("runnable 异步回调...");
}
}
// 答案二：
// 通过java并发包中Executor#execute，实现异步执行
// 代码实现
public class TestExecute(){
public static void main(String[] args) throws ExecutionException, InterruptedException {
// async 实现异步回调
async();
}
private static void async() {
ExecutorService executorService =
Executors.newSingleThreadExecutor();
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("Hello World async 1");
}
});
executorService.execute(() ->{
System.out.println("Hello World async 2");
});
// executorService.execute(() ->{
// throw new RuntimeException("手动抛出的异常...");
// });
System.out.println("async 异步回调...");
executorService.shutdown();
}
}
自定义实现函数式回调接口
// 函数式回调接口设计
public class CallbackDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 同步执行
sync();
}
private static void sync() {
CallbackExecutor callbackExecutor = new CallbackExecutor();
Optional.ofNullable(callbackExecutor).get().execute(() -> System.out.println("自定义执行器..."));
callbackExecutor.execute(() -> {
System.out.println("hello world sync 1");
});
callbackExecutor.execute(() -> {
System.out.println("hello world sync 2");
});
callbackExecutor.run();
System.out.println("sync 同步回调...");
}
public interface Callback {
void callback();
}
public static class CallbackExecutor{
private Queue<Callback> callbackQueue = new LinkedList<>();
public void execute(Callback callback) {
callbackQueue.add(callback);
}
public void run() {
callbackQueue.forEach(callback -> callback.callback());
}
}
}
Lambda方式改造函数式回调接口
// 上述实现了函数式回调接口
// 由于项目采用的是JDK1.8.0_92，为了适应代码流式化和代码简洁处理、代码公共逻辑抽取，故此进行改造
/**
* @ClassName: Java8CallbackDemo
* @Description: java 8 Lambda 实现 CallbackDemo
* @Author: 尚先生
* @CreateDate: 2019/5/8 9:54
* @Version: 1.0
*/
public class Java8CallbackDemo {
// 定义全局并发安全队列
public static LinkedBlockingQueue<Callback> queues = new LinkedBlockingQueue<>();
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 同步执行
sync();
}
private static void sync() {
// 初始化 InvokerHandler 对象
InvokerHandler invokerHandler = new InvokerHandler();
invokerHandler.execute((Java8CallbackDemo.Callback)() -> {
System.out.println("hello world sync 1");},(function -> queues.add(function)));
invokerHandler.execute((Java8CallbackDemo.Callback)() -> {
System.out.println("hello world sync 2");},(function -> queues.add(function)));
queues.forEach(queue -> invokerHandler.run(queue,Callback::callback));
System.out.println("sync 同步回调...");
}
interface Callback {
void callback();
}
static class InvokerHandler {
public <T, R> R execute(T t, Function<T, R> function) {
return function.apply(t);
}
public <T> void run(T t, Consumer<T> consumer) {
consumer.accept(t);
}
}
}
至此，函数式回调接口设计全部完成，后续章节会讨论更多的模式设计，敬请关注。
完整代码和相关依赖请见GitHub
https://github.com/dwyanewede/project-learn/tree/master/src/main/java/com/learn/demo/design/pattern
公众号推荐
