企业信息系统集成框架（设计思路）C++模式

设计要求：

1.企业信息系统框架、第三方产品通过接口层进行分层。

2.企业信息系统框架如何自由的继承第三方产品：通过一个抽象类。（软件设计要求：模块要求松，接口要求紧）。

设计步骤：

1.报文的接受与发送抽象类；

　　C++与C语言设计区别：C语言中有个句柄，原因是需要分配一个结构体资源，把发送和接受的信息存储起来。而C++中由于有类的存在，可以直接将这个句柄内容存储在子类中，不需要再单独设置。

2.测试界面面向抽象类框架集成，开始初步完成测试界面.

4.厂商的产品实现（自己的头文件和.cpp文件）

5.搭建加解密产品接入信息系统

1）创建加解密抽象类头文件

2）厂商实现具体内容

3）接入测试层

6.将测试界面的框架集成为一个类（有两种方式：继承与组合）

下面是代码：

1.报文的发送与接收抽象类框架。

 #pragma once

 //写一套接口，用纯虚函数写;用来接收和发送数据
 class CSocketProtocol
 {
 public:
     //客户端初始化
     virtual int Init_Socket(/*in*/) = ;

     //客户端发送报文
     virtual int Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/) = ;

     //客户端接收报文
     virtual int Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/) = ;

     //客户端释放资源
     virtual int Destroy_Socket(/*in*/) = ;

     //虚析构函数，可以用来释放所有的子类和基类资源
     virtual ~CSocketProtocol()
     {
         ;
     }
 };

2.单个厂商对此抽象类的实现（包含了厂商的头文件和厂商代码的实现）

 #pragma once
 #include<string>
 #include "CSocketProtocol.h"

 //注意C++与C最大不通过在这里：C++可以把信息直接存储在类中；C需要创建一个结构体来收发内容
 class ProductA : public CSocketProtocol
 {
 public:
     //客户端初始化
     virtual int Init_Socket(/*in*/);

     //客户端发送报文
     virtual int Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/);

     //客户端接收报文
     virtual int Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/);

     //客户端释放资源
     virtual int Destroy_Socket(/*in*/);

 //设置类的私有属性，将收发的内容存储在类中。
 private:
     unsigned char *BaoWen;
     int len;

 };

 #pragma once
 #include "ProductA.h"

     //客户端初始化
 int ProductA::Init_Socket(/*in*/)
 {
     BaoWen = NULL;
     len = ;
     return ;
 }

 //客户端发送报文
 int ProductA::Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/)
 {
     if (sendBuf == NULL)
         return -;

     this->BaoWen = (unsigned char *)malloc(sizeof(unsigned char)*sendLen);
     if (!BaoWen)
     {
         return -;
     }
     memcpy(BaoWen, sendBuf, sendLen);
     len = sendLen;
     return ;
 }

 //客户端接收报文
 int ProductA::Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/)
 {
     if (recvBuf ==NULL)
         return -;
     if (recvLen == NULL)
         return -;
     memcpy(recvBuf, BaoWen, len);
     *recvLen = this->len;
     return ;
 }

 //客户端释放资源
 int ProductA::Destroy_Socket(/*in*/)
 {
     if (BaoWen != NULL)
     {
         free (BaoWen);
         BaoWen = NULL;
         len = ;
     }
     return ;
 }

3.加解密的抽象类框架。

 #pragma once
 #include <iostream>

 class EncDec
 {
 public:
     //加密函数
     virtual int EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen) = ;
     //解密函数
     virtual int DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen) = ;
     ~EncDec()
     {
         ;
     }
 };

4.单个厂商加解密的函数实现（包含两部分：厂商的头文件和代码实现）

 #pragma once
 #include"EncDec.h"
 #include "des.h"

 class HwEncDec : public EncDec
 {
 public:
     //加密函数
     virtual int EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen);
     //解密函数
     virtual int DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen);
 };

 #include"HwEncDec.h"
 #include "des.h"

 //加密函数
 int HwEncDec::EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen)
 {
     if (plain == NULL)
         return -;
     if (miBuf == NULL)
         return -;
     if (miLen == NULL)
         return -;
     int ret = ;
     ret = DesEnc(plain, plainLen, miBuf, miLen);
     if (ret != )
     {
         printf("DesEnc()error:[%d]\n", ret);
         return ret;
     }
     return ret;
 }
 //解密函数
 int HwEncDec::DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen)
 {
     if (miBuf == NULL)
         return -;
     if (plainBuf == NULL)
         return -;
     if (palinLen == NULL)
         return -;
     int ret = ;
     ret = DesDec(miBuf, miLen, plainBuf, palinLen);
     if (ret != )
     {
         printf("DesDec()error:[%d]\n", ret);
         return ret;
     }

     return ret;
 }

5.测试界面的集成调用：

 #define _CRT_SECURE_NO_WARNINGS
 #include<iostream>
 using namespace std;
 #include"CSocketProtocol.h"
 #include"ProductA.h"
 #include "EncDec.h"
 #include "HwEncDec.h"

 //测试框架步骤：
 //1.先创建一个接口抽象类指针；指向具体的第三方产品
 //2.设计接收和发送报文的内存及其长度变量
 //3.测试界面面向抽象类框架集成:设计一个函数将；将抽象类的指针和接发报文内容集成起来。

 //3.测试界面面向抽象类框架集成
 int SekSendAndRecv11(CSocketProtocol *csp, EncDec *ecdc, unsigned char *in, int inLen, unsigned char *out, int *outLen)
 {
     int ret = ;
     //创建接收密文的内存和长度
     unsigned char miWen[] = {  };
     int miwenLen = ;
     //创建接受明文的内存和长度（可以不创建，和密文用同一个）
     unsigned char plain[] = {  };
     int plainLen = ;
     //客户端初始化
     ret = csp->Init_Socket();
     if (ret)
     {
         printf("Init_Socket()error:[%d]\n", ret);
         goto End;
     }

     //发送数据前先进行加密
     ret = ecdc->EncData(in, inLen, miWen, &miwenLen);
     if (ret)
     {
         printf("EncData()error:[%d]\n", ret);
         goto End;
     }

     //客户端发送报文
     ret = csp->Send_Socket(miWen, miwenLen);
     if (ret)
     {
         printf("Send_Socket()error:[%d]\n", ret);
         goto End;
     }

     //客户端接收报文
     ret = csp->Recv_Socket(plain, &plainLen);
     if (ret)
     {
         printf("Recv_Socket()error:[%d]\n", ret);
         goto End;
     }

     //接受的报文为加密内容，需要解密。
     ret = ecdc->DecData(plain, plainLen, out, outLen);
     if (ret)
     {
         printf("DecData()error:[%d]\n", ret);
         goto End;
     }
 End:
     //客户端释放资源
     ret = csp->Destroy_Socket();

     return ;
 }

 int main()
 {
     int ret = ;
     //1.先创建一个接口抽象类指针；指向具体的第三方产品
     CSocketProtocol *csp = NULL;
     csp = new ProductA ;
     EncDec *ecdc = NULL;
     ecdc = new HwEncDec;

     //2.设计接收和发送报文的内存及其长度变量
     unsigned char in[];
     int inLen;
     unsigned char out[];
     int outLen;
     strcpy((char *)in, "ahgquwquwqeyqufnaskmc");
     inLen = ;

     //3.设计一个函数将；将抽象类的指针和接发报文内容集成起来。
     ret  = SekSendAndRecv11(csp, ecdc, in, inLen, out, &outLen);
     if (ret)
     {
         printf("SekSendAndRecv()error:[%d]\n", ret);
         return ret;
     }
     printf("out: %s\n", out);
     printf("outLen: %d\n", outLen);

     //不要忘了释放基类与子类的资源（虚析构函数可以释放基类与派生类的资源释放）
     delete csp;

     system("pause");
     return ret;
 }

6.将测试界面的框架集成为一个类（有两种方式：继承与组合）

 #define _CRT_SECURE_NO_WARNINGS
 #include<iostream>
 using namespace std;
 #include"CSocketProtocol.h"
 #include"ProductA.h"
 #include "EncDec.h"
 #include "HwEncDec.h"

 class mainOp
 {
 public:
     mainOp()
     {
         csp = NULL;
         ecdc = NULL;
     }
     mainOp(CSocketProtocol *csp, EncDec    *ecdc)
     {
         this->csp = csp;
         this->ecdc = ecdc;
     }
     void setCSP(CSocketProtocol *csp)
     {
         this->csp = csp;
     }
     void setEcDc(EncDec    *ecdc)
     {
         this->ecdc = ecdc;
     }
     int SekSendAndRecv(unsigned char *in, int inLen, unsigned char *out, int *outLen)
     {
         int ret = ;
         //创建接收密文的内存和长度
         unsigned char miWen[] = {  };
         int miwenLen = ;
         //创建接受明文的内存和长度（可以不创建，和密文用同一个）
         unsigned char plain[] = {  };
         int plainLen = ;
         //客户端初始化
         ret = csp->Init_Socket();
         if (ret)
         {
             printf("Init_Socket()error:[%d]\n", ret);
             goto End;
         }

         //发送数据前先进行加密
         ret = ecdc->EncData(in, inLen, miWen, &miwenLen);
         if (ret)
         {
             printf("EncData()error:[%d]\n", ret);
             goto End;
         }

         //客户端发送报文
         ret = csp->Send_Socket(miWen, miwenLen);
         if (ret)
         {
             printf("Send_Socket()error:[%d]\n", ret);
             goto End;
         }

         //客户端接收报文
         ret = csp->Recv_Socket(plain, &plainLen);
         if (ret)
         {
             printf("Recv_Socket()error:[%d]\n", ret);
             goto End;
         }

         //接受的报文为加密内容，需要解密。
         ret = ecdc->DecData(plain, plainLen, out, outLen);
         if (ret)
         {
             printf("DecData()error:[%d]\n", ret);
             goto End;
         }
     End:
         //客户端释放资源
         ret = csp->Destroy_Socket();
         return ;
     }
 private:
     CSocketProtocol *csp;
     EncDec            *ecdc;
 };

 int main()
 {
     int ret = ;
     //1.先创建一个接口抽象类指针；指向具体的第三方产品
     CSocketProtocol *csp = NULL;
     csp = new ProductA;
     EncDec *ecdc = NULL;
     ecdc = new HwEncDec;

     //继承类的两种使用，调用有参构造和采用注入方式：
     //第一种：采用外部注入
     mainOp *mop = new mainOp;
     mop->setCSP(csp);
     mop->setEcDc(ecdc);

     //第二种：采用调用有参构造
     //mainOp *mop = new mainOp(csp,ecdc);

     //2.设计接收和发送报文的内存及其长度变量
     unsigned char in[];
     int inLen;
     unsigned char out[];
     int outLen;
     strcpy((char *)in, "ahgquwquwqeyqufnaskmc");
     inLen = ;

     ret = mop->SekSendAndRecv(in, inLen, out, &outLen);
     if (ret)
     {
         printf("SekSendAndRecv()error:[%d]\n", ret);
         return ret;
     }
     printf("out: %s\n", out);
     printf("outLen: %d\n", outLen);

     //不要忘了释放基类与子类的资源（虚析构函数可以释放基类与派生类的资源释放）
     delete csp;
     delete ecdc;
     delete mop;

     system("pause");
     return ret;
 }

7.代码中的注意点：

　　1）头文件“des.h”是我此次所用的加密文件；由于太大，就不上传了，你们可以换成自己的就行。