18154768944

Committed 01 Oct 2025 07:26AM UTC coverage: 81.882% (-0.005%) from 81.887%

Build # 18154768944

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #290 from TAKETODAY/dev/jspecify

jspecify

Coverage Stats

59788 of 78013 branches covered (76.64%)

Branch coverage included in aggregate %.

141239 of 167496 relevant lines covered (84.32%)

3.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.25

today-context/src/main/java/infra/context/support/ApplicationListenerDetector.java

/*
 * Copyright 2017 - 2025 the original author or authors.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see [https://www.gnu.org/licenses/]
 */

package infra.context.support;

import org.jspecify.annotations.Nullable;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import infra.beans.factory.InitializationBeanPostProcessor;
import infra.beans.factory.config.DestructionAwareBeanPostProcessor;
import infra.beans.factory.support.MergedBeanDefinitionPostProcessor;
import infra.beans.factory.support.RootBeanDefinition;
import infra.context.ApplicationListener;
import infra.context.event.ApplicationEventMulticaster;
import infra.logging.Logger;
import infra.logging.LoggerFactory;
import infra.util.ObjectUtils;

/**
 * {@code BeanPostProcessor} that detects beans which implement the {@code ApplicationListener}
 * interface. This catches beans that can't reliably be detected by {@code getBeanNamesForType}
 * and related operations which only work against top-level beans.
 *
 * <p>With standard Java serialization, this post-processor won't get serialized as part of
 * {@code DisposableBeanAdapter} to begin with. However, with alternative serialization
 * mechanisms, {@code DisposableBeanAdapter.writeReplace} might not get used at all, so we
 * defensively mark this post-processor's field state as {@code transient}.
 *
 * @author Juergen Hoeller
 * @author <a href="https://github.com/TAKETODAY">Harry Yang</a>
 * @since 4.0
 */
final class ApplicationListenerDetector
        implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, InitializationBeanPostProcessor {

  private static final Logger logger = LoggerFactory.getLogger(ApplicationListenerDetector.class);

  private final transient AbstractApplicationContext applicationContext;

  private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);

  ApplicationListenerDetector(AbstractApplicationContext applicationContext) {
    this.applicationContext = applicationContext;
  }

  @Override
  public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    if (ApplicationListener.class.isAssignableFrom(beanType)) {
      this.singletonNames.put(beanName, beanDefinition.isSingleton());
    }
  }

  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
  }

  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) {
    // FIXME 优化 singletonNames
    if (bean instanceof ApplicationListener) {
      // potentially not detected as a listener by getBeanNamesForType retrieval
      Boolean flag = singletonNames.get(beanName);
      if (Boolean.TRUE.equals(flag)) {
        // singleton bean (top-level or inner): register on the fly
        applicationContext.addApplicationListener((ApplicationListener<?>) bean);
      }
      else if (Boolean.FALSE.equals(flag)) {
        if (logger.isWarnEnabled() && !applicationContext.containsBean(beanName)) {
          // inner bean with other scope - can't reliably process events
          logger.warn("Inner bean '{}' implements ApplicationListener interface " +
                  "but is not reachable for event multicasting by its containing ApplicationContext " +
                  "because it does not have singleton scope. Only top-level listener beans are allowed " +
                  "to be of non-singleton scope.", beanName);
        }
        singletonNames.remove(beanName);
      }
    }
    return bean;
  }

  @Override
  public void postProcessBeforeDestruction(Object bean, String beanName) {
    if (bean instanceof ApplicationListener) {
      try {
        ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
        multicaster.removeApplicationListener((ApplicationListener<?>) bean);
        multicaster.removeApplicationListenerBean(beanName);
      }
      catch (IllegalStateException ex) {
        // ApplicationEventMulticaster not initialized yet - no need to remove a listener
      }
    }
  }

  @Override
  public boolean requiresDestruction(Object bean) {
    return (bean instanceof ApplicationListener);
  }

  @Override
  public boolean equals(@Nullable Object other) {
    return (this == other || (other instanceof ApplicationListenerDetector &&
            this.applicationContext == ((ApplicationListenerDetector) other).applicationContext));
  }

  @Override
  public int hashCode() {
    return ObjectUtils.nullSafeHashCode(this.applicationContext);
  }

}

1	/*
2	* Copyright 2017 - 2025 the original author or authors.
3	*
4	* This program is free software: you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation, either version 3 of the License, or
7	* (at your option) any later version.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program. If not, see [https://www.gnu.org/licenses/]
16	*/
17
18	package infra.context.support;
19
20	import org.jspecify.annotations.Nullable;
21
22	import java.util.Map;
23	import java.util.concurrent.ConcurrentHashMap;
24
25	import infra.beans.factory.InitializationBeanPostProcessor;
26	import infra.beans.factory.config.DestructionAwareBeanPostProcessor;
27	import infra.beans.factory.support.MergedBeanDefinitionPostProcessor;
28	import infra.beans.factory.support.RootBeanDefinition;
29	import infra.context.ApplicationListener;
30	import infra.context.event.ApplicationEventMulticaster;
31	import infra.logging.Logger;
32	import infra.logging.LoggerFactory;
33	import infra.util.ObjectUtils;
34
35	/**
36	* {@code BeanPostProcessor} that detects beans which implement the {@code ApplicationListener}
37	* interface. This catches beans that can't reliably be detected by {@code getBeanNamesForType}
38	* and related operations which only work against top-level beans.
39	*
40	* <p>With standard Java serialization, this post-processor won't get serialized as part of
41	* {@code DisposableBeanAdapter} to begin with. However, with alternative serialization
42	* mechanisms, {@code DisposableBeanAdapter.writeReplace} might not get used at all, so we
43	* defensively mark this post-processor's field state as {@code transient}.
44	*
45	* @author Juergen Hoeller
46	* @author <a href="https://github.com/TAKETODAY">Harry Yang</a>
47	* @since 4.0
48	*/
49	final class ApplicationListenerDetector
50	implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, InitializationBeanPostProcessor {
51
52	private static final Logger logger = LoggerFactory.getLogger(ApplicationListenerDetector.class);	4✔
53
54	private final transient AbstractApplicationContext applicationContext;
55
56	private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);	6✔
57
58	ApplicationListenerDetector(AbstractApplicationContext applicationContext) {	2✔
59	this.applicationContext = applicationContext;	3✔
60	}	1✔
61
62	@Override
63	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
64	if (ApplicationListener.class.isAssignableFrom(beanType)) {	4✔
65	this.singletonNames.put(beanName, beanDefinition.isSingleton());	8✔
66	}
67	}	1✔
68
69	@Override
70	public Object postProcessBeforeInitialization(Object bean, String beanName) {
71	return bean;	2✔
72	}
73
74	@Override
75	public Object postProcessAfterInitialization(Object bean, String beanName) {
76	// FIXME 优化 singletonNames
77	if (bean instanceof ApplicationListener) {	3✔
78	// potentially not detected as a listener by getBeanNamesForType retrieval
79	Boolean flag = singletonNames.get(beanName);	6✔
80	if (Boolean.TRUE.equals(flag)) {	4✔
81	// singleton bean (top-level or inner): register on the fly
82	applicationContext.addApplicationListener((ApplicationListener<?>) bean);	6✔
83	}
84	else if (Boolean.FALSE.equals(flag)) {	4✔
85	if (logger.isWarnEnabled() && !applicationContext.containsBean(beanName)) {	3!
86	// inner bean with other scope - can't reliably process events
87	logger.warn("Inner bean '{}' implements ApplicationListener interface " +	×
88	"but is not reachable for event multicasting by its containing ApplicationContext " +
89	"because it does not have singleton scope. Only top-level listener beans are allowed " +
90	"to be of non-singleton scope.", beanName);
91	}
92	singletonNames.remove(beanName);	5✔
93	}
94	}
95	return bean;	2✔
96	}
97
98	@Override
99	public void postProcessBeforeDestruction(Object bean, String beanName) {
100	if (bean instanceof ApplicationListener) {	3!
101	try {
102	ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();	4✔
103	multicaster.removeApplicationListener((ApplicationListener<?>) bean);	4✔
104	multicaster.removeApplicationListenerBean(beanName);	3✔
105	}
106	catch (IllegalStateException ex) {	×
107	// ApplicationEventMulticaster not initialized yet - no need to remove a listener
108	}	1✔
109	}
110	}	1✔
111
112	@Override
113	public boolean requiresDestruction(Object bean) {
114	return (bean instanceof ApplicationListener);	3✔
115	}
116
117	@Override
118	public boolean equals(@Nullable Object other) {
119	return (this == other \|\| (other instanceof ApplicationListenerDetector &&	16!
120	this.applicationContext == ((ApplicationListenerDetector) other).applicationContext));
121	}
122
123	@Override
124	public int hashCode() {
125	return ObjectUtils.nullSafeHashCode(this.applicationContext);	×
126	}
127
128	}

TAKETODAY / today-infrastructure / 18154768944

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous