/* * Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.util;/** * 
 * The root class from which all event state objects shall be derived. * 
 * All Events are constructed with a reference to the object, the "source", * that is logically deemed to be the object upon which the Event in question * initially occurred upon. * * @since JDK1.1 */public class EventObject implements java.io.Serializable {    private static final long serialVersionUID = 5516075349620653480L;    /**     * The object on which the Event initially occurred.     */    protected transient Object  source;    /**     * Constructs a prototypical Event.     *     * @param    source    The object on which the Event initially occurred.     * @exception  IllegalArgumentException  if source is null.     */    public EventObject(Object source) {        if (source == null)            throw new IllegalArgumentException("null source");        this.source = source;    }    /**     * The object on which the Event initially occurred.     *     * @return   The object on which the Event initially occurred.     */    public Object getSource() {        return source;    }    /**     * Returns a String representation of this EventObject.     *     * @return  A a String representation of this EventObject.     */    public String toString() {        return getClass().getName() + "[source=" + source + "]";    }}

/* * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.awt.event;import java.util.EventListener;/** * The listener interface for receiving "interesting" mouse events * (press, release, click, enter, and exit) on a component. * (To track mouse moves and mouse drags, use the * MouseMotionListener.) * 
 * The class that is interested in processing a mouse event * either implements this interface (and all the methods it * contains) or extends the abstract MouseAdapter class * (overriding only the methods of interest). * 
 * The listener object created from that class is then registered with a * component using the component's addMouseListener * method. A mouse event is generated when the mouse is pressed, released * clicked (pressed and released). A mouse event is also generated when * the mouse cursor enters or leaves a component. When a mouse event * occurs, the relevant method in the listener object is invoked, and * the MouseEvent is passed to it. * * @author Carl Quinn * * @see MouseAdapter * @see MouseEvent * @see Tutorial: Writing a Mouse Listener * * @since 1.1 */public interface MouseListener extends EventListener {    /**     * Invoked when the mouse button has been clicked (pressed     * and released) on a component.     */    public void mouseClicked(MouseEvent e);    /**     * Invoked when a mouse button has been pressed on a component.     */    public void mousePressed(MouseEvent e);    /**     * Invoked when a mouse button has been released on a component.     */    public void mouseReleased(MouseEvent e);    /**     * Invoked when the mouse enters a component.     */    public void mouseEntered(MouseEvent e);    /**     * Invoked when the mouse exits a component.     */    public void mouseExited(MouseEvent e);}

/* * Copyright 2002-2015 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.context;import java.util.EventObject;/** * Class to be extended by all application events. Abstract as it * doesn't make sense for generic events to be published directly. * * @author Rod Johnson * @author Juergen Hoeller */public abstract class ApplicationEvent extends EventObject {    /** use serialVersionUID from Spring 1.2 for interoperability */    private static final long serialVersionUID = 7099057708183571937L;    /** System time when the event happened */    private final long timestamp;    /**     * Create a new ApplicationEvent.     * @param source the object on which the event initially occurred (never {
     @code null})     */    public ApplicationEvent(Object source) {        super(source);        this.timestamp = System.currentTimeMillis();    }    /**     * Return the system time in milliseconds when the event happened.     */    public final long getTimestamp() {        return this.timestamp;    }}

/* * Copyright 2002-2015 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.context;import java.util.EventListener;/** * Interface to be implemented by application event listeners. * Based on the standard {
     @code java.util.EventListener} interface * for the Observer design pattern. * * 
As of Spring 3.0, an ApplicationListener can generically declare the event type * that it is interested in. When registered with a Spring ApplicationContext, events * will be filtered accordingly, with the listener getting invoked for matching event * objects only. * * @author Rod Johnson * @author Juergen Hoeller * @param 
       
         the specific ApplicationEvent subclass to listen to * @see org.springframework.context.event.ApplicationEventMulticaster */public interface ApplicationListener
        
          extends EventListener {    /**     * Handle an application event.     * @param event the event to respond to     */    void onApplicationEvent(E event);}
        
       

/* * Copyright 2002-2015 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.context;/** * Interface that encapsulates event publication functionality. * Serves as super-interface for {
     @link ApplicationContext}. * * @author Juergen Hoeller * @author Stephane Nicoll * @since 1.1.1 * @see ApplicationContext * @see ApplicationEventPublisherAware * @see org.springframework.context.ApplicationEvent * @see org.springframework.context.event.EventPublicationInterceptor */public interface ApplicationEventPublisher {    /**     * Notify all matching listeners registered with this     * application of an application event. Events may be framework events     * (such as RequestHandledEvent) or application-specific events.     * @param event the event to publish     * @see org.springframework.web.context.support.RequestHandledEvent     */    void publishEvent(ApplicationEvent event);    /**     * Notify all matching listeners registered with this     * application of an event.     * 
If the specified {
     @code event} is not an {
     @link ApplicationEvent},     * it is wrapped in a {
     @link PayloadApplicationEvent}.     * @param event the event to publish     * @since 4.2     * @see PayloadApplicationEvent     */    void publishEvent(Object event);}

/* * Copyright 2002-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.context.event;import org.springframework.context.ApplicationEvent;import org.springframework.context.ApplicationListener;import org.springframework.core.ResolvableType;/** * Interface to be implemented by objects that can manage a number of * {
     @link ApplicationListener} objects, and publish events to them. * * 
An {
     @link org.springframework.context.ApplicationEventPublisher}, typically * a Spring {
     @link org.springframework.context.ApplicationContext}, can use an * ApplicationEventMulticaster as a delegate for actually publishing events. * * @author Rod Johnson * @author Juergen Hoeller * @author Stephane Nicoll */public interface ApplicationEventMulticaster {    /**     * Add a listener to be notified of all events.     * @param listener the listener to add     */    void addApplicationListener(ApplicationListener
        listener);    /**     * Add a listener bean to be notified of all events.     * @param listenerBeanName the name of the listener bean to add     */    void addApplicationListenerBean(String listenerBeanName);    /**     * Remove a listener from the notification list.     * @param listener the listener to remove     */    void removeApplicationListener(ApplicationListener
        listener);    /**     * Remove a listener bean from the notification list.     * @param listenerBeanName the name of the listener bean to add     */    void removeApplicationListenerBean(String listenerBeanName);    /**     * Remove all listeners registered with this multicaster.     * 
After a remove call, the multicaster will perform no action     * on event notification until new listeners are being registered.     */    void removeAllListeners();    /**     * Multicast the given application event to appropriate listeners.     * 
Consider using {
     @link #multicastEvent(ApplicationEvent, ResolvableType)}     * if possible as it provides a better support for generics-based events.     * @param event the event to multicast     */    void multicastEvent(ApplicationEvent event);    /**     * Multicast the given application event to appropriate listeners.     * 
If the {
     @code eventType} is {
     @code null}, a default type is built     * based on the {
     @code event} instance.     * @param event the event to multicast     * @param eventType the type of event (can be null)     * @since 4.2     */    void multicastEvent(ApplicationEvent event, ResolvableType eventType);}

/* * Copyright 2002-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.context.event;import java.util.concurrent.Executor;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.beans.factory.BeanFactory;import org.springframework.context.ApplicationEvent;import org.springframework.context.ApplicationListener;import org.springframework.core.ResolvableType;import org.springframework.util.ErrorHandler;/** * Simple implementation of the {
     @link ApplicationEventMulticaster} interface. * * 
Multicasts all events to all registered listeners, leaving it up to * the listeners to ignore events that they are not interested in. * Listeners will usually perform corresponding {
     @code instanceof} * checks on the passed-in event object. * * 
By default, all listeners are invoked in the calling thread. * This allows the danger of a rogue listener blocking the entire application, * but adds minimal overhead. Specify an alternative task executor to have * listeners executed in different threads, for example from a thread pool. * * @author Rod Johnson * @author Juergen Hoeller * @author Stephane Nicoll * @see #setTaskExecutor */public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {    private Executor taskExecutor;    private ErrorHandler errorHandler;    /**     * Create a new SimpleApplicationEventMulticaster.     */    public SimpleApplicationEventMulticaster() {    }    /**     * Create a new SimpleApplicationEventMulticaster for the given BeanFactory.     */    public SimpleApplicationEventMulticaster(BeanFactory beanFactory) {        setBeanFactory(beanFactory);    }    /**     * Set a custom executor (typically a {
     @link org.springframework.core.task.TaskExecutor})     * to invoke each listener with.     * 
Default is equivalent to {
     @link org.springframework.core.task.SyncTaskExecutor},     * executing all listeners synchronously in the calling thread.     * 
Consider specifying an asynchronous task executor here to not block the     * caller until all listeners have been executed. However, note that asynchronous     * execution will not participate in the caller's thread context (class loader,     * transaction association) unless the TaskExecutor explicitly supports this.     * @see org.springframework.core.task.SyncTaskExecutor     * @see org.springframework.core.task.SimpleAsyncTaskExecutor     */    public void setTaskExecutor(Executor taskExecutor) {        this.taskExecutor = taskExecutor;    }    /**     * Return the current task executor for this multicaster.     */    protected Executor getTaskExecutor() {        return this.taskExecutor;    }    /**     * Set the {
     @link ErrorHandler} to invoke in case an exception is thrown     * from a listener.     * 
Default is none, with a listener exception stopping the current     * multicast and getting propagated to the publisher of the current event.     * If a {
     @linkplain #setTaskExecutor task executor} is specified, each     * individual listener exception will get propagated to the executor but     * won't necessarily stop execution of other listeners.     * 
Consider setting an {
     @link ErrorHandler} implementation that catches     * and logs exceptions (a la     * {
     @link org.springframework.scheduling.support.TaskUtils#LOG_AND_SUPPRESS_ERROR_HANDLER})     * or an implementation that logs exceptions while nevertheless propagating them     * (e.g. {
     @link org.springframework.scheduling.support.TaskUtils#LOG_AND_PROPAGATE_ERROR_HANDLER}).     * @since 4.1     */    public void setErrorHandler(ErrorHandler errorHandler) {        this.errorHandler = errorHandler;    }    /**     * Return the current error handler for this multicaster.     * @since 4.1     */    protected ErrorHandler getErrorHandler() {        return this.errorHandler;    }    @Override    public void multicastEvent(ApplicationEvent event) {        multicastEvent(event, resolveDefaultEventType(event));    }    @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) {                executor.execute(new Runnable() {                    @Override                    public void run() {                        invokeListener(listener, event);                    }                });            }            else {                invokeListener(listener, event);            }        }    }    private ResolvableType resolveDefaultEventType(ApplicationEvent event) {        return ResolvableType.forInstance(event);    }    /**     * Invoke the given listener with the given event.     * @param listener the ApplicationListener to invoke     * @param event the current event to propagate     * @since 4.1     */    protected void invokeListener(ApplicationListener
        listener, ApplicationEvent event) {        ErrorHandler errorHandler = getErrorHandler();        if (errorHandler != null) {            try {                doInvokeListener(listener, event);            }            catch (Throwable err) {                errorHandler.handleError(err);            }        }        else {            doInvokeListener(listener, event);        }    }    @SuppressWarnings({
     "unchecked", "rawtypes"})    private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {        try {            listener.onApplicationEvent(event);        }        catch (ClassCastException ex) {            String msg = ex.getMessage();            if (msg == null || msg.startsWith(event.getClass().getName())) {                // Possibly a lambda-defined listener which we could not resolve the generic event type for                Log logger = LogFactory.getLog(getClass());                if (logger.isDebugEnabled()) {                    logger.debug("Non-matching event type for listener: " + listener, ex);                }            }            else {                throw ex;            }        }    }}

package org.hzgj.spring.study.event;import org.springframework.context.ApplicationEvent;/** * 定义一个描饥饿状态的事件 * * @author chen.nie * @date 2018/4/26 **/public class HungryEvent extends ApplicationEvent {    /**     * Create a new ApplicationEvent.     *     * @param source the object on which the event initially occurred (never {
     @code null})     */    public HungryEvent(Object source) {        super(source);    }}

package org.hzgj.spring.study.event;import org.springframework.context.ApplicationEventPublisher;import org.springframework.context.ApplicationEventPublisherAware;import org.springframework.stereotype.Component;/** * Person类，如果属性hungry的值为0，则通知厨师做饭吃。 */@Componentpublic class Person implements ApplicationEventPublisherAware {    private int hungry;    private String name;    public int getHungry() {        return hungry;    }    public void setHungry(int hungry) {        this.hungry = hungry;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    private ApplicationEventPublisher applicationEventPublisher;    @Override    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {        this.applicationEventPublisher = applicationEventPublisher;    }    public void isNeedEat() {        if (this.hungry == 0) {            System.out.println("太饿了,需要吃东西");            new Thread(() -> this.applicationEventPublisher.publishEvent(new HungryEvent(this))).start();            System.out.println("通知完毕");        }    }}

package org.hzgj.spring.study.event;import org.springframework.context.ApplicationListener;import org.springframework.stereotype.Component;/** * 厨师类用于对饥饿事件的监听... * * @author chen.nie * @date 2018/4/26 **/@Componentpublic class Chef implements ApplicationListener
      
        {    @Override    public void onApplicationEvent(HungryEvent event) {        if (event.getSource() instanceof Person) {            Person person = (Person) event.getSource();            System.out.println(person.getName() + "饿了,开始做饭");            try {                Thread.sleep(2000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("做饭完毕....开始吃吧");        }    }}
      

package org.hzgj.spring.study;import org.hzgj.spring.study.event.Person;import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.naming.NamingException;import java.io.IOException;public class Main {    public static void main(String[] args) throws IOException, NamingException {        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");        Person person = applicationContext.getBean(Person.class);        person.setHungry(0);        person.setName("admin");        person.isNeedEat();    }}

/* * Copyright 2002-2016 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.core.io.support;import java.io.IOException;import java.lang.reflect.Constructor;import java.net.URL;import java.util.ArrayList;import java.util.Arrays;import java.util.Enumeration;import java.util.List;import java.util.Properties;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.core.annotation.AnnotationAwareOrderComparator;import org.springframework.core.io.UrlResource;import org.springframework.util.Assert;import org.springframework.util.ClassUtils;import org.springframework.util.ReflectionUtils;import org.springframework.util.StringUtils;/** * General purpose factory loading mechanism for internal use within the framework. * * 
{
     @code SpringFactoriesLoader} {
     @linkplain #loadFactories loads} and instantiates * factories of a given type from {
     @value #FACTORIES_RESOURCE_LOCATION} files which * may be present in multiple JAR files in the classpath. The {
     @code spring.factories} * file must be in {
     @link Properties} format, where the key is the fully qualified * name of the interface or abstract class, and the value is a comma-separated list of * implementation class names. For example: * * 
example.MyService=example.MyServiceImpl1,example.MyServiceImpl2
 * * where {
     @code example.MyService} is the name of the interface, and {
     @code MyServiceImpl1} * and {
     @code MyServiceImpl2} are two implementations. * * @author Arjen Poutsma * @author Juergen Hoeller * @author Sam Brannen * @since 3.2 */public abstract class SpringFactoriesLoader {    private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);    /**     * The location to look for factories.     * 
Can be present in multiple JAR files.     */    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";    /**     * Load and instantiate the factory implementations of the given type from     * {
     @value #FACTORIES_RESOURCE_LOCATION}, using the given class loader.     * 
The returned factories are sorted in accordance with the {
     @link AnnotationAwareOrderComparator}.     * 
If a custom instantiation strategy is required, use {
     @link #loadFactoryNames}     * to obtain all registered factory names.     * @param factoryClass the interface or abstract class representing the factory     * @param classLoader the ClassLoader to use for loading (can be {
     @code null} to use the default)     * @see #loadFactoryNames     * @throws IllegalArgumentException if any factory implementation class cannot     * be loaded or if an error occurs while instantiating any factory     */    public static 
       
         List
        
          loadFactories(Class
         
           factoryClass, ClassLoader classLoader) {        Assert.notNull(factoryClass, "'factoryClass' must not be null");        ClassLoader classLoaderToUse = classLoader;        if (classLoaderToUse == null) {            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();        }        List
          
            factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);        if (logger.isTraceEnabled()) {            logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);        }        List
           
             result = new ArrayList
            
             (factoryNames.size()); for (String factoryName : factoryNames) { result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse)); } AnnotationAwareOrderComparator.sort(result); return result; } /** * Load the fully qualified class names of factory implementations of the * given type from { @value #FACTORIES_RESOURCE_LOCATION}, using the given * class loader. * @param factoryClass the interface or abstract class representing the factory * @param classLoader the ClassLoader to use for loading resources; can be * { @code null} to use the default * @see #loadFactories * @throws IllegalArgumentException if an error occurs while loading factory names */ public static List
             
               loadFactoryNames(Class
               factoryClass, ClassLoader classLoader) { String factoryClassName = factoryClass.getName(); try { Enumeration
              
                urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION)); List
               
                 result = new ArrayList
                
                 (); while (urls.hasMoreElements()) { URL url = urls.nextElement(); Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url)); String factoryClassNames = properties.getProperty(factoryClassName); result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames))); } return result; } catch (IOException ex) { throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() + "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex); } } @SuppressWarnings("unchecked") private static 
                 
                   T instantiateFactory(String instanceClassName, Class
                  
                    factoryClass, ClassLoader classLoader) { try { Class
                    instanceClass = ClassUtils.forName(instanceClassName, classLoader); if (!factoryClass.isAssignableFrom(instanceClass)) { throw new IllegalArgumentException( "Class [" + instanceClassName + "] is not assignable to [" + factoryClass.getName() + "]"); } Constructor
                    constructor = instanceClass.getDeclaredConstructor(); ReflectionUtils.makeAccessible(constructor); return (T) constructor.newInstance(); } catch (Throwable ex) { throw new IllegalArgumentException("Unable to instantiate factory class: " + factoryClass.getName(), ex); } }}
                  
                 
                
               
              
             
            
           
          
         
        
       

/* * Copyright 2002-2011 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.context;/** * Callback interface for initializing a Spring {
     @link ConfigurableApplicationContext} * prior to being {
     @linkplain ConfigurableApplicationContext#refresh() refreshed}. * * 
Typically used within web applications that require some programmatic initialization * of the application context. For example, registering property sources or activating * profiles against the {
     @linkplain ConfigurableApplicationContext#getEnvironment() * context's environment}. See {
     @code ContextLoader} and {
     @code FrameworkServlet} support * for declaring a "contextInitializerClasses" context-param and init-param, respectively. * * 
{
     @code ApplicationContextInitializer} processors are encouraged to detect * whether Spring's {
     @link org.springframework.core.Ordered Ordered} interface has been * implemented or if the @{
     @link org.springframework.core.annotation.Order Order} * annotation is present and to sort instances accordingly if so prior to invocation. * * @author Chris Beams * @since 3.1 * @see org.springframework.web.context.ContextLoader#customizeContext * @see org.springframework.web.context.ContextLoader#CONTEXT_INITIALIZER_CLASSES_PARAM * @see org.springframework.web.servlet.FrameworkServlet#setContextInitializerClasses * @see org.springframework.web.servlet.FrameworkServlet#applyInitializers */public interface ApplicationContextInitializer
       
         {    /**     * Initialize the given application context.     * @param applicationContext the application to configure     */    void initialize(C applicationContext);}
       

/* * Copyright 2012-2016 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.boot;import org.springframework.context.ApplicationContext;import org.springframework.context.ConfigurableApplicationContext;import org.springframework.core.env.ConfigurableEnvironment;import org.springframework.core.io.support.SpringFactoriesLoader;/** * Listener for the {
     @link SpringApplication} {
     @code run} method. * {
     @link SpringApplicationRunListener}s are loaded via the {
     @link SpringFactoriesLoader} * and should declare a public constructor that accepts a {
     @link SpringApplication} * instance and a {
     @code String[]} of arguments. A new * {
     @link SpringApplicationRunListener} instance will be created for each run. * * @author Phillip Webb * @author Dave Syer */public interface SpringApplicationRunListener {    /**     * Called immediately when the run method has first started. Can be used for very     * early initialization.     */    void starting();    /**     * Called once the environment has been prepared, but before the     * {
     @link ApplicationContext} has been created.     * @param environment the environment     */    void environmentPrepared(ConfigurableEnvironment environment);    /**     * Called once the {
     @link ApplicationContext} has been created and prepared, but     * before sources have been loaded.     * @param context the application context     */    void contextPrepared(ConfigurableApplicationContext context);    /**     * Called once the application context has been loaded but before it has been     * refreshed.     * @param context the application context     */    void contextLoaded(ConfigurableApplicationContext context);    /**     * Called immediately before the run method finishes.     * @param context the application context or null if a failure occurred before the     * context was created     * @param exception any run exception or null if run completed successfully.     */    void finished(ConfigurableApplicationContext context, Throwable exception);}

/* * Copyright 2012-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.boot.context.event;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.boot.SpringApplication;import org.springframework.boot.SpringApplicationRunListener;import org.springframework.context.ApplicationContextAware;import org.springframework.context.ApplicationListener;import org.springframework.context.ConfigurableApplicationContext;import org.springframework.context.event.ApplicationEventMulticaster;import org.springframework.context.event.SimpleApplicationEventMulticaster;import org.springframework.context.support.AbstractApplicationContext;import org.springframework.core.Ordered;import org.springframework.core.env.ConfigurableEnvironment;import org.springframework.util.ErrorHandler;/** * {
     @link SpringApplicationRunListener} to publish {
     @link SpringApplicationEvent}s. * 
 * Uses an internal {
     @link ApplicationEventMulticaster} for the events that are fired * before the context is actually refreshed. * * @author Phillip Webb * @author Stephane Nicoll */public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {    private final SpringApplication application;    private final String[] args;    private final SimpleApplicationEventMulticaster initialMulticaster;    public EventPublishingRunListener(SpringApplication application, String[] args) {        this.application = application;        this.args = args;        this.initialMulticaster = new SimpleApplicationEventMulticaster();        for (ApplicationListener
        listener : application.getListeners()) {            this.initialMulticaster.addApplicationListener(listener);        }    }    @Override    public int getOrder() {        return 0;    }    @Override    @SuppressWarnings("deprecation")    public void starting() {        this.initialMulticaster                .multicastEvent(new ApplicationStartedEvent(this.application, this.args));    }    @Override    public void environmentPrepared(ConfigurableEnvironment environment) {        this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(                this.application, this.args, environment));    }    @Override    public void contextPrepared(ConfigurableApplicationContext context) {    }    @Override    public void contextLoaded(ConfigurableApplicationContext context) {        for (ApplicationListener
        listener : this.application.getListeners()) {            if (listener instanceof ApplicationContextAware) {                ((ApplicationContextAware) listener).setApplicationContext(context);            }            context.addApplicationListener(listener);        }        this.initialMulticaster.multicastEvent(                new ApplicationPreparedEvent(this.application, this.args, context));    }    @Override    public void finished(ConfigurableApplicationContext context, Throwable exception) {        SpringApplicationEvent event = getFinishedEvent(context, exception);        if (context != null && context.isActive()) {            // Listeners have been registered to the application context so we should            // use it at this point if we can            context.publishEvent(event);        }        else {            // An inactive context may not have a multicaster so we use our multicaster to            // call all of the context's listeners instead            if (context instanceof AbstractApplicationContext) {                for (ApplicationListener
        listener : ((AbstractApplicationContext) context)                        .getApplicationListeners()) {                    this.initialMulticaster.addApplicationListener(listener);                }            }            if (event instanceof ApplicationFailedEvent) {                this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());            }            this.initialMulticaster.multicastEvent(event);        }    }    private SpringApplicationEvent getFinishedEvent(            ConfigurableApplicationContext context, Throwable exception) {        if (exception != null) {            return new ApplicationFailedEvent(this.application, this.args, context,                    exception);        }        return new ApplicationReadyEvent(this.application, this.args, context);    }    private static class LoggingErrorHandler implements ErrorHandler {        private static Log logger = LogFactory.getLog(EventPublishingRunListener.class);        @Override        public void handleError(Throwable throwable) {            logger.warn("Error calling ApplicationEventListener", throwable);        }    }}

@Override    public void refresh() throws BeansException, IllegalStateException {        synchronized (this.startupShutdownMonitor) {            // Prepare this context for refreshing.            prepareRefresh();            // Tell the subclass to refresh the internal bean factory.            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();            // Prepare the bean factory for use in this context.            prepareBeanFactory(beanFactory);            try {                // Allows post-processing of the bean factory in context subclasses.                postProcessBeanFactory(beanFactory);                // Invoke factory processors registered as beans in the context.                invokeBeanFactoryPostProcessors(beanFactory);                // Register bean processors that intercept bean creation.                registerBeanPostProcessors(beanFactory);                // Initialize message source for this context.                initMessageSource();                // Initialize event multicaster for this context.                initApplicationEventMulticaster();                // Initialize other special beans in specific context subclasses.                onRefresh();                // Check for listener beans and register them.                registerListeners();                // Instantiate all remaining (non-lazy-init) singletons.                finishBeanFactoryInitialization(beanFactory);                // Last step: publish corresponding event.                finishRefresh();            }            catch (BeansException ex) {                if (logger.isWarnEnabled()) {                    logger.warn("Exception encountered during context initialization - " +                            "cancelling refresh attempt: " + ex);                }                // Destroy already created singletons to avoid dangling resources.                destroyBeans();                // Reset 'active' flag.                cancelRefresh(ex);                // Propagate exception to caller.                throw ex;            }            finally {                // Reset common introspection caches in Spring's core, since we                // might not ever need metadata for singleton beans anymore...                resetCommonCaches();            }        }    }

package com.hzgj.lyrk.member.applicationlistener;import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;import org.springframework.context.ApplicationListener;/** * META-INF/spring.factories 配置的listener测试* @author chen.nie* @date 2018/4/26**/public class MyBootStrapApplicationListener implements ApplicationListener
      
        {    @Override    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {        System.out.println("BootStrapApplicationListener");    }}
      

package com.hzgj.lyrk.member.commandlinerunner;import org.springframework.boot.CommandLineRunner;import org.springframework.stereotype.Component;/** * commandLineRunner测试 * * @author chen.nie * @date 2018/4/26 **/@Componentpublic class MyCommandRunner implements CommandLineRunner {    @Override    public void run(String... args) throws Exception {        System.out.println("MyCommandRunner execute .....");    }}