Cjson CHttpString::GetJsonData(){
int nLeft = str.Find("\r\n\r\n");
nLeft = nLeft + 4;
Cjson json;
json.LoadJson((LPSTR)(LPCTSTR)str.Mid(nLeft,str.GetLength() - nLeft));
return json;
}
DWORD WINAPI ThreadRecvHandling(LPVOID lpParam){
Threadpackage package = *((Threadpackage *)lpParam);
delete (Threadpackage *)lpParam;
//package.pmutex->Lock();
//判断是否使用json
if(package.ifUseJson == 1){
//接收的是服务端主动发来的数据，会有两种情况，一种是回复，一种是主动发送
Cjson json;
json.LoadJson(package.pBuf);
int MsgID = json["MsgID"].toValue().nValue;
int CheckKeyClient = json["CheckKeyClient"].toValue().nValue;
int CheckKeyServer = json["CheckKeyServer"].toValue().nValue;
//如果是回复客户端，得到回应，不需要继续Send
if(CheckKeyClient >= 0 && CheckKeyServer == -1){
Cjson jsonRsp = json;
jsonRsp["MsgID"] = "delete";
jsonRsp["CheckKeyClient"] = "delete";
//把响应json和寄存json传给虚函数
package.pThis->ReceiveRspJson(jsonRsp,MsgID,package.pThis->mapCheck[CheckKeyClient]);
//删除map中的寄存包裹
package.pThis->DeleteMap(CheckKeyClient);
}
//如果是服务端主动发送，则需要给响应
else if(CheckKeyClient == -1 && CheckKeyServer >= 0){
Cjson jsonReq = json;
jsonReq["MsgID"] = "delete";
jsonReq["CheckKeyServer"] = "delete";
package.pThis->SendJsonRsp(package.pThis->ReceiveReqJson(jsonReq,MsgID),MsgID,CheckKeyServer,3);
}
else{
CString strError = "";
strError.Format("key值出错，CheckKeyClient = %d，CheckKeyServer = %d",CheckKeyClient,CheckKeyServer);
AfxMessageBox(strError);
}
}
else package.pThis->receive(package.pBuf,package.RecvLength);
//package.pmutex->Unlock();
free(package.pBuf);
return 0;
}
int CAceTCPClient::SendJsonRsp(Cjson jsonRsp,int MsgID,int CheckKeyServer,int sendTimes){
if(ifUseJson == 0){
AfxMessageBox("未设置使用json模式");
return 0;
}
//设置消息号
jsonRsp["MsgID"] = MsgID;
//如果客户端回复发包
jsonRsp["CheckKeyServer"] = CheckKeyServer;
//发送回复包
CString strSendJson = jsonRsp.tostring("","").c_str();
return ppeer->send((LPSTR)(LPCTSTR)strSendJson,strSendJson.GetLength()); //发送数据
}
string CjsonA::AddTypeValue(string strResult,int *nInsert,BOOL ifFirst,string strField,Cjson TypeValue,string NewLineSign,string FormatSign,int FormatLength){
int length = FormatLength;
string strFormatSign = "";
while(length--!=0){
strFormatSign = strFormatSign + FormatSign;
}
string strOne = strFormatSign + "\"" + strField + "\"";
if(TypeValue.type == "class CstrValue"){
CstrValue strValueTemp = TypeValue.toValue();
//字符串
if(strValueTemp.type == 1){
strOne = strOne + " : \"" + strValueTemp.strValue + "\"";
}
//整数和小数
if(strValueTemp.type == 2 || strValueTemp.type == 3){
strOne = strOne + " : " + strValueTemp.strValue;
}
}
if(TypeValue.type == "class CszValue"){
CszValue szValue = TypeValue.tosz();
string strszValue = "";
int i = -1;
while(i++ != szValue.size() - 1){
if(i != 0) strszValue = strszValue + ",";
Cjson TypeValueTemp = szValue.vecszValue.at(i);
if(TypeValueTemp.type == "class CstrValue"){
CstrValue strValueTemp = TypeValueTemp.toValue();
//字符串
if(strValueTemp.type == 1){
strszValue = strszValue + "\"" + strValueTemp.strValue + "\"";
}
//整数和小数
if(strValueTemp.type == 2 || strValueTemp.type == 3){
strszValue = strszValue + strValueTemp.strValue;
}
}
if(TypeValueTemp.type == "class CjsonA"){
CjsonA jsonTemp = TypeValueTemp.toJson();
string strResultTemp = jsonTemp.tostring(NewLineSign,FormatSign,FormatLength + 1);
strszValue = strszValue + strResultTemp;
}
}
strOne = strOne + " : [" + strszValue + "]";//空数组
}
if(TypeValue.type == "class CjsonA"){
CjsonA jsonTemp = TypeValue.toJson();
string strResultTemp = jsonTemp.tostring(NewLineSign,FormatSign,FormatLength + 1);
strOne = strOne + " : " + strResultTemp;
}
if(ifFirst == 1){
strOne = NewLineSign + strOne;
}
else{
strOne = "," + NewLineSign + strOne;
}
CStringManager::Insert(strResult,*nInsert,strOne);
*nInsert = *nInsert + CStringManager::GetLength(strOne);
return strResult;
}
int CAceTCPServer::SendRspJson(Cjson jsonRsp,int MsgID,int CheckKeyClient,ACE_SOCK_Stream* ppeer,int sendTimes){
if(ifUseJson == 0){
AfxMessageBox("未设置使用json模式");
return 0;
}
//设置消息号
jsonRsp["MsgID"] = MsgID;
//如果客户端回复发包
jsonRsp["CheckKeyClient"] = CheckKeyClient;
//发送回复包
CString strSendJson = jsonRsp.toCString("","");
return ppeer->send((LPSTR)(LPCTSTR)strSendJson,strSendJson.GetLength()); //发送数据
}
int Cjson::size(){
//先获得最原始的Cjson地址
Cjson *TypeValueTemp = pJson->vecCjson.at(0);
int i = -1;
while(i++ != pJson->vecField.size() - 1){
//如果用户输入错误则直接返回-1
if(pJson->vecField.at(i).field == "" && pJson->vecField.at(i).num == -1) return -1;
//如果是字段
if(pJson->vecField.at(i).field != "" && TypeValueTemp->type == "class CjsonA"){
//如果有这个字段再返回
auto it = ((CjsonA*)TypeValueTemp->pClass)->mapdata.begin();
for(;it != ((CjsonA*)TypeValueTemp->pClass)->mapdata.end();it++){
if(it->first.c_str() == pJson->vecField.at(i).field){
//pJson值在[]重载时已经带下去了
TypeValueTemp = &((CjsonA*)TypeValueTemp->pClass)->mapdata[(pJson->vecField.at(i).field)];
goto rem;
}
}
//如果循环自然退出则表示没找到返回-1
return -1;
rem:;
}
else if(pJson->vecField.at(i).num != -1 && TypeValueTemp->type == "class CszValue"){
//如果数组中有这么长再返回
if(((CszValue*)TypeValueTemp->pClass)->vecszValue.size() > (unsigned int)pJson->vecField.at(i).num){
//pJson已经在[]重载时带下去了
TypeValueTemp = &((CszValue*)TypeValueTemp->pClass)->vecszValue.at(pJson->vecField.at(i).num);
}
else return -1;
}
else return -1;
}
if(type == "class CjsonA") return TypeValueTemp->toJson().size();
else if(type == "class CszValue") return TypeValueTemp->tosz().size();
else return -1;
}
int CAceTCPClient::SendJsonReq(Cjson jsonReq,int MsgID,Cjson jsonCheckPackage,int nDeleteTime,int sendTimes){
if(ifUseJson == 0){
AfxMessageBox("未设置使用json模式");
return 0;
}
//设置消息号
jsonReq["MsgID"] = MsgID;
//如果客户端主动发包则加上寄存钥匙
jsonReq["CheckKeyClient"] = ++CheckKeyClient;
//根据钥匙把包裹存入map中
mapCheck[CheckKeyClient] = jsonCheckPackage;
//定时器，过一定时间之后把对应的包裹删除，防止出现因为网络不好对面不回信息的情况
CDeleteMapWatch* pWatch = new CDeleteMapWatch;
WatchPac* ppackage = new WatchPac;
ppackage->CheckKeyClient = CheckKeyClient;
ppackage->pThis = this;
pWatch->CountDown(nDeleteTime * 1000,ppackage);
//发送
CString strSendJson = jsonReq.tostring("","").c_str();
return ppeer->send((LPSTR)(LPCTSTR)strSendJson,strSendJson.GetLength()); //发送数据
}
Cjson* Cjson::TypeEqual(string strTemp){
//把传进来的field循环查看，如果有则修改，无则创建
int level = -1;
Cjson* pTypeValueReturn = pJson->vecCjson.at(0);
Cjson* pTypeValueTemp = pJson->vecCjson.at(0);
int i = -1;
while(i++ != pTypeValueReturn->pJson->vecField.size() - 1){
//表示当前层数
level++;
//如果field是空并且数字小于0说明用户填错
if(pTypeValueReturn->pJson->vecField.at(i).field == "" && pTypeValueReturn->pJson->vecField.at(i).num < 0){
//跳到结尾
goto rem;
}
//如果field不是空说明此处是字段
if(pTypeValueReturn->pJson->vecField.at(i).field != ""){
//如果当前层是最后一层则说明现在应该创建或覆盖字段
if(i == pTypeValueReturn->pJson->vecField.size() - 1){
//如果发现是"\"delete\""则把当前字段删除
if(strTemp == "\"delete\""){
auto it = pTypeValueTemp->toJson().mapdata.begin();
for(;it!=pTypeValueTemp->toJson().mapdata.end();it++){
if(it->first.c_str() == pTypeValueReturn->pJson->vecField.at(i).field){
//在释放之后pJson值会丢失，因为释放的是本层Cjson，所以pJson会被重置，所以先取出来
//CjsonA *pJsonTemp = pJson;
pTypeValueTemp->toJson().mapdata.erase(it);
goto rem;
//这里使用pJsonTemp来清空
//pJsonTemp->vecField.clear();
//pJsonTemp->vecCjson.clear();
//return pTypeValueReturn;
}
}
}
else{
//因为当不是最后一层的时候，只可能通过json的map找到一个数组或json传进来
//如果找到了一个数组但是用户指定当前层为字段的话说明用户要把数组改为json，应该先到上一层创建一个json，然后再获得创建层map进行赋值
if(pTypeValueTemp->type == "class CszValue"){
//重新给上一层赋值新的json，以便下面使用
pTypeValueReturn->pJson->vecCjson.at(level - 1)->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i - 1).field)] = CjsonA();
pTypeValueTemp = &(pTypeValueReturn->pJson->vecCjson.at(level - 1)->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i - 1).field)]);
}
//退回上一层添加或覆盖字段
pTypeValueTemp->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i).field)] = (Cjson)(CstrValue)strTemp;
}
break;
}
//如果当前层根本不是json说明用户改变了当前层的性质，且不会是最后一层，因为如果是则在上面跳出循环了
if(pTypeValueTemp->type != "class CjsonA"){
//如果下一层是field说明需要创建一个json，以便下面使用
if(pTypeValueReturn->pJson->vecField.at(i + 1).field != ""){
//重新给上一层赋值新的json，以便下面使用
pTypeValueReturn->pJson->vecCjson.at(level - 1)->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i - 1).field)] = CjsonA();
}
//如果下一层是数字说明需要创建一个数组，以便下面使用
else{
pTypeValueReturn->pJson->vecCjson.at(level - 1)->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i - 1).field)] = CszValue();
}
}
//如果当前层能找到
auto it = pTypeValueTemp->toJson().mapdata.begin();
for(;it != pTypeValueTemp->toJson().mapdata.end();it++){
//如果能找到，直接跳出，因为只是取下一层指针所以此处不需要操作
if(it->first.c_str() == pTypeValueReturn->pJson->vecField.at(i).field) break;
}
if(it == pTypeValueTemp->toJson().mapdata.end()){
//如果下一层是field说明需要创建一个json
if(pTypeValueReturn->pJson->vecField.at(i + 1).field != ""){
pTypeValueTemp->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i).field)] = CjsonA();
}
//如果下一层是数字说明需要创建一个数组
else{
pTypeValueTemp->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i).field)] = CszValue();
}
}
//把找到的下一层Cjson传给指针
pTypeValueTemp = &(pTypeValueTemp->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i).field)]);
}
//否则是数字
else{
//如果当前层数组根本不存在则先创建数组
if(pTypeValueTemp->type != "class CszValue"){
//map在改数据的时候会先执行这个类的析构，所以不用管节点内存泄漏
//重新给上一层赋值新的空数组，以便下面使用
pTypeValueReturn->pJson->vecCjson.at(level - 1)->toJson().mapdata[(pTypeValueReturn->pJson->vecField.at(i - 1).field)] = CszValue();
}
//如果vec中的数字比数组实际大小大则追加在末尾
if(pTypeValueReturn->pJson->vecField.at(i).num >= (int)pTypeValueTemp->tosz().vecszValue.size()){
//如果本层是最后一层则追加一个字段
if(i == pTypeValueReturn->pJson->vecField.size() - 1){
//如果是"\"delete\""
if(strTemp == "\"delete\""){
if(pTypeValueTemp->tosz().vecszValue.size() >= 1) pTypeValueTemp->tosz().vecszValue.pop_back();
}
//如果是"\"insert\""
else if(strTemp == "\"insert\""){
//这里不会有影响，因为当填入数值过大时就不会取到这一层，上一层还是有pJson值的
pTypeValueTemp->tosz().vecszValue.push_back(CstrValue(strTemp));
}
else{
pTypeValueTemp->tosz().vecszValue.push_back(CstrValue(strTemp));
}
break;
}
//如果下一层是field则追加一个json
else if(pTypeValueReturn->pJson->vecField.at(i + 1).field != ""){
pTypeValueTemp->tosz().vecszValue.push_back(CjsonA());
}
//如果下一层是数字说明用户填错，因为数组中是不可以直接添加数组的
else{
goto rem;
}
//写size - 1的原因是当用户输入的数字过大时也采用最后一个
pTypeValueTemp = &(pTypeValueTemp->tosz().vecszValue.at(pTypeValueTemp->tosz().vecszValue.size() - 1));
}
//如果有则覆盖
else{
//如果本层是最后一层则覆盖字段
if(i == pTypeValueReturn->pJson->vecField.size() - 1){
//如果是"\"delete\""
if(strTemp == "\"delete\""){
pTypeValueTemp->tosz().vecszValue.erase(pTypeValueTemp->tosz().vecszValue.begin() + pTypeValueReturn->pJson->vecField.at(i).num);
}
//如果是"\"insert\""
else if(strTemp == "\"insert\""){
//因为insert出来的东西正是本层所指的CTypeValue，所以会导致pJson为空
//CjsonA* pJsonTemp = pJson;
Cjson temp = CstrValue(strTemp);
auto num = pTypeValueTemp->tosz().vecszValue.begin() + pTypeValueReturn->pJson->vecField.at(i).num;
pTypeValueTemp->tosz().vecszValue.insert(num,temp);
//pJson = pJsonTemp;
}
else{
Cjson temp = (CstrValue(strTemp));
int num = pTypeValueReturn->pJson->vecField.at(i).num;
pTypeValueTemp->tosz().vecszValue.at(num) = temp;
}
break;
}
//如果下一层是field则覆盖一个空json
else if(pTypeValueReturn->pJson->vecField.at(i + 1).field != ""){
pTypeValueTemp->tosz().vecszValue.at(pTypeValueReturn->pJson->vecField.at(i).num) = CjsonA();
}
//如果下一层是数字说明用户填错，因为数组中是不可以直接添加数组的
else{
goto rem;
}
//给下一层指针
pTypeValueTemp = &(pTypeValueTemp->tosz().vecszValue.at(pTypeValueReturn->pJson->vecField.at(i).num));
}
}
}
rem:
//使用过一次就清空
pTypeValueReturn->pJson->vecField.clear();
pTypeValueReturn->pJson->vecCjson.clear();
return pTypeValueReturn;
}
DWORD WINAPI ThreadClientHandling(LPVOID lpParam){
Threadpackage ClientPackage = *((Threadpackage *)lpParam);
delete (Threadpackage *)lpParam;
//用户处理的虚函数不能上锁，如果一旦有一条线程Sleep则所有的都会被卡住
//ClientPackage.pmutex->Lock();
//不使用json模式
if(ClientPackage.ifUseJson == 0){
ClientPackage.pThis->receive(ClientPackage.pBuf,ClientPackage.nReceiveLength,ClientPackage.ppeer);
}
//使用json模式
else if(ClientPackage.ifUseJson == 1){
Cjson json;
json.LoadJson(ClientPackage.pBuf);
int MsgID = json["MsgID"].toValue().nValue;
int CheckKeyClient = json["CheckKeyClient"].toValue().nValue;
int CheckKeyServer = json["CheckKeyServer"].toValue().nValue;
//如果是客户端主动发来的包，需要给响应
if(CheckKeyClient >= 0 && CheckKeyServer == -1){
//重置顺序，方便获得返回通路
vector<ACE_SOCK_Stream*> vecSendIPPeer;
//操作vector加锁
ClientPackage.pmutex->Lock();
int i = -1;
while(i++ != ClientPackage.pThis->vecIPPeer.size() - 1){
if(ClientPackage.pThis->vecIPPeer.at(i) != ClientPackage.ppeer){
vecSendIPPeer.push_back(ClientPackage.pThis->vecIPPeer.at(i));
}
}
vecSendIPPeer.push_back(ClientPackage.ppeer);
ClientPackage.pmutex->Unlock();
Cjson jsonReq = json;
jsonReq["MsgID"] = "delete";
jsonReq["CheckKeyClient"] = "delete";
Cjson jsonRsp = ClientPackage.pThis->ReceiveReqJson(jsonReq,MsgID,&vecSendIPPeer);
//根据vector里的通路来发
i = -1;
while(i++ != vecSendIPPeer.size() - 1){
ClientPackage.pThis->SendRspJson(jsonRsp,MsgID,CheckKeyClient,vecSendIPPeer.at(i));
}
}
//如果是客户端响应服务器发来的包
else if(CheckKeyClient == -1 && CheckKeyServer >= 0){
Cjson jsonRsp = json;
jsonRsp["MsgID"] = "delete";
jsonRsp["CheckKeyClient"] = "delete";
//把响应json和寄存json传给虚函数
ClientPackage.pThis->ReceiveRspJson(jsonRsp,MsgID,ClientPackage.pThis->mapCheck[CheckKeyServer]);
//删除map中的寄存包裹
ClientPackage.pThis->DeleteMap(CheckKeyServer);
}
else{
CString strError = "";
strError.Format("Key值出错，CheckKeyClient = %d，CheckKeyServer = %d",CheckKeyClient,CheckKeyServer);
AfxMessageBox(strError);
}
}
else{
CString strError = "";
strError.Format("是否使用json值出错，值为%d",ClientPackage.ifUseJson);
AfxMessageBox(strError);
}
//ClientPackage.pmutex->Unlock();
return 0;
}
