函数处理结果返回给调用函数，实现代码模块化，便于单元测试

func wsRouter(clientID string, req ClientRequest) {

switch req.Method {
//--------------------------------------------------dy
case "/createGroup", "/addGroupMember", "/addGroupMemberList", "/deleteGroupMember":
dyRouter(req.Method, clientID, req.Args)
//--------------------------------------------------Ficow Shen
case "/chatMessageList":
chatMessageList(clientID, req.Args)
case "/sessionList":
sessionList(clientID, req.Args)
case "/sendTextMessage":
sendTextMessage(clientID, req.Args)

//--------------------------------------------------Pismery
case "/getObjectData":
getObjectData(clientID, req.Args)
case "/deleteGroup":
deleteGroup(clientID, req.Args)
case "/alterObjectData":
alterObjectData(clientID, req.Args)
case "/searchFriend":
searchFriend(clientID, req.Args)
case "/groupManagerList":
groupManagerList(clientID, req.Args)
//--------------------------------------------------Decaf
case "/getFriendList":
getFriendList(clientID, req.Args)
case "/getGroupList":
getGroupList(clientID, req.Args)
case "/getGroupMember":
getGroupMember(clientID, req.Args)
case "/setGroupManager":
setGroupManager(clientID, req.Args)
case "/searchGroup":
searchGroup(clientID, req.Args)
default:
dispatchSystemMsgToClient(clientID, req.Method, errBadAPI, mBadAPI)
// case "/链接":
// 	yourFunc(req.Args)
// }
}
}

　　

package Network

import (
"logs"
)

func dyRouter(URL string, userID string, req interface{}) {
var (
code   int         = Success
msg    string      = ""
result interface{} = nil
)
defer func() {
writeResponseToClient(userID, ServerResponse{
Method:  URL,
Code:    code,
Message: msg,
Result:  result,
})
if code != Success {
logs.Print("code:", code, "\tmsg:", msg, "\tresult", result)
}
}()
dataMap, ok := req.(map[string]interface{})
if !ok {
code = errAssertType
msg = "type isn't map[string]interface{}"
return
}
var data dy_judge = dataMap
switch URL {
case "/createGroup":
code, msg, result = createGroup(userID, data)
break
case "/addGroupMember":
code, msg, result = addGroupMember(userID, data)
break
case "/addGroupMemberList":
code, msg, result = addGroupMemberList(userID, data)
break
case "/deleteGroupMember":
code, msg, result = deleteGroupMember(userID, data)
break
}
}

　　

　

package Network

import (
"SQL/FSDB"

"logs"

_ "github.com/lib/pq"
)

type SessionInfo struct {
FriendSessions interface{} `json:"FriendSessions"`
GroupSessions  interface{} `json:"GroupSessions"`
}

func sessionList(clientID string, args interface{}) {

var errCode = Success
var errMsg = ""
var result interface{}
defer func() {
err := writeResponseToClient(clientID, ServerResponse{
Method:  "/sessionList",
Code:    errCode,
Message: errMsg,
Result:  result,
})
if err != nil {
logs.Print("/sessionList writeResponseToClient,Err:", err.Error())
return
}
}()

tx, db, err := FSDB.BeginTx()
if err != nil {
errCode = errEndTx
errMsg = "FSDB.BeginTx 执行错误：" + err.Error()
return
}
defer func() {
defer closeDB(db)
if errCode == Success {
err := tx.Commit()
if err != nil {
errCode = errEndTx
errMsg = err.Error()
logs.Print("/sessionList tx.Commit err:", err.Error())
}
return
}
err := tx.Rollback()
if err != nil {
errCode = errEndTx
errMsg = err.Error()
logs.Print("*sessionList tx.Rollback err:", err.Error())
}
}()

var friendSessions interface{}
errCode, errMsg, friendSessions = friendSessionInContext(tx, clientID)
if errCode != Success {
return
}
var groupSessions interface{}
errCode, errMsg, groupSessions = groupSessionInContext(tx, clientID)
if errCode != Success {
return
}

sessionInfo := SessionInfo{
FriendSessions: friendSessions,
GroupSessions:  groupSessions,
}
result = sessionInfo

// // 更新用户在线时间
// updateUserOnlineTime(tx, clientID, currentTime())
}

　　

上面是一个数据分流处理的函数，然后每个分流函数处理完后的数据都调用了writeResponseToClient，但这样在对某个分流函数进行分流测试时无法将数据返回到调用处，单元测试时就无法得到测试返回值，所以应统一将结果返回到函数调用处进行处理

修改后：

// websocket接口都在这里部署路由
func wsRouter(clientID string, req ClientRequest) {
var res *ServerResponse
switch req.Method {
//--------------------------------------------------dy
case "/createGroup", "/addGroupMember", "/addGroupMemberList", "/deleteGroupMember":
res = dyRouter(req.Method, clientID, req.Args)
//--------------------------------------------------Ficow Shen
case "/chatMessageList":
res = chatMessageList(clientID, req.Args)
case "/sessionList":
res = sessionList(clientID, req.Args)
case "/sendTextMessage":
res = sendTextMessage(clientID, req.Args)

//--------------------------------------------------Pismery
case "/getObjectData":
res = getObjectData(clientID, req.Args)
case "/deleteGroup":
res = deleteGroup(clientID, req.Args)
case "/alterObjectData":
res = alterObjectData(clientID, req.Args)
case "/searchFriend":
res = searchFriend(clientID, req.Args)
case "/groupManagerList":
res = groupManagerList(clientID, req.Args)
//--------------------------------------------------Decaf
case "/getFriendList":
res = getFriendList(clientID, req.Args)
case "/getGroupList":
res = getGroupList(clientID, req.Args)
case "/getGroupMember":
res = getGroupMember(clientID, req.Args)
case "/setGroupManager":
res = setGroupManager(clientID, req.Args)
case "/searchGroup":
res = searchGroup(clientID, req.Args)
default:
res = &ServerResponse{
Method:  req.Method,
Code:    errBadAPI,
Message: mBadAPI,
}
// case "/链接":
// 	yourFunc(req.Args)
// }
}
if res.Code == errBadAPI {
dispatchSystemMsgToClient(clientID, req.Method, errBadAPI, mBadAPI)
} else {
writeResponseToClient(clientID, res)
}
}

　　

func dyRouter(URL string, userID string, req interface{}) (response *ServerResponse) {
var (
code   int         = Success
msg    string      = ""
result interface{} = nil
)
defer func() {
if code != Success {
logs.Print("code:", code, "\tmsg:", msg, "\tresult", result)
}
response = &ServerResponse{
Method:  URL,
Code:    code,
Message: msg,
Result:  result,
}
}()
dataMap, ok := req.(map[string]interface{})
if !ok {
code = errAssertType
msg = "type isn't map[string]interface{}"
return
}
var data dy_judge = dataMap
switch URL {
case "/createGroup":
code, msg, result = createGroup(userID, data)
break
case "/addGroupMember":
code, msg, result = addGroupMember(userID, data)
break
case "/addGroupMemberList":
code, msg, result = addGroupMemberList(userID, data)
break
case "/deleteGroupMember":
code, msg, result = deleteGroupMember(userID, data)
break
}
return
}

　　

func chatMessageList(clientID string, args interface{}) (response *ServerResponse) {

var errCode = Success
var errMsg = ""
var res interface{}
defer func() {
response = &ServerResponse{
Method:  "/chatMessageList",
Code:    errCode,
Message: errMsg,
Result:  res,
}
}()

var ok = false
var judger FSJudger
if ok, errCode, errMsg, judger = initJudger(args); !ok {
return
}

userID := clientID
talkerID := ""
if ok, errCode, errMsg, talkerID = judger.isValidID("talkerID"); !ok {
return
}
if userID == talkerID {
errCode = errInvalidTalker
errMsg = mInvalidChat
return
}
talkerIsUser := false
if talkerIsUser, ok = judger.boolValueOf("talkerIsUser"); !ok {
return
}
if talkerIsUser {
if ok, errCode, errMsg = isExistTalkerID(userID, talkerID, true); !ok {
return
}
} else {
if ok, errCode, errMsg = isExistTalkerID(userID, talkerID, false); !ok {
return
}
}
pageIndex := 0
if ok, errCode, errMsg, pageIndex = judger.isValidPageIndex(); !ok {
return
}
pageSize := 0
if ok, errCode, errMsg, pageSize = judger.isValidPageSize(); !ok {
return
}

errCode, errMsg, res = getMsgListFromDB(userID, talkerID, talkerIsUser, pageIndex, pageSize)
return
}