概述

• 本文主要描述一個超精簡的訂閱發布事件組件--SPEvent。
• 在實際開發過程中，一個事件的產生會產生很多業務的執行，或者多個事件都要執行同一個業務的執行。在這種場景下有兩種做法：

1. 將同一個事件的業務放在一個函數中，然后事件產生的時候執行對應的函數。
2. 某個業務需要哪個事件，它自己監聽對應事件并執行。

• 顯然，第一種策略會將業務與業務之間耦合在一起，對后期維護是非常痛苦的；第二種顯然會更加有優勢，不同業務完全解耦，獨立完成事件的業務。
• 第二種策略的方式，實際在軟件架構中經常看到，比如MQTT的通信(通過訂閱對應的topic去監聽對應內容)。
• 有了上述的需求，作者做了一個超精簡的訂閱發布事件組件。整個邏輯很簡單。

超精簡的SPEvent組件，實現方法

1. 整個訂閱發布事件機制，引入兩個東西：EventHub和EventNode。

• EventHub：每一個事件類型都為一個EventHub，然后掛在HubList中。
• EventNode：每一個訂閱事件的業務為一個EventNode，然后掛在對應的EventHub中。

• 整個訂閱發布事件機制圍繞著EventHub和EventNode，特點：

• 資源占用極小，接口操作簡單
• 事件支持動態訂閱，動態注銷。

• SPEvent采用雙向鏈表進行維護整個訂閱-發布邏輯

• SPEvent一定存在一個EventHubList鏈表來維護事件類型，它默認是沒有任何EventHub節點，
• 訂閱事件流程：當訂閱者訂閱事件之后，如果事件不存在，則申請一個EventHub，并將EventHub掛在到EventHubList鏈表中；然后申請一個EventNode，及將對應EventNode掛在EventNodeList鏈表。
• 發布事件流程：當發布者發布事件時，會從EventHubList中查詢有沒有對應的EventHub，如果EventHub存在，則將事件消息發布給對應EventHub下所有EventNode。
• 注銷事件訂閱流程：當訂閱者注銷已經訂閱的事件，會從EventHubList中查詢有沒有對應的EventHub，如果EventHub存在，則將對應EventNode從EventHub中刪除。

超精簡的SPEvent組件，接口說明：

超精簡的SPEvent組件，代碼實現

1. 整個代碼接口存在3個文件：spevent.c、spevent.h、spevent_def.h。其中：
2. spevent_def.h文件說明：定義了屏蔽平臺相關接口的宏和定義了雙向量表操作的宏定義。雙向量表在SPEvent中式至關重要數據結構：

#ifndef__SPEVENT_DEF_H__
#define__SPEVENT_DEF_H__



#include
#include
#include
#include
#include
#include
#include

#defineSPEVENT_INLINEstatic__inline
#defineSPEVENT_EVENT_NAME_LEN16

#ifndefSPEVENT_MALLOC
#defineSPEVENT_MALLOCmalloc
#endif

#ifndefSPEVENT_FREE
#defineSPEVENT_FREEfree
#endif

#ifndefSPEVENT_PRINT
#defineSPEVENT_PRINTprintf
#endif

structSPEventListNode
{
structSPEventListNode*next;
structSPEventListNode*prev;
};
typedefstructSPEventListNodeSPEventList;

SPEVENT_INLINEvoidSPEVENT_LIST_INIT(SPEventList*l)
{
l->next=l->prev=l;
}

SPEVENT_INLINEvoidSPEVENT_LIST_INSERT_AFTER(SPEventList*l,SPEventList*n)
{
l->next->prev=n;
n->next=l->next;
l->next=n;
n->prev=l;
}

SPEVENT_INLINEvoidSPEVENT_LIST_INSERT_BEFORE(SPEventList*l,SPEventList*n)
{
l->prev->next=n;
n->prev=l->prev;
l->prev=n;
n->next=l;
}

SPEVENT_INLINEvoidSPEVENT_LIST_REMOVE(SPEventList*n)
{
n->next->prev=n->prev;
n->prev->next=n->next;
n->next=n->prev=n;
}

SPEVENT_INLINEintSPEVENT_LIST_LEN(constSPEventList*l)
{
intlen=0;
constSPEventList*p=l;
while(p->next!=l){
p=p->next;
len++;
}
returnlen;
}

#defineSPEVENT_CONTAINER_OF(ptr,type,member)
((type*)((char*)(ptr)-(unsignedlong)(&((type*)0)->member)))

#defineSPEVENT_LIST_OBJ_INIT(obj){&(obj),&(obj)}

#defineSPEVENT_LIST_ENTRY(node,type,member)
SPEVENT_CONTAINER_OF(node,type,member)

#defineSPEVENT_LIST_FOR_EACH(pos,head)
for(pos=(head)->next;pos!=(head);pos=pos->next)

#defineSPEVENT_LIST_FOR_EACH_SAFE(pos,n,head)
for(pos=(head)->next,n=pos->next;pos!=(head);
pos=n,n=pos->next)

#defineSPEVENT_LIST_FOR_EACH_ENTRY(pos,head,member)
for(pos=SPEVENT_LIST_ENTRY((head)->next,typeof(*pos),member);
&pos->member!=(head);
pos=SPEVENT_LIST_ENTRY(pos->member.next,typeof(*pos),member))

#defineSPEVENT_LIST_FOR_EACH_ENTRY_SAFE(pos,n,head,member)
for(pos=SPEVENT_LIST_ENTRY((head)->next,typeof(*pos),member),
n=SPEVENT_LIST_ENTRY(pos->member.next,typeof(*pos),member);
&pos->member!=(head);
pos=n,n=SPEVENT_LIST_ENTRY(n->member.next,typeof(*n),member))

#defineSPEVENT_LIST_FIRST_ENTRY(ptr,type,member)
SPEVENT_LIST_ENTRY((ptr)->next,type,member)

#endif

3. spevent.c文件說明：SPEvent的接口實現；整個邏輯通過鏈表的嵌套，實現了事件的管理，事件的訂閱，事件的發布。

#include"spevent.h"

staticSPEventListg_hublist={0};

staticSPEventHubNode*SPEventFindHubNode(SPEventList*list,constchar*event)
{
SPEventHubNode*hubNode=NULL;
SPEventList*node=NULL;

SPEVENT_LIST_FOR_EACH(node,list){
hubNode=SPEVENT_LIST_ENTRY(node,SPEventHubNode,hubList);
if(hubNode!=NULL&&strcmp(hubNode->event,event)==0){
returnhubNode;
}
}
returnNULL;
}

staticSPEventEventNode*SPEventFindEventNode(SPEventList*eventList,SPEventHandlehandle)
{
SPEventEventNode*eventNode=NULL;
SPEventList*node=NULL;

SPEVENT_LIST_FOR_EACH(node,eventList){
eventNode=SPEVENT_LIST_ENTRY(node,SPEventEventNode,list);
if(eventNode!=NULL&&handle==eventNode->handle){
returneventNode;
}
}
returnNULL;
}

SPEventEventNode*SPEventSubscribe(constchar*event,SPEventHandlehandle)
{
SPEventHubNode*hubNode=NULL;
SPEventEventNode*eventNode=NULL;

hubNode=SPEventFindHubNode(&g_hublist,event);
if(hubNode==NULL){
hubNode=(SPEventHubNode*)SPEVENT_MALLOC(sizeof(SPEventHubNode));
if(hubNode==NULL){
SPEVENT_PRINT("SPEVENThub(%s)mallocfailedrn",event);
returnNULL;
}
memset(hubNode->event,0,SPEVENT_EVENT_NAME_LEN);
memcpy(hubNode->event,event,strlen(event));
SPEVENT_LIST_INSERT_AFTER(&g_hublist,&(hubNode->hubList));
SPEVENT_LIST_INIT(&(hubNode->eventList));
}

eventNode=(SPEventEventNode*)SPEVENT_MALLOC(sizeof(SPEventEventNode));
if(eventNode==NULL){
SPEVENT_PRINT("SPEVENTevent(%s)mallocfailedrn",event);
returnNULL;
}
eventNode->handle=handle;
SPEVENT_LIST_INSERT_AFTER(&hubNode->eventList,&(eventNode->list));

SPEVENT_PRINT("SPEVENTevent(%s)Subscribesuccessrn",event);
returneventNode;
}

boolSPEventUnsubscribe(constchar*event,SPEventEventNode*node)
{
SPEventHubNode*hubNode=NULL;
SPEventEventNode*eventNode=NULL;

hubNode=SPEventFindHubNode(&g_hublist,event);
if(hubNode==NULL){
SPEVENT_PRINT("SPEVENThub(%s)findfailedrn",event);
returnfalse;
}
eventNode=SPEventFindEventNode(&(hubNode->eventList),node->handle);
if(eventNode==NULL){
SPEVENT_PRINT("SPEVENTevent(%s)findfailedrn",event);
returnfalse;
}
SPEVENT_LIST_REMOVE(&(eventNode->list));
SPEVENT_FREE(eventNode);
eventNode=NULL;

SPEVENT_PRINT("SPEVENTevent(%s)Unsubscribesuccessrn",event);
returntrue;
}

boolSPEventPublish(constchar*event,void*payload)
{
SPEventHubNode*hubNode=NULL;
SPEventEventNode*eventNode=NULL;
SPEventList*node=NULL;

hubNode=SPEventFindHubNode(&g_hublist,event);
if(hubNode==NULL){
SPEVENT_PRINT("SPEVENThub(%s)findfailedrn");
returnfalse;
}
SPEVENT_LIST_FOR_EACH(node,&(hubNode->eventList)){
eventNode=SPEVENT_LIST_ENTRY(node,SPEventEventNode,list);
if(eventNode->handle){
eventNode->handle(event,payload);
}
}

SPEVENT_PRINT("SPEVENTevent(%s)Publishsuccessrn",event);
returntrue;
}

voidSPEventClear(void)
{
SPEventHubNode*hubNode=NULL;
SPEventEventNode*eventNode=NULL;
SPEventList*hubList=NULL;
SPEventList*eventList=NULL;

SPEVENT_LIST_FOR_EACH(hubList,&g_hublist){
hubNode=SPEVENT_LIST_ENTRY(hubList,SPEventHubNode,hubList);
if(hubNode==NULL){
continue;
}
SPEVENT_LIST_FOR_EACH(eventList,&(hubNode->eventList)){
eventNode=SPEVENT_LIST_ENTRY(eventList,SPEventEventNode,list);
if(eventNode==NULL){
continue;
}
SPEVENT_LIST_REMOVE(&(eventNode->list));
SPEVENT_FREE(eventNode);
eventNode=NULL;
}

SPEVENT_LIST_REMOVE(&(hubNode->hubList));
SPEVENT_FREE(hubNode);
hubNode=NULL;
}
}

voidRecvtInfoDump(void)
{
SPEventHubNode*hubNode=NULL;
SPEventEventNode*eventNode=NULL;
SPEventList*hubList=NULL;
SPEventList*eventList=NULL;
inteventNodeCount=0;

SPEVENT_PRINT("SPEVENTlist:rn");

SPEVENT_LIST_FOR_EACH(hubList,&g_hublist){
hubNode=SPEVENT_LIST_ENTRY(hubList,SPEventHubNode,hubList);
if(hubNode==NULL){
continue;
}
SPEVENT_PRINT("SPEVENTevent(%s):",hubNode->event);
eventNodeCount=0;
SPEVENT_LIST_FOR_EACH(eventList,&(hubNode->eventList)){
eventNode=SPEVENT_LIST_ENTRY(eventList,SPEventEventNode,list);
if(eventNode==NULL){
continue;
}
eventNodeCount++;
}
SPEVENT_PRINT("%drn",eventNodeCount);
}
}

voidSPEventInit(void)
{
SPEVENT_LIST_INIT(&g_hublist);
}

voidSPEventDeinit(void)
{
SPEventClear();
}

3. spevent.h文件說明：SPEvent的接口申明及SPEvent相關接口體的定義。

#ifndef__SPEVENT_H__
#define__SPEVENT_H__

#include"spevent_def.h"
typedefvoid(*SPEventHandle)(constchar*event,void*payload);

typedefstruct
{
SPEventHandlehandle;
SPEventListlist;
}SPEventEventNode;

typedefstruct
{
charevent[SPEVENT_EVENT_NAME_LEN];
SPEventListeventList;
SPEventListhubList;
}SPEventHubNode;

voidSPEventInit(void);

voidSPEventDeinit(void);

SPEventEventNode*SPEventSubscribe(constchar*event,SPEventHandlehandle);

boolSPEventUnsubscribe(constchar*event,SPEventEventNode*node);

boolSPEventPublish(constchar*event,void*payload);

voidSPEventClear(void);

voidRecvtInfoDump(void);

#endif

超精簡的SPEvent組件，實例：

#include
voidSPEventHandle1(constchar*event,void*payload)
{
SPEVENT_PRINT("Event1:%s,payload:%s",event,payload);
}

voidSPEventHandle2(constchar*event,void*payload)
{
SPEVENT_PRINT(ent2:%s,payload:%s",event,payload);
}

intmain()
{
SPEventInit();

SPEventEventNode*eventNode1=SPEventSubscribe("Rice",SPEventHandle1);
if(eventNode1!=NULL)
{
SPEventPublish("Rice","hello");
}else{
rlog_e("SPEVENTsubscribeeventfailed");
}

SPEventEventNode*eventNode2=SPEventSubscribe("Rice",SPEventHandle2);
if(eventNode2!=NULL)
{
SPEventPublish("Rice","world");
}else{
rlog_e("SPEVENTsubscribeeventfailed");
}

RecvtInfoDump();

SPEventUnsubscribe("Rice",eventNode1);

SPEventPublish("Rice","Hello world");

RecvtInfoDump();
return0;
}

• 結果：

SPEVENTevent(Rice)Subscribesuccess
Event1:Rice,payload:hello
SPEVENTevent(Rice)Publishsuccess
SPEVENTevent(Rice)Subscribesuccess
Event2:Rice,payload:world
Event1:Rice,payload:world
SPEVENTevent(Rice)Publishsuccess
SPEVENTlist:
SPEVENTevent(Rice):2
SPEVENTevent(Rice)Unsubscribesuccess
Event2:Rice,payload:Hello world
SPEVENTevent(Rice)Publishsuccess
SPEVENTlist:
SPEVENTevent(Rice):1