Wie starten Sie web-server zum öffnen der Seite im browser in golang?

Wie kann ich vorübergehend öffnen Sie eine web-Seite im browser mit golang?

Wie hier ist, wie es gemacht wird mit HTTPServer in python.

InformationsquelleAutor Ciasto piekarz | 2016-09-04

24

Ihre Frage ist ein wenig irreführend, da es fragt, wie öffnen Sie eine lokale Seite in der web-browser, aber Sie wirklich wollen, zu wissen, wie man Feuer auf einem web-server, so kann es im browser geöffnet werden.

Für die letztere (feuern ein Webserver für die Verarbeitung statischer Dateien), können Sie die http.FileServer() Funktion. Für Antworten zu präsentieren, denn im detail finden Sie unter: Umfassen js-Datei in Vorlage Gehen und Mit golang webserver Woher kommt der Stamm der website-Karte auf das Dateisystem>.

Beispiel dienen Ihre /tmp/data Ordner:
```
http.Handle("/", http.FileServer(http.Dir("/tmp/data")))
panic(http.ListenAndServe(":8080", nil))
```
Wenn Sie wollen, um zu dienen dynamische Inhalte (erstellt von Go-code), können Sie die net/http Paket und schreiben Sie Ihre eigenen handler erzeugen der Antwort, z.B.:
```
func myHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello from Go")
}

func main() {
    http.HandleFunc("/", myHandler)
    panic(http.ListenAndServe(":8080", nil))
}
```
Als die erste (um eine Seite zu öffnen in Ihrem Standard-browser), gibt es keine eingebaute Unterstützung in der Go-Standardbibliothek. Aber es ist nicht schwer, Sie müssen nur zur Ausführung eines OS-spezifischen externen Befehl. Sie können diese cross-Plattform-Lösung:
```
//open opens the specified URL in the default browser of the user.
func open(url string) error {
    var cmd string
    var args []string

    switch runtime.GOOS {
    case "windows":
        cmd = "cmd"
        args = []string{"/c", "start"}
    case "darwin":
        cmd = "open"
    default: //"linux", "freebsd", "openbsd", "netbsd"
        cmd = "xdg-open"
    }
    args = append(args, url)
    return exec.Command(cmd, args...).Start()
}
```
Diesem Beispiel-code stammt aus Gowut (die Gehen Web-UI-Toolkit; Offenlegung: ich bin der Autor).

Verwenden diese, um die zuvor gestartete webserver in Ihrem Standard-browser:
```
open("http://localhost:8080/")
```
Eine Letzte Sache zu beachten: http.ListenAndServe() blockiert und kehrt nie zurück (falls kein Fehler vorliegt). So haben Sie den server starten oder den browser in einem anderen goroutine, zum Beispiel:
```
go open("http://localhost:8080/")
panic(http.ListenAndServe(":8080", nil))
```
Überprüfen Sie heraus diese Frage für andere alternativen wie browser starten, nachdem der webserver gestartet wurde: Go: Wie kann ich den browser starten, NACHDEM der server gestartet Zuhören?
- ist ein Go-Meister... Schöne Arbeit
- Vielleicht ein ParseRequestURI Validierung für die url-parameter wird nicht Schaden. Man weiß nie, wie SO code kopiert und eingefügt, in der wildnis.
- stackoverflow.com/a/32742904/3236818 erklärt, wie Sie den browser nachdem der server gestartet wird, hören. ohne polling.
InformationsquelleAutor icza
0

Es ist durchaus ein Allgemeines problem. Sie können xdg-open Programm, um es für Sie tun. Führen Sie einfach den Prozess aus Gehen. Die xdg-open wird die Gabel von selbst so können wir einfach nutzen Run und warten, bis das Ende des Prozesses.
```
package main

import "os/exec"

func main() {
    exec.Command("xdg-open", "http://example.com/").Run()
}
```
- Was ist, wenn ich wollte, dann schließen Sie die Registerkarte, die geöffnet wurde xdg-open?
- Das ist nicht möglich.
InformationsquelleAutor Grzegorz Żur

Gebäude an der Paul ' s Antwort, hier ist eine Lösung, die funktioniert auf Windows:

package main

import (
    "log"
    "net/http"
    "os/exec"
    "time"
)


func main() {
    http.HandleFunc("/", myHandler)
    go func() {
        <-time.After(100 * time.Millisecond)
        err := exec.Command("explorer", "http://127.0.0.1:8080").Run()
        if err != nil {
            log.Println(err)
        }
    }()

    log.Println("running at port localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

InformationsquelleAutor Sebastian

-2

Letzte mal, dass ich so etwas Tat, ich habe eine kurze Verzögerung auf, bevor Sie den browser, um sicherzustellen, dass der server hatte Zeit zu hören, bevor der browser geschickt die erste Anfrage. Auf meinem Linux-system, xdg war nicht ganz richtig konfiguriert und anstatt die Festsetzung der xdg-Konfiguration, die ich gerade fest verdrahtet, es mit "firefox" statt "xdg-open". Starten Sie den browser auf der gleichen Maschine wie der web-server für eine gute Sache in der Entwicklung. Aber in der Bereitstellung der web-server wird wahrscheinlich laufen auf einem headless-remote-system und es könnte mehr Sinn machen, drucken Sie einfach die Start-URL auf der Konsole für ein copy-paste von einer terminal-session auf dem remote-server in einem lokalen browser.
```
package main

import (
    "fmt"
    "net/http"
    "time"
)

func myHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello from Go")
}

func main() {
    http.HandleFunc("/", myHandler)
    go func() {
        <-time.After(100 * time.Millisecond)
        open("http://localhost:8080/")
    }()
    panic(http.ListenAndServe(":8080", nil))
}
```
- Hi. Der code, den Sie zur Verfügung gestellt haben, hat eine Reihe von syntax-Fehlern, einschließlich Import "net/http", " importieren "os/exec" aber nicht, es zu benutzen und aufrufen von "open" ist nicht definiert. Könnten Sie bitte Bearbeiten Sie den code (und test), um diese Frage zu beantworten. Danke.
InformationsquelleAutor Paul Buis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.