ErisPulse ErisPulse
Открыть интерактивную версию →
Разделы страницы
Статическое зеркало — интерактивная версия является основной Открыть интерактивную версию →

Обзор архитектуры

Tip

Когда читать эту статью: если вы хотите понять, что происходит за кулисами фреймворка — как проходит сообщение, в каком порядке инициализируются модули, что происходит при горячем перезагрузке, или если вы хотите разобраться, почему фреймворк ведёт себя так, как он ведёт. Если вы хотите просто писать обработчики, достаточно прочитать Введение в обработку событий; если нет необходимости, можете пропустить эту статью.

Сообщение от пользователя до ответа бота проходит через адаптеры, промежуточные слои, фильтрацию по сферам, распределение по приоритетам и другие этапы; модули также не загружаются сразу при запуске. В этой статье мы используем диаграммы, чтобы показать эту цепочку и объяснить, что вы можете изменить на каждом этапе.

Основная архитектура SDK

Ниже представлена диаграмма основных модулей SDK и их взаимосвязей:

graph TB
    SDK["sdk<br/>Единый вход"]

    SDK --> Event["Event<br/>Система событий"]
    SDK --> Lifecycle["Lifecycle<br/>Управление жизненным циклом"]
    SDK --> Logger["Logger<br/>Управление логами"]
    SDK --> Storage["Storage / env<br/>Управление хранилищем"]
    SDK --> Config["Config<br/>Управление конфигурацией"]
    SDK --> AdapterMgr["Adapter<br/>Управление адаптерами"]
    SDK --> ModuleMgr["Module<br/>Управление модулями"]
    SDK --> Router["Router<br/>Управление маршрутизацией"]
    SDK --> Client["Client<br/>HTTP-клиент"]
    Event --> Command["command"]
    Event --> Message["message"]
    Event --> Notice["notice"]
    Event --> Request["request"]
    Event --> Meta["meta"]
    Event --> Conversation["Conversation<br/>Ветвление + сохранение"]

    AdapterMgr --> BaseAdapter["BaseAdapter"]
    BaseAdapter --> P1["云湖"]
    BaseAdapter --> P2["Telegram"]
    BaseAdapter --> P3["OneBot11/12"]
    BaseAdapter --> PN["..."]

    ModuleMgr --> BaseModule["BaseModule"]
    BaseModule --> CM["Пользовательский модуль"]

    BaseAdapter -.-> SendDSL["SendDSL<br/>Отправка сообщений"]

Описание основных модулей

Модуль Описание
Event Система событий, предоставляющая обработку событий command / message / notice / request / meta, а также Conversation для многократных диалогов
Adapter Менеджер адаптеров, отвечает за регистрацию, запуск и остановку адаптеров для различных платформ
Module Менеджер модулей, отвечает за регистрацию, загрузку и выгрузку плагинов, поддерживает объявление зависимостей и топологическую сортировку
Lifecycle Менеджер жизненного цикла, предоставляет обработчики жизненного цикла на основе событий
Storage Хранилище на основе SQLite, поддерживающее общие SQL-запросы с цепочечной синтаксической структурой
Config Управление конфигурационными файлами в формате TOML
Logger Модульная система логирования, поддерживающая под-логгеры
Router Управление маршрутизацией HTTP/WebSocket, через абстракцию обертывает底层后端 (в настоящее время FastAPI + Uvicorn), поддерживает маршрутизацию с помощью декораторов, промежуточные слои, группировку, ограничение скорости, CORS
Client Единый HTTP/WS-клиент (до версии 2.8.0 был HttpClient, оставлен как совместимый псевдоним), через абстракцию обертывает底层请求库 (в настоящее время aiohttp), предоставляет статистику запросов, повторные попытки, логирование, WebSocket-клиент, систему исключений ErisPulse. WebSocket-клиент и серверная часть WebSocket используют общий базовый класс WebSocketConnectionBase

Процесс инициализации

Ниже представлена диаграмма полного процесса инициализации sdk.init():

flowchart TD
    A["sdk.init()"] --> B["Подготовка среды выполнения"]
    B --> B1["Загрузка конфигурационного файла"]
    B1 --> B2["Настройка обработки глобальных исключений"]
    B2 --> C["Обнаружение адаптеров и модулей"]
    C --> D{"Параллельная загрузка"}
    D --> D1["Загрузка адаптеров из PyPI"]
    D --> D2["Загрузка модулей из PyPI"]
    D1 & D2 --> E["Регистрация адаптеров"]
    E --> E1["Запуск адаптеров"]
    E1 --> F["Регистрация модулей"]
    F --> F1{"Проверка зависимостей"}
    F1 -->|"Отсутствуют зависимости"| F2["Пропустить модуль и записать предупреждение"]
    F1 -->|"Зависимости присутствуют"| F3["Топологическая сортировка<br/>(алгоритм Кана + приоритеты)"]
    F3 --> G["Инициализация модулей по порядку<br/>(инстанцирование + on_load)"]
    F2 --> G
    G --> H["Запуск сервера маршрутизации"]
    H --> K["Готов к работе"]

Подробное описание этапов инициализации

Полная цепочка инициализации (Finder / Loader / Manager / Router), базовые входные точки (init() / init_task() / init_sync()) и ручной полный запуск см. в Процесс запуска и ручное управление.

Процесс обработки событий

Ниже представлена диаграмма полного пути сообщения от платформы до обработчика:

flowchart LR
    A["Сообщение от платформы"] --> B["Приём адаптером"]
    B --> C["Преобразование в стандарт OneBot12"]
    C --> D["adapter.emit()"]
    D --> E["Выполнение цепочки промежуточных слоёв"]
    E --> F{"Рассылка событий"}
    F --> G1["command<br/>Обработчик команд"]
    F --> G2["message<br/>Обработчик сообщений"]
    F --> G3["notice<br/>Обработчик уведомлений"]
    F --> G4["request<br/>Обработчик запросов"]
    F --> G5["meta<br/>Обработчик мета-событий"]
    G1 & G2 & G3 & G4 & G5 --> H["Вызов обработчиков"]
    H --> I["event.reply()<br/>Ответ через SendDSL"]
    I --> J["Отправка адаптером на платформу"]

Подробное описание цепочки обработки событий

На этой диаграмме показан результат; ниже разобрано, что происходит "за кадром" после вызова adapter.emit() — это трёхуровневая цепочка рассылки:

sequenceDiagram
    participant P as Платформа
    participant A as Адаптерный слой<br/>AdapterManager.emit
    participant T as Слой задач<br/>_dispatch_handler_task
    participant E as Модуль событий<br/>_process_event

    P->>A: Оригинальное событие
    A->>A: Извлечение platform/type/detail_type + исходные поля
    A->>A: [Recv] Запись в лог
    A->>A: lifecycle.adapter.event.receive (самый ранний хук)
    A->>A: Обработка self-поля (ветвление meta / автоматическая регистрация бота)
    A->>A: Цепочка промежуточных слоёв (последовательно, можно изменить данные события)
    A->>A: Сбор обработчиков (конкретный тип + подстановочный *)
    A->>A: Аутентификация и фильтрация по сферам (до создания задачи, тихое удаление/пропуск)
    A->>T: asyncio.create_task (fire-and-forget)
    A->>A: lifecycle.adapter.event.dispatched (последний хук)
    T->>T: Получение семафора для параллелизма (по умолчанию 64)
    T->>E: Вызов обработчиков, зарегистрированных в модуле событий
    E->>E: lifecycle.event.pre_process
    E->>E: ignore_self (по умолчанию игнорировать собственные сообщения)
    E->>E: Группировка по приоритетам: высокий → низкий, последовательно между группами, параллельно внутри
    E->>E: Выполнение копий внутри группы + объединение полей (предупреждение при конфликтах)
    E->>E: Проверка stop() после группы, блокировка низших приоритетов
    T->>T: Запись в лог при медленных задачах (предупреждение при >1с, время wait_reply исключено)

Что делает фреймворк и что вы можете изменить:

