Pagine di errore nell'applicazione web basata su go

Question

Stiamo creando un sito Web utilizzando solo i componenti incorporati come http.HandleFunc per impostare il routing e il pacchetto html.template per il rendering delle pagine. Niente di speciale e funziona perfettamente. Ora sono arrivato a pensare alla gestione degli errori e mi piacerebbe catturare il panico e whatnots e reindirizzare a una pagina di errore statico. Qual è il modo migliore per farlo con go?

L'approccio di forza bruta che ho pensato prima è quello di ridirigere semplicemente quando viene rilevato un errore, ma sarebbe bello con un generico tutto-anche. Non ho trovato nulla nei documenti a riguardo.

(pensando anche circa 404 lungo le stesse linee.)

Answer 1

C'è una grande scrittura sul blog golang sulla gestione di errori e copre specificamente errori correlati web verso la fine.

http://blog.golang.org/2011/07/error-handling-and-go.html

In sostanza, si avvolgono i gestori HTTP regolari con la propria che possono restituire un errore. Il wrapper verifica se i nuovi gestori restituiscono un errore e in tal caso reagiscono. Io uso qualcosa di simile a questo, dove io chiamo anche recuperare. Ecco uno snippet del codice che uso (che è gratuito e aperto).

Anche se non ho ancora fornito una pagina personalizzata per errori, è stato a mio avviso e dovrebbe essere banale da aggiungere.

// Error is the expected return of a dae.Handler, or nil otherwise. 
type Error struct { 
    Error error 
    Code int 
    Message string 
} 

// NewError is a helper for creating an Error pointer. 
func NewError(err error, code int, msg string) *Error { 
    return &Error{err, code, msg} 
} 

// Handler is used to cast functions to its type to implement ServeHTTP. 
// Code that panics is automatically recovered and delivers a server 500 error. 
type Handler func(http.ResponseWriter, *http.Request) *Error 

// NewHandler is a helper to chain multiple functions together. 
func New(fn ...Handler) Handler { 
    if len(fn) == 0 { 
     panic("No Handlers passed in.") 
    } 

    h := Handler(fn[0]) 
    for i := 1; i < len(fn); i++ { 
     h = h.Add(fn[i]) 
    } 
    return h 
} 

// ServeHTTP implements the http.Handler interface. If an appHandler returns an 
// error, the error is inspected and an appropriate response is written out. 
func (fn Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { 
    defer func() { 
     if r := recover(); r != nil { 
      log.Printf("%v", r) 
      http.Error(w, "A serious error has occured.", 500) 
      if Debug { 
       panic(r.(error)) 
      } 
     } 
    }() 

    if e := fn(w, r); e != nil { 
     log.Printf("Code: %v, Message: \"%s\", Error: %v", e.Code, e.Message, e.Error) 
     switch e.Code { 
     case 500: 
      http.Error(w, e.Message, e.Code) 
     case 404: 
      http.NotFound(w, r) 
      fmt.Fprint(w, e.Message) 
     case 200: 
      fmt.Fprint(w, e.Message) 
     } 
    } 
}