Best practice per la registrazione delle eccezioni dei servizi GWT

Question

Ho deciso di aggiungere il sistema di registrazione al mio livello di servizio GWT. Prima di tutto volevo registrare tutte le eccezioni generate da quel livello. Avevo un oggetto simile a ServletDispatcher di Spring, che chiama altri servizi. Pensavo di poter aggiungere la registrazione lì, ma mi sono reso conto che i servizi GWT eseguivano il wrapping delle eccezioni controllate in ServletResponse e deselezionate in UnexpectedException.

Qualcuno può condividere la sua esperienza con questo problema? Qual è il modo migliore per registrare le eccezioni controllate e deselezionate per tutti i servizi GWT.

---

ho trovato la soluzione che suggerisce di estendere il flusso eccezioni RemoteServiceServlet e di esclusione predefiniti. Ma trovo questa soluzione troppo dispendiosa in termini di tempo. Anybode conosce una variante più semplice?

Answer 1

Sul lato server, abbiamo una sottoclasse di RemoteServiceServlet che usiamo per tutte le implementazioni del servizio. Lei dice che sembra che richiede tempo, ma ecco come appare il codice. Lo fai una volta e hai finito.

@Override 
protected void doUnexpectedFailure(Throwable t) { 
    t.printStackTrace(System.err); 
    super.doUnexpectedFailure(t); 
} 

Nota: in realtà non inviare a System.err e probabilmente non dovrebbe neanche, ma si ottiene l'idea.

Sul lato client, viene utilizzata una sottoclasse di AsyncCallback denominata AsyncSuccessCallback. Gestisce il caso onFailure in modo uniforme per la maggior parte delle nostre chiamate RPC. La maggior parte del nostro codice di callback può gestire il caso onSuccess sapendo che onFailure è gestito. Fornisce anche un posto unico per modificare questa implementazione in un secondo momento.

public abstract class AsyncSuccessCallback<T> implements AsyncCallback<T> { 

    public void onFailure(Throwable t) { 
     handleException(t); 
    } 

    protected void handleException(Throwable t) { 
     Window.alert(t.getMessage()); 
    } 

} 

Nota: in realtà non usiamo Window.alert, ma di nuovo, si ottiene l'idea. Quello che facciamo in questo caso è visualizzare un DialogBox GWT che visualizza un modulo che esegue un POST su un altro server che accetta segnalazioni di errore. Il modulo consente all'utente di digitare una descrizione di cosa stavano facendo quando si è verificato l'errore.

Sul lato client, se si vuole ottenere l'analisi dello stack, è necessario scrivere un po 'di codice aggiuntivo:

// for lineEnding, use "<br>" for HTML, "\n" for text 
public static final String getStackTrace(Throwable t, String lineEnding) { 
    Object[] stackTrace = t.getStackTrace(); 
    if (stackTrace != null) { 
     StringBuilder output = new StringBuilder(); 
     for (Object line : stackTrace) { 
      output.append(line); 
      output.append(lineEnding); 
     } 
     return output.toString(); 
    } else { 
     return "[stack unavailable]"; 
    } 
} 

Answer 2

Quali eccezioni si desidera registrare? Lato client o lato server? Abbiamo una grande applicazione aziendale con gwt. Utilizziamo il pattern MVP sul client e tutte le richieste al server vengono eseguite utilizzando una classe RPCservice generica. Ad esempio saveUserService = new remoteService();

sul lato server elaboriamo SaveUserRequest e prepariamo SaveUserResponse utilizzando lo schema di comando. Tutte le eccezioni sono trattate qui, a parte l'eccezione ClientWarningException che viene lasciata propagare fino al client in cui viene visualizzato un messaggio piacevole per l'utente.

Questo è forse un po 'prolisso, ma è stato adattato bene su una grande app con circa 100k loc.

Answer 3

Usa gwt-dispatch. La registrazione può essere incorporata nel servizio di spedizione standard, come mostrato nel seguente esempio, che è stato rimosso dalla pagina di stampa gwt-Getting Started.

public class SimpleDispatchServlet extends RemoteServiceServlet 
     implements StandardDispatchService { 

    private Dispatch dispatch; 

    public SimpleDispatchServlet() { 
     InstanceActionHandlerRegistry registry = 
      new DefaultActionHandlerRegistry(); 
     registry.addHandler(new IncrementCounterHandler()); 
     dispatch = new SimpleDispatch(registry); 
    } 

    public Result execute(Action<?> action) throws DispatchException { 
     try { 
      return dispatch.execute(action); 
     } catch (RuntimeException e) { 
      log("Exception while executing " + action.getClass().getName() 
       + ": " + e.getMessage(), e); 
      throw e; 
     } 
    } 
}