Этап Что делает фреймворк Что вы можете изменить
Приём Извлекает стандартные поля, сохраняет {platform}_raw исходные данные; записывает [Recv] лог Наблюдение за adapter.event.receive для получения самого раннего события
self-поле Для мета-событий ветвление connect/disconnect/heartbeat; для обычных событий автоматическая регистрация бота и запуск adapter.bot.online Наблюдение за adapter.bot.online / bot.offline
Промежуточные слои Последовательно выполняются, если возвращаемое значение не None, то заменяется событие Регистрация промежуточных слоёв для изменения/перехвата события
Сбор обработчиков Сначала берётся конкретный тип обработчика, затем * подстановочный обработчик —
Аутентификация Определяется, принимать ли событие по пользователю>сессии>боту>адаптеру (scope.is_identity_allowed), отклонённые события удаляются ErisPulse.scope.identity привязка
Фильтрация по сферам Определяется по владельцу модуля (scope.is_allowed), сессионный>бот>платформенный уровень, не прошедшие фильтр тихо пропускаются Настройка белого/чёрного списка сфер
Планирование Каждый обработчик запускается в отдельной asyncio.Task, emit() не ждёт завершения обработчика —
Приоритеты Высокий приоритет выполняется первым; между группами последовательно, внутри групп параллельно (каждая группа получает копию события, изменения объединяются, конфликты предупреждаются) @command(..., priority=N) / указание при регистрации
Блокировка После обработки группы проверяется event.is_stopped(), если true, то выполняются только более высокие приоритеты event.mark_processed(stop=True) / event.done()

Распространённые заблуждения:

  1. Фильтрация по сферам тихая — отфильтрованные обработчики не вызывают ошибок и не отвечают, только в логах TRACE видно (core.scope.denied). При "мой модуль не получает сообщения" сначала проверьте привязку сфер.
  2. Обработчики обрабатываются параллельно — фреймворк уже создал для каждого обработчика отдельную задачу, вам не нужно дополнительно оборачивать в asyncio.create_task.
  3. Блокировка не действует внутри группы — mark_processed(stop=True) блокирует только более низкие приоритеты, обработчики в одной группе не прерываются.
  4. Порог медленного лога фиксирован 1 секунда — если обработчик затрачивает более 1 секунды, в логе появляется предупреждение (время wait_reply исключено), но выполнение не прерывается.

Подробнее о привязке сфер, аутентификации и ограничениях действий см. в Сфера (scope); о текстовом фильтре сфер и ACL пользователя команд см. в Введение в обработку событий; о настройке верхнего лимита параллелизма см. в Руководство по конфигурации.

События жизненного цикла

Ниже представлена диаграмма последовательности событий жизненного цикла компонентов фреймворка:

flowchart LR
    subgraph Core["Основное"]
        direction LR
        C1["core.init.start"] --> C2["core.init.complete"]
    end

    subgraph AdapterLife["Адаптер"]
        direction LR
        A1["adapter.start"] --> A2["adapter.status.change"] --> A3["adapter.stop"] --> A4["adapter.stopped"]
    end

    subgraph ModuleLife["Модуль"]
        direction LR
        M1["module.load"] --> M2["module.init"] --> M3["module.unload"]
    end

    subgraph BotLife["Бот"]
        direction LR
        B1["adapter.bot.online"] --> B2["adapter.bot.offline"]
    end

    Core --> AdapterLife
    AdapterLife --> ModuleLife
    AdapterLife -.-> BotLife

Наблюдение за событиями жизненного цикла

Полный список методов наблюдения за событиями (lifecycle.on() / once() / has_handlers()), все события жизненного цикла и формат данных см. в Управление жизненным циклом.

Стратегии загрузки модулей

ErisPulse поддерживает три стратегии загрузки модулей, возвращаемые get_load_strategy() в виде ModuleLoadStrategy:

flowchart TD
    A["Регистрация модуля в ModuleManager"] --> B{"Стратегия загрузки"}
    B -->|"lazy_load = true<br/>+ activate_on объявлено"| C["Создание прокси-объекта ModuleActivator"]
    B -->|"lazy_load = true<br/>activate_on не объявлено"| D["Создание прокси-объекта LazyModule"]
    B -->|"lazy_load = false"| E["Немедленное создание экземпляра"]
    C --> F["Регистрация stub'ов событий/команд в диспетчере"]
    F --> G["Привязка к свойству sdk"]
    G --> H["Активация при поступлении события"]
    H --> I["Инстанцирование + on_load() + удаление stub'ов"]
    D --> J["Привязка к свойству sdk"]
    J --> K["Инициализация при первом обращении к свойству"]
    E --> L["Вызов on_load()"]
    L --> M["Привязка к свойству sdk"]

Подробнее смотрите Систему ленивой загрузки, Управление жизненным циклом и документацию модуля.

