2024年ZLMediaKit源码分析 - NotifyCenter_zlmediakit源码解析(3)，2024年最新Golang项目开发如何设计整体架构

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

std::unordered_map<std::string, EventDispatcher::Ptr> _mapListener;

template
void addListener(void *tag, const std::string &event, FUNC &&func) {
getDispatcher(event, true)->addListener(tag, std::forward(func));
}

EventDispatcher::Ptr getDispatcher(const std::string &event, bool create = false) {
std::lock_guardstd::recursive_mutex lck(_mtxListener);
//查找事件
auto it = _mapListener.find(event);
if (it != _mapListener.end()) {
//事件存在则直接返回
return it->second;
}
if (create) {
//如果为空则创建一个
EventDispatcher::Ptr dispatcher(new EventDispatcher());
_mapListener.emplace(event, dispatcher);
return dispatcher;
}
return nullptr;
}

EventDispatcher，该函数将标识（tag）,处理函数（func）插入自身的成员变量\_mapListener，这是一个键值对。存储了多个执行函数

 using MapType = std::unordered_multimap<void \*, std::shared_ptr<void> >;
template<typename FUNC>
void addListener(void \*tag, FUNC &&func) {
    // 类型别名
    using funType = typename function\_traits<typename std::remove_reference<FUNC>::type>::stl_function_type;
    // 创建对象
    std::shared_ptr<void> pListener(new funType(std::forward<FUNC>(func)), [](void \*ptr) {
        // 析构
        funType \*obj = (funType \*) ptr;
        delete obj;
    });
    std::lock_guard<std::recursive_mutex> lck(_mtxListener);
    _mapListener.emplace(tag, pListener);
}

## 事件分发


emitEvent也是调用getDispatcher，然后找到EventDispatcher执行emitEvent

template<typename …ArgsType>
int emitEvent(const std::string &strEvent, ArgsType &&…args) {
auto dispatcher = getDispatcher(strEvent);
if (!dispatcher) {
//该事件无人监听
return 0;
}
return dispatcher->emitEvent(std::forward(args)…);
}

EventDispatcher的emitEvent函数如下

template<typename …ArgsType>
int emitEvent(ArgsType &&…args) {
using funType = std::function<void(decltype(std::forward(args))…)>;
decltype(_mapListener) copy;
{
//先拷贝(开销比较小)，目的是防止在触发回调时还是上锁状态从而导致交叉互锁
std::lock_guardstd::recursive_mutex lck(_mtxListener);
copy = _mapListener;
}

    int ret = 0;
    // 遍历
    for (auto &pr : copy) {
        funType \*obj = (funType \*) (pr.second.get());
        try {
            //执行
            (\*obj)(std::forward<ArgsType>(args)...);
            ++ret;
        } catch (InterruptException &) {
            ++ret;
            break;
        }
    }
    return ret;
}

## 总结


1. NoticeCenter实现了全局的事件分发器，我们可以学习其实现应用到我们项目中解耦类似的场景。
2. 如果处理函数没有做异步处理，那么他归属的线程在触发事件里，就是在emitEvent时的线程，而不是在调用者所在的线程，


## 完整源码及测试


function\_traits.h

#ifndef SRC_UTIL_FUNCTION_TRAITS_H_
#define SRC_UTIL_FUNCTION_TRAITS_H_

#include

namespace toolkit {

template
struct function_traits;

//普通函数
template<typename Ret, typename… Args>
struct function_traits<Ret(Args…)>
{
public:
enum { arity = sizeof…(Args) };
typedef Ret function_type(Args…);
typedef Ret return_type;
using stl_function_type = std::function<function_type>;
typedef Ret(*pointer)(Args…);

template<size_t I>
struct args
{
    static\_assert(I < arity, "index is out of range, index must less than sizeof Args");
    using type = typename std::tuple_element<I, std::tuple<Args...> >::type;
};

};

//函数指针
template<typename Ret, typename… Args>
struct function_traits<Ret(*)(Args…)> : function_traits<Ret(Args…)>{};

//std::function
template <typename Ret, typename… Args>
struct function_traits<std::function<Ret(Args…)>> : function_traits<Ret(Args…)>{};

//member function
#define FUNCTION_TRAITS(…)
template <typename ReturnType, typename ClassType, typename… Args>
struct function_traits<ReturnType(ClassType:😗)(Args…) __VA_ARGS__> : function_traits<ReturnType(Args…)>{}; \

FUNCTION_TRAITS()
FUNCTION_TRAITS(const)
FUNCTION_TRAITS(volatile)
FUNCTION_TRAITS(const volatile)

//函数对象
template
struct function_traits : function_traits<decltype(&Callable::operator())>{};

} /* namespace toolkit */

#endif /* SRC_UTIL_FUNCTION_TRAITS_H_ */

NoticeCenter.h

/*
* Copyright © 2016 The ZLToolKit project authors. All Rights Reserved.
*
* This file is part of ZLToolKit(https://github.com/ZLMediaKit/ZLToolKit).
*
* Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree.
*/

#ifndef SRC_UTIL_NOTICECENTER_H_
#define SRC_UTIL_NOTICECENTER_H_

#include
#include
#include
#include
#include
#include <unordered_map>
#include “function_traits.h”

namespace toolkit {

class EventDispatcher {
public:
friend class NoticeCenter;
using Ptr = std::shared_ptr;

~EventDispatcher() = default;

private:
using MapType = std::unordered_multimap<void *, std::shared_ptr >;

EventDispatcher() = default;

class InterruptException : public std::runtime\_error {
public:
    InterruptException() : std::runtime\_error("InterruptException") {}

    ~InterruptException() {}
};

template<typename ...ArgsType>
int emitEvent(ArgsType &&...args) {
    using funType = std::function<void(decltype(std::forward<ArgsType>(args))...)>;
    decltype(_mapListener) copy;
    {
        //先拷贝(开销比较小)，目的是防止在触发回调时还是上锁状态从而导致交叉互锁
        std::lock_guard<std::recursive_mutex> lck(_mtxListener);
        copy = _mapListener;
    }

    int ret = 0;
    for (auto &pr : copy) {
        funType \*obj = (funType \*) (pr.second.get());
        try {
            (\*obj)(std::forward<ArgsType>(args)...);
            ++ret;
        } catch (InterruptException &) {
            ++ret;
            break;
        }
    }
    return ret;
}

template<typename FUNC>
void addListener(void \*tag, FUNC &&func) {
    using funType = typename function\_traits<typename std::remove_reference<FUNC>::type>::stl_function_type;

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

l-1715659804842)]
[外链图片转存中…(img-IiFiwA3v-1715659804842)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取