$ go get github.com/julienschmidt/httprouter@v1
go: downloading github.com/julienschmidt/httprouter v1.3.0

router := httprouter.New()
router.HandlerFunc(http.MethodGet, "/snippet/view/:id", app.snippetView)

 package main
 import (
   "net/http"
   "github.com/julienschmidt/httprouter" // New import
   "github.com/justinas/alice"
 )

 func (app *application) routes() http.Handler {
  
-  mux := http.NewServeMux()
-	fileServer := http.FileServer(http.Dir("./ui/static/"))
-	mux.Handle("/static/", http.StripPrefix("/static", fileServer))
-	mux.HandleFunc("/", app.home)
-	mux.HandleFunc("/snippet/view", app.snippetView)
-	mux.HandleFunc("/snippet/create", app.snippetCreate)
-	// Create a middleware chain containing our 'standard' middleware
-	// which will be used for every request our application receives.
-	standard := alice.New(app.recoverPanic, app.logRequest, sercureHeaders)
-	// Return the 'standard' middleware chain followed by the servemux.
-	return standard.Then(mux)

+	// Initialize the router.
+	router := httprouter.New()
+	// Update the pattern for the route for the static files.
+	fileServer := http.FileServer(http.Dir("./ui/static/"))
+	router.Handler(http.MethodGet, "/static/*filepath", http.StripPrefix("/static", fileServer))
+	// And then create the routes using the appropriate methods, patterns and
+	// handlers.
+	router.HandlerFunc(http.MethodGet, "/", app.home)
+	router.HandlerFunc(http.MethodGet, "/snippet/view/:id", app.snippetView)
+	router.HandlerFunc(http.MethodGet, "/snippet/create", app.snippetCreate)
+	router.HandlerFunc(http.MethodPost, "/snippet/create", app.snippetCreatePost)
+	// Create the middleware chain as normal.
+	standard := alice.New(app.recoverPanic, app.logRequest, secureHeaders)
+	// Wrap the router with the middleware and return it as normal.
+	return standard.Then(router)
 }

   package main
   
   import (
   	"errors"
   	"fmt"
   	"net/http"
   	"strconv"
   
   	"github.com/julienschmidt/httprouter" // New import
   	"snippetbox.alexedwards.net/internal/models"
   )
   
   func (app *application) home(w http.ResponseWriter, r *http.Request) {
   	// Because httprouter matches the "/" path exactly, we can now remove the
   	// manual check of r.URL.Path != "/" from this handler.
-  if r.URL.Path != "/" {
-		http.NotFound(w, r)
-		return
-	}
   
   	snippets, err := app.snippets.Latest()
   	if err != nil {
   		app.serverError(w, r, err)
   		return
   	}
   	data := app.newTemplateData(r)
   	data.Snippets = snippets
   	app.render(w, r, http.StatusOK, "home.html", data)
   }



   func (app *application) snippetView(w http.ResponseWriter, r *http.Request) {
+   	// When httprouter is parsing a request, the values of any named parameters
+   	// will be stored in the request context. We'll talk about request context
+   	// in detail later in the book, but for now it's enough to know that you can
+   	// use the ParamsFromContext() function to retrieve a slice containing these
+   	// parameter names and values like so:
+  	params := httprouter.ParamsFromContext(r.Context())


+   	// We can then use the ByName() method to get the value of the "id" named
+   	// parameter from the slice and validate it as normal.
+   	id, err := strconv.Atoi(params.ByName("id"))
-     id, err := strconv.Atoi(r.URL.Query().Get("id"))
   	if err != nil || id < 1 {
   		app.notFound(w)
   		return
   	}
   	snippet, err := app.snippets.Get(id)
   	if err != nil {
   		if errors.Is(err, models.ErrNoRecord) {
   			app.notFound(w)
   		} else {
   			app.serverError(w, r, err)
   		}
   		return
   	}
   	data := app.newTemplateData(r)
   	data.Snippet = snippet
   	app.render(w, r, http.StatusOK, "view.html", data)
   }
   
   // Add a new snippetCreate handler, which for now returns a placeholder
   // response. We'll update this shortly to show a HTML form.
   func (app *application) snippetCreate(w http.ResponseWriter, r *http.Request) {
   	w.Write([]byte("Display the form for creating a new snippet..."))
   }
   
   // Rename this handler to snippetCreatePost.
   func (app *application) snippetCreatePost(w http.ResponseWriter, r *http.Request) {
    // Checking if the request method is a POST is now superfluous and can be
   	// removed, because this is done automatically by httprouter.

-    if r.Method != http.MethodPost {
-	  	w.Header().Set("Allow", http.MethodPost)
-	  	app.clientError(w, http.StatusMethodNotAllowed)
-		  return
-	 }
   	title := "O snail"
   	content := "O snail\nClimb Mount Fuji,\nBut slowly, slowly!\n\n– Kobayashi Issa"
   	expires := 7
   	id, err := app.snippets.Insert(title, content, expires)
   	if err != nil {
   		app.serverError(w, r, err)
   		return
   	}
-    http.Redirect(w, r, fmt.Sprintf("/snippet/view?id=%d", id), http.StatusSeeOther)
   	// Update the redirect path to use the new clean URL format.
+   	http.Redirect(w, r, fmt.Sprintf("/snippet/view/%d", id), http.StatusSeeOther)
   }