Архитектура ленивой активации по событиям (activate_on)

Note

Эта функция доступна в ErisPulse с версии 2.8.0.

activate_on позволяет модулю загружаться только при первом поступлении соответствующего события/команды, что позволяет избежать постоянного использования памяти и гарантирует, что события не будут потеряны:

flowchart LR
    subgraph Declare["Объявление модуля"]
        S1["get_load_strategy() возвращает<br/>ModuleLoadStrategy(activate_on=...)"] --> S2["Синтаксис activate_on:<br/>свободное сочетание str / dict / list"]
        S2 --> S2a["'message' → по типу события"]
        S2 --> S2b["{'notice': 'group_member_increase'}<br/>→ тип + detail_type"]
        S2 --> S2c["{'command': 'roll'}<br/>→ срабатывание команды (сокращённая/списочная запись)"]
        S2 --> S2d["{'command': {'name': 'dice', 'help': ...,<br/>'aliases': [...], 'hidden': ...}}<br/>→ срабатывание команды (запись в виде dict)"]
    end

    subgraph Runtime["Во время выполнения"]
        R1["ModuleActivator регистрирует stub'ы"] --> R1a["События stub → message/notice/request/meta менеджер<br/>приоритет ACTIVATION_STUB_PRIORITY (очень низкий)"]
        R1 --> R1b["Команды stub → менеджер команд<br/>заполнитель команды (отражение dict-объявления help/usage/group/aliases/hidden)"]
        R1a --> R2{"Поступление события"}
        R1b --> R2
        R2 --> R3["Фильтрация по сферам по owner"]
        R3 --> R4["asyncio.Lock для предотвращения повторной активации"]
        R4 --> R5["Инстанцирование модуля + вызов on_load()"]
        R5 --> R6["Удаление всех stub'ов"]
        R6 --> R7["Передача события к реальному обработчику"]
    end

    Declare --> Runtime

Ключевые моменты семантики триггера:

Полный синтаксис activate_on (str / dict / list), объявление команды в виде dict, цепочка отката help для заполнителя команды, фильтрация по сферам и семантика неудачи см. в Системе ленивой загрузки.

Архитектура локальной папки плагинов

Note

Эта функция доступна в ErisPulse с версии 2.8.0.

Локальные плагины (папка plugins/) не требуют публикации и автоматически обнаруживаются и загружаются при запуске фреймворка:

flowchart TD
    A["Папка проекта plugins/<br/>(ErisPulse.framework.plugins_dir, поддерживает несколько каталогов)"] --> B{"PluginFolderLoader.discover()"}
    B --> C["Файл: dice.py → имя плагина = имя файла"]
    B --> D["Пакет: weather/ (с __init__.py) → имя плагина = имя каталога"]
    B --> E["Игнорировать: __pycache__ / с _ в начале / не .py / без __init__.py"]
    C --> F["Импорт модуля (spec_from_file_location)"]
    D --> G["Импорт модуля (sys.path + import_module)"]
    F --> H["Идентификация класса модуля: Main (подкласс BaseModule) в приоритете, в противном случае первый подкласс"]
    G --> H
    H --> I["Создание moduleInfo с entry-point"]
    I --> J["ModuleLoader.load() объединяет<br/>локальные модули в приоритете над PyPI"]
    J --> K["Совместное использование с модулями из PyPI:<br/>включённое состояние / сфера / meta / i18n / контекст"]

Соглашения и особенности:

  • Имя плагина: для файла — имя файла, для пакета — имя каталога
  • Для локального плагина moduleInfo.meta.source == "plugin_folder", он совместим с модулями из PyPI
  • При совпадении имен локальный модуль имеет приоритет (удобно для отладки), при отключении удаляется и entry-point

Архитектура горячей перезагрузки модулей

Горячая перезагрузка применяется ко всем источникам модулей одинаково: локальные плагины (plugins/), модули, зарегистрированные во время выполнения (sdk.module.register()), и модули из PyPI, которые можно перезагрузить через sdk.reload_module() / sdk.module.reload() — по умолчанию полная перезагрузка (очистка кэша импорта по имени пакета и повторный импорт зависимостей, full=False — лёгкий выход); sdk.reload_all_modules() / sdk.module.reload_all() может перезагрузить все зарегистрированные модули за один раз (например, после обновления пакетов через pip):

