近期在公司实习，参与了公司的一个分布式的应用服务系统。系统采用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。