Take a look at the class diagram for the SmartLifecycle interface:

As shown in the figure above, After Lifecycle and Phased interfaces are inherited, SmartLifecycle defines a total of six methods. To facilitate the subsequent source code analysis, we will give a brief introduction:

The six methods of the full text of the main line: 1, to see how the six methods in the source code; 2. See how six methods implement SmartLifeCycle in a custom mock interface. How to simulate in simulation

As can be seen from the above listing, the ability to sense changes in the container will ultimately come from Lifecycle, and SmartLifecycle is just an enhanced version of Lifecycle. You can customize the priority (getPhase) and decide whether or not to start with the container (isAutoStartup). And the ability to accept a runnable object (stop(runnable)) when stopped;

Hands, refresh AbstractApplicationContext class method, in bean instantiation and after the initialization, can call finishRefresh method, shown in the diagram below the red box:

The initLifecycleProcessor method assigns a value to the applicationContext member variable lifecycleProcessor. If you already have a bean named “lifecycleProcessor”, LifecycleProcessor is equal to the bean, otherwise it instantiates a DefaultLifecycleProcessor object, let lifecycleProcessor is equal to this object, And register this object in the Spring environment (named “lifecycleProcessor”), source code is as follows:

protected void initLifecycleProcessor() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if(beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) { this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class); }}else{ DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor(); defaultProcessor.setBeanFactory(beanFactory); this.lifecycleProcessor = defaultProcessor; beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor); }}Copy the code

Goldfinger: initLifecycleProcessor()= Setup variable + register bean initLifecycleProcessor() each branch in initLifecycleProcessor() does two things: Setup variables lifecycleProcessor and objects to register to Spring (in fact, many places in Spring are initialized to do both things, set variables and register beans) (1) Spring IOC container already exists in the bean, directly set variables; (2) The bean does not exist in the Spring IOC container, set the variable and register the bean.

First, assign the defaultProcessor variable, and second, inject the defaultProcessor object into the Spring IOC container (BeanFactory and Application) : (1) If the Spring IOC container already has a bean named “lifecycleProcessor”, the lifecycleProcessor is equal to this bean. (2) If the Spring IOC container has a bean named “lifecycleProcessor”, the lifecycleProcessor is equal to this bean. Not instantiate a DefaultLifecycleProcessor object, let lifecycleProcessor is equal to this object, and the object to be registered to spring environment (called “lifecycleProcessor”)

Here, the LIFECYCLE_PROCESSOR_BEAN_NAME constant is the string “lifecycleProcessor”.



If the business is not a custom LifecycleProcessor, you create a DefaultLifecycleProcessor object by default

When you return, you return directly

The place where start for an instance of SmartLifecycle is called is inside the LifecycleGroup, and the corresponding method is doStart, as shown below, which takes precedence over dependent beans:

Priority depends on the bean is to point to: a String [] dependenciesForBean = enclosing the beanFactory. GetDependenciesForBean (beanName); for (String dependency : DependenciesForBean (doStart(lifecycleBeans, dependency, autoStartupOnly)) {$dependenciesForBean (lifecycleBeans, dependency, autoStartupOnly); }

private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
        Lifecycle bean = lifecycleBeans.remove(beanName);
        if(bean ! = null && ! this.equals(bean)) { String[] dependenciesForBean = this.beanFactory.getDependenciesForBean(beanName);for(String dependency : DependenciesForBean (doStart(lifecycleBeans, dependency, autoStartupOnly)) {$dependenciesForBean (lifecycleBeans, dependency, autoStartupOnly); } // return isRunningfalseSecond: cannot be an implementation class for SmartLifecycle. ** If SmartLifecycle is an implementation class, its isAutoStartup method must returntrue支那if(! bean.isRunning() && (! autoStartupOnly || ! (bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {if (logger.isDebugEnabled()) {
                    logger.debug("Starting bean '" + beanName + "' of type [" + bean.getClass() + "]"); } try { bean.start(); } catch (Throwable ex) { throw new ApplicationContextException; }}}}Copy the code

Summary: Spring container initialization for SmartLifecycle instance processing logic:

1. Lifecycle processing is delegated to LifecycleProcessor, so have this instance ready; (The first and second steps are the entry, and the third step is to prepare the instance, set the properties and inject the bean.)
2. Group all Lifecycle instances by phase; (Get the instance and group it, before and in the middle of Step 4 above)
3. Execute the start method of each Lifecycle object in turn, starting with the group with the smallest phase value; (After Step 4 above and Step 5 above)

Startup process:

AbstractApplicationContext class refresh () method — > refresh () in the finishRefresh () method — > finishRefresh getLifecycleProcessor in () ().onRefresh()–> startBeans() –> start() –> doStart() the entire process, which contains doStart() ‘s own recursive call

Closing process:

AbstractApplicationContext class doClose () – > DefaultLifecycleProcessor in the classonClose()— > DefaultLifecycleProcessor stopBeans in class () – > LifecycleGroup class the stop () – > DefaultLifecycleProcessor doStop in class () (including, DoStop () contains recursive calls.

Just notice a recursive call here to do the iterative work

Start from AbstractApplicationContext doClose () method: LifecycleProcessor onClose method is invoked in AbstractApplicationContext doClose method, shown in the diagram below the red box,(Goldfinger: doClose() brings together the basic logic to perform when a container is closed, many of which are here.) ：

Hammered out call logic, can visit the DefaultLifecycleProcessor SmartLifecycle instance how stop method is invoked;

Startup process:

AbstractApplicationContext class refresh () method — > refresh () in the finishRefresh () method — > finishRefresh getLifecycleProcessor in () ().onRefresh()–> startBeans() –> start() –> doStart() the entire process, which contains doStart() ‘s own recursive call

Closing process:

AbstractApplicationContext class doClose () – > DefaultLifecycleProcessor in the classonClose()— > DefaultLifecycleProcessor stopBeans in class () – > LifecycleGroup class the stop () – > DefaultLifecycleProcessor doStop in class () (including, DoStop () contains recursive calls.



CTRL + Alt +B to go to onClose()

Expand the stopBeans method: Similar to startBeans

The stopBeans() method is similar to the startBeans() method

private void stopBeansLifecycle <String, Lifecycle> lifecycleBeans = getLifecycleBeans(); Lifecycle <String, Lifecycle> lifecycleBeans (); Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();for(Map.Entry<String, Lifecycle> entry : lifecycleBeans.entrySet()) { Lifecycle bean = entry.getValue(); Int shutdownOrder = getPhase(bean); //SmartLifecycle instance will return via getPhase. LifecycleGroup group = phases.get(shutdownOrder);if (group == null) {
                group = new LifecycleGroup(shutdownOrder, this.timeoutPerShutdownPhase, lifecycleBeans, false); Lifecycle instance phases. Put (shutdownOrder, group); // Lifecycle instance Phases. } group.add(entry.getKey(), bean); }if(phases.size() > 0) { List<Integer> keys = new ArrayList<Integer>(phases.keySet()); Collections.sort(keys, collections.reverseOrder ()); // Collections.sort(keys, collections.reverseOrder ());for(Integer key: keys) {// For Lifecycle instances of the same phase, execute the stop method phase.get (key).stop(); }}}Copy the code

Goldfinger: This code is similar to the start logic, except that it is executed in the opposite order. This is why getLifecycleBeans() uses LinkedHashMap, which is called by startBeans() and stopBeans() at the same time

Finally take a look at the LifecycleGroup stop method which is called looping through Lifecycle’s stop method, which will actually call into Lifecycle’s stop method, as well as the multi-threaded logic we analyzed above:

private void doStop(Map<String, ? extends Lifecycle> lifecycleBeans, final String beanName, final CountDownLatch latch, Final Set<String> countDownBeanNames) {// Remove current bean from member variable lifecycleBeans, Lifecycle bean = lifecycleBeans.remove(beanName); Lifecycle bean = lifecycleBeans.remove(beanName);if(bean ! = null) {/ / find rely on beans, to ensure implementation depend on the bean to stop calling through the iteration method String [] dependentBeans = enclosing the beanFactory. GetDependentBeans (beanName);for(String dependentBean: dependentBeans) {// Iterate doStop(lifecycleBeans, dependentBean, latch, countDownBeanNames); } try {//isRunning returnstrueLifecycle will be executed so be careful when customizing Lifecycleif (bean.isRunning()) {
                    if (bean instanceof SmartLifecycle) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Asking bean '" + beanName + "' of type [" + bean.getClass() + "] to stop"); } countDownBeanNames.add(beanName); // Pass in the CountDownLatch (+ 1) logic so that a new thread can execute the logic in SmartLifecycle's stop method. Do not execute the logic in Runnable until the end of the process so that the main thread does not wait. ((SmartLifecycle) bean).stop(newRunnable() {
                            @Override
                            public void run() {
                                latch.countDown();
                                countDownBeanNames.remove(beanName);
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Bean '" + beanName + "' completed its stop procedure"); }}}); }else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Stopping bean '" + beanName + "' of type [" + bean.getClass() + "]"); } // If it is not a SmartLifecycle instance, stop is called and bean.stop() is executed in the current thread;if (logger.isDebugEnabled()) {
                            logger.debug("Successfully stopped bean '" + beanName + "'"); }}}else if(bean instanceof SmartLifecycle) {// The number of counters in CountDownLatch is calculated by the number of Instances of SmartLifecycle. If the count is not in the runing state, the stop method of the instance will not be called. Instead of waiting for the stop, the latch is reduced by one latch.countdown (); } } catch (Throwable ex) {if (logger.isWarnEnabled()) {
                    logger.warn("Failed to stop bean '" + beanName + "'", ex); }}}}Copy the code

