近期在公司实习，参与了公司的一个分布式的应用服务系统。系统采用Golang语言作为系统的开发语言，在开发过程中采用了Go语言的反射函数的特性来取代了以前常使用的switch语法。
switch-case是一种多种选择的语法，其本质与if-else方法差不多，都是通过判断条件来执行不同的方法。而Go提供了一种机制在运行时更新变量和检查它们的值，调用它们的方法，和它们支持的内在操作，但是在编译时并不知道这些变量的类型。这种机制被称为反射，反射也可以让我们将类型本身作为第一类的值类型处理。
Web应用路由问题
在我们编写Web应用过程中，常常会遇到一个路由需要对应一个方法，我们会选择使用switch的方法来进行路由的匹配，若是路由匹配成功，我们会调用一个方法，这种方法能够很简便的完成我们的工作，也便于程序员在编写代码过程中厘清思路。
问题：
在一个URL的路由中，我们在request中通过cmd的参数来对应一个方法，这样我们要如何根据一个cmd对应一个方法？
可能针对这个问题有人会说，我们为什么不把cmd放到URL里面，这样的话就是一个方法对应一个路由，而且大多数的Web框架会通过回调函数来进行函数调用，针对于这个问题，我只能说大部分的都是将cmd放到http的request里面的，具体的好处可能就是减少了对API的监管，以及当路由比较多的时间能够减少麻烦吧。
用switch方法实现：
cmd := this.GetString("cmd")
switch cmd{
case "ls":
ls()
case "cd":
cd()
default:
fmt.Println("cmd method missing")
}
上述的方法先通过URL的参数获取到cmd，然后通过cmd来调用相对应的方法。在传统的MVC的设计模式中，需要在Controller中添加switch方法，同时需要在Model中实现相对应的方法，总计修改了2个文件。
go语言反射函数
reflect包
在reflect包中，主要通过Typeof()和Valueof()两个方法来实现反射。两个方法相互结合，能够反射出被反射函数的全部信息。
package main
import (
"fmt"
"reflect"
)
type Ref struct {
id int
name string
}
func (ref *Ref)GetName(){
fmt.Println("getName()函数")
}
func (ref *Ref)GetNameById(){
fmt.Println("getNameById()函数")
}
func main(){
t := reflect.TypeOf(&Ref{})
v := reflect.ValueOf(new(Ref))
fmt.Println(t)
fmt.Println(v)
for i:= 0; i< t.NumMethod();i++{
fmt.Println(t.Method(i).Name)
v.Method(i).Call(nil)
}
}
TypeOf()
TypeOf()函数主要是打印出被反射函数的类型，其返回结果是reflect.Type类型。
在上面的示例中，通过Method().Name能够反射其方法的函数名。
常用的方法：
- func (t *rtype)String() string
- func (t *rtype)Name() string
- func (t *rtype)Kind() reflect.kind
- func (t *rtype)Method(int) reflect.Method
- func (t *rtype)Elem() reflect.Type
- func (t *rtype)In(int) reflect.Type
ValueOf()
ValueOf()函数主要是打印出被反射函数的类型，其返回结果是reflect.Value类型。
在上面的示例中，通过Method().Call()能够反射出其函数并执行。
常用的方法：
- func (v Value)String() string
- func (v Value)Elem() reflect.Value
- func (v Value)Method(int) reflect.Value
- func (v Value)Call(in []Value) (r []Value)
反射的实现过程
由于有反射的存在，因此在传统的MVC的设计模式中，当我们添加服务时，不需要修改Controller端的代码，Controller只需要维持一个map的表，里面的就来存储需要被反射的models。
package server
import(
"reflect"
"fmt"
)
// ReServer 来保存map的结构体
type ReServer struct {
m map[string]interface{}
}
// RegisterService 注册服务
func (this *ReServer)RegisterService(service interface{})(err error){
serviceType := reflect.TypeOf(service).Elem()
ServiceName := serviceType.Name()
if _,ok := this.m[ServiceName]
if ok {
fmt.Println("service has been registered")
}else{
this.m[ServiceName] = service
}
return
}
// Start 服务启动
func (this *ReServer)Start(){
for k,v := range this.m {
// 里面根据业务逻辑执行想要的方法
}
}
在上诉的例子中，通过对services的服务注册，就能够通过Start()函数发现服务，并且根据业务来实现自己的代码。
package main
import (
"server"
)
type Server struct {
}
func (server *Server)funOne(){
fmt.Println("Server FunOne")
}
func main(){
reServer := &server.ReServer{
m: make(map[string]interface{})
}
err := reServer.RegisterService(new(Server))
reServer.Start()
}
因此在我们主函数中，导入封装好的包，只需要注册一个结构体，就能够将自己的方法反射出来实现。
对应上面的Web的路由问题，我们将Controller进行封装，然后将Model进行反射，当我们业务增加时，我们在Model里面添加就可以了，不需要修改Controller。
