...
Run Format

Source file src/net/http/example_test.go

Documentation: net/http

  // Copyright 2012 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package http_test
  
  import (
  	"fmt"
  	"io"
  	"io/ioutil"
  	"log"
  	"net/http"
  )
  
  func ExampleHijacker() {
  	http.HandleFunc("/hijack", func(w http.ResponseWriter, r *http.Request) {
  		hj, ok := w.(http.Hijacker)
  		if !ok {
  			http.Error(w, "webserver doesn't support hijacking", http.StatusInternalServerError)
  			return
  		}
  		conn, bufrw, err := hj.Hijack()
  		if err != nil {
  			http.Error(w, err.Error(), http.StatusInternalServerError)
  			return
  		}
  		// Don't forget to close the connection:
  		defer conn.Close()
  		bufrw.WriteString("Now we're speaking raw TCP. Say hi: ")
  		bufrw.Flush()
  		s, err := bufrw.ReadString('\n')
  		if err != nil {
  			log.Printf("error reading string: %v", err)
  			return
  		}
  		fmt.Fprintf(bufrw, "You said: %q\nBye.\n", s)
  		bufrw.Flush()
  	})
  }
  
  func ExampleGet() {
  	res, err := http.Get("http://www.google.com/robots.txt")
  	if err != nil {
  		log.Fatal(err)
  	}
  	robots, err := ioutil.ReadAll(res.Body)
  	res.Body.Close()
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Printf("%s", robots)
  }
  
  func ExampleFileServer() {
  	// Simple static webserver:
  	log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))
  }
  
  func ExampleFileServer_stripPrefix() {
  	// To serve a directory on disk (/tmp) under an alternate URL
  	// path (/tmpfiles/), use StripPrefix to modify the request
  	// URL's path before the FileServer sees it:
  	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
  }
  
  func ExampleStripPrefix() {
  	// To serve a directory on disk (/tmp) under an alternate URL
  	// path (/tmpfiles/), use StripPrefix to modify the request
  	// URL's path before the FileServer sees it:
  	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
  }
  
  type apiHandler struct{}
  
  func (apiHandler) ServeHTTP(http.ResponseWriter, *http.Request) {}
  
  func ExampleServeMux_Handle() {
  	mux := http.NewServeMux()
  	mux.Handle("/api/", apiHandler{})
  	mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
  		// The "/" pattern matches everything, so we need to check
  		// that we're at the root here.
  		if req.URL.Path != "/" {
  			http.NotFound(w, req)
  			return
  		}
  		fmt.Fprintf(w, "Welcome to the home page!")
  	})
  }
  
  // HTTP Trailers are a set of key/value pairs like headers that come
  // after the HTTP response, instead of before.
  func ExampleResponseWriter_trailers() {
  	mux := http.NewServeMux()
  	mux.HandleFunc("/sendstrailers", func(w http.ResponseWriter, req *http.Request) {
  		// Before any call to WriteHeader or Write, declare
  		// the trailers you will set during the HTTP
  		// response. These three headers are actually sent in
  		// the trailer.
  		w.Header().Set("Trailer", "AtEnd1, AtEnd2")
  		w.Header().Add("Trailer", "AtEnd3")
  
  		w.Header().Set("Content-Type", "text/plain; charset=utf-8") // normal header
  		w.WriteHeader(http.StatusOK)
  
  		w.Header().Set("AtEnd1", "value 1")
  		io.WriteString(w, "This HTTP response has both headers before this text and trailers at the end.\n")
  		w.Header().Set("AtEnd2", "value 2")
  		w.Header().Set("AtEnd3", "value 3") // These will appear as trailers.
  	})
  }
  

View as plain text