设计模式之Future模式例子

在我认为，实例教学比理论教学更加容易理解，并且理论知识网上一大堆，这里就不重复了，所以记录下Future模式的一种实现例子，以备以后可以查看。

如果不太懂Future模式时干什么的，最好先普及下理论知识再来看更好。

好，现在我们就开始来讲解分析我的例子：

首先需要定义的就是输入和输出参数的格式，这里简单的创建了一个如下：

public class Result {
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }
}

public class Task {
    private int id ;
    private String requestinfo;

    public Task(int id, String requestinfo) {
        this.id = id;
        this.requestinfo = requestinfo;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getRequestinfo() {
        return requestinfo;
    }

    public void setRequestinfo(String requestinfo) {
        this.requestinfo = requestinfo;
    }
}

好，定义完了输入和输出参数类型，现在开始定义数据类型Data接口：

public interface Data {
    Result getRequestinfo();
}

很简单的一个接口，下面定义一个FutureData和RealData分别实现Data接口并处理

public class FutureData implements Data{

//    FutureData这个类只是一个装饰,实际调用的还是RealData
    private RealData realData;
//    用来控制RealData是否赋值完
    private boolean isReady = false;

//    实现一个setRealData方法,用来赋值,并且实现线程间的通信
    public synchronized  void setRealData(RealData realData){
        if (isReady){
            return;
        }
        this.realData = realData;
        isReady=true;
        notify();
    }

//    实际调用的时RealData的方法,wait()是为了等待赋值完成
    @Override
    public synchronized Result getRequestinfo() {
        while (!isReady){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return this.realData.getRequestinfo();
    }
}

public class RealData implements Data{

    Result result = new Result();

    public RealData(Task task){
        System.out.println("开始处理任务,请稍后");
        try {
//            模拟处理时间
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        这里处理就是简单的把参数内容传进来,复杂处理可以进一步扩展
        result.setResultdata(task.getRequestinfo());
    }
    @Override
    public Result getRequestinfo() {
        return this.result;
    }
}

现在就需要提供一个对外部的接口可以来调用，我们设为FutureClient

public class FutureClient {

//    注意这里的参数需要为final
    public Data request(final Task task){
        final FutureData futureData = new FutureData();

        new Thread(new Runnable() {
            @Override
            public void run() {
                RealData realData = new RealData(task);
                futureData.setRealData(realData);
            }
        }).start();
        return futureData;
    }
}

现在我们就可以在Main函数中调用了

public class Main {
    public static void main(String[] args) {
        Task task = new Task(1,"传入参数");
        Data data = new FutureClient().request(task);
        System.out.println("参数已传入");
        System.out.println("传入参数为："+data.getRequestinfo().getResultdata());
    }
}

结果为

到这里我们整个Future模式就完成了，当然JDK底层也提供了Future，以后可以直接使用。