耗时任务，避免回调嵌套的构思

最新推荐文章于 2024-05-10 09:14:14 发布

爱吃烧鸡大肘子的肉肉酱

最新推荐文章于 2024-05-10 09:14:14 发布

阅读量113

点赞数

文章标签： windows java android-studio 设计模式学习

本文链接：https://blog.csdn.net/happy0li/article/details/134539621

版权

背景

针对一些序列任务的耗时操作，比如A执行完了，执行B，B执行完，执行C，且每一步操作都属于耗时操作。如果不使用已有框架，最朴素的写法就是回调，在A执行完的回调中，启动B，但是这样会陷入一个回调地狱，导致代码过长，回调嵌套回调，让人头疼。
尝试封装自己的框架，来解决回调嵌套的问题。

解决方法

自定义框架，用于解决上述问题。

定义耗时任务统一接口

public interface ICommand<T> {
    /**
     * 获取命令ID
     *
     * @return 命令ID
     */
    String getCommandId();

    /**
     * 获取执行结果
     */
    void execute(@NonNull TsCallBack<T> callback);

    /**
     * 停止执行
     */
    void stop();

    /**
     * 获取命令结果
     *
     * @return 结果
     */
    T getResult();

}

任务执行完的回调接口

public interface ICommandResultCallback<T> {

    void onResult(@NonNull T Result);
}

任务执行结果

public class CommandResult<T> {
    private int mErrorCode;
    private T mData;

    public CommandResult() {
    }

    public CommandResult(int errorCode, T data) {
        mErrorCode = errorCode;
        mData = data;
    }

    public int getErrorCode() {
        return mErrorCode;
    }
   public void setErrorCode(int errorCode) {
        mErrorCode = errorCode;
    }

    public T getData() {
        return mData;
    }

    public void setData(T data) {
        mData = data;
    } 
     /**
     * 响应是否成功
     *
     * @return true  成功
     */
    public boolean isSuccess() {
        return mErrorCode == ResultCode.RESULT_OK.getCode() && mData != null;
    }
 /**
     * 构建成功结果
     * @param data 数据
     * @return
     */
    public CommandResult<T> buildSuccessResult(T data) {
        return new CommandResult<>(ResultCode.RESULT_OK.getCode(), data);
    }

任务基类

public abstract class BaseCommand<T> implements ICommand<T> {
    protected boolean mStop = false;
    
    @Override
    public void stop() {
        mStop = true;
    }
}

任务分发类

public class CommandHandler<T> {
    //命令集合
    private final List<ICommand> mCommands = new ArrayList<>();
    //命令结果
    private final Map<ICommand, CommandResult> mCommandResult = new HashMap<>();
    @NonNull
    private final TsCallBack<T> mTsCallBack;

    public CommandHandler(@NonNull TsCallBack<T> tsCallBack) {
        mTsCallBack = tsCallBack;
    }
    
/**
     * 启动执行
     */
    public void startExecute() {
        try {
            if (isFinish()) {
                return;
            }
            ICommand<T> endCommand = takeLast();
            loopExecuteCommand(endCommand);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 停止
     */
    public void stop() {
        for (ICommand command : mCommands) {
            command.stop();
        }
        mCommands.clear();
    }
    
     /**
     * 依次执行
     */
    private void loopExecuteCommand(ICommand<T> endCommand) {
        ICommand command = take();
        if (command != null) {
            command.execute(new TsCallBack<CommandResult>() {
                @Override
                public void onResult(@NonNull CommandResult result) {
                    if (result.isSuccess()) {
                        mCommandResult.put(command, result);
                         if (isFinish()) {
                            executeEndCommand(endCommand);
                        } else {
                            loopExecuteCommand(endCommand);
                        }
                        return;
                    }
                    mTsCallBack.onResult(createResult(result.getErrorCode(), null));
                }
            });
        }
    }
    
     /**
     * 获取对应命令的结果
     *
     * @param command 命令
     * @return 该条命令执行的结果
     */
    @Nullable
    public CommandResult getResult(ICommand command) {
        return mCommandResult.get(command);
    }
    
     /**
     * 执行最后一条命令
     *
     * @param endCommand 命令
     */
    private void executeEndCommand(ICommand<T> endCommand) {
        endCommand.execute(mTsCallBack);
    }
    
    /**
     * 构建最终回调结果
     *
     * @param errorCode 错误码
     * @param data      数据
     * @return 回调结果
     */
    private CommandResult<T> createResult(int errorCode, @Nullable T data) {
        return new CommandResult<>(errorCode, null);
    }
    
    /**
     * 命令是否执行结束
     */
    private boolean isFinish() {
        return mCommands.isEmpty();
    }
    
     /**
     * 获取命令
     */
    @Nullable
    private ICommand take() {
        if (mCommands.isEmpty()) {
            return null;
        }
        return mCommands.remove(0);
    }
    
     /**
     * 获取最后一条命令
     */
    private ICommand<T> takeLast() throws CommandException {
        if (mCommands.isEmpty()) {
            throw new CommandException();
        }
        int size = mCommands.size();
        return mCommands.get(size - 1);
    }
    
    /**
     * 添加命令
     *
     * @param command 命令
     */
    public void add(@NonNull ICommand command) {
        mCommands.add(command);
    }
    
    /**
     * 清空命令
     */
    public void clear() {
        mCommands.clear();
    }

    /**
     * 移除命令
     *
     * @param command 命令
     */
    private void remove(@NonNull ICommand command) {
        mCommands.remove(command);
    }
}

任务封装

吃饭

public class EatCommand extends BaseCommand<Integer> {

    @Override
    public String getCommandId() {
        return "eat rice...";
    }
    @Override
    public void execute(@NonNull TsCallBack<Integer> callback) {
        try {
            if(mStop){
                return;
            }
            Thread.sleep(4000);
            Log.e("Command", "EatCommand执行完成");
            callback.onResult(new CommandResult<Integer>().buildSuccessResult(10));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     @Override
    public Integer getResult() {
        return 10;
    }

起床

public class GetUpCommand extends BaseCommand<String> {
    @Override
    public String getCommandId() {
        return "get up....";
    }
    
     @Override
    public void execute(@NonNull TsCallBack<String> callback) {
        try {
            if(mStop){
                return;
            }
            Thread.sleep(2000);
            Log.e("Command", "GetUpCommand执行完成");
            callback.onResult(new CommandResult<String>().buildSuccessResult("00点"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     @Override
    public String getResult() {
        return "00点";
    }
}

睡觉

public class GoBedCommand extends BaseCommand<Void> {
    @Override
    public String getCommandId() {
        return "Go bed...";
    }
    
     @Override
    public void execute(@NonNull TsCallBack<Void> callback) {
        try {
            if(mStop){
                return;
            }
            Thread.sleep(2000);
            Log.e("Command", "GoBedCommand执行完成");
            callback.onResult(new CommandResult<Void>().buildSuccessResult(null));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     @Override
    public Void getResult() {
        return null;
    }
}

外面闲逛

public class HangoutCommand extends BaseCommand<Integer> {
    @Override
    public String getCommandId() {
        return "hang out...";
    }
    @Override
    public void execute(@NonNull TsCallBack<Integer> callback) {
        try {
            if (mStop) {
                return;
            }
            Thread.sleep(1000);
            Log.e("Command", "HangoutCommand执行完成");
            callback.onResult(new CommandResult<Integer>().buildSuccessResult(3));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     @Override
    public Integer getResult() {
        return 3;
    }
}

使用

public void startCommnad() {
        GetUpCommand getUpCommand = new GetUpCommand();
        EatCommand eatCommand = new EatCommand();
        HangoutCommand hangoutCommand = new HangoutCommand();
        GoBedCommand goBedCommand = new GoBedCommand();
        CommandHandler commandHandler = new CommandHandler<>(new TsCallBack<Void>() {
            @Override
            public void onResult(@NonNull CommandResult<Void> Result) {
                Log.e("command", hangoutCommand.getResult() + "");
                Log.e("command", "整个流程结束了");
            }
        });
        commandHandler.add(getUpCommand);
        commandHandler.add(eatCommand);
        commandHandler.add(hangoutCommand);
        commandHandler.add(goBedCommand);
        commandHandler.startExecute();
    }