Spring有一些你可以处理的标准事件。

为此，您必须创建并注册一个实现ApplicationListener接口的bean，类似于以下内容：

package test.pack.age;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
public class ApplicationListenerBean implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ContextRefreshedEvent) {
            ApplicationContext applicationContext = ((ContextRefreshedEvent) event).getApplicationContext();
            // now you can do applicationContext.getBean(...)
            // ...
        }
    }
}

然后在servlet.xml或applicationContext.xml文件中注册此bean：

<bean id="eventListenerBean" class="test.pack.age.ApplicationListenerBean" />

Spring会在application context初始化时通知它。
在Spring 3中（如果你使用的是这个版本），ApplicationListener class is generic和你可以声明你感兴趣的事件类型，事件将被相应地过滤。你可以像这样简化你的bean代码：

public class ApplicationListenerBean implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        ApplicationContext applicationContext = event.getApplicationContext();
        // now you can do applicationContext.getBean(...)
        // ...
    }
}

从Spring 4.2开始，您可以使用@EventListener（documentation）

@Component
class MyClassWithEventListeners {
    @EventListener({ContextRefreshedEvent.class})
    void contextRefreshedEvent() {
        System.out.println("a context refreshed event happened");
    }
}

创建注解

@Retention(RetentionPolicy.RUNTIME)
    public @interface AfterSpringLoadComplete {
    }

创建类

public class PostProxyInvokerContextListener implements ApplicationListener<ContextRefreshedEvent> {
    @Autowired
    ConfigurableListableBeanFactory factory;
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        ApplicationContext context = event.getApplicationContext();
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            try {
                BeanDefinition definition = factory.getBeanDefinition(name);
                String originalClassName = definition.getBeanClassName();
                Class<?> originalClass = Class.forName(originalClassName);
                Method[] methods = originalClass.getMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(AfterSpringLoadComplete.class)){
                        Object bean = context.getBean(name);
                        Method currentMethod = bean.getClass().getMethod(method.getName(), method.getParameterTypes());
                        currentMethod.invoke(bean);
                    }
                }
            } catch (Exception ignored) {
            }
        }
    }
}

通过@Component注解或在xml中注册该类

<bean class="ua.adeptius.PostProxyInvokerContextListener"/>

并在你想要的任何方法上使用注解，你想在上下文初始化后运行，比如：

@AfterSpringLoadComplete
    public void init() {}

请按照下面的步骤做一些处理后，应用程序上下文得到加载，即应用程序准备服务。
1.创建以下注解，即
@Retention（RetentionPolicy.RUNTIME）@Target（value= {ElementType.METHOD，ElementType.TYPE}）public @interface AfterApplicationReady {}
2.创建下面的类，这是一个监听器，它在应用程序就绪状态下获得调用。

@Component
    public class PostApplicationReadyListener implements ApplicationListener<ApplicationReadyEvent> {
    public static final Logger LOGGER = LoggerFactory.getLogger(PostApplicationReadyListener.class);
    public static final String MODULE = PostApplicationReadyListener.class.getSimpleName();
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        try {
            ApplicationContext context = event.getApplicationContext();
            String[] beans = context.getBeanNamesForAnnotation(AfterAppStarted.class);
            LOGGER.info("bean found with AfterAppStarted annotation are : {}", Arrays.toString(beans));
            for (String beanName : beans) {
                Object bean = context.getBean(beanName);
                Class<?> targetClass = AopUtils.getTargetClass(bean);
                Method[] methods = targetClass.getMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(AfterAppStartedComplete.class)) {
                        LOGGER.info("Method:[{} of Bean:{}] found with AfterAppStartedComplete Annotation.", method.getName(), beanName);
                        Method currentMethod = bean.getClass().getMethod(method.getName(), method.getParameterTypes());
                        LOGGER.info("Going to invoke method:{} of bean:{}", method.getName(), beanName);
                        currentMethod.invoke(bean);
                        LOGGER.info("Invocation compeleted method:{} of bean:{}", method.getName(), beanName);
                    }
                }
            }
        } catch (Exception e) {
            LOGGER.warn("Exception occured : ", e);
        }
    }
}

最后，当你启动你的Spring应用程序，就在log声明应用程序启动之前，你的监听器将被调用。

我有一个单页应用程序在输入URL时，它正在创建一个HashMap（由我的网页使用），其中包含来自多个数据库的数据。我在服务器启动时做了以下事情来加载所有内容-
1-已创建ContextListenerClass

public class MyAppContextListener implements ServletContextListener
    @Autowired
    private  MyDataProviderBean myDataProviderBean; 
    public MyDataProviderBean getMyDataProviderBean() {
        return MyDataProviderBean;
    }
    public void setMyDataProviderBean(MyDataProviderBean MyDataProviderBean) {
        this.myDataProviderBean = MyDataProviderBean;
    }
    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        System.out.println("ServletContextListener destroyed");
    }
    @Override
    public void contextInitialized(ServletContextEvent context) {
        System.out.println("ServletContextListener started");
        ServletContext sc = context.getServletContext();
        WebApplicationContext springContext = WebApplicationContextUtils.getWebApplicationContext(sc);
        MyDataProviderBean MyDataProviderBean = (MyDataProviderBean)springContext.getBean("myDataProviderBean");
        Map<String, Object> myDataMap = MyDataProviderBean.getDataMap();
        sc.setAttribute("myMap", myDataMap);
    }

2-在web.xml中添加以下条目

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
<listener>
    <listener-class>com.context.listener.MyAppContextListener</listener-class>
</listener>

3-在我的控制器类中，更新了代码，以首先检查servletContext中的Map

@RequestMapping(value = "/index", method = RequestMethod.GET)
        public String index(@ModelAttribute("model") ModelMap model) {
            Map<String, Object> myDataMap = new HashMap<String, Object>();
            if (context != null && context.getAttribute("myMap")!=null)
            {
                myDataMap=(Map<String, Object>)context.getAttribute("myMap");
            }
            else
            {
                myDataMap = myDataProviderBean.getDataMap();
            }
            for (String key : myDataMap.keySet())
            {
                model.addAttribute(key, myDataMap.get(key));
            }
            return "myWebPage";
        }

有了这么多的变化，当我启动我的tomcat时，它在startTime期间加载dataMap，并将所有内容放入servletContext中，然后由Controller Class使用，以从已经填充的servletContext中获取结果。

您的bean还可以实现SmartInitializingSingleton.afterSingletonsInstantiated（）。这是Spring文档（v 6.0.12）中列出的可能性之一：https://docs.spring.io/spring-framework/reference/core/beans/factory-nature.html#beans-factory-lifecycle-initializingbean
请注意，@PostConstruct和初始化方法通常在容器的单例创建锁中执行。bean示例只有在从@PostConstruct方法返回后才被视为完全初始化并准备好发布给其他人。这些单独的初始化方法仅用于验证配置状态，并可能基于给定的配置准备一些数据结构，但不用于外部bean访问的进一步活动。否则，存在初始化死锁的风险。
对于要触发昂贵的初始化后活动的场景，例如异步数据库准备步骤，您的bean应该实现SmartInitializingSingleton.afterSingletonsInstantiated（）或依赖于上下文刷新事件：实现ApplicationException或声明其注解等效项@ EventException（ContextRefreshedEvent.class）。这些变体在所有常规单例初始化之后出现，因此在任何单例创建锁之外。
或者，您可以实现（智能）生命周期接口并与容器的整体生命周期管理集成，包括自动启动机制，预销毁停止步骤和潜在的停止/重新启动回调（见下文）。