package main

import (
    "io"
    "net/http"
    "os"
)

func main() {

    fileUrl := "https://golangcode.com/images/avatar.jpg"

    if err := DownloadFile("avatar.jpg", fileUrl); err != nil {
        panic(err)
    }
}

// DownloadFile will download a url to a local file. It's efficient because it will
// write as it downloads and not load the whole file into memory.
func DownloadFile(filepath string, url string) error {

    // Get the data
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // Create the file
    out, err := os.Create(filepath)
    if err != nil {
        return err
    }
    defer out.Close()

    // Write the body to file
    _, err = io.Copy(out, resp.Body)
    return err
}

Parse URL in Go

by yhuang Go fmt.Println fmt net net.SplitHostPort net/url

Parsing a URL which includes a scheme, authentication info, host, port, path, query params, and a query fragment.

package main

import (
    "fmt"
    "net"
    "net/url"
)

func main() {

    s := "postgres://user:pass@host.com:5432/path?k=v#f"

    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }

    fmt.Println(u.Scheme)

    fmt.Println(u.User)
    fmt.Println(u.User.Username())
    p, _ := u.User.Password()
    fmt.Println(p)

    fmt.Println(u.Host)
    host, port, _ := net.SplitHostPort(u.Host)
    fmt.Println(host)
    fmt.Println(port)

    fmt.Println(u.Path)
    fmt.Println(u.Fragment)

    fmt.Println(u.RawQuery)
    m, _ := url.ParseQuery(u.RawQuery)
    fmt.Println(m)
    fmt.Println(m["k"][0])
}

Last Run  :
postgres
user:pass
user
pass
host.com:5432
host.com
5432
/path
f
k=v
map[k:[v]]
v

HTTP Client in Go

by yhuang Go fmt.Println bufio bufio.NewScanner fmt http.Get

The Go standard library comes with excellent support for HTTP clients and servers in the net/http package. In this example we’ll use it to issue simple HTTP requests.

package main

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

func main() {

    // Issue an HTTP GET request to a server.
    // http.Get is a convenient shortcut around creating an http.Client object and calling its Get method;
    // it uses the http.DefaultClient object which has useful default settings.
    resp, err := http.Get("http://gobyexample.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response status:", resp.Status)

    scanner := bufio.NewScanner(resp.Body)
    for i := 0; scanner.Scan() && i < 5; i++ {
        fmt.Println(scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        panic(err)
    }
}

Execute HTTP POST Request in Go

by yhuang Go fmt.Println fmt http.Post io/ioutil ioutil.ReadAll

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "strings"
)

func main() {

    resp, err := http.Post("https://mysite.com/endpoint", "text/plain", strings.NewReader("Content Body"))
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()
    fmt.Println(resp.Status)

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(body))
}

HTTP Server in Go

by yhuang Go fmt.Fprintf http.HandleFunc http.Request http.ResponseWriter fmt

Writing a basic HTTP server is easy using the net/http package.

package main

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

// A fundamental concept in net/http servers is handlers.
// A handler is an object implementing the http.Handler interface.
// A common way to write a handler is by using the http.HandlerFunc adapter on functions
// with the appropriate signature.
func hello(w http.ResponseWriter, req *http.Request) {

    // Functions serving as handlers take a http.ResponseWriter and a http.Request as arguments.
    // The response writer is used to fill in the HTTP response.
    // Here our simple response is just “hello\n”.
    fmt.Fprintf(w, "hello\n")
}

func headers(w http.ResponseWriter, req *http.Request) {

    // This handler does something a little more sophisticated by reading all the
    // HTTP request headers and echoing them into the response body.
    for name, headers := range req.Header {
        for _, h := range headers {
            fmt.Fprintf(w, "%v: %v\n", name, h)
        }
    }
}

func main() {

    // We register our handlers on server routes using the http.HandleFunc convenience function.
    // It sets up the default router in the net/http package and takes a function as an argument.
    http.HandleFunc("/hello", hello)
    http.HandleFunc("/headers", headers)

    // Finally, we call the ListenAndServe with the port and a handler.
    // nil tells it to use the default router we’ve just set up.
    log.Fatal(http.ListenAndServe(":8090", nil))
}

Dial for SMTP Connection in Go

by yhuang Go log log.Fatal net/smtp smtp.Dial

package main

import (
    "log"
    "net/smtp"
)

func main() {
    // Connect to the remote SMTP server.
    c, err := smtp.Dial("mail.example.com:25")
    if err != nil {
        log.Fatal(err)
    }
}

Web Socket Server in Go

by yhuang Go http.HandleFunc http.Request http.ResponseWriter fmt fmt.Printf

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
        conn, _ := upgrader.Upgrade(w, r, nil) // error ignored for sake of simplicity

        for {
            // Read message from browser
            msgType, msg, err := conn.ReadMessage()
            if err != nil {
                return
            }

            // Print the message to the console
            fmt.Printf("%s sent: %s\n", conn.RemoteAddr(), string(msg))

            // Write message back to browser
            if err = conn.WriteMessage(msgType, msg); err != nil {
                return
            }
        }
    })

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, "websockets.html")
    })

    http.ListenAndServe(":8080", nil)
}