LifecycleGroup has passed the Runnable to the implementation class when stop(Runnable) is called. Therefore, the implementation class should remember to execute the Runnable run method, otherwise it will cause the external call logic parameters are not prepared, affecting the execution of the calling thread;

This is the closing container phase of the SmartLifecycle instance processing logic, briefly summarized as follows:

1. AbstractApplicationContext doClose methods in closed containers when implemented, this call LifecycleProcessor onClose method, LifecycleProcessor is responsible for all instances of Lifecycle of closing operation; (Steps 1 and 2)
2. Group all Lifecycle instances by phase; (Between steps 3 and 4)
3. Execute the stop method on each Lifecycle object, starting with the group with the largest phase value; (After Step 4)
4. For each SmartLifecycle instance, if you want to execute in parallel to speed up the stop execution, you can use a new thread in the stop method to execute the stop business logic, but don’t forget to call the Runnable parameter run method to complete the main thread count and statistics. (Step 6 inside the doStop() method)
5. The main thread uses CountDownLatch and after calling the Stop method of the SmartLifecycle instance will wait until the count reaches the total number of SmartLifecycle instances or wait for a timeout, and then continue to execute backward. Latch.await (this.timeout, timeunit.milliseconds); Lifecycle will wait until all Lifecycle instances have executed.

Lifecycle is done when the container is started. Lifecycle is done when the container is closed.

Goldfinger: Close logic: from stopBeans()->stop()->doStop()

The above code is similar to the start logic, except that the order of execution is reversed. Enter stop() to check the stop logic:

Enter the doStop() method

Goldfinger: six methods, the full text of the core, the actual source code for six methods of processing, simulation of six methods of logic

For the 6 methods, just know where the actual call is and how the logic is written

The start() method is called in the source code as follows:

// LifecycleProcessor is the manager for all Lifecycle implementation classes and contains operations that will Lifecycle. Lifecycle implementation class start method getLifecycleProcessor().onrefresh ();Copy the code

These two lines of code initialize the LifecycleProcessor, then use it to call the start method of the Lifecycle implementation class, and finally use it to call the Stop method of the Lifecycle implementation class.

StartBeans – > start () – > doStart ()

The logic of the simulated isRunning() is the same as that of the actual isRunning()

@Override
    public boolean isRunning() {
        return isRunningFlag();
    }
Copy the code

Goldfinger: logic in doStop()

Two use locations are startBeans() and doStart()

Because SmartLifeCycle is a Phased,

So, execute ((Phased) bean).getPhase()

This is how SmartLifeCycle implements the Phased interface to sort start()

   @Override
    public int getPhase() {
        return 666;
    }
Copy the code

Where the stop() method is actually called: closes the custom relationship in the logic, and also calls the custom start() method when started

Copy SmartLifeCycle’s stop(Runnable Runnable) method (this.stop(); The callback. The run ())

Print a line, set the flag bit, and callback.run();

  @Override
    public void stop(Runnable callback) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                Utils.printTrack("do stop with callback param"); / / set tofalseSetRunningFlag (false); Callback has CountDownLatch instances. The total number of SmartLifecycle objects is the number of CountDownLatch instances. CountDownLatch instances are reduced by one only when this method is called backwait; callback.run(); } }).start(); }Copy the code

CountDownLatch Limitations of the latch: Just counting in concurrent cases, just changing a number, just serving SmartLifeCycle and its subclasses, just latching. Await (this.timeout, timeunit.milliseconds) in stop() methods; The trigger condition is only that the child thread executes after the main thread executes

The count in CountDownLatch is the number of Lifecycle instances in the current LifecycleGroup that will be reduced as Lifecycle instances are closed, either the stop method or the doStop method is reduced to 0 and the main thread is ready to execute

The CountDownLatch class, introduced in JDk1.5, is in the java.util.concurrent package, so it has to do with concurrency.

Goldfinger: Latch is determined using the smartMemberCount variable and is determined using the stop() and doStop() methods

First, latch is determined using the smartMemberCount variable:

The smartMemberCount variable is only identified in the Add method of the LifecycleGroup class (SmartLifeCycle and its subclass instances must be ++), Only used in the LifecycleGroup class’s stop method to initialize the latch capacity

Second, latch is established using the stop() and doStop() methods:

Either stop() or doStop() must be an instance of SmartLifeCycle and its subclasses latch.countdown ();

Stop () method:

Stop () CountDownLatch = new CountDownLatch(this.smartMemberCount); The constructor initializes the number of threads



DoStop () method:

Summary:

Latch is used only for SmartLifeCycle: Whether the LifecycleGroup’s add() method determines the smartMemberCount and then uses smartMemberCount to determine the number of latches, or latch.countdown (), the latch is used only for SmartLifeCycle.

Ok, lifecycleBeans identified, see how and where it is used, in the doStart() and doStop() methods



Look at the doStart() method first



LifecycleBeans in the doStart() method are just passed parameters, not global lifecycleBeans,

Lifecyclebeans.remove (beanName) inside doStart(); If the key exists, the method returns the value previously mapped to the specified key, otherwise it returns NULL.

Just executing your own method completion does not have any effect on the global lifecycleBeans

Look again at the doStop() method

As shown in the figure above, After Lifecycle and Phased interfaces are inherited, SmartLifecycle defines a total of six methods. To facilitate the subsequent source code analysis, we will give a brief introduction:

The six methods of the full text of the main line: 1, to see how the six methods in the source code; 2. See how six methods implement SmartLifeCycle in a custom mock interface. How to simulate in simulation

As can be seen from the above listing, the ability to sense changes in the container will ultimately come from Lifecycle, and SmartLifecycle is just an enhanced version of Lifecycle. You can customize the priority (getPhase) and decide whether or not to start with the container (isAutoStartup). And the ability to accept a runnable object (stop(runnable)) when stopped;

This is the closing container phase of the SmartLifecycle instance processing logic, briefly summarized as follows:

1. AbstractApplicationContext doClose methods in closed containers when implemented, this call LifecycleProcessor onClose method, LifecycleProcessor is responsible for all instances of Lifecycle of closing operation; (Steps 1 and 2)
2. Group all Lifecycle instances by phase; (Between steps 3 and 4)
3. Execute the stop method on each Lifecycle object, starting with the group with the largest phase value; (After Step 4)
4. For each SmartLifecycle instance, if you want to execute in parallel to speed up the stop execution, you can use a new thread in the stop method to execute the stop business logic, but don’t forget to call the Runnable parameter run method to complete the main thread count and statistics. (Step 6 inside the doStop() method)
5. The main thread uses CountDownLatch and after calling the Stop method of the SmartLifecycle instance will wait until the count reaches the total number of SmartLifecycle instances or wait for a timeout, and then continue to execute backward. Latch.await (this.timeout, timeunit.milliseconds); Lifecycle will wait until all Lifecycle instances have executed.

SmartLifeCycle completed

Play code every day, progress every day!!