技术阅读周刊第十四期：常用的 Git 配置

func NewServer(
 logger *Logger
 config *Config
 commentStore *commentStore
 anotherStore *anotherStore
) http.Handler {
 mux := http.NewServeMux()
 addRoutes(
  mux,
  Logger,
  Config,
  commentStore,
  anotherStore,
 )
 var handler http.Handler = mux
 handler = someMiddleware(handler)
 handler = someMiddleware2(handler)
 handler = someMiddleware3(handler)
 return handler
}

func addRoutes(
 mux                 *http.ServeMux,
 logger              *logging.Logger,
 config              Config,
 tenantsStore        *TenantsStore,
 commentsStore       *CommentsStore,
 conversationService *ConversationService,
 chatGPTService      *ChatGPTService,
 authProxy           *authProxy
) {
 mux.Handle("/api/v1/", handleTenantsGet(logger, tenantsStore))
 mux.Handle("/oauth2/", handleOAuth2Proxy(logger, authProxy))
 mux.HandleFunc("/healthz", handleHealthzPlease(logger))
 mux.Handle("/", http.NotFoundHandler())
}

func run(ctx context.Context, w io.Writer, args []string) error {
 ctx, cancel := signal.NotifyContext(ctx, os.Interrupt)
 defer cancel()

 // ...
}

func main() {
 ctx := context.Background()
 if err := run(ctx, os.Stdout, os.Args); err != nil {
  fmt.Fprintf(os.Stderr, "%s\n", err)
  os.Exit(1)
 }
}

// handleSomething handles one of those web requests
// that you hear so much about.
func handleSomething(logger *Logger) http.Handler {
 thing := prepareThing()
 return http.HandlerFunc(
  func(w http.ResponseWriter, r *http.Request) {
   // use thing to handle request
   logger.Info(r.Context(), "msg", "handleSomething")
  }
 )
}

func encode[T any](w http.ResponseWriter, r *http.Request, status int, v T) error {
 w.Header().Set("Content-Type", "application/json")
 w.WriteHeader(status)
 if err := json.NewEncoder(w).Encode(v); err != nil {
  return fmt.Errorf("encode json: %w", err)
 }
 return nil
}

func decode[T any](r *http.Request) (T, error) {
 var v T
 if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
  return v, fmt.Errorf("decode json: %w", err)
 }
 return v, nil
}

// Validator is an object that can be validated.
type Validator interface {
 // Valid checks the object and returns any
 // problems. If len(problems) == 0 then
 // the object is valid.
 Valid(ctx context.Context) (problems map[string]string)
}

func decodeValid[T Validator](r *http.Request) (T, map[string]string, error) {
 var v T
 if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
  return v, nil, fmt.Errorf("decode json: %w", err)
 }
 if problems := v.Valid(r.Context()); len(problems) > 0 {
  return v, problems, fmt.Errorf("invalid %T: %d problems", v, len(problems))
 }
 return v, nil, nil
}

func handleTemplate(files string...) http.HandlerFunc {
 var (
  init    sync.Once
  tpl     *template.Template
  tplerr  error
 )
 return func(w http.ResponseWriter, r *http.Request) {
  init.Do(func(){
   tpl, tplerr = template.ParseFiles(files...)
  })
  if tplerr != nil {
   http.Error(w, tplerr.Error(), http.StatusInternalServerError)
   return
  }
  // use tpl
 }
}