Detaillierte Analyse des Quellcodes des Spring-Ereignismechanismus

Dieser Artikel bietet Ihnen eine detaillierte Analyse des Quellcodes des Spring-Ereignismechanismus. Ich hoffe, er wird Ihnen als Referenz dienen.

Vorwort: Da es zuvor Probleme bei der Verwendung des Spring-Ereignismechanismus gab, habe ich versucht, den Quellcode dieses Artikels zu verstehen. Der Spring-Ereignismechanismus ist eigentlich die Veröffentlichung/das Abonnement von Ereignissen (beachten Sie, dass sich das Abonnement in Spring auf das Zuhören bezieht).

PS: Spring-Version ist 5.1.5.RELEASE

Quellcode-Analyse

Initialisierung

Der Schlüssel zur Initialisierung ist die Registrierung von Kernkomponenten

1. Die Schlüsselmethode ist die Methode PrepareBeanFactory() von AbstractApplicationContext. 2. Initialisierung und Registrierung von ApplicationEventMulticaster() 🎜>

3. Die Schlüsselmethode für die Initialisierung und Registrierung von ApplicationListener ist die Methode registerListeners() von AbstractApplicationContext.

Ich werde hier nicht auf Details eingehen selbst

Ereignisveröffentlichung/-abonnement

Die Schlüsselmethode für die Veröffentlichung/das Abonnement von Ereignissen ist „publishEvent“ von AbstractApplicationContext. Der Quellcode lautet wie folgt:

    protected void publishEvent(Object event, ResolvableType eventType) {
        // 避免空指针
        Assert.notNull(event, "Event must not be null");
        if (logger.isTraceEnabled()) {
            logger.trace("Publishing event in " + getDisplayName() + ": " + event);
        }

        // 处理event对象，将其转换为ApplicationEvent
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
            applicationEvent = (ApplicationEvent) event;
        }
        else {
            applicationEvent = new PayloadApplicationEvent<object>(this, event);
            if (eventType == null) {
                eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
            }
        }

        // 是否延迟多播，即将事件发布到所有监听器中
        if (this.earlyApplicationEvents != null) {
            this.earlyApplicationEvents.add(applicationEvent);
        }
        else {
            //此处为事件监听处理器的调用关键
            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
        }

        // 是否将事件发布到父容器中
        if (this.parent != null) {
            if (this.parent instanceof AbstractApplicationContext) {
                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
            }
            else {
                this.parent.publishEvent(event);
            }
        }
    }</object>

Durch Codeverfolgung wurde festgestellt, dass Spring die Standardimplementierung von ApplicationEventMulticaster, SimpleApplicationEventMulticaster, verwendet, um die Ereignisüberwachung auszulösen. Die Schlüsselmethode für die Methode multicastEvent() lautet wie folgt:

    @Override
    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
        // 获取事件类型
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        for (final ApplicationListener> listener : getApplicationListeners(event, type)) {//依次遍历事件监听器
            // 获取线程池
            Executor executor = getTaskExecutor();
            if (executor != null) {//线程池不为null，则异步调用监听器
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        invokeListener(listener, event);
                    }
                });
            }
            else {// 同步调用监听器
                invokeListener(listener, event);
            }
        }
    }

Dieser Artikel lautet Weitere spannende Inhalte finden Sie in der Rubrik

Java Video Tutorial

auf der chinesischen PHP-Website!

Das obige ist der detaillierte Inhalt vonDetaillierte Analyse des Quellcodes des Spring-Ereignismechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!