From 260a9552e3c203842ead0d29b54ae3eceaaed4cb Mon Sep 17 00:00:00 2001
From: vCaesar <vzvway@gmail.com>
Date: Tue, 10 Jan 2017 20:41:33 +0800
Subject: [PATCH] Update en RESTful

---
 en/08.3.md | 55 +++++++++++++++++++++++++++++++++---------------------
 1 file changed, 34 insertions(+), 21 deletions(-)

diff --git a/en/08.3.md b/en/08.3.md
index 3a337dfc..a2895036 100644
--- a/en/08.3.md
+++ b/en/08.3.md
@@ -68,48 +68,61 @@ The picture above shows three levels that are currently implemented in REST. You
 
 We can simulate `PUT` and `DELETE` requests by adding a hidden `_method` field in our POST requests, however these requests must be converted on the server side before they are processed. My personal applications use this workflow to implement REST interfaces. Standard RESTful interfaces are easily implemented in Go, as the following example demonstrates:
 
+```Go
+
 	package main
 
 	import (
 		"fmt"
-		"github.com/drone/routes"
+		"github.com/julienschmidt/httprouter"
+		"log"
 		"net/http"
 	)
 
-	func getuser(w http.ResponseWriter, r *http.Request) {
-		params := r.URL.Query()
-		uid := params.Get(":uid")
+	func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+		fmt.Fprint(w, "Welcome!\n")
+	}
+
+	func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
+	}
+
+	func getuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		uid := ps.ByName("uid")
 		fmt.Fprintf(w, "you are get user %s", uid)
 	}
 
-	func modifyuser(w http.ResponseWriter, r *http.Request) {
-		params := r.URL.Query()
-		uid := params.Get(":uid")
+	func modifyuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		uid := ps.ByName("uid")
 		fmt.Fprintf(w, "you are modify user %s", uid)
 	}
 
-	func deleteuser(w http.ResponseWriter, r *http.Request) {
-		params := r.URL.Query()
-		uid := params.Get(":uid")
+	func deleteuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		uid := ps.ByName("uid")
 		fmt.Fprintf(w, "you are delete user %s", uid)
 	}
 
-	func adduser(w http.ResponseWriter, r *http.Request) {
-		params := r.URL.Query()
-		uid := params.Get(":uid")
-		fmt.Fprint(w, "you are add user %s", uid)
+	func adduser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		// uid := r.FormValue("uid")
+		uid := ps.ByName("uid")
+		fmt.Fprintf(w, "you are add user %s", uid)
 	}
 
 	func main() {
-		mux := routes.New()
-		mux.Get("/user/:uid", getuser)
-		mux.Post("/user/:uid", modifyuser)
-		mux.Del("/user/:uid", deleteuser)
-		mux.Put("/user/", adduser)
-		http.Handle("/", mux)
-		http.ListenAndServe(":8088", nil)
+		router := httprouter.New()
+		router.GET("/", Index)
+		router.GET("/hello/:name", Hello)
+
+		router.GET("/user/:uid", getuser)
+		router.POST("/adduser/:uid", adduser)
+		router.DELETE("/deluser/:uid", deleteuser)
+		router.PUT("/moduser/:uid", modifyuser)
+
+		log.Fatal(http.ListenAndServe(":8080", router))
 	}
 
+```
+
 This sample code shows you how to write a very basic REST application. Our resources are users, and we use different functions for different methods. Here, we imported a third-party package called `github.com/drone/routes`. We've already covered how to implement a custom router in previous chapters -the `drone/routes` package implements some very convenient router mapping rules that make it very convenient for implementing RESTful architecture. As you can see, REST requires you to implement different logic for different HTTP methods of the same resource.
 
 ## Summary