tangping/goProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始化项目

Browse Source
This commit is contained in:
皮蛋13361098506
2025-01-06 16:01:02 +08:00
commit 1b77f62820
575 changed files with 69193 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
trunk/framework/handleMgr/doc.go Normal file
View File

@@ -0,0 +1,81 @@
// ************************************
// @package: handleMgr
// @description: 全局操作接口管理API类
// @author:
// @revision history:
// @create date: 2022-02-23 16:24:59
// ************************************
package handleMgr
/*
用于提供全局操作接口管理API类
*/
/*
接口说明
接口1：
// RegisterNewModule
// @description: 注册方法
// parameter:
// @moduleName:模块名
// @structObject:模块对象
// @monitorTime:监控日志超时时间,传入0是用默认值100
// return:
示例：RegisterNewModule("test", new(testBll), 0)
接口2：
// Done
// @description: 执行访问
// parameter:
// @logicalId:逻辑实例Id-同一串行错误类的唯一标识
// @moduleName:模块名
// @funcName:执行方法名称
// @parameter:方法参数
// @isHaveResult:是否处理返回值
// return:
// @data:返还对象
// @code:错误码-0未无错误
// @message:错误说明-空字符串为无错误
示例：data,code,mes := Done("test", "testBll", "Add", parameter, false)
注意：
注册的类实现的方法返回值必须是*ResponseObject为返回对象
示例：
type testBll struct {
}
// TestAdd
// @description:测试添加
// parameter:
// @receiver t:
// @x:
// @y:
// return:
// @*ResponseObject:
func (t testBll) TestAdd(x, y int) *ResponseObject {
responseObj := GetInitResponseObj()
data[x] = y
z := x + y
responseObj.SetData(z)
responseObj.SetResultStatus("错误码")
return responseObj
}
func TestNew(t *testing.T) {
// 注册类
RegisterNewModule("test", new(testBll), 10)
// 调用方法
data, code, mes := Done("test", "testBll", "TestAdd", parameter, false)
// 可以重复注册多个类,逻辑实例Id保持一致即可
RegisterNewModule("test", new(test2Bll), 10)
data, code, mes := Done("test", "test2Bll", "TestAdd", parameter, false)
}
*/

131
trunk/framework/handleMgr/handleMgr.go Normal file
View File

@@ -0,0 +1,131 @@
// ************************************
// @package: handleMgr
// @description: 全局操作接口管理
// @author:
// @revision history:
// @create date: 2022-02-21 15:53:59
// ************************************
package handleMgr
import (
"fmt"
"Framework/goroutineMgr"
"goutil/logUtil"
"runtime/debug"
"time"
)
var (
handleData = make(map[string]*HandleObj)
)
// RegisterNewModule
// @description: 注册调用方法
// parameter:
// @logicalId:逻辑实例Id-同一串行错误类的唯一标识
// @structObject:模块对象
// @monitorTime:监控日志超时时间,传入0是用默认值100
// return:
func RegisterNewModule(logicalId string, structObject interface{}, monitorTime int64) {
// 注册模块,开启线程
_, isExists := handleData[logicalId]
if isExists == false {
newHandleObj := NewHandleObj(logicalId)
handleData[logicalId] = newHandleObj
// 设置监控默认值
if monitorTime == 0 {
monitorTime = 100
}
// 开启监控-channel
go func() {
registerName := fmt.Sprintf("handleMgr.RegisterNewModule.logicalId=%s", logicalId)
goroutineMgr.MonitorZero(registerName)
defer goroutineMgr.ReleaseMonitor(registerName)
defer logErrorRecover()
ret := 0
for {
select {
case c := <-newHandleObj.HandleChannel:
start := time.Now().UnixMilli()
responseObject := CallFunction(c)
end := time.Now().UnixMilli()
if c.IsHaveResult == true {
c.ResultChan <- responseObject
}
if end-start > monitorTime {
message := fmt.Sprintf("方法执行时间超长，logicalId:%s,moduleName：%s,MethodName:%s,消耗时间过程,总耗时:%d,需要检查代码！！！！！", logicalId, c.ModuleName, c.MethodName, end-start)
logUtil.ErrorLog(message)
}
ret++
if ret == 100 {
num := len(newHandleObj.HandleChannel)
if num > 500 {
message := fmt.Sprintf("时间戳:%d,channel监控,内部待执行操作过多，logicalId:%s,当前待执行数量:%d,需要检查代码！！！！！", time.Now().UnixMilli(), logicalId, num)
logUtil.ErrorLog(message)
}
}
default:
// 如果找不到数据则休眠5ms
time.Sleep(5 * time.Millisecond)
}
}
}()
}
// 注册对象
RegisterFunction(structObject)
}
// Done
// @description: 执行访问
// parameter:
// @logicalId:逻辑实例Id-同一串行错误类的唯一标识
// @moduleName:模块名
// @funcName:执行方法名称
// @parameter:方法参数
// @isHaveResult:是否处理返回值
// return:
// @data:返还对象
// @code:错误码-0未无错误
// @message:错误说明-空字符串为无错误
func Done(logicalId string, moduleName string, funcName string, parameter []interface{}, isHaveResult bool) (data interface{}, code int, message string) {
responseObj := NewRequestObject(moduleName, funcName, parameter, isHaveResult)
handleObj, isExists := handleData[logicalId]
if isExists == false {
message := fmt.Sprintf("未注册模块，moduleName：%s", moduleName)
logUtil.ErrorLog(message)
return nil, -1, message
}
handleObj.HandleChannel <- responseObj
if responseObj.IsHaveResult == false {
return nil, 0, ""
}
for {
select {
case responseObject := <-responseObj.ResultChan:
// 处理返回值
return responseObject.Data, 0, responseObject.Message
default:
// 如果找不到数据则休眠5ms
time.Sleep(5 * time.Millisecond)
}
}
}
// logErrorRecover
// @description: 打印日志
// parameter:
// return:
func logErrorRecover() {
if err := recover(); err != nil {
msg := fmt.Sprintf("err msg:%s stack:%s", err, debug.Stack())
logUtil.ErrorLog(msg)
}
}

