企业信息系统集成框架（设计思路）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*/) = 0;

    //客户端发送报文
    virtual int Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/) = 0;
    
    //客户端接收报文
    virtual int Recv_Socket(unsigned char *recvBuf/*in*/, int *recvLen/*out*/) = 0;
    
    //客户端释放资源
    virtual int Destroy_Socket(/*in*/) = 0;

    //虚析构函数，可以用来释放所有的子类和基类资源
    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 = 0;
    return 0;
}

//客户端发送报文
int ProductA::Send_Socket(unsigned char *sendBuf/*in*/, int sendLen/*in*/)
{
    if (sendBuf == NULL)
        return -1;
    
    this->BaoWen = (unsigned char *)malloc(sizeof(unsigned char)*sendLen);
    if (!BaoWen)
    {
        return -2;
    }
    memcpy(BaoWen, sendBuf, sendLen);
    len = sendLen;
    return 0;
}

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

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

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

#pragma once
#include <iostream>

class EncDec
{
public:
    //加密函数
    virtual int EncData(unsigned char *plain, int plainLen, unsigned char *miBuf, int *miLen) = 0;
    //解密函数
    virtual int DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen) = 0;
    ~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 -1;
    if (miBuf == NULL)
        return -2;
    if (miLen == NULL)
        return -3;
    int ret = 0;
    ret = DesEnc(plain, plainLen, miBuf, miLen);
    if (ret != 0)
    {
        printf("DesEnc()error:[%d]
", ret);
        return ret;
    }
    return ret;
}
//解密函数
int HwEncDec::DecData(unsigned char *miBuf, int miLen, unsigned char *plainBuf, int *palinLen)
{
    if (miBuf == NULL)
        return -1;
    if (plainBuf == NULL)
        return -2;
    if (palinLen == NULL)
        return -3;
    int ret = 0;
    ret = DesDec(miBuf, miLen, plainBuf, palinLen);
    if (ret != 0)
    {
        printf("DesDec()error:[%d]
", 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 = 0;
    //创建接收密文的内存和长度
    unsigned char miWen[1024] = { 0 };
    int miwenLen = 0;
    //创建接受明文的内存和长度（可以不创建，和密文用同一个）
    unsigned char plain[1024] = { 0 };
    int plainLen = 0;
    //客户端初始化
    ret = csp->Init_Socket();
    if (ret)
    {
        printf("Init_Socket()error:[%d]
", ret);
        goto End;
    }
    
    //发送数据前先进行加密
    ret = ecdc->EncData(in, inLen, miWen, &miwenLen);
    if (ret)
    {
        printf("EncData()error:[%d]
", ret);
        goto End;
    }
    
    //客户端发送报文
    ret = csp->Send_Socket(miWen, miwenLen);
    if (ret)
    {
        printf("Send_Socket()error:[%d]
", ret);
        goto End;
    }
    
    //客户端接收报文
    ret = csp->Recv_Socket(plain, &plainLen);
    if (ret)
    {
        printf("Recv_Socket()error:[%d]
", ret);
        goto End;
    }
    
    //接受的报文为加密内容，需要解密。
    ret = ecdc->DecData(plain, plainLen, out, outLen);
    if (ret)
    {
        printf("DecData()error:[%d]
", ret);
        goto End;
    }
End:
    //客户端释放资源
    ret = csp->Destroy_Socket();
    

    return 0;
}

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

    //2.设计接收和发送报文的内存及其长度变量
    unsigned char in[1024];
    int inLen;
    unsigned char out[1024];
    int outLen;
    strcpy((char *)in, "ahgquwquwqeyqufnaskmc");
    inLen = 10;
    
    //3.设计一个函数将；将抽象类的指针和接发报文内容集成起来。
    ret  = SekSendAndRecv11(csp, ecdc, in, inLen, out, &outLen);
    if (ret)
    {
        printf("SekSendAndRecv()error:[%d]
", ret);
        return ret;
    }
    printf("out: %s
", out);
    printf("outLen: %d
", 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 = 0;
        //创建接收密文的内存和长度
        unsigned char miWen[1024] = { 0 };
        int miwenLen = 0;
        //创建接受明文的内存和长度（可以不创建，和密文用同一个）
        unsigned char plain[1024] = { 0 };
        int plainLen = 0;
        //客户端初始化
        ret = csp->Init_Socket();
        if (ret)
        {
            printf("Init_Socket()error:[%d]
", ret);
            goto End;
        }

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

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

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

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

int main()
{
    int ret = 0;
    //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[1024];
    int inLen;
    unsigned char out[1024];
    int outLen;
    strcpy((char *)in, "ahgquwquwqeyqufnaskmc");
    inLen = 10;
    
    ret = mop->SekSendAndRecv(in, inLen, out, &outLen);
    if (ret)
    {
        printf("SekSendAndRecv()error:[%d]
", ret);
        return ret;
    }
    printf("out: %s
", out);
    printf("outLen: %d
", outLen);


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

    system("pause");
    return ret;
}

7.代码中的注意点：

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