2012-12-11 5 views
5

Wir bauen eine Website mit gehen nur mit den eingebauten Sachen wie http.HandleFunc zum Einrichten von Routing-und html.template-Paket zum Rendern von Seiten. Nichts wirklich Besonderes und es funktioniert gut. Jetzt habe ich mich mit der Fehlerbehandlung beschäftigt und möchte Panics und Whatnots aufspüren und auf eine statische Fehlerseite umleiten. Was ist der beste Weg, es mit go zu machen?Fehlerseiten in Go basierte Webanwendung

Der Brute-Force-Ansatz, über den ich zuerst nachgedacht habe, ist nur umzuleiten, wenn ein Fehler erkannt wird, aber es wäre nett mit einem generischen Catch-All auch. Ich habe in den Unterlagen nichts darüber gefunden.

(Denken Sie auch über 404 s auf der gleichen Linie.)

Antwort

8

Es gibt eine große Schreib auf dem golang Blog über die Fehlerbehandlung und deckt speziell Web-Fehlern gegen Ende.

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

Grundsätzlich wickeln Sie die regulären HTTP-Handler mit Ihrem eigenen, die einen Fehler zurückgeben kann. Der Wrapper prüft, ob Ihre neuen Handler einen Fehler zurückgeben und wenn dies der Fall ist. Ich benutze etwas Ähnliches, wo ich auch "Wiederherstellung" anrufe. Hier ist ein Ausschnitt des Codes, den ich verwende (der frei und offen ist).

Während ich noch nicht eine benutzerdefinierte Seite für Fehler zur Verfügung stellen, war es in meinen Gedanken und sollte trivial sein, hinzuzufügen.

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