{{define "title"}}Home{{end}} {{define "main"}}
<h2>Latest Snippets</h2>
{{if .Snippets}}
<table>
  <tr>
    <th>Title</th>
    <th>Created</th>
    <th>ID</th>
  </tr>
  {{range .Snippets}}
  <tr>
    <!-- Use the new clean URL style-->
    <td><a href="/snippet/view/{{.ID}}">{{.Title}}</a></td>
    <td>{{humanDate .Created}}</td>
    <td>#{{.ID}}</td>
  </tr>
  {{end}}
</table>
{{else}}
<p>There's nothing to see here... yet!</p>
{{end}} {{end}}

HTTP/1.1 405 Method Not Allowed
Allow: GET, OPTIONS
Content-Security-Policy: default-src 'self'; style-src 'self' fonts.googleapis.com; font-src fonts.gstatic.com
Content-Type: text/plain; charset=utf-8
Referrer-Policy: origin-when-cross-origin
X-Content-Type-Options: nosniff
X-Frame-Options: deny
X-Xss-Protection: 0
Date: Wed, 06 Sep 2023 14:45:12 GMT
Content-Length: 19
Method Not Allowed

$ curl http://localhost:4000/snippet/view/99
Not Found
$ curl http://localhost:4000/missing
404 page not found

package main

import (
	"net/http"

	"github.com/julienschmidt/httprouter"
	"github.com/justinas/alice" // New import
)

func (app *application) routes() http.Handler {

	router := httprouter.New()
	// Create a handler function which wraps our notFound() helper, and then
	// assign it as the custom handler for 404 Not Found responses. You can also
	// set a custom handler for 405 Method Not Allowed responses by setting
	// router.MethodNotAllowed in the same way too.
	router.NotFound = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		app.notFound(w)
	})

	// Update the pattern for the route for the static files.
	fileServer := http.FileServer(http.Dir("./ui/static/"))
	router.Handler(http.MethodGet, "/static/*filepath", http.StripPrefix("/static", fileServer))
	// And then create the routes using the appropriate methods, patterns and
	// handlers.
	router.HandlerFunc(http.MethodGet, "/", app.home)
	router.HandlerFunc(http.MethodGet, "/snippet/view/:id", app.snippetView)
	router.HandlerFunc(http.MethodGet, "/snippet/create", app.snippetCreate)
	router.HandlerFunc(http.MethodPost, "/snippet/create", app.snippetCreatePost)
	// Create the middleware chain as normal.
	standard := alice.New(app.recoverPanic, app.logRequest, sercureHeaders)
	// Wrap the router with the middleware and return it as normal.
	return standard.Then(router)
}

$ curl http://localhost:4000/snippet/view/99
Not Found
$ curl http://localhost:4000/missing
Not Found