/*





*/

Routing in Go with gorilla/mux

by yhuang Go fmt fmt.Fprintf github.com/gorilla/mux http.ListenAndServe http.Request

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()

    // Methods
    // r.HandleFunc("/books/{title}", CreateBook).Methods("POST")
    // r.HandleFunc("/books/{title}", ReadBook).Methods("GET")
    // r.HandleFunc("/books/{title}", UpdateBook).Methods("PUT")
    // r.HandleFunc("/books/{title}", DeleteBook).Methods("DELETE")

    // Hostname and Subdomains
    // r.HandleFunc("/books/{title}", BookHandler).Host("www.mybookstore.com")

    // Schemes
    // r.HandleFunc("/secure", SecureHandler).Schemes("https")
    // r.HandleFunc("/insecure", InsecureHandler).Schemes("http")

    // Path Prefix and Subrouters
    // bookrouter := r.PathPrefix("/books").Subrouter()
    // bookrouter.HandleFunc("/", AllBooks)
    // bookrouter.HandleFunc("/{title}", GetBook)

    r.HandleFunc("/books/{title}/page/{page}", func(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        title := vars["title"]
        page := vars["page"]

        fmt.Fprintf(w, "You've requested the book: %s on page %s\n", title, page)
    })

    http.ListenAndServe(":80", r)
}

HTTP Serve Static Files in Go

by yhuang Go http.Dir http.FileServer http.Handle http.ListenAndServe http.StripPrefix

package main

import "net/http"

func main() {
    fs := http.FileServer(http.Dir("assets/"))
    http.Handle("/static/", http.StripPrefix("/static/", fs))

    http.ListenAndServe(":8080", nil)
}

Log HTTP Requests in Go

by yhuang Go http.HandlerFunc http.Request http.ResponseWriter fmt fmt.Fprintln

package main

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

func logging(f http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.URL.Path)
        f(w, r)
    }
}

func foo(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "foo")
}

func main() {
    http.HandleFunc("/foo", logging(foo))
    http.ListenAndServe(":8080", nil)
}

HTTP Cookie Session in Go

by yhuang Go http.HandleFunc http.Request http.ResponseWriter fmt fmt.Fprintln

You may want to persist visitor data through cookies sent and received as cookies.

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/sessions"
)

var (
    // key must be 16, 24 or 32 bytes long (AES-128, AES-192 or AES-256)
    key   = []byte("super-secret-key")
    store = sessions.NewCookieStore(key)
)

func secret(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "cookie-name")

    // Check if user is authenticated
    if auth, ok := session.Values["authenticated"].(bool); !ok || !auth {
        http.Error(w, "Forbidden", http.StatusForbidden)
        return
    }

    // Print secret message
    fmt.Fprintln(w, "The cake is a lie!")
}

func login(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "cookie-name")

    // Authentication goes here
    // ...

    // Set user as authenticated
    session.Values["authenticated"] = true
    session.Save(r, w)
}

func logout(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "cookie-name")

    // Revoke users authentication
    session.Values["authenticated"] = false
    session.Save(r, w)
}

func main() {
    http.HandleFunc("/secret", secret)
    http.HandleFunc("/login", login)
    http.HandleFunc("/logout", logout)

    http.ListenAndServe(":8080", nil)
}

Decode JSON Request in Go

by yhuang Go encoding/json fmt fmt.Fprintf http.HandleFunc http.ListenAndServe

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type User struct {
    Firstname string `json:"firstname"`
    Lastname  string `json:"lastname"`
    Age       int    `json:"age"`
}

func main() {
    http.HandleFunc("/decode", func(w http.ResponseWriter, r *http.Request) {
        var user User
        json.NewDecoder(r.Body).Decode(&user)

        fmt.Fprintf(w, "%s %s is %d years old!", user.Firstname, user.Lastname, user.Age)
    })

    http.ListenAndServe(":8080", nil)
}

Encode JSON Response in Go

by yhuang Go encoding/json http.HandleFunc http.ListenAndServe http.Request http.ResponseWriter

package main

import (
    "encoding/json"
    "net/http"
)

type User struct {
    Firstname string `json:"firstname"`
    Lastname  string `json:"lastname"`
    Age       int    `json:"age"`
}

func main() {
    http.HandleFunc("/encode", func(w http.ResponseWriter, r *http.Request) {
        peter := User{
            Firstname: "John",
            Lastname:  "Doe",
            Age:       25,
        }

        json.NewEncoder(w).Encode(peter)
    })

    http.ListenAndServe(":8080", nil)
}

// $ go run json.go
// $ curl -s http://localhost:8080/encode
// {"firstname":"John","lastname":"Doe","age":25}

Escape HTML Content in Go

by yhuang Go fmt fmt.Println html html.EscapeString

Escape HTML so that special characters don't render as HTML but as text in the browser.

package main

import (
    "fmt"
    "html"
)

func main() {

    unescaped := ``
    escaped := html.EscapeString(unescaped)
    fmt.Println(escaped)
}

Last Run  :
<script>alert(123);</script>

Web

Filter by Language