Blackberry design pattern question:

Question

Je suis en train d'implémenter une classe qui est responsable de toutes mes requêtes HTTP du Blackberry. J'ai environ 10 écrans qui utilisent cette classe pour interroger un service Web et obtenir des données à partir de celui-ci. Quel serait le modèle standard à utiliser dans ce cas?

Actuellement je l'ai configuré comme suit: -

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. 
     } 
    } 

} 

Il fonctionne, mais ne semble pas juste, et si un seul écran a des requêtes réseau plusieurs types, je suis forcée d'ajouter un drapeau garder une trace de la fonction qu'il est censé rappeler.

Y a-t-il une meilleure façon de procéder?

Merci,
Teja.

Answer 1

Utilisez une interface de rappel, par ex. 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); 
     } 
    } 
} 

Ce découple nous espérons que votre NetworkAccessClass de connaître sur tous les écrans. Puis vos écrans implémentent NetworkAccessClass.ResponseHandler ou ils transmettent un gestionnaire d'adaptateur (classe interne anonyme) pour appeler les méthodes correctes sur l'écran, par exemple.

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

Vous pouvez utiliser un écouteur, qui est une interface simple, la classe de réseau rappellerait chaque fois que se produit quelque chose d'intéressant:

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 
      } 
     }); 
    } 
} 

Ceci est connu comme le modèle Observable/observateur. L'observable avertit ses observateurs quand quelque chose arrive, mais sans avoir à connaître leur type exact. La classe des listes de diffusion dissocie les deux parties.