26
trunk/framework/handleMgr/handleObj.go Normal file
View File

@@ -0,0 +1,26 @@
// ************************************
// @package: handleMgr
// @description: HandleObj 操作对象
// @author: zhaoxin
// @revision history:
// @create date: 2022-02-21 16:52:44
// ************************************
package handleMgr
// HandleObj 操作对象
type HandleObj struct {
// 模块命名
ModuleName string
// 操作channel
HandleChannel chan *RequestObject
}
// NewHandleObj 初始化
func NewHandleObj(moduleName string) *HandleObj {
return &HandleObj{
ModuleName: moduleName,
HandleChannel: make(chan *RequestObject, 1000),
}
}

351
trunk/framework/handleMgr/reflect.go Normal file
View File

@@ -0,0 +1,351 @@
// ************************************
// @package: handleMgr
// @description: 反射类
// @author:
// @revision history:
// @create date: 2022-02-23 16:33:27
// ************************************
package handleMgr
import (
"fmt"
"goutil/logUtil"
"reflect"
"strings"
)
const (
// 定义用于分隔模块名称和方法名称的分隔符
con_DelimeterOfObjAndMethod = "_"
)
var (
// 定义存放所有方法映射的变量
methodMap = make(map[string]*ReflectMethod, 4)
// 函数返回值类型
responseType reflect.Type = reflect.TypeOf(new(ResponseObject))
)
// getStructName
// @description: 获取结构体类型的名称
// parameter:
// @structType:结构体类型
// return:
// @string:结构体类型的名称
func getStructName(structType reflect.Type) string {
reflectTypeStr := structType.String()
reflectTypeArr := strings.Split(reflectTypeStr, ".")
return reflectTypeArr[len(reflectTypeArr)-1]
}
// getFullMethodName
// @description: 获取完整的方法名称
// parameter:
// @structName:结构体名称
// @methodName:方法名称
// return:
// @string:完整的方法名称
func getFullMethodName(structName, methodName string) string {
return structName + con_DelimeterOfObjAndMethod + methodName
}
// resolveMethodInOutParams
// @description: 解析方法的输入输出参数
// parameter:
// @method:方法对应的反射值
// return:
// @inTypes:输入参数类型集合
// @outTypes:输出参数类型集合
func resolveMethodInOutParams(method reflect.Value) (inTypes []reflect.Type, outTypes []reflect.Type) {
methodType := method.Type()
for i := 0; i < methodType.NumIn(); i++ {
inTypes = append(inTypes, methodType.In(i))
}
for i := 0; i < methodType.NumOut(); i++ {
outTypes = append(outTypes, methodType.Out(i))
}
return
}
// RegisterFunction
// @description: 对象注册
// parameter:
// @structObject:对象
// return:
func RegisterFunction(structObject interface{}) {
// 获取structObject对应的反射 Type 和 Value
reflectValue := reflect.ValueOf(structObject)
reflectType := reflect.TypeOf(structObject)
// 提取对象类型名称
structName := getStructName(reflectType)
// 获取structObject中返回值为responseObject的方法
for i := 0; i < reflectType.NumMethod(); i++ {
// 获得方法名称
methodName := reflectType.Method(i).Name
// 获得方法及其输入参数的类型列表
method := reflectValue.MethodByName(methodName)
inTypes, outTypes := resolveMethodInOutParams(method)
// 判断输出参数数量是否正确
if len(outTypes) != 1 {
continue
}
// 判断返回值是否为responseObject
if outTypes[0] != responseType {
continue
}
// 添加到列表中
methodMap[getFullMethodName(structName, methodName)] = NewReflectMethod(method, inTypes, outTypes)
}
}
// CallFunction
// @description: 调用方法
// parameter:
// @requestObject:请求对象
// return:
// @responseObj:返还对象
func CallFunction(requestObject *RequestObject) (responseObj *ResponseObject) {
responseObj = GetInitResponseObj()
var reflectMethod *ReflectMethod
var ok bool
// 根据传入的ModuleName和MethodName找到对应的方法对象
key := getFullMethodName(requestObject.ModuleName, requestObject.MethodName)
if reflectMethod, ok = methodMap[key]; !ok {
message := fmt.Sprintf("找不到指定的方法：%s", key)
logUtil.ErrorLog(message)
responseObj.SetResultStatus(-2, message)
return
}
// 判断参数数量是否相同
inTypesLength := len(reflectMethod.InTypes)
paramLength := len(requestObject.Parameters)
if paramLength != inTypesLength {
message := fmt.Sprintf("传入的参数数量不符，本地方法%s的参数数量：%d，传入的参数数量为：%d", key, inTypesLength, paramLength)
logUtil.ErrorLog(message)
responseObj.SetResultStatus(-3, message)
return
}
// 构造参数
in := make([]reflect.Value, inTypesLength)
for i := 0; i < inTypesLength; i++ {
inTypeItem := reflectMethod.InTypes[i]
paramItem := requestObject.Parameters[i]
// 已支持类型：Client,Player(非基本类型)
// 已支持类型：Bool,Int,Int8,Int16,Int32,Int64,Uint,Uint8,Uint16,Uint32,Uint64,Float32,Float64,String
// 已支持类型：以及上面所列出类型的Slice类型
// 未支持类型：Uintptr,Complex64,Complex128,Array,Chan,Func,Interface,Map,Ptr,Struct,UnsafePointer
// 由于byte与int8同义，rune与int32同义，所以并不需要单独处理
// 枚举参数的类型，并进行类型转换
switch inTypeItem.Kind() {
case reflect.Bool:
if paramBool, ok := paramItem.(bool); ok {
in[i] = reflect.ValueOf(paramBool)
}
case reflect.Int:
if paramFloat64, ok := paramItem.(int); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Int8:
if paramFloat64, ok := paramItem.(int8); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Int16:
if paramFloat64, ok := paramItem.(int16); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Int32:
if paramFloat64, ok := paramItem.(int32); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Int64:
if paramFloat64, ok := paramItem.(int64); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Uint:
if paramFloat64, ok := paramItem.(uint); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Uint8:
if paramFloat64, ok := paramItem.(uint8); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Uint16:
if paramFloat64, ok := paramItem.(uint16); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Uint32:
if paramFloat64, ok := paramItem.(uint32); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Uint64:
if paramFloat64, ok := paramItem.(uint64); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Float32:
if paramFloat64, ok := paramItem.(float32); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.Float64:
if paramFloat64, ok := paramItem.(float64); ok {
in[i] = reflect.ValueOf(paramFloat64)
}
case reflect.String:
if paramString, ok := paramItem.(string); ok {
in[i] = reflect.ValueOf(paramString)
}
case reflect.Slice:
// 如果是Slice类型，则需要对其中的项再次进行类型判断及类型转换
if paramInterface, ok := paramItem.([]interface{}); ok {
switch inTypeItem.String() {
case "[]bool":
paramsInner := make([]bool, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramBool, ok := paramInterface[i].(bool); ok {
paramsInner[i] = paramBool
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]int":
paramsInner := make([]int, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(int); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]int8":
paramsInner := make([]int8, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(int8); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]int16":
paramsInner := make([]int16, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(int16); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]int32":
paramsInner := make([]int32, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(int32); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]int64":
paramsInner := make([]int64, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(int64); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]uint":
paramsInner := make([]uint, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(uint); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
// case "[]uint8": 特殊处理
case "[]uint16":
paramsInner := make([]uint16, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(uint16); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]uint32":
paramsInner := make([]uint32, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(uint32); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]uint64":
paramsInner := make([]uint64, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(uint64); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]float32":
paramsInner := make([]float32, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(float32); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]float64":
paramsInner := make([]float64, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramFloat64, ok := paramInterface[i].(float64); ok {
paramsInner[i] = paramFloat64
}
}
in[i] = reflect.ValueOf(paramsInner)
case "[]string":
paramsInner := make([]string, len(paramInterface))
for i := 0; i < len(paramInterface); i++ {
if paramString, ok := paramInterface[i].(string); ok {
paramsInner[i] = paramString
}
}
in[i] = reflect.ValueOf(paramsInner)
}
} else if inTypeItem.String() == "[]uint8" { // 由于[]uint8在传输过程中会被转化成字符串，所以单独处理;
if paramString, ok := paramItem.(string); ok {
paramUint8 := ([]uint8)(paramString)
in[i] = reflect.ValueOf(paramUint8)
}
}
}
}
// 判断是否有无效的参数（传入的参数类型和方法定义的类型不匹配导致没有赋值）
for _, item := range in {
if reflect.Value.IsValid(item) == false {
message := fmt.Sprintf("type:%v,value:%v.方法%s传入的参数%v无效", reflect.TypeOf(item), reflect.ValueOf(item), key, requestObject.Parameters)
logUtil.ErrorLog(message)
responseObj.SetResultStatus(-1, message)
return
}
}
out := reflectMethod.Method.Call(in)
// 并输出结果到客户端（由于只有一个返回值，所以取out[0]）
if responseObj, ok = (&out[0]).Interface().(*ResponseObject); !ok {
message := fmt.Sprintf("返回值类型推断为ResponseObject 出错, tyep is :%v", reflect.TypeOf(out[0]))
logUtil.ErrorLog(message)
responseObj.SetResultStatus(-1, message)
return
}
return
}

41
trunk/framework/handleMgr/reflectMethod.go Normal file
View File

@@ -0,0 +1,41 @@
// ************************************
// @package: handleMgr
// @description: 反射类-反射的方法和输入、输出参数类型组合类型
// @author:
// @revision history:
// @create date: 2022-02-23 16:33:43
// ************************************
package handleMgr
import (
"reflect"
)
// ReflectMethod 反射的方法和输入、输出参数类型组合类型
type ReflectMethod struct {
// 反射出来的对应方法对象
Method reflect.Value
// 反射出来的方法的输入参数的类型集合
InTypes []reflect.Type
// 反射出来的方法的输出参数的类型集合
OutTypes []reflect.Type
}
// NewReflectMethod
// @description:创建反射的方法和输入、输出参数类型组合类型
// parameter:
// @_method:反射出来的对应方法对象
// @_inTypes:反射出来的方法的输入参数的类型集合
// @_outTypes:反射出来的方法的输出参数的类型集合
// return:
// @*ReflectMethod:
func NewReflectMethod(_method reflect.Value, _inTypes []reflect.Type, _outTypes []reflect.Type) *ReflectMethod {
return &ReflectMethod{
Method: _method,
InTypes: _inTypes,
OutTypes: _outTypes,
}
}

46
trunk/framework/handleMgr/requestObject.go Normal file
View File

@@ -0,0 +1,46 @@
// ************************************
// @package: handleMgr
// @description: 反射类-请求对象
// @author:
// @revision history:
// @create date: 2022-02-23 16:33:53
// ************************************
package handleMgr
// RequestObject 请求对象
type RequestObject struct {
// 请求的模块名称
ModuleName string
// 请求的方法名称
MethodName string
// 请求的参数数组
Parameters []interface{}
// 是否处理返回值
IsHaveResult bool
// 执行完成,返回chan监控
ResultChan chan *ResponseObject
}
// NewRequestObject
// @description:
// parameter:
// @moduleName:模块名名称
// @methodName:执行方法名称
// @parameters:方法参数
// @isHaveResult:是否处理返回值
// return:
// @*RequestObject:
func NewRequestObject(moduleName string, methodName string, parameters []interface{}, isHaveResult bool) *RequestObject {
return &RequestObject{
ModuleName: moduleName,
MethodName: methodName,
Parameters: parameters,
IsHaveResult: isHaveResult,
ResultChan: make(chan *ResponseObject, 1),
}
}

63
trunk/framework/handleMgr/responseObject.go Normal file
View File

@@ -0,0 +1,63 @@
// ************************************
// @package: handleMgr
// @description: 反射类-响应对象
// @author:
// @revision history:
// @create date: 2022-02-23 16:34:08
// ************************************
package handleMgr
// ResponseObject 响应对象
type ResponseObject struct {
// 错误码
Code int
// 响应结果的状态值所对应的描述信息
Message string
// 响应结果的数据
Data interface{}
}
// SetResultStatus
// @description: 设置响应结果的状态值
// parameter:
// @receiver r:
// @code:响应结果的错误码
// @message:响应结果的字符串
// return:响应结果对象
// @*ResponseObject:
func (r *ResponseObject) SetResultStatus(code int, message string) *ResponseObject {
r.Code = code
r.Message = message
return r
}
// SetData
// @description: 设置响应结果的状态值
// parameter:
// @receiver r:
// @message:响应结果的字符串
// return:响应结果对象
// @*ResponseObject:
func (r *ResponseObject) SetData(data interface{}) *ResponseObject {
r.Data = data
return r
}
// GetInitResponseObj
// @description: 初始化
// parameter:
// @moduleName:模块名名称
// @methodName:执行方法名称
// @parameters:方法参数
// @isHaveResult:是否处理返回值
// return:
// @*ResponseObject:GetInitResponseObj
func GetInitResponseObj() *ResponseObject {
return &ResponseObject{
Message: "",
Data: nil,
}
}

133
trunk/framework/handleMgr/test_test.go Normal file
View File

@@ -0,0 +1,133 @@
package handleMgr
import (
"fmt"
"reflect"
"testing"
"time"
)
// ---------------申请示例实例--------------
var (
data = make(map[int]int, 0)
)
type testBll struct {
}
// TestAdd
// @description:测试添加
// parameter:
// @receiver t:
// @x:
// @y:
// return:
// @*ResponseObject:
func (t testBll) TestAdd(x, y int) *ResponseObject {
responseObj := GetInitResponseObj()
data[x] = y
z := x + y
print(x)
responseObj.SetData(z)
responseObj.SetResultStatus(-11111, "错误码")
return responseObj
}
// See1
// @description:测试添加
// parameter:
// @receiver t:
// @x:
// return:
// @*ResponseObject:
func (t testBll) See1(x int) *ResponseObject {
responseObj := GetInitResponseObj()
fmt.Print(x)
return responseObj
}
// See2
// @description:测试添加
// parameter:
// @receiver t:
// @x:
// return:
// @*ResponseObject:
func (t testBll) See2(x int) *ResponseObject {
responseObj := GetInitResponseObj()
time.Sleep(2000 * time.Millisecond)
fmt.Print(x)
return responseObj
}
func (t testBll) ReMove(x int) *ResponseObject {
responseObj := GetInitResponseObj()
delete(data, x)
return responseObj
}
// ---------------测试方法--------------
func TestNew(t *testing.T) {
var paramItem interface{}
paramItem = 123
paramFloat64, ok := paramItem.(int)
if ok {
x := reflect.ValueOf(int(paramFloat64))
t.Log(x)
}
t.Log(paramFloat64)
t.Log(ok)
//t.Log("A")
//RegisterNewModule("test", new(testBll), 10)
//parameter := []interface{}{"1", 2}
//x, y, mes := Done("test", "testBll", "TestAdd", parameter, false)
//for key, item := range data {
// t.Log(key, item)
//}
//t.Log("B2")
//parameter1 := []interface{}{2, 2}
//x, y, mes = Done("test", "testBll", "TestAdd", parameter1, true)
//for key, item := range data {
// t.Log(key, item)
//}
//t.Log(x)
//t.Log(y)
//t.Log(mes)
//t.Log("B3")
//
//t.Log("C")
//parameter2 := []interface{}{2}
//Done("test", "testBll", "ReMove", parameter2, true)
//for key, item := range data {
// t.Log(key, item)
//}
//t.Log("D")
//
//t.Log(time.Now().UnixMilli())
//parameter3 := []interface{}{1}
//Done("test", "testBll", "See2", parameter3, false)
//t.Log(time.Now().UnixMilli())
//parameter4 := []interface{}{2}
//Done("test", "testBll", "See1", parameter4, true)
//t.Log(time.Now().UnixMilli())
//parameter5 := []interface{}{1}
//Done("test", "testBll", "See1", parameter5, true)
//t.Log(time.Now().UnixMilli())
//
//t.Log("E")
//
//t.Log(time.Now().UnixMilli())
//for i := 0; i < 1000; i++ {
// Done("test", "testBll", "See1", parameter5, true)
//}
//t.Log(time.Now().UnixMilli())
//t.Log("F")
t.Error("G")
}