Lixv

A := 10 // a 的类型就是int，值就是10，这是go语言的语法糖帮助我们简单创建的类型
var a int = 10 // 实际上应该是这样创建, 在声明值的时候标注类型

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int = 42
	var str string = "Hello, Reflect!"

	fmt.Println(reflect.TypeOf(num))  // 输出: int
	fmt.Println(reflect.TypeOf(str))  // 输出: string
}

	var a myFloat64 // 自定义类型
	var b *float64  // 指针

	reflectType(a) // 输出：TypeOf: main.myFloat64, 类型：myFloat64，种类：float64
	reflectType(b) // 输出：TypeOf: TypeOf: *float64, 类型：，种类：ptr

	type Person struct {
		Name string
		Age  int
	}
	var p = Person{
		Name: "Lixin",
		Age:  21,
	}
	reflectType(p) // TypeOf: TypeOf: main.Person, 类型：Person，种类：struct

// go reflect标准库源码
// A Kind represents the specific kind of type that a Type represents.
// The zero Kind is not a valid kind.
type Kind uint

const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Pointer
	Slice
	String
	Struct
	UnsafePointer
)

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 使用 reflect.ValueOf 获取 reflect.Value
	v := reflect.ValueOf(42)

	// 获取原始值
	value := v.Interface()
	fmt.Println(value) // 输出: 42

	// 使用类型断言将原始值转换为具体类型
	if i, ok := value.(int); ok {
		fmt.Println(i * 2) // 输出: 84
	}

	// 使用其他方法获取原始值
	b := reflect.ValueOf(true).Bool()
	fmt.Println(b) // 输出: true

	f := reflect.ValueOf(3.14).Float()
	fmt.Println(f) // 输出: 3.14

	s := reflect.ValueOf("hello").String()
	fmt.Println(s) // 输出: hello

	t := reflect.ValueOf(42).Type()
	fmt.Println(t) // 输出: int
}

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	p := Person{Name: "Alice", Age: 25}

	// 使用反射获取变量的指针值
	// 这里必须是指针，因为我们是通过底层指针去更改值的
	v := reflect.ValueOf(&p)

	// 检查是否是指针类型并且可寻址
	if v.Kind() == reflect.Ptr && v.Elem().CanSet() {
		// 获取指针指向的值
		elem := v.Elem()

		// 获取字段的值并修改
		nameField := elem.FieldByName("Name")
		if nameField.IsValid() && nameField.Kind() == reflect.String {
			nameField.SetString("Bob")
		}

		ageField := elem.FieldByName("Age")
		if ageField.IsValid() && ageField.Kind() == reflect.Int {
			ageField.SetInt(30)
		}
	}

	fmt.Printf("%+v", p) // 输出: {Name:Bob Age:30}
}

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	// *int类型空指针
	var a *int
	fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil()) //var a *int IsNil: true
	// nil值
	fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid()) // nil IsValid: false
	// 实例化一个匿名结构体
	b := struct{}{}
	// 尝试从结构体中查找"abc"字段
	fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid()) // 不存在的结构体成员: false
	// 尝试从结构体中查找"abc"方法
	fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid()) // 不存在的结构体方法: false
	// map
	c := map[string]int{}
	// 尝试从map中查找一个不存在的键
	fmt.Println("map中不存在的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid()) // map中不存在的键： false
}

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name   string
	Age    int
	Height float64
}

func (p Person) SayHello() {
	fmt.Println("Hello, my name is", p.Name)
}

func main() {
	p := Person{
		Name:   "John",
		Age:    30,
		Height: 1.75,
	}

	// 获取结构体字段信息
	t := reflect.TypeOf(p)
	fmt.Println("Struct fields:")
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("Name: %s, Type: %s\n", field.Name, field.Type)
	}

	// 根据字段名获取结构体字段信息
	field, ok := t.FieldByName("Age")
	if ok {
		fmt.Println("\nField by name:")
		fmt.Printf("Name: %s, Type: %s\n", field.Name, field.Type)
	}

	// 获取结构体方法信息
	v := reflect.ValueOf(p)
	fmt.Println("\nMethods:")
	for i := 0; i < t.NumMethod(); i++ {
		method := t.Method(i)
		fmt.Printf("Name: %s, Type: %s\n", method.Name, method.Type)
	}

	// 根据方法名获取结构体方法信息
	method, ok := t.MethodByName("SayHello")
	if ok {
		fmt.Println("\nMethod by name:")
		fmt.Printf("Name: %s, Type: %s\n", method.Name, method.Type)
	}
}

// 输出
Struct fields:
Name: Name, Type: string
Name: Age, Type: int
Name: Height, Type: float64

Field by name:
Name: Age, Type: int

Methods:
Name: SayHello, Type: func(main.Person)

Method by name:
Name: SayHello, Type: func(main.Person)
``

通过上面这个例子，你可以看出reflect的威力，比如我可以通过某个结构体的方法，只要将方法名称写成一定的格式，就可以帮我自动注册HTTP方法，比如我有个结构体Service，只要在这个结构体下写Get_XXX,就可以注册路径为/xxx的get服务，下面就是一个示例：

```go
package main

import (
	"fmt"
	"net/http"
	"reflect"
	"strings"
)

type Service struct{}

func (s *Service) Get_Hubs(w http.ResponseWriter, r *http.Request) {
	fmt.Println("Handling GET request for /hubs")
}

func (s *Service) Post_Name(w http.ResponseWriter, r *http.Request) {
	fmt.Println("Handling POST request for /name")
}

func RegisterHTTPHandlers(service interface{}) {
	svcType := reflect.TypeOf(service)
	svcValue := reflect.ValueOf(service)

	for i := 0; i < svcType.NumMethod(); i++ {
		method := svcType.Method(i)
		methodName := method.Name

		if strings.HasPrefix(methodName, "Get_") || strings.HasPrefix(methodName, "Post_") {
			parts := strings.Split(methodName, "_")
			if len(parts) < 2 {
				continue
			}

			path := "/" + strings.ToLower(strings.Join(parts[1:], "/"))
			handler := svcValue.MethodByName(methodName).Interface().(func(http.ResponseWriter, *http.Request))
			http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
				switch r.Method {
				case http.MethodGet:
					if strings.HasPrefix(methodName, "Get_") {
						handler(w, r)
					} else {
						http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
					}
				case http.MethodPost:
					if strings.HasPrefix(methodName, "Post_") {
						handler(w, r)
					} else {
						http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
					}
				default:
					http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
				}
			})
		}
	}
}

func main() {
	service := &Service{}
	RegisterHTTPHandlers(service)

	fmt.Println("Listening on http://localhost:8889")
	http.ListenAndServe(":8889", nil)
}

Listening on http://localhost:8889
Handling POST request for /name
Handling GET request for /hubs