janux源码走读（五）Janus事件处理模块（events/）

5.1、事件处理模块架构图

事件发布 事件发布 事件同步 Janus Core 事件处理模块 事件处理器 事件类型管理 位掩码过滤 事件订阅 事件分发器 批量发送优化 故障恢复机制 事件传输通道 MQTT RabbitMQ 简单事件处理 MQTT Broker RabbitMQ Broker 本地事件队列 janus_events_init janus_events_notify_handlers

关键说明：

• 事件处理模块是Janus核心通信层 ，通过janus_events_init初始化
• 传输通道（MQTT/RabbitMQ/简单事件）是事件的传输载体
• 事件类型管理（位掩码）实现精细化订阅

---

5.2、各事件处理方式

5.2.1. MQTT事件处理（events/mqtt.c）

原理

• MQTT作为传输通道 ：基于paho.mqtt.c库实现事件发布
• 关键机制 ：事件类型位掩码 （JANUS_EVENT_TYPE_*） + 批量发送优化

作用

• 将事件通过MQTT发布到Broker，实现跨服务事件通知
• 适用于需要高可靠、异步事件传递的场景

源码 （ events/mqtt.c）

// MQTT事件初始化（注册到事件处理模块）
int janus_events_mqtt_init() {
    // 1. 创建MQTT客户端
    mqtt_client = mqtt_client_create("janus_events", "janus", "janus", 0);
    if (!mqtt_client) return -1;
    
    // 2. 连接MQTT Broker
    if (mqtt_client_connect(mqtt_client, "127.0.0.1", 1883, 60) != 0) {
        mqtt_client_destroy(mqtt_client);
        return -1;
    }
    
    // 3. 注册事件处理回调
    janus_events_set_handler(janus_events_mqtt_handler);
    return 0;
}

// 事件处理回调（核心！）
static void janus_events_mqtt_handler(janus_event_type type, 
                                    janus_session *session,
                                    json_t *event) {
    // 1. 构建MQTT主题（基于事件类型）
    char topic[128];
    snprintf(topic, sizeof(topic), "janus/events/%d", type);
    
    // 2. 发布事件（JSON格式）
    char *event_str = json_dumps(event, 0);
    mqtt_client_publish(mqtt_client, topic, event_str, 0, 0);
    free(event_str);
}

流程图：MQTT事件处理
JANUS_EVENT_TYPE_SESSION JANUS_EVENT_TYPE_WEBRTC 事件触发 事件类型 构建主题: janus/events/1 构建主题: janus/events/2 MQTT Broker 订阅者接收

时序图：MQTT事件传递
Core MQTT_Handler MQTT_Broker Subscriber janus_events_notify_handlers(type, session, event) 构建MQTT主题 publish(topic, event) 推送事件 处理事件 Core MQTT_Handler MQTT_Broker Subscriber

---

5.5.2. RabbitMQ事件处理（events/rabbitmq.c）

原理

• AMQP作为传输通道 ：基于amqp-client库实现事件发布
• 关键机制 ：队列绑定 （channel_queue_bind） + 事件批量发送

作用

• 将事件通过RabbitMQ发布到队列，实现高可靠、批量事件传递
• 适用于需要持久化、高吞吐的事件场景

源码 （ events/rabbitmq.c）

// RabbitMQ事件初始化（注册到事件处理模块）
int janus_events_rabbitmq_init() {
    // 1. 创建连接
    conn = amqp_new_connection();
    amqp_socket = amqp_tcp_socket_new(conn);
    if (!amqp_socket) return -1;
    
    // 2. 连接RabbitMQ
    if (amqp_socket_open(amqp_socket, "localhost", 5672) != 0) {
        amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
        return -1;
    }
    
    // 3. 声明队列（"janus.events"）
    amqp_channel_open(conn, 1);
    amqp_queue_declare(conn, 1, amqp_cstring_bytes("janus.events"), 
                      0, 0, 0, 0, amqp_empty_table);
    
    // 4. 注册事件处理回调
    janus_events_set_handler(janus_events_rabbitmq_handler);
    return 0;
}

// 事件处理回调（核心！）
static void janus_events_rabbitmq_handler(janus_event_type type, 
                                        janus_session *session,
                                        json_t *event) {
    // 1. 构建消息（JSON格式）
    char *event_str = json_dumps(event, 0);
    
    // 2. 发布到RabbitMQ队列
    amqp_basic_publish(conn, 1, amqp_cstring_bytes(""), 
                      amqp_cstring_bytes("janus.events"), 
                      0, 0, amqp_cstring_bytes(event_str));
    free(event_str);
}

流程图：RabbitMQ事件处理
事件触发 构建JSON事件 连接RabbitMQ 发布到队列 队列绑定 订阅者消费

时序图：RabbitMQ事件传递
Core RabbitMQ_Handler RabbitMQ_Broker Subscriber janus_events_notify_handlers(type, session, event) 构建JSON事件 publish("janus.events", event) 推送事件 处理事件 Core RabbitMQ_Handler RabbitMQ_Broker Subscriber

---

5.2.3. 简单事件处理（events/simple.c）

原理

• 本地事件队列 ：基于g_queue实现事件存储
• 关键机制 ：同步事件处理 （janus_events_notify_handlers） + 批量发送优化

作用

• 实现本地事件同步处理 ，适用于低延迟、高实时性的场景
• 作为其他事件传输的默认回退机制

源码 （events/simple.c）

// 简单事件初始化（注册到事件处理模块）
int janus_events_simple_init() {
    // 1. 创建事件队列
    events_queue = g_queue_new();
    
    // 2. 注册事件处理回调
    janus_events_set_handler(janus_events_simple_handler);
    return 0;
}

// 事件处理回调（核心！）
static void janus_events_simple_handler(janus_event_type type, 
                                      janus_session *session,
                                      json_t *event) {
    // 1. 事件入队（用于批量发送）
    janus_event *evt = g_new0(janus_event, 1);
    evt->type = type;
    evt->session = session;
    evt->event = event;
    g_queue_push_tail(events_queue, evt);
    
    // 2. 批量发送优化（非实时）
    if (g_queue_get_length(events_queue) >= MAX_GROUP_SIZE) {
        janus_events_simple_flush();
    }
}

// 批量发送事件（核心！）
static void janus_events_simple_flush() {
    // 1. 从队列取出事件
    GList *current = g_queue_peek_head_link(events_queue);
    while (current && g_queue_get_length(events_queue) > 0) {
        janus_event *evt = (janus_event *)current->data;
        
        // 2. 处理事件（实际业务逻辑）
        janus_core_handle_event(evt->type, evt->session, evt->event);
        
        // 3. 释放事件
        json_decref(evt->event);
        g_free(evt);
        current = g_list_next(current);
    }
    
    // 4. 清空队列
    g_queue_clear(events_queue);
}

流程图：简单事件处理
>=MAX_GROUP_SIZE <=MAX_GROUP_SIZE 事件触发 事件入队 队列长度 批量处理 等待下一次触发 处理事件 释放资源

时序图：简单事件处理
Core Simple_Handler Event_Queue janus_events_notify_handlers(type, session, event) 事件入队 队列长度检查 队列长度≥MAX_GROUP_SIZE? 是→批量处理 处理事件 执行业务逻辑 Core Simple_Handler Event_Queue

---