中介模式

1、中介模式产生背景：当系统变得越来越复杂之后，模块与模块的之间依赖性非常强大，后期维护加大。

2、引入中介模式之后变得简洁了：模块与模块之间不直接引用，单方面直接通过中介者交互，中介甚至不需要依赖任何模块，模块也不需要知道其他模块的存在，这样由系统的网状结构变得更加简洁，大大减低了后期系统的维护，如图所示：

如何在模块与模块之间进行通信根据以往经验：
单独一个模块就是一个单独的插件，插件需要注册到中介者，也就是插件管理中心，插件只需要和插件管理中心交互
如性能数据模块如何通过数据上报模块数据上报？
1、先拿到当前数据性能模块实例；
2、根据当前数据性能模块实例拿到插件管理中心实例；
3、从插件管理中心根据数据上报模块提供的名字拿到数据上报模块实例；
4、此时，数据上报模块实例根据数据上报模块提供的服务名称，得到相应的服务；
5、通过服务进行相应的函数调用，这样性能数据就能通过数据上报模块进行数据上报；

详细代码如下：

#import <Foundation/Foundation.h>
#import <list>
#import <iostream>

#define kReportService  "kReportService"
#define kLoggerService  "kLoggerService"

template<typename T>
class Singleton{
protected:
    Singleton(){
    }
    virtual ~Singleton(){
    }
private:
    static T* m_pInstance;
public:
    static T* GetInstance(){
        if (NULL == m_pInstance) {
            m_pInstance = new T();
        }
        return m_pInstance;
    }
};
template<typename T> T*Singleton<T>::m_pInstance = NULL;

class IPluginService;
class MediatorPlugin;

class IPlugin{
protected:
    MediatorPlugin* m_pMediatorPlugin;
public:
    virtual ~IPlugin(){
    }
    virtual const char* GetName() const = 0;
    virtual IPluginService* GetServiceByName(const char* serviceName) = 0;
    virtual MediatorPlugin* GetPuginManager() = 0;
    virtual void RegisterPlugin(IPlugin* plugin) = 0;
public:
    
};

//插件管理中心
class MediatorPlugin:public Singleton<MediatorPlugin>{
private:
    std::list<IPlugin*> list;
public:
    
    void Install(IPlugin* plugin){
        if (!plugin) {
            return;
        }
        std::list<IPlugin*>::iterator iter = std::find(list.begin(), list.end(), plugin);
        if (iter == list.end()) {
            list.push_back(plugin);
        }
    }
    
    void Uninstall(IPlugin* plugin){
        if (!plugin) {
            return;
        }
        std::list<IPlugin*>::iterator iter = std::find(list.begin(), list.end(), plugin);
        if (iter != list.end()) {
            list.erase(iter);
        }
    }
    
    IPlugin* GetPluginByName(const char* pluginName){
        if (!pluginName) {
            return NULL;
        }
        
        for (std::list<IPlugin*>::iterator iter = list.begin(); iter != list.end(); ++iter) {
            IPlugin* plugin = (IPlugin*)*iter;
            if(strcmp(pluginName, plugin -> GetName()) == 0){
                return plugin;
            }
        }
    
        return NULL;
    }
};

class IPluginService{
public:
    virtual void Report(const char* data,int len){
        
    };
    virtual void Logger(const char* data,int len){
        
    };
};

class ReportPluginService:public Singleton<ReportPluginService>,public IPluginService{
public:
    void Report(const char* data,int len){
        std::cout<< "ReportPluginService report data:"<<data << " len: "<<len<<std::endl;
    }
};

class LoggerPluginService:public Singleton<LoggerPluginService>,public IPluginService{
public:
    void Logger(const char* data,int len){
        std::cout<< "LoggerPluginService logger data:"<<data << " len: "<<len<<std::endl;
    }
};

class PluginBase:public IPlugin{
public:
    PluginBase(){
        m_pMediatorPlugin = NULL;
    }
    const char* GetName() const{
        return "";
    }

    void RegisterPlugin(IPlugin* plugin){
        m_pMediatorPlugin = MediatorPlugin::GetInstance();
        m_pMediatorPlugin -> Install(plugin);
    }

    MediatorPlugin * GetPuginManager(){
        return m_pMediatorPlugin;;
    }

    IPluginService* GetServiceByName(const char* serviceName){
        return NULL;;
    }
};

//性能数模插件
class PerformancePlugin:public Singleton<PerformancePlugin>,public PluginBase{

public:
    const char* GetName() const{
        return "Performance";
    }
    IPluginService* GetServiceByName(const char* serviceName){
        return NULL;
    }
};
//数据上报插件
class ReportPlugin:public Singleton<ReportPlugin>,public PluginBase{
public:
    const char* GetName() const{
        return "Report";
    }
    
    IPluginService* GetServiceByName(const char* serviceName){
        if (strcmp(serviceName, kReportService) == 0) {
            return ReportPluginService::GetInstance();
        }
        return NULL;
    }
};

//日志插件
class LoggerPlugin:public Singleton<LoggerPlugin>,public PluginBase{
public:
    const char* GetName() const{
        return "Logger";
    }
    
    IPluginService* GetServiceByName(const char* serviceName){
        if (strcmp(serviceName, kLoggerService) == 0) {
            return LoggerPluginService::GetInstance();
        }
        return NULL;
    }
};

//日志处理插件
static void RegisterPlugin(IPlugin* plugin){
    if (!plugin) {
        return;
    }
    plugin -> RegisterPlugin(plugin);
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //注册
        {
            RegisterPlugin(PerformancePlugin::GetInstance());
            RegisterPlugin(ReportPlugin::GetInstance());
            RegisterPlugin(LoggerPlugin::GetInstance());
        }
        //1、先拿到当前数据性能模块实例；
        IPlugin* currentPlugin = PerformancePlugin::GetInstance();
        if (!currentPlugin) {
            return 0;
        }
        //2、根据当前数据性能模块实例拿到插件管理中心实例；
        MediatorPlugin* pluginManager = currentPlugin -> GetPuginManager();
        if (!pluginManager) {
            return 0;
        }
        //3、从插件管理中心根据数据上报模块提供的名字拿到数据上报模块实例；
        IPlugin* reportPlugin = pluginManager -> GetPluginByName("Report");
        if (!reportPlugin) {
            return 0;
        }
        //4、此时，数据上报模块实例根据数据上报模块提供的服务名称，得到相应的服务；
        IPluginService* reportService = reportPlugin -> GetServiceByName(kReportService);
        if (!reportService) {
            return 0;
        }
        //5、通过服务进行相应的函数调用，这样性能数据就能通过数据上报模块进行数据上报；
        reportService -> Report("数据上报1", strlen("数据上报1"));
        reportService -> Report("数据上报2", strlen("数据上报2"));
        
        //附加：获取日志处理插件

        IPlugin* loggerPlugin = pluginManager -> GetPluginByName("Logger");
        if (!loggerPlugin) {
            return 0;
        }
        //获取日志处理提供的服务
        IPluginService* loggerService = loggerPlugin -> GetServiceByName(kLoggerService);
        if (!loggerService) {
            return 0;
        }
        loggerService -> Logger("日志1", strlen("日志1"));
        loggerService -> Logger("日志2", strlen("日志2"));
        
    }
    return 0;
}