初探 SpringBoot DevTools 重启应用原理

朴灿烈づ我的快乐病毒、 2022-01-30 11:25 153阅读 0赞

### 文章目录 ###

*   *  DevTools 重启功能介绍
     *   *  重启和重载的区别
     *  原理分析
     *   *  流程总览
         *  源码分析
         *   *  文件变化触发机制的实现
             *  服务重启的实现
     *  总结

## DevTools 重启功能介绍 ##

`spring-boot-devtools`会在源码路径`src/main`上的文件发生更改时自动重启`SpringApplication`。这样当我们改变一个类的时候，不需要点击编译器的重启按钮。但是重启的粒度其实还是比较大的，是重启整个Spring容器。 尤其是我们的应用内容过多或者包含着web容器的时候。当然和这个工具有类似功能的还有**Jrebel**，它使用的技术是重载，粒度小，但是收费。不在我们今天的讨论范围之内。

### 重启和重载的区别 ###

> The restart technology provided by Spring Boot works by using **two classloaders.** Classes that do not change (for example, those from third-party jars) are loaded into a **base classloader.** Classes that you are actively developing are loaded into a **restart classloader.**

> When the application is restarted, the restart classloader is **thrown away** and a new one is created. This approach means that application restarts are typically much faster than “**cold starts**”, since the base classloader is already available and populated.

> If you find that restarts are not quick enough for your applications or you encounter classloading issues, you could consider reloading technologies such as **JRebel** from ZeroTurnaround. These work by rewriting classes as they are loaded to make them more amenable to reloading.

首先重启的粒度是比较大的，每次启动，**Spring容器会重新启动**。而重载的粒度是**一个类**，把类通过类加载器重新加载到JVM中。

## 原理分析 ##

### 流程总览 ###

首先我们看一下, SpringBoot 从监听文件变化，到重新启动的序列图，一句话解释就是：**首先有一个检测文件变化线程，如果检测到文件（泛指class文件）变化了，就重启服务器。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwNzYwNDQ_size_16_color_FFFFFF_t_70]

### 源码分析 ###

`SpringBoot` 的 起点都是从`AutoConfiguration`开始的，当然`DevTools`也不例外

#### 文件变化触发机制的实现 ####

那么我们首先来看一下这个配置

@Configuration
    	@ConditionalOnProperty(prefix = "spring.devtools.restart", name = "enabled", matchIfMissing = true)
    	static class RestartConfiguration
    			implements ApplicationListener<ClassPathChangedEvent> { 
    
    		private final DevToolsProperties properties;
    
    		RestartConfiguration(DevToolsProperties properties) { 
    			this.properties = properties;
    		}
    
    		@Override
    		public void onApplicationEvent(ClassPathChangedEvent event) { 
    			if (event.isRestartRequired()) { 
    				Restarter.getInstance().restart(
    						new FileWatchingFailureHandler(fileSystemWatcherFactory()));
    			}
    		}
    
    		@Bean
    		@ConditionalOnMissingBean
    		public ClassPathFileSystemWatcher classPathFileSystemWatcher() { 
    			URL[] urls = Restarter.getInstance().getInitialUrls();
    			ClassPathFileSystemWatcher watcher = new ClassPathFileSystemWatcher(
    					fileSystemWatcherFactory(), classPathRestartStrategy(), urls);
    			watcher.setStopWatcherOnRestart(true);
    			return watcher;
    		}
    
    	}

可以看到配置了一个`classPathFileSystemWatcher`监听当前`classpath`的内容。当文件变化的时候会发送一个事件`ClassPathChangedEvent`

然后在监听到事件之后，服务器进行重启

public void onApplicationEvent(ClassPathChangedEvent event) { 
    			if (event.isRestartRequired()) { 
    				Restarter.getInstance().restart(
    						new FileWatchingFailureHandler(fileSystemWatcherFactory()));
    			}
    		}

分析一下入口方法`Restater.start()`

protected void start(FailureHandler failureHandler) throws Exception { 
    		do { 
    			Throwable error = doStart();
    			if (error == null) { 
    				return;
    			}
    			if (failureHandler.handle(error) == Outcome.ABORT) { 
    				return;
    			}
    		}
    		while (true);
    	}

可以看到这里的**失败处理器**，只要返回的不是`ABORT`，就重新启动。

那么我们具体来看一下`FailureHandler`这个处理器的方法

@FunctionalInterface
    public interface FailureHandler { 
    
    	/** * {@link FailureHandler} that always aborts. */
    	FailureHandler NONE = (failure) -> Outcome.ABORT;
    
    	/** * Handle a run failure. Implementations may block, for example to wait until specific * files are updated. * @param failure the exception * @return the outcome */
    	Outcome handle(Throwable failure);
    
    	/** * Various outcomes for the handler. */
    	enum Outcome { 
    
    		/** * Abort the relaunch. */
    		ABORT,
    
    		/** * Try again to relaunch the application. */
    		RETRY
    
    	}
    
    }

是一个支持lambda表达式的接口。中间一个一个枚举信号，分别是`ABORT`和`RETRY`,如果是`ABORT`,那么就退出重启，也就是这个整个应用运行过程中，不会再进行重启。如果是`RETRY`,那么就是开始重新启动服务。

在`SpringBoot`中，默认只有本地文件监听器的实现，当然如果我们有需求的话，也可以通过实现这个接口，从而实现网络指令来进行重启（网络运维）

class FileWatchingFailureHandler implements FailureHandler { 
    
    	private final FileSystemWatcherFactory fileSystemWatcherFactory;
    
    	FileWatchingFailureHandler(FileSystemWatcherFactory fileSystemWatcherFactory) { 
    		this.fileSystemWatcherFactory = fileSystemWatcherFactory;
    	}
    
    	@Override
    	public Outcome handle(Throwable failure) { 
    		CountDownLatch latch = new CountDownLatch(1);
    		FileSystemWatcher watcher = this.fileSystemWatcherFactory.getFileSystemWatcher();
    		watcher.addSourceFolders(
    				new ClassPathFolders(Restarter.getInstance().getInitialUrls()));
    		watcher.addListener(new Listener(latch));
    		watcher.start();
    		try { 
    			latch.await();
    		}
    		catch (InterruptedException ex) { 
    			Thread.currentThread().interrupt();
    		}
    		return Outcome.RETRY;
    	}
    
    	private static class Listener implements FileChangeListener { 
    
    		private final CountDownLatch latch;
    
    		Listener(CountDownLatch latch) { 
    			this.latch = latch;
    		}
    
    		@Override
    		public void onChange(Set<ChangedFiles> changeSet) { 
    			this.latch.countDown();
    		}
    
    	}
    
    }

可以看到上面的使用的`FileWatchingFailureHandler`中的有一个`FileChangeListener`。这个的作用就是监听文件的变化，当文件变化的时候，进行通知。这里默认监听的是`target\classes`。

这里就是通过`CountDownLatch`的特性， 当文件变化的时候，改变信号量，这样对应的`latch.await()`就可以接收到消息，从而停止阻塞，返回`RETRY`。这段逻辑也就意味**从开始的时候阻塞住handle返回方法，等File变化的时候，再进行处理的，也就是意味着下面的方法一直是阻塞的。优美。**

#### 服务重启的实现 ####

`Restarter.java`

private Throwable doStart() throws Exception { 
    		Assert.notNull(this.mainClassName, "Unable to find the main class to restart");
    		URL[] urls = this.urls.toArray(new URL[0]);
    		ClassLoaderFiles updatedFiles = new ClassLoaderFiles(this.classLoaderFiles);
    		ClassLoader classLoader = new RestartClassLoader(this.applicationClassLoader,
    				urls, updatedFiles, this.logger);
    		if (this.logger.isDebugEnabled()) { 
    			this.logger.debug("Starting application " + this.mainClassName + " with URLs "
    					+ Arrays.asList(urls));
    		}
    		return relaunch(classLoader);
    	}

可以看到这里`new RestartClassLoader(this.applicationClassLoader, urls, updatedFiles, this.logger)`创建了一个新的类加载器，讲AppClassLoader作为父类，这样每一次在使用\`\`加载的时候，

`RestartLauncher`

RestartLauncher(ClassLoader classLoader, String mainClassName, String[] args,
    			UncaughtExceptionHandler exceptionHandler) { 
    		this.mainClassName = mainClassName;
    		this.args = args;
    		setName("restartedMain");
    		setUncaughtExceptionHandler(exceptionHandler);
    		setDaemon(false);
    		setContextClassLoader(classLoader);
    	}
    
    	@Override
    	public void run() { 
    		try { 
    			Class<?> mainClass = getContextClassLoader().loadClass(this.mainClassName);
    			Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
    			mainMethod.invoke(null, new Object[] {  this.args });
    		}
    		catch (Throwable ex) { 
    			this.error = ex;
    			getUncaughtExceptionHandler().uncaughtException(this, ex);
    		}
    	}

看到这个启动的类，可发现几个有意思的东西，

*  一个是会把当前线程的类加载器设置为刚刚创建的类加载器，这样在其它的获取类的时候，只要是根据`Thread.getContextClassLoader()`,就可以获取到最新的类，而`Spring`在启动的时候，就是根据这个当前线程的类加载器去扫描和创建`BeanDefinition`的。
 *  一个是`restartedMain`这个线程的出处找到了，
 *  一个是下面启动的时候，就是反射执行带着注解的 `MainClass`。也就是我们第一次启动`SpringBoot`应用的地方

## 总结 ##

知道了这个Spring对重启和文件和类变换的思路，我们也可以尝试着做一些细粒度的事情，比如Mybatis的`Xml`变换之后，重新扫描`Mybatis`。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwNzYwNDQ_size_16_color_FFFFFF_t_70]: /images/20220130/bfee618d81044154af05679e110611a5.png