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

时间：2016-08-05 00:31:44 阅读：585 评论：0 收藏：0 [点我收藏+]

标签：

技术分享

设计要求：

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

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

设计步骤：

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

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

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

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

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

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

2）厂商实现具体内容

3）接入测试层

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

下面是代码：

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

 1 #pragma once
 2 
 3 //写一套接口，用纯虚函数写;用来接收和发送数据
 4 class CSocketProtocol
 5 {
 6 public:
 7     //客户端初始化
 8     virtual int Init_Socket(/*in*/) = 0;
 9 
10     //客户端发送报文
11     virtual int Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/) = 0;
12     
13     //客户端接收报文
14     virtual int Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/) = 0;
15     
16     //客户端释放资源
17     virtual int Destroy_Socket(/*in*/) = 0;
18 
19     //虚析构函数，可以用来释放所有的子类和基类资源
20     virtual ~CSocketProtocol()
21     {
22         ;
23     }
24 };

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

 1 #pragma once
 2 #include<string>
 3 #include "CSocketProtocol.h"
 4 
 5 
 6 //注意C++与C最大不通过在这里：C++可以把信息直接存储在类中；C需要创建一个结构体来收发内容
 7 class ProductA : public CSocketProtocol
 8 {
 9 public:
10     //客户端初始化
11     virtual int Init_Socket(/*in*/);
12 
13     //客户端发送报文
14     virtual int Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/);
15 
16     //客户端接收报文
17     virtual int Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/);
18 
19     //客户端释放资源
20     virtual int Destroy_Socket(/*in*/);
21 
22 //设置类的私有属性，将收发的内容存储在类中。
23 private:
24     unsigned char *BaoWen;
25     int len;
26 
27 };

 1 #pragma once
 2 #include "ProductA.h"
 3 
 4 
 5     //客户端初始化
 6 int ProductA::Init_Socket(/*in*/)
 7 {
 8     BaoWen = NULL;
 9     len = 0;
10     return 0;
11 }
12 
13 //客户端发送报文
14 int ProductA::Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/)
15 {
16     if (sendBuf == NULL)
17         return -1;
18     
19     this->BaoWen = (unsigned char *)malloc(sizeof(unsigned char)*sendLen);
20     if (!BaoWen)
21     {
22         return -2;
23     }
24     memcpy(BaoWen, sendBuf, sendLen);
25     len = sendLen;
26     return 0;
27 }
28 
29 //客户端接收报文
30 int ProductA::Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/)
31 {
32     if (recvBuf ==NULL)
33         return -1;
34     if (recvLen == NULL)
35         return -2;
36     memcpy(recvBuf, BaoWen, len);
37     *recvLen = this->len;
38     return 0;
39 }
40 
41 //客户端释放资源
42 int ProductA::Destroy_Socket(/*in*/)
43 {
44     if (BaoWen != NULL)
45     {
46         free (BaoWen);
47         BaoWen = NULL;
48         len = 0;
49     }
50     return 0;
51 }

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

 1 #pragma once
 2 #include <iostream>
 3 
 4 class EncDec
 5 {
 6 public:
 7     //加密函数
 8     virtual int EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen) = 0;
 9     //解密函数
10     virtual int DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen) = 0;
11     ~EncDec()
12     {
13         ;
14     }
15 };

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

 1 #pragma once
 2 #include"EncDec.h"
 3 #include "des.h"
 4 
 5 class HwEncDec : public EncDec
 6 {
 7 public:
 8     //加密函数
 9     virtual int EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen);
10     //解密函数
11     virtual int DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen);
12 };

 1 #include"HwEncDec.h"
 2 #include "des.h"
 3 
 4 //加密函数
 5 int HwEncDec::EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen)
 6 {
 7     if (plain == NULL)
 8         return -1;
 9     if (miBuf == NULL)
10         return -2;
11     if (miLen == NULL)
12         return -3;
13     int ret = 0;
14     ret = DesEnc(plain, plainLen, miBuf, miLen);
15     if (ret != 0)
16     {
17         printf("DesEnc()error:[%d]\n", ret);
18         return ret;
19     }
20     return ret;
21 }
22 //解密函数
23 int HwEncDec::DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen)
24 {
25     if (miBuf == NULL)
26         return -1;
27     if (plainBuf == NULL)
28         return -2;
29     if (palinLen == NULL)
30         return -3;
31     int ret = 0;
32     ret = DesDec(miBuf, miLen, plainBuf, palinLen);
33     if (ret != 0)
34     {
35         printf("DesDec()error:[%d]\n", ret);
36         return ret;
37     }
38 
39     return ret;
40 }

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

  1 #define _CRT_SECURE_NO_WARNINGS
  2 #include<iostream>
  3 using namespace std;
  4 #include"CSocketProtocol.h"
  5 #include"ProductA.h"
  6 #include "EncDec.h"
  7 #include "HwEncDec.h"
  8 
  9 //测试框架步骤：
 10 //1.先创建一个接口抽象类指针；指向具体的第三方产品
 11 //2.设计接收和发送报文的内存及其长度变量
 12 //3.测试界面面向抽象类框架集成:设计一个函数将；将抽象类的指针和接发报文内容集成起来。
 13 
 14 
 15 //3.测试界面面向抽象类框架集成
 16 int SekSendAndRecv11(CSocketProtocol *csp, EncDec *ecdc, unsigned char *in, int inLen, unsigned char *out, int *outLen)
 17 {
 18     int ret = 0;
 19     //创建接收密文的内存和长度
 20     unsigned char miWen[1024] = { 0 };
 21     int miwenLen = 0;
 22     //创建接受明文的内存和长度（可以不创建，和密文用同一个）
 23     unsigned char plain[1024] = { 0 };
 24     int plainLen = 0;
 25     //客户端初始化
 26     ret = csp->Init_Socket();
 27     if (ret)
 28     {
 29         printf("Init_Socket()error:[%d]\n", ret);
 30         goto End;
 31     }
 32     
 33     //发送数据前先进行加密
 34     ret = ecdc->EncData(in, inLen, miWen, &miwenLen);
 35     if (ret)
 36     {
 37         printf("EncData()error:[%d]\n", ret);
 38         goto End;
 39     }
 40     
 41     //客户端发送报文
 42     ret = csp->Send_Socket(miWen, miwenLen);
 43     if (ret)
 44     {
 45         printf("Send_Socket()error:[%d]\n", ret);
 46         goto End;
 47     }
 48     
 49     //客户端接收报文
 50     ret = csp->Recv_Socket(plain, &plainLen);
 51     if (ret)
 52     {
 53         printf("Recv_Socket()error:[%d]\n", ret);
 54         goto End;
 55     }
 56     
 57     //接受的报文为加密内容，需要解密。
 58     ret = ecdc->DecData(plain, plainLen, out, outLen);
 59     if (ret)
 60     {
 61         printf("DecData()error:[%d]\n", ret);
 62         goto End;
 63     }
 64 End:
 65     //客户端释放资源
 66     ret = csp->Destroy_Socket();
 67     
 68 
 69     return 0;
 70 }
 71 
 72 int main()
 73 {
 74     int ret = 0;
 75     //1.先创建一个接口抽象类指针；指向具体的第三方产品
 76     CSocketProtocol *csp = NULL;
 77     csp = new ProductA ;
 78     EncDec *ecdc = NULL;
 79     ecdc = new HwEncDec;
 80 
 81     //2.设计接收和发送报文的内存及其长度变量
 82     unsigned char in[1024];
 83     int inLen;
 84     unsigned char out[1024];
 85     int outLen;
 86     strcpy((char *)in, "ahgquwquwqeyqufnaskmc");
 87     inLen = 10;
 88     
 89     //3.设计一个函数将；将抽象类的指针和接发报文内容集成起来。
 90     ret  = SekSendAndRecv11(csp, ecdc, in, inLen, out, &outLen);
 91     if (ret)
 92     {
 93         printf("SekSendAndRecv()error:[%d]\n", ret);
 94         return ret;
 95     }
 96     printf("out: %s\n", out);
 97     printf("outLen: %d\n", outLen);
 98 
 99 
100     //不要忘了释放基类与子类的资源（虚析构函数可以释放基类与派生类的资源释放）
101     delete csp;
102 
103     system("pause");
104     return ret;
105 }

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

  1 #define _CRT_SECURE_NO_WARNINGS
  2 #include<iostream>
  3 using namespace std;
  4 #include"CSocketProtocol.h"
  5 #include"ProductA.h"
  6 #include "EncDec.h"
  7 #include "HwEncDec.h"
  8 
  9 class mainOp
 10 {
 11 public:
 12     mainOp()
 13     {
 14         csp = NULL;
 15         ecdc = NULL;
 16     }
 17     mainOp(CSocketProtocol *csp, EncDec    *ecdc)
 18     {
 19         this->csp = csp;
 20         this->ecdc = ecdc;
 21     }
 22     void setCSP(CSocketProtocol *csp)
 23     {
 24         this->csp = csp;
 25     }
 26     void setEcDc(EncDec    *ecdc)
 27     {
 28         this->ecdc = ecdc;
 29     }
 30     int SekSendAndRecv(unsigned char *in, int inLen, unsigned char *out, int *outLen)
 31     {
 32         int ret = 0;
 33         //创建接收密文的内存和长度
 34         unsigned char miWen[1024] = { 0 };
 35         int miwenLen = 0;
 36         //创建接受明文的内存和长度（可以不创建，和密文用同一个）
 37         unsigned char plain[1024] = { 0 };
 38         int plainLen = 0;
 39         //客户端初始化
 40         ret = csp->Init_Socket();
 41         if (ret)
 42         {
 43             printf("Init_Socket()error:[%d]\n", ret);
 44             goto End;
 45         }
 46 
 47         //发送数据前先进行加密
 48         ret = ecdc->EncData(in, inLen, miWen, &miwenLen);
 49         if (ret)
 50         {
 51             printf("EncData()error:[%d]\n", ret);
 52             goto End;
 53         }
 54 
 55         //客户端发送报文
 56         ret = csp->Send_Socket(miWen, miwenLen);
 57         if (ret)
 58         {
 59             printf("Send_Socket()error:[%d]\n", ret);
 60             goto End;
 61         }
 62 
 63         //客户端接收报文
 64         ret = csp->Recv_Socket(plain, &plainLen);
 65         if (ret)
 66         {
 67             printf("Recv_Socket()error:[%d]\n", ret);
 68             goto End;
 69         }
 70 
 71         //接受的报文为加密内容，需要解密。
 72         ret = ecdc->DecData(plain, plainLen, out, outLen);
 73         if (ret)
 74         {
 75             printf("DecData()error:[%d]\n", ret);
 76             goto End;
 77         }
 78     End:
 79         //客户端释放资源
 80         ret = csp->Destroy_Socket();
 81         return 0;
 82     }
 83 private:
 84     CSocketProtocol *csp;
 85     EncDec            *ecdc;
 86 };
 87 
 88 int main()
 89 {
 90     int ret = 0;
 91     //1.先创建一个接口抽象类指针；指向具体的第三方产品
 92     CSocketProtocol *csp = NULL;
 93     csp = new ProductA;
 94     EncDec *ecdc = NULL;
 95     ecdc = new HwEncDec;
 96     
 97     //继承类的两种使用，调用有参构造和采用注入方式：
 98     //第一种：采用外部注入
 99     mainOp *mop = new mainOp;
100     mop->setCSP(csp);
101     mop->setEcDc(ecdc);
102     
103     //第二种：采用调用有参构造
104     //mainOp *mop = new mainOp(csp,ecdc);
105     
106     //2.设计接收和发送报文的内存及其长度变量
107     unsigned char in[1024];
108     int inLen;
109     unsigned char out[1024];
110     int outLen;
111     strcpy((char *)in, "ahgquwquwqeyqufnaskmc");
112     inLen = 10;
113     
114     ret = mop->SekSendAndRecv(in, inLen, out, &outLen);
115     if (ret)
116     {
117         printf("SekSendAndRecv()error:[%d]\n", ret);
118         return ret;
119     }
120     printf("out: %s\n", out);
121     printf("outLen: %d\n", outLen);
122 
123 
124     //不要忘了释放基类与子类的资源（虚析构函数可以释放基类与派生类的资源释放）
125     delete csp;
126     delete ecdc;
127     delete mop;
128 
129     system("pause");
130     return ret;
131 }

7.代码中的注意点：

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

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

标签：

原文地址：http://www.cnblogs.com/yyx1-1/p/5738924.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行