example_test.go

Documentation: net/http

		 1  // Copyright 2012 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package http_test
		 6  
		 7  import (
		 8  	"context"
		 9  	"fmt"
		10  	"io"
		11  	"log"
		12  	"net/http"
		13  	"os"
		14  	"os/signal"
		15  )
		16  
		17  func ExampleHijacker() {
		18  	http.HandleFunc("/hijack", func(w http.ResponseWriter, r *http.Request) {
		19  		hj, ok := w.(http.Hijacker)
		20  		if !ok {
		21  			http.Error(w, "webserver doesn't support hijacking", http.StatusInternalServerError)
		22  			return
		23  		}
		24  		conn, bufrw, err := hj.Hijack()
		25  		if err != nil {
		26  			http.Error(w, err.Error(), http.StatusInternalServerError)
		27  			return
		28  		}
		29  		// Don't forget to close the connection:
		30  		defer conn.Close()
		31  		bufrw.WriteString("Now we're speaking raw TCP. Say hi: ")
		32  		bufrw.Flush()
		33  		s, err := bufrw.ReadString('\n')
		34  		if err != nil {
		35  			log.Printf("error reading string: %v", err)
		36  			return
		37  		}
		38  		fmt.Fprintf(bufrw, "You said: %q\nBye.\n", s)
		39  		bufrw.Flush()
		40  	})
		41  }
		42  
		43  func ExampleGet() {
		44  	res, err := http.Get("http://www.google.com/robots.txt")
		45  	if err != nil {
		46  		log.Fatal(err)
		47  	}
		48  	body, err := io.ReadAll(res.Body)
		49  	res.Body.Close()
		50  	if res.StatusCode > 299 {
		51  		log.Fatalf("Response failed with status code: %d and\nbody: %s\n", res.StatusCode, body)
		52  	}
		53  	if err != nil {
		54  		log.Fatal(err)
		55  	}
		56  	fmt.Printf("%s", body)
		57  }
		58  
		59  func ExampleFileServer() {
		60  	// Simple static webserver:
		61  	log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))
		62  }
		63  
		64  func ExampleFileServer_stripPrefix() {
		65  	// To serve a directory on disk (/tmp) under an alternate URL
		66  	// path (/tmpfiles/), use StripPrefix to modify the request
		67  	// URL's path before the FileServer sees it:
		68  	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
		69  }
		70  
		71  func ExampleStripPrefix() {
		72  	// To serve a directory on disk (/tmp) under an alternate URL
		73  	// path (/tmpfiles/), use StripPrefix to modify the request
		74  	// URL's path before the FileServer sees it:
		75  	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
		76  }
		77  
		78  type apiHandler struct{}
		79  
		80  func (apiHandler) ServeHTTP(http.ResponseWriter, *http.Request) {}
		81  
		82  func ExampleServeMux_Handle() {
		83  	mux := http.NewServeMux()
		84  	mux.Handle("/api/", apiHandler{})
		85  	mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		86  		// The "/" pattern matches everything, so we need to check
		87  		// that we're at the root here.
		88  		if req.URL.Path != "/" {
		89  			http.NotFound(w, req)
		90  			return
		91  		}
		92  		fmt.Fprintf(w, "Welcome to the home page!")
		93  	})
		94  }
		95  
		96  // HTTP Trailers are a set of key/value pairs like headers that come
		97  // after the HTTP response, instead of before.
		98  func ExampleResponseWriter_trailers() {
		99  	mux := http.NewServeMux()
	 100  	mux.HandleFunc("/sendstrailers", func(w http.ResponseWriter, req *http.Request) {
	 101  		// Before any call to WriteHeader or Write, declare
	 102  		// the trailers you will set during the HTTP
	 103  		// response. These three headers are actually sent in
	 104  		// the trailer.
	 105  		w.Header().Set("Trailer", "AtEnd1, AtEnd2")
	 106  		w.Header().Add("Trailer", "AtEnd3")
	 107  
	 108  		w.Header().Set("Content-Type", "text/plain; charset=utf-8") // normal header
	 109  		w.WriteHeader(http.StatusOK)
	 110  
	 111  		w.Header().Set("AtEnd1", "value 1")
	 112  		io.WriteString(w, "This HTTP response has both headers before this text and trailers at the end.\n")
	 113  		w.Header().Set("AtEnd2", "value 2")
	 114  		w.Header().Set("AtEnd3", "value 3") // These will appear as trailers.
	 115  	})
	 116  }
	 117  
	 118  func ExampleServer_Shutdown() {
	 119  	var srv http.Server
	 120  
	 121  	idleConnsClosed := make(chan struct{})
	 122  	go func() {
	 123  		sigint := make(chan os.Signal, 1)
	 124  		signal.Notify(sigint, os.Interrupt)
	 125  		<-sigint
	 126  
	 127  		// We received an interrupt signal, shut down.
	 128  		if err := srv.Shutdown(context.Background()); err != nil {
	 129  			// Error from closing listeners, or context timeout:
	 130  			log.Printf("HTTP server Shutdown: %v", err)
	 131  		}
	 132  		close(idleConnsClosed)
	 133  	}()
	 134  
	 135  	if err := srv.ListenAndServe(); err != http.ErrServerClosed {
	 136  		// Error starting or closing listener:
	 137  		log.Fatalf("HTTP server ListenAndServe: %v", err)
	 138  	}
	 139  
	 140  	<-idleConnsClosed
	 141  }
	 142  
	 143  func ExampleListenAndServeTLS() {
	 144  	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
	 145  		io.WriteString(w, "Hello, TLS!\n")
	 146  	})
	 147  
	 148  	// One can use generate_cert.go in crypto/tls to generate cert.pem and key.pem.
	 149  	log.Printf("About to listen on 8443. Go to https://127.0.0.1:8443/")
	 150  	err := http.ListenAndServeTLS(":8443", "cert.pem", "key.pem", nil)
	 151  	log.Fatal(err)
	 152  }
	 153  
	 154  func ExampleListenAndServe() {
	 155  	// Hello world, the web server
	 156  
	 157  	helloHandler := func(w http.ResponseWriter, req *http.Request) {
	 158  		io.WriteString(w, "Hello, world!\n")
	 159  	}
	 160  
	 161  	http.HandleFunc("/hello", helloHandler)
	 162  	log.Fatal(http.ListenAndServe(":8080", nil))
	 163  }
	 164  
	 165  func ExampleHandleFunc() {
	 166  	h1 := func(w http.ResponseWriter, _ *http.Request) {
	 167  		io.WriteString(w, "Hello from a HandleFunc #1!\n")
	 168  	}
	 169  	h2 := func(w http.ResponseWriter, _ *http.Request) {
	 170  		io.WriteString(w, "Hello from a HandleFunc #2!\n")
	 171  	}
	 172  
	 173  	http.HandleFunc("/", h1)
	 174  	http.HandleFunc("/endpoint", h2)
	 175  
	 176  	log.Fatal(http.ListenAndServe(":8080", nil))
	 177  }
	 178  
	 179  func newPeopleHandler() http.Handler {
	 180  	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	 181  		fmt.Fprintln(w, "This is the people handler.")
	 182  	})
	 183  }
	 184  
	 185  func ExampleNotFoundHandler() {
	 186  	mux := http.NewServeMux()
	 187  
	 188  	// Create sample handler to returns 404
	 189  	mux.Handle("/resources", http.NotFoundHandler())
	 190  
	 191  	// Create sample handler that returns 200
	 192  	mux.Handle("/resources/people/", newPeopleHandler())
	 193  
	 194  	log.Fatal(http.ListenAndServe(":8080", mux))
	 195  }
	 196
View as plain text