Question

我正在实现一个负责Blackberry所有HTTP请求的类。我有大约10个左右的屏幕，使用这个类来查询Web服务并从中获取数据。在这种情况下使用的标准模式是什么？

目前我的设置如下 -

public class NetworkAccessClass
{

    public NetworkAccessClass(String url, String methodName, Vector paramNames, Vector paramValues, MainScreen screen) {
        // perform inits
    }

    public void run() {
        // Get Data
        if(screen.instanceOf(LoginScreen)) {
            ((LoginScreen) screen).requestSucceded(responseData);
        }
        // So on for all 10 screens.
        catch() {
            ((LoginScreen) screen).requestFailed(errorCode);
            // So on for all 10 screens.
        }
    }

}

它可以工作，但看起来不对，如果单个屏幕有多种类型的网络请求，我将被迫添加一个标志来跟踪它应该回调的功能。

有更好的方法吗？

谢谢，
的Teja。

Answer 1

使用回调界面，例如ResponseHandler：

public class NetworkAccessClass
{

    public interface ResponseHandler {
        void requestSucceeded(ResponseData responseData);
        void requestFailed(ErrorCode errorCode);
    }

    public NetworkAccessClass(
        String url,
        String methodName,
        Vector paramNames,
        Vector paramValues,
        ResponseHandler responseHandler) {
        // perform inits
    }

    public void run() {
        // Get Data
        try {
            ...
            responseHandler.requestSuceeded(responseData);
        catch() {
            responseHandler.requestFailed(errorCode);
        }
    }
}

这有望使您的NetworkAccessClass与所有屏幕无关。然后你的屏幕实现NetworkAccessClass.ResponseHandler或者他们传递一个适配器处理程序（匿名内部类）来调用屏幕上正确的方法，例如。

class LoginScreen {
    ...
        new NetworkAccessClass(url, methodName, paramNames, paramValues,
            new ResponseHandler() {
                @Override
                void requestSucceeded(ResponseData responseData) {
                    LoginScreen.this.handleLoginSuccess(responseData);
                }
                @Override
                void requestFailed(ErrorCode errorCode) {
                    LoginScreen.this.handleLoginFailure(errorCode);
                }
    }
    ...
}

Answer 2

你可以使用一个监听器，这是一个简单的接口，网络类会在有趣的事情发生时回调：

public interface NetworkListener {
    void requestSucceeded(byte[] responseData);
    void requestFailed(int errorCode);
}

public class NetworkAccess {
    // ...

    public void run() {
        // Get Data
        if (successful) {
            fireSucess(responseData);
        }
        catch(SomeException e) {
            fireFailure(errorCode);
        }
    }

    public void addNetworkListener(NetworkListener listener) {
        // add listener to list of listeners
    }

    private void fireSuccess(byte[] responseData) {
        for (NetworkListener l : listeners) {
            l.requestSucceeded(responseData);
        }
    }

    // ...
}

public class LoginScreen {
    private void foo() {
        NetworkAccess access = new NetworkAccess(...);
        access.addNetworkListener(new NetworkListener() {
            public void requestSucceeded(byte[] responseData) {
                 // do what you want
            }
            public void requestFailed(int errorCode) {
                 // do what you want
            }
        });
    }
}

这被称为Observable / observer模式。当有事情发生时，观察者会通知观察者，但不必知道他们的确切类型。列表器类将两方分离。

黑莓设计模式问题：

2 个答案: