[C++知识库] C++设计模式之观察者者模式：多线程拷贝文件，能够支持多种拷贝文件进度通知（QT平台）

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C++设计模式之观察者者模式：多线程拷贝文件，能够支持多种拷贝文件进度通知（QT平台） -> 正文阅读

[C++知识库]C++设计模式之观察者者模式：多线程拷贝文件，能够支持多种拷贝文件进度通知（QT平台）

C++设计模式之观察者者模式：多线程拷贝文件，能够支持多种拷贝文件进度（QT平台）

一、观察者模式

最近在学习设计模式，学习到了观察者模式。观察者模式的定义说明，我就不赘述了。网上有很多资料。直接把我的代码展示给大家，让大家了解观察者模式的用法。

二、实际应用
拷贝文件是一个很常见功能，拷贝文件时，一般都会有进度条的。假如客户有一个新的需求，比如拷贝完成以后有一个提示音，类似于迅雷下载文件完成以后的提示音。用观察者模式就可以很好解决这个新的需求，上代码。

三、抽象的通知类（class IProgress）
这个抽象类用来通知拷贝文件的进度
头文件：

#ifndef IPROGRESS_H
#define IPROGRESS_H


class IProgress { public:
    IProgress();
    virtual ~IProgress(){}
    virtual void DoProgress(float value) = 0;

#endif // IPROGRESS_H

源文件：

#include "iprogress.h"

IProgress::IProgress()
{

}`

这个类定义了一个纯虚函数：virtual void DoProgress(float value) = 0来处理拷贝文件进度。
四、拷贝文件类（class CopyFile）
头文件：

#ifndef COPYFILE_H
#define COPYFILE_H
#include <list>
class IProgress;
class CopyFile
{
public:
    CopyFile();
    ~CopyFile();
    void addNotice(IProgress *notice);
    void removeNotice(IProgress *notice);
    void doCopy(const char *srcFileName, const char *descFileName);
protected:
    void onProgress(float value);
private:
   std::list<IProgress*> m_listIProgress;

};

#endif // COPYFILE_H

源文件：

#include "copyfile.h"
#include "iprogress.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
using namespace std;
CopyFile::CopyFile()
{
}

CopyFile::~CopyFile()
{
}

void CopyFile::addNotice(IProgress *notice)
{
    m_listIProgress.push_back(notice);
}

void CopyFile::removeNotice(IProgress *notice)
{
    m_listIProgress.remove(notice);
}

void CopyFile::doCopy(const char *srcFileName, const char *descFileName)
{
    FILE *fp1,*fp2;
    char res[1024] = {0};
    long long len;
    fp1 = fopen(srcFileName,"rb");
    fp2 = fopen(descFileName,"wb");
    fseek(fp1,0,SEEK_END);
    len = _ftelli64(fp1);
    fseek(fp1,0,SEEK_SET);
    //printf("len:%d",len);
    long long count = len /1024;
    long long remain = len%1024;
    for(long long i=0;i<count;i++)
    {
        fread(res, 1, sizeof(res), fp1);
        fwrite(res, 1, sizeof(res), fp2);
        onProgress(((float)((i+1)*sizeof(res)))/(float)len);

    }
    memset(res,0,sizeof(res));
    if(remain)
    {
        fread(res, 1, remain, fp1);
        fwrite(res, 1, remain, fp2);
        onProgress(1);
    }
    //fseek(fp2,0,SEEK_SET);
    fclose(fp1);
    fclose(fp2);
}

void CopyFile::onProgress(float value)
{
    list<IProgress*>::iterator itor = m_listIProgress.begin();
    while(itor != m_listIProgress.end())
    {
        (*itor)->DoProgress(value);
        ++itor;
    }
}

拷贝文件类定义了一个拷贝文件函数，拷贝文件函数我用的是标准文件IO,进行文件复制操作。我这个程序是用QT开发的，为什么我不用QT的接口操作，而用标准文件IO操作，是因为这样设计可以最大程度把代码复用，我这个类可以放在其它C++平台使用编译。然后还定义了一个存放通知者的容器。通过这个通知者容器去调用通知者各自的处理进度的方法。而我这个类不用具体去关心进度如何显示，只需要调用对应的接口就行了，这样就和进度显示的代码解耦合了。
五、普通进度条对话框类（class Dialog_progressBar）
头文件：

#ifndef DIALOG_PROGRESSBAR_H
#define DIALOG_PROGRESSBAR_H

#include "iprogress.h"

#include <QDialog>

namespace Ui {
class Dialog_progressBar;
}

class Dialog_progressBar : public QDialog, public IProgress
{
    Q_OBJECT

public:
    explicit Dialog_progressBar(QWidget *parent = 0);
    ~Dialog_progressBar();
    virtual void DoProgress(float value);
signals:
    void sig_Progress(float value);
private:
    Ui::Dialog_progressBar *ui;
};

#endif // DIALOG_PROGRESSBAR_H

#include "dialog_progressbar.h"
#include "ui_dialog_progressbar.h"
#include <QDebug>
Dialog_progressBar::Dialog_progressBar(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Dialog_progressBar)
{
    ui->setupUi(this);
    setModal(false);
}

Dialog_progressBar::~Dialog_progressBar()
{
    delete ui;
}

void Dialog_progressBar::DoProgress(float value)
{
    //ui->progressBar->setValue(value*100);
    int progressBarValue = value*100;
    QMetaObject::invokeMethod(ui->progressBar, "setValue",
                                Q_ARG(int, progressBarValue));
//    ui->progressBar->setValue(progressBarValue);
    if(!this->isVisible())
    {
        QMetaObject::invokeMethod(this, "show");
    }
    if(value == 1)
    {
        QMetaObject::invokeMethod(this, "hide");
        //this->hide();
    }
}

这里没什么好说的，就是重新实现了void DoProgress(float value)这个虚函数。就是要注意一下，这里由于我用到了多线程去处理拷贝文件，这个void DoProgress(float value)在另外一个线程执行的。而进度条对话框是在主线程创建的，所以不能直接调用界面的槽函数，直接调用程序会崩溃的。只能通过 QMetaObject::invokeMethod这种方式去调用。
六、拷贝完成后音效类（class MusicNotice）
头文件：

#ifndef MUSICNOTICE_H
#define MUSICNOTICE_H

#include "iprogress.h"

class QMediaPlayer;

class MusicNotice : public IProgress
{
public:
    MusicNotice();
    ~MusicNotice();
    virtual void DoProgress(float value);
private:
    QMediaPlayer *m_pPlayer;
};

#endif // MUSICNOTICE_H

源文件：

#include "musicnotice.h"
#include <QMediaPlayer>

MusicNotice::MusicNotice()
{
    m_pPlayer = new QMediaPlayer();
}

MusicNotice::~MusicNotice()
{
    m_pPlayer->deleteLater();
}


void MusicNotice::DoProgress(float value)
{
    if(value == 1)
    {
        m_pPlayer->setMedia(QUrl::fromLocalFile("./sound.mp3"));
        m_pPlayer->setVolume(50);
        m_pPlayer->play();
    }
}

实现virtual void DoProgress(float value);下载完成后播放音乐。
七、拷贝管理类，配合QThread使用（CopyObject）
头文件：

#ifndef COPYOBJECT_H
#define COPYOBJECT_H

#include "copyfile.h"
#include "dialog_progressbar.h"
#include <QObject>

class CopyObject : public QObject
{
    Q_OBJECT
public:
    explicit CopyObject(QObject *parent = 0);
    inline CopyFile *getCopyFileObj(){return &m_copyFile;}
public slots:
    void doCopy(QString srcFileName, QString descFileName);
signals:

public slots:
private:
    CopyFile m_copyFile;
};

#endif // COPYOBJECT_H

源文件：

#include "copyobject.h"
#include "copyfile.h"
CopyObject::CopyObject(QObject *parent) : QObject(parent)
{

}

void CopyObject::doCopy(QString srcFileName, QString descFileName)
{
    m_copyFile.doCopy(srcFileName.toLocal8Bit().data(),
                      descFileName.toLocal8Bit().data());
}

这个主要是配和QT的多线程使用而定义一个继承QObject的类。
八、主界面类
头文件：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include "copyfile.h"
#include "iprogress.h"
#include <QMainWindow>
#include <QThread>

class QProgressBar;
class IProgress;
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
signals:
    void sig_copyFile(const QString& srcFileName, const QString& descFileName);
private slots:
    void on_pushButton_import_clicked();

    void on_pushButton_copy_clicked();

private:
    Ui::MainWindow *ui;
    QThread copyThread;
    IProgress *m_pNotice = nullptr;
    IProgress *m_pDialog_progressBar;
};

#endif // MAINWINDOW_H

源文件：

#include "copyobject.h"
#include "mainwindow.h"
#include "musicnotice.h"
#include "ui_mainwindow.h"
#include "dialog_progressbar.h"
#include <QMessageBox>
#include <QFileDialog>
#include <QProgressBar>
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    m_pNotice = new MusicNotice;
    m_pDialog_progressBar = new Dialog_progressBar(this);
    CopyObject *pCopyObject = new CopyObject;
    if(pCopyObject->getCopyFileObj())
    {
        pCopyObject->getCopyFileObj()->addNotice(m_pDialog_progressBar);
        pCopyObject->getCopyFileObj()->addNotice(m_pNotice);
    }
    pCopyObject->moveToThread(&copyThread);
    connect(&copyThread, &QThread::finished, pCopyObject, &QObject::deleteLater);
    connect(this, &MainWindow::sig_copyFile, pCopyObject, &CopyObject::doCopy);
    copyThread.start();
}

MainWindow::~MainWindow()
{
    delete ui;
    delete m_pNotice;
    copyThread.quit();
    copyThread.wait();
}

void MainWindow::on_pushButton_import_clicked()
{
    QString fileName = QFileDialog::getOpenFileName(this, tr("打开文件"),
                                                     "./",
                                                     tr(" (*.*)"));
    if(!fileName.isEmpty())
    {
        ui->lineEdit_src->setText(fileName);
    }

}

void MainWindow::on_pushButton_copy_clicked()
{
    QString dir = QFileDialog::getExistingDirectory(this, tr("打开文件夹"),
                                                      "./",
                                                      QFileDialog::ShowDirsOnly
                                                      | QFileDialog::DontResolveSymlinks);
    if(!dir.isEmpty())
    {
        ui->lineEdit_des->setText(dir);
        if(ui->lineEdit_src->text().isEmpty())
             QMessageBox::warning(this,tr("拷贝出错"),tr("未选择源文件"));
        else
        {
            QString descFileName = ui->lineEdit_des->text() + "/copyfile";
            emit sig_copyFile(ui->lineEdit_src->text(),descFileName);
        }
    }
    else
    {
        QMessageBox::warning(this,tr("拷贝出错"),tr("未选择目标文件夹"));
    }

}

main.cpp:

#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

这里讲一下使用多线程的好处，由于拷贝文件是一个耗时操作，尤其是拷贝大文件，很容易堵塞界面，用多线程就能很好的解决这个问题。

八、界面
在这里插入图片描述

九、实际运行效果
在这里插入图片描述
复制完成的音乐播放没办法在网页展示出来，大家可以把我代码拷贝过去用QT运行一下，看一下实际的运行效果。
十、总结
其实学设计模式主要要学会如何把代码模块块、类化，一个功能一个类，每个类之间不要有很强的联系，不要把所有的功能都集中在一个类，尤其是集中在主界面类。界面就是界面，只是用来和用户进行交互的，不要把逻辑功能都耦合在界面类里面，这样你的代码就很不好复用了。
并且我们看到用到观察模式以后，多个进度如何处理的类可以交给多人去写，并行进行代码编写工作，比如在一个团队里面，程序框架师把这个观察者模式的框架搭起来了，员工甲可以写进度条动画显示，员工乙可以写音效进度条。两个人可以同时开发，互不干扰。极大的节省了开发时间，提高了工作效率。还有就是用户有一个新的进度通知显示需求，对于已经发布的程序来说，不可能重新修改原有的代码，重新编译部署测试，再发布。使用观察者模式就可以只增加一个类，把这个类编译成动态库，再通过修改程序的配置文件来动态加载新增的动态库，这个就极大的扩展了程序，而不需要重新编译主程序界面代码，重新部署编译发布主程序界面，极大的降低了每个功能和主界面程序的耦合性。