flowchart TD
    A["sdk.enable_plugin_hot_reload()<br/>(автоматически отслеживает, только локальные плагины)"] --> B["PluginReloadWatcher запущен"]
    B --> C["PollingObserver (фоновый поток)<br/>периодически сравнивает mtime файлов .py"]
    C --> D{"Изменение файла плагина"}
    D --> E["Дебаунсинг (по умолчанию 1 секунда)"]
    E --> F["_handle_change анализирует имя плагина<br/>(файл или пакет)"]
    F --> G["asyncio.run_coroutine_threadsafe<br/>перенаправление в основной цикл событий"]
    G --> H["sdk.reload_module(name, full=True по умолчанию)<br/>(также можно вручную перезагрузить любой модуль)"]
    H --> I["Предварительная проверка синтаксиса (построчное разбор) <br/>при ошибке перезагрузка отклоняется, старый экземпляр продолжает обслуживание"]
    I --> J["Выгрузка старого экземпляра (on_before_unload → on_unload) <br/>собираются зависимости для каскадной перезагрузки"]
    J --> K{"Источник модуля?"}
    K -->|"plugin_folder"| L["Очистка регистрации и sys.modules плагина<br/>повторный сканирование папки plugins/"]
    K -->|"runtime во время выполнения"| M["Очистка кэша по определению модуля и повторный импорт<br/>восстановление по имени класса (страж __main__)"]
    K -->|"PyPI"| N["Очистка регистрации + по top_level очистка пакета<br/>sys.modules поддерева + байт-код __pycache__<br/>(при отсутствии метаданных по старому объекту модуля верхний сегмент)<br/>обновление кэша импорта и повторный поиск entry-point"]
    L --> O["Повторная регистрация + загрузка"]
    M --> O
    N --> O
    O --> P["Привязка нового экземпляра к свойству sdk<br/>проверка идентичности нового и старого класса (предупреждение при ложной перезагрузке)"]
    P --> Q["Каскадная перезагрузка зависимостей<br/>(полная перезагрузка плагинов/во время выполнения;<br/>зависимости PyPI по умолчанию также перезагружаются код)"]
    L -.->|"Файл удалён"| R["Удаление из результата загрузки"]
    M -.->|"Определение не может быть безопасно перезагружено"| R
    N -.->|"entry-point исчез (удалён)"| R

Различия между тремя источниками только на этапе обнаружения, предварительная проверка, выгрузка и каскадная перезагрузка идентичны:

  • Локальные плагины (moduleInfo.meta.source == "plugin_folder"): после очистки sys.modules соответствующего имени плагина повторно сканируется папка plugins/; если файл удалён, он удаляется из результата загрузки
  • Модули, зарегистрированные во время выполнения (source == "runtime"): повторный импорт по определению модуля, восстановление по имени класса и повторная регистрация; классы, определённые в __main__ / без исходного файла отклоняются от перезагрузки (страж предупреждения, чтобы избежать повторного выполнения скрипта входной точки)
  • Пакеты из PyPI: по meta.top_level очищается поддерево sys.modules пакета, обновляется кэш импорта (преодоление кэша entry-point на 60 секунд) и повторно импортируется; если entry-point исчез (pip-удалён), он удаляется из результата загрузки

Стандартная семантика и гарантии надёжности (2.11):

  • reload = полная перезагрузка: по умолчанию очищается sys.modules по имени пакета и повторно импортируются зависимости; full=False — только очистка метаданных, зависимости PyPI повторно инстанцируются (выход для производительности при больших зависимостях)
  • Предварительный барьер синтаксической проверки: перед началом выгрузки происходит построчная синтаксическая проверка, при ошибке перезагрузка отклоняется — старый экземпляр не выгружается и продолжает обслуживание, синтаксические ошибки никогда не приведут модуль в "полумёртвое состояние" (при большом количестве файлов превышает лимит)
  • Кэш-поддержка: при отсутствии метаданных top_level используется двойная генерация очистки по старому объекту модуля __name__ префикс → модульному классу __module__ префикс; при перезагрузке также очищаются байт-коды исходных файлов (в pycache), даже небольшие изменения в тот же секунду и с одинаковой длиной вступают в силу
  • Проверка идентичности: после успешной перезагрузки утверждается изменение идентичности нового и старого класса, если не изменилось (например, C-расширения, кэш не очищается) — явное предупреждение и событие module.reload с identity_changed: false; module.get_info() с полями running_identity / stale показывает "зарегистрированная версия ≠ текущая версия"
  • Проверка ошибок: при неудачной загрузке (исключение + traceback) можно напрямую получить через module.last_error(имя) / get_info()["last_error"], при этом очищается кэш импорта модуля — "измените код и перезагрузите ещё раз" обязательно прочитает новый код
  • Перезагрузка заставляет модуль, который был лениво загружен, активироваться (явное логирование); reload_all_modules() сохраняет стратегию ленивой загрузки, только модули, которые были загружены до перезагрузки, повторно активируются, модули, находящиеся в спящем состоянии, остаются в спящем состоянии
  • reload_all_modules() перезагружает в порядке зависимостей, при неудаче одного модуля записывается диагностика и пропускается (без общей отката —副作用 on_unload не отменить, семантика как у горячей перезагрузки одного модуля); при неудаче перезагрузки, когда старый экземпляр уже откатился, лог будет явно указывать, что старый экземпляр находится в состоянии завершения

Архитектура горячей перезагрузки адаптеров

Горячая перезагрузка адаптеров на уровне кода (2.11) идентична цепочке модулей: sdk.adapter.reload(название_платформы) / sdk.reload_adapter(название_платформы) применяется ко локальным плагинам и пакетам из PyPI:

flowchart TD
    A["sdk.adapter.reload(название_платформы)"] --> B["Предварительная проверка синтаксиса (построчное разбор) <br/>при ошибке отклоняется перезагрузка, старый адаптер продолжает обслуживание"]
    B --> C["Снимок: adapterInfo / экземпляр / состояние запуска /<br/>задача запуска / bots / записи в sys.modules"]
    C --> D["Выгрузка (shutdown очищает:<br/>маршрутизацию/события/команды/задачи/соединения/bot offline + ан регистрации)"]
    D --> E["Очистка кэша: байт-коды __pycache__ →<br/>sys.modules поддерево → invalidate_caches<br/>→ кэш finder → запись пути плагинов"]
    E --> F{"Источник?"}
    F -->|"Папка плагинов"| G["Повторное сканирование plugins/(discover_adapters)"]
    F -->|"Пакет из PyPI"| H["Повторный поиск entry-point и повторный импорт<br/>(очистка по top_level + класс __module__ как резерв)"]
    G --> I["Повторная регистрация + запуск (в том же состоянии)<br/>проверка идентичности класса (предупреждение при ложной перезагрузке)"]
    H --> I
    I --> J["Событие adapter.reload<br/>identity_changed / version_old→new / was_started"]
    G -.->|"Плагин удалён"| K["Удаление из результата загрузки"]
    H -.->|"entry-point исчез"| K
    I -.->|"Неудача"| L["Откат: восстановление sys.modules /<br/>зарегистрированных заглушек / экземпляра / состояния запуска"]

Различия с цепочкой модулей:

  • У адаптеров нет ленивой загрузки и каскадной перезагрузки зависимостей: перезагрузка не распространяется на другие адаптеры, которые от него зависят (только предупреждение — зависимые через реестр косвенно используют, без семантики каскада экземпляров)
  • Запуск асинхронный (через startup через _run_adapter, включая пропуск зависимостей и экспоненциальную отмену с повторными попытками): временный сбой запуска не считается неудачей перезагрузки (код уже обновлён), результат передаётся через adapter.status.change
  • Ловушка повторного использования экземпляра register (если классы совпадают, старый экземпляр повторно используется) решается "очисткой pyc + sys.modules + проверкой идентичности"
  • События жизненного цикла: adapter.reload (payload содержит adapter_name / success / full / duration_ms / identity_changed / version_old→new / was_started / source)

Далее

  • Если хотите ручное управление запуском / остановкой: смотрите Процесс запуска и ручное управление, где разобрана цепочка инициализации, отдельные запуск и остановка адаптеров и маршрутизации
  • Если хотите разобраться с ленивой загрузкой и спящим состоянием: смотрите Систему ленивой загрузки, включая полный синтаксис activate_on для ленивой активации по событиям
  • Если хотите использовать жизненный цикл при написании модуля: смотрите Управление жизненным циклом, где представлены все события жизненного цикла и методы наблюдения