Go语言开发小技巧&易错点100例（十二）

package main

import (
	"fmt"
	"log"
	"net/http"
)

// 全局异常处理器
func globalErrorHandler(err error, w http.ResponseWriter, r *http.Request) {
	// 记录错误信息
	log.Printf("Error: %v", err)

	// 设置HTTP状态码
	if httpErr, ok := err.(*http.Error); ok {
		w.WriteHeader(httpErr.Code)
	} else {
		w.WriteHeader(http.StatusInternalServerError)
	}

	// 返回错误消息给客户端
	w.Write([]byte(err.Error()))
}

// 自定义HTTP错误处理函数
func handleError(w http.ResponseWriter, r *http.Request, err error) {
	// 在这里你可以根据需要对错误进行特殊处理
	// 如果没有特殊处理，则调用全局异常处理器
	globalErrorHandler(err, w, r)
}

// 示例HTTP处理函数
func helloHandler(w http.ResponseWriter, r *http.Request) {
	// 示例：故意制造一个错误
	panic("Something went wrong!")
}

func main() {
	// 设置自定义错误处理函数
	http.DefaultServeMux.HandleFunc("/", helloHandler)
	http.DefaultServeMux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("OK"))
	})

	// 使用自定义错误处理函数作为全局异常处理器
	http.DefaultServeMux.HandlerFunc("/global-error-handler").Func = func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				handleError(w, r, err)
			}
		}()
		http.NotFound(w, r)
	}

	fmt.Println("Server is running at http://localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

x := 42
t := reflect.TypeOf(x)
fmt.Println(t) // 输出: int

v := reflect.ValueOf(x)
fmt.Println(v.Int()) // 输出: 42

type MyStruct struct {
    Name string
}

func (m *MyStruct) SayHello() {
    fmt.Println("Hello, my name is", m.Name)
}

ms := &MyStruct{Name: "Alice"}
method := reflect.ValueOf(ms).MethodByName("SayHello")
method.Call(nil) // 输出: Hello, my name is Alice

type Student struct {
   Id   int64
   Name string
   Age  int
}

func TestStruct(t *testing.T) {
   stu := Student{1, "zs", 12}
   obj := reflect.ValueOf(stu)
   field := obj.FieldByName("Name")
   field1 := obj.Field(0)
   num := obj.NumField()
   fmt.Println("字段数量：", num)
   fmt.Println("Name字段的值：", field)
   fmt.Println("第0个字段的值：", field1)
   obj1 := reflect.ValueOf(new(Student))
   addr := obj1.CanAddr() //是否能寻址
   if addr {
      fmt.Println(obj1.Addr())
   }
}

// 切片类型的反射
func TestSlice(t *testing.T) {
   slice := make([]int, 10)
   s := reflect.ValueOf(slice)
   //加入元素
   s.Index(0).Set(reflect.ValueOf(100))
   //获取元素
   i := s.Index(0).Interface()
   fmt.Println(slice)
   fmt.Println(i)
}

// Map类型的反射
func TestMap(t *testing.T) {
   m := make(map[string]interface{})
   m["A"] = 1
   m["B"] = 2
   m["C"] = 3
   mv := reflect.ValueOf(m)
   //赋值
   mv.SetMapIndex(reflect.ValueOf("D"),reflect.ValueOf(4))
   iter := mv.MapRange()
   keys := mv.MapKeys()
   fmt.Println(keys)
   for iter.Next() {
      fmt.Println(iter.Value())
   }
}

func TestReflection(t *testing.T) {
   var x float64 = 3.4
   v := reflect.ValueOf(x)
   //v.SetFloat(7.1) // Error: will panic.

   p:= reflect.ValueOf(&x)

   v1 := p.Elem()
   fmt.Println("settability of v:", v1.CanSet())
   v1.SetFloat(7.1)
   fmt.Println(v.Interface())
   fmt.Println(x)
}