⏭️ 🍛 👩🏾 Javaコードの日曜大工の動的コンパイル 🧝🏻 ◻️ 👨🏽‍✈️

この記事では、ホットデプロイの実装、つまり実行中のアプリケーションへのJavaコード変更の高速配信について説明します。

まず、少し歴史。数年前からCUBAプラットフォームで企業アプリケーションを作成しています。それらはサイズと機能が非常に異なりますが、1つはすべて似ています-多くのユーザーインターフェイスがあります。

ある時点で、サーバーを常に再起動してユーザーインターフェイスを開発するのは非常に面倒であることがわかりました。ホットスワップの使用には大きな制限があります（フィールド、クラスメソッドを追加および名前変更することはできません）。各サーバーの再起動には少なくとも10秒かかり、さらに再ログインして開発中の画面に移動する必要がありました。

完全なホットデプロイについて考える必要がありました。アンダーカット-コードとデモアプリケーションの問題に対する当社のソリューション。

背景

CUBAプラットフォームでの画面の開発には、画面の宣言型XML記述子の作成が含まれます。これは、コントローラークラスの名前を示します。したがって、スクリーンコントローラークラスは常にフルネームで取得されます。

また、ほとんどの場合、スクリーンコントローラーはそれ自体のものであることに注意する必要があります。つまり、他のコントローラーやクラスだけでは使用されません（これは起こりますが、頻繁ではありません）。

最初に、Groovyを使用してホットデプロイの問題を解決しようとしました。ソースGroovyコードのサーバーへのダウンロードを開始し、GroovyClassLoaderを介してスクリーンコントローラーのクラスを取得しました。これにより、サーバーへの変更の配信速度で問題が解決しましたが、多くの新しい問題が発生しました：当時のGroovyはIDEのサポートが比較的貧弱で、動的な型付けにより、経験の浅い開発者に気付かれずにコンパイルされていないコードを書くことができました。そうすることができます。

プロジェクトには何百もの画面があり、それぞれがいつでも壊れる可能性があるため、画面コントローラーでのGroovyの使用を放棄する必要がありました。

それから私たちは一生懸命に考えました。サーバーへのコードの即時配信（再起動なし）の利点を得ると同時に、コードの品質をあまり危険にさらさないようにしたかったのです。 Java 1.6に登場した機能-ToolProvider.getSystemJavaCompiler（）（IBM.comの説明）が助けになりました。このオブジェクトを使用すると、ソースコードからjava.lang.Class型のオブジェクトを取得できます。試してみることにしました。

実装

クラスローダーをGroovyClassLoaderに似たものにすることにしました。コンパイルされたクラスをキャッシュし、クラスにアクセスするたびに、クラスのソースコードがファイルシステム上で更新されたかどうかを確認します。更新されると、コンパイルが開始され、結果がキャッシュに保存されます。

リンクをクリックすると、クラスローダーの詳細な実装を確認できます。

この記事では、実装の重要なポイントに焦点を当てます。

メインクラスであるJavaClassLoaderから始めましょう。

短縮JavaClassLoaderコード

public class JavaClassLoader extends URLClassLoader implements ApplicationContextAware { ..... protected final Map<String, TimestampClass> compiled = new ConcurrentHashMap<>(); protected final ConcurrentHashMap<String, Lock> locks = new ConcurrentHashMap<>(); protected final ProxyClassLoader proxyClassLoader; protected final SourceProvider sourceProvider; protected XmlWebApplicationContext applicationContext; private static volatile boolean refreshing = false; ..... @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = (XmlWebApplicationContext) applicationContext; this.applicationContext.setClassLoader(this); } public Class loadClass(final String fullClassName, boolean resolve) throws ClassNotFoundException { String containerClassName = StringUtils.substringBefore(fullClassName, "$"); try { lock(containerClassName); Class clazz; if (!sourceProvider.getSourceFile(containerClassName).exists()) { clazz = super.loadClass(fullClassName, resolve); return clazz; } CompilationScope compilationScope = new CompilationScope(this, containerClassName); if (!compilationScope.compilationNeeded()) { return getTimestampClass(fullClassName).clazz; } String src; try { src = sourceProvider.getSourceString(containerClassName); } catch (IOException e) { throw new ClassNotFoundException("Could not load java sources for class " + containerClassName); } try { log.debug("Compiling " + containerClassName); final DiagnosticCollector<JavaFileObject> errs = new DiagnosticCollector<>(); SourcesAndDependencies sourcesAndDependencies = new SourcesAndDependencies(rootDir, this); sourcesAndDependencies.putSource(containerClassName, src); sourcesAndDependencies.collectDependencies(containerClassName); Map<String, CharSequence> sourcesForCompilation = sourcesAndDependencies.collectSourcesForCompilation(containerClassName); @SuppressWarnings("unchecked") Map<String, Class> compiledClasses = createCompiler().compile(sourcesForCompilation, errs); Map<String, TimestampClass> compiledTimestampClasses = wrapCompiledClasses(compiledClasses); compiled.putAll(compiledTimestampClasses); linkDependencies(compiledTimestampClasses, sourcesAndDependencies.dependencies); clazz = compiledClasses.get(fullClassName); updateSpringContext(); return clazz; } catch (Exception e) { proxyClassLoader.restoreRemoved(); throw new RuntimeException(e); } finally { proxyClassLoader.cleanupRemoved(); } } finally { unlock(containerClassName); } } private void updateSpringContext() { if (!refreshing) { refreshing = true; applicationContext.refresh(); refreshing = false; } } ..... /** * Add dependencies for each class and ALSO add each class to dependent for each dependency */ private void linkDependencies(Map<String, TimestampClass> compiledTimestampClasses, Multimap<String, String> dependecies) { for (Map.Entry<String, TimestampClass> entry : compiledTimestampClasses.entrySet()) { String className = entry.getKey(); TimestampClass timestampClass = entry.getValue(); Collection<String> dependencyClasses = dependecies.get(className); timestampClass.dependencies.addAll(dependencyClasses); for (String dependencyClassName : timestampClass.dependencies) { TimestampClass dependencyClass = compiled.get(dependencyClassName); if (dependencyClass != null) { dependencyClass.dependent.add(className); } } } } ..... }

loadClassを呼び出すとき、次のアクションを実行します。

このクラスのソースコードがファイルシステムにあるかどうかを確認し、ない場合は、継承されたloadClassを呼び出します
コンパイルが必要かどうかを確認します。たとえば、クラスのソースコードを含むファイルが変更されています。ここでは、クラスでの1ファイルの変更だけでなく、すべての依存関係も追跡していることを覚えておく必要があります
依存関係を収集します-コンパイルするクラスに依存するすべてのものと、依存するすべてのもの
コンパイルのために各依存関係をチェックし、コンパイルする必要がないものを捨てます
ソースコードをコンパイルします
結果をキャッシュに入れる
必要に応じて、Springコンテキストを更新する
要求されたクラスを返します

updateSpringContext（）メソッドに注意を払うと、クラスがロードされるたびにSpringコンテキストが更新されます。これはデモアプリケーションで行われましたが、実際のプロジェクトでは、このような頻繁なコンテキストの更新は通常必要ありません。

誰かが疑問に思うかもしれません-クラスが依存するものをどのように決定するのですか？答えは簡単です-インポートセクションを解析します。以下はこれを行うコードです。

依存関係コレクションコード。

 class SourcesAndDependencies { private static final String IMPORT_PATTERN = "import (.+?);"; private static final String IMPORT_STATIC_PATTERN = "import static (.+)\\..+?;"; public static final String WHOLE_PACKAGE_PLACEHOLDER = ".*"; final Map<String, CharSequence> sources = new HashMap<>(); final Multimap<String, String> dependencies = HashMultimap.create(); private final SourceProvider sourceProvider; private final JavaClassLoader javaClassLoader; SourcesAndDependencies(String rootDir, JavaClassLoader javaClassLoader) { this.sourceProvider = new SourceProvider(rootDir); this.javaClassLoader = javaClassLoader; } public void putSource(String name, CharSequence sourceCode) { sources.put(name, sourceCode); } /** * Recursively collects all dependencies for class using imports * * @throws java.io.IOException */ public void collectDependencies(String className) throws IOException { CharSequence src = sources.get(className); List<String> importedClassesNames = getDynamicallyLoadedImports(src); String currentPackageName = className.substring(0, className.lastIndexOf('.')); importedClassesNames.addAll(sourceProvider.getAllClassesFromPackage(currentPackageName));//all src from current package for (String importedClassName : importedClassesNames) { if (!sources.containsKey(importedClassName)) { addSource(importedClassName); addDependency(className, importedClassName); collectDependencies(importedClassName); } else { addDependency(className, importedClassName); } } } /** * Decides what to compile using CompilationScope (hierarchical search) * Find all classes dependent from those we are going to compile and add them to compilation as well */ public Map<String, CharSequence> collectSourcesForCompilation(String rootClassName) throws ClassNotFoundException, IOException { Map<String, CharSequence> dependentSources = new HashMap<>(); collectDependent(rootClassName, dependentSources); for (String dependencyClassName : sources.keySet()) { CompilationScope dependencyCompilationScope = new CompilationScope(javaClassLoader, dependencyClassName); if (dependencyCompilationScope.compilationNeeded()) { collectDependent(dependencyClassName, dependentSources); } } sources.putAll(dependentSources); return sources; } /** * Find all dependent classes (hierarchical search) */ private void collectDependent(String dependencyClassName, Map<String, CharSequence> dependentSources) throws IOException { TimestampClass removedClass = javaClassLoader.proxyClassLoader.removeFromCache(dependencyClassName); if (removedClass != null) { for (String dependentName : removedClass.dependent) { dependentSources.put(dependentName, sourceProvider.getSourceString(dependentName)); addDependency(dependentName, dependencyClassName); collectDependent(dependentName, dependentSources); } } } private void addDependency(String dependent, String dependency) { if (!dependent.equals(dependency)) { dependencies.put(dependent, dependency); } } private void addSource(String importedClassName) throws IOException { sources.put(importedClassName, sourceProvider.getSourceString(importedClassName)); } private List<String> unwrapImportValue(String importValue) { if (importValue.endsWith(WHOLE_PACKAGE_PLACEHOLDER)) { String packageName = importValue.replace(WHOLE_PACKAGE_PLACEHOLDER, ""); if (sourceProvider.directoryExistsInFileSystem(packageName)) { return sourceProvider.getAllClassesFromPackage(packageName); } } else if (sourceProvider.sourceExistsInFileSystem(importValue)) { return Collections.singletonList(importValue); } return Collections.emptyList(); } private List<String> getDynamicallyLoadedImports(CharSequence src) { List<String> importedClassNames = new ArrayList<>(); List<String> importValues = getMatchedStrings(src, IMPORT_PATTERN, 1); for (String importValue : importValues) { importedClassNames.addAll(unwrapImportValue(importValue)); } importValues = getMatchedStrings(src, IMPORT_STATIC_PATTERN, 1); for (String importValue : importValues) { importedClassNames.addAll(unwrapImportValue(importValue)); } return importedClassNames; } private List<String> getMatchedStrings(CharSequence source, String pattern, int groupNumber) { ArrayList<String> result = new ArrayList<>(); Pattern importPattern = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE); Matcher matcher = importPattern.matcher(source); while (matcher.find()) { result.add(matcher.group(groupNumber)); } return result; } }

気配りのある読者は尋ねます-コンパイル自体はどこですか？以下は彼女のコードです。

CharSequenceCompilerショートコード

 public class CharSequenceCompiler<T> { ..... // The compiler instance that this facade uses. private final JavaCompiler compiler; public CharSequenceCompiler(ProxyClassLoader loader, Iterable<String> options) { compiler = ToolProvider.getSystemJavaCompiler(); if (compiler == null) { throw new IllegalStateException("Cannot find the system Java compiler. " + "Check that your class path includes tools.jar"); } ..... } ..... public synchronized Map<String, Class<T>> compile( final Map<String, CharSequence> classes, final DiagnosticCollector<JavaFileObject> diagnosticsList) throws CharSequenceCompilerException { List<JavaFileObject> sources = new ArrayList<JavaFileObject>(); for (Map.Entry<String, CharSequence> entry : classes.entrySet()) { String qualifiedClassName = entry.getKey(); CharSequence javaSource = entry.getValue(); if (javaSource != null) { final int dotPos = qualifiedClassName.lastIndexOf('.'); final String className = dotPos == -1 ? qualifiedClassName : qualifiedClassName.substring(dotPos + 1); final String packageName = dotPos == -1 ? "" : qualifiedClassName .substring(0, dotPos); final JavaFileObjectImpl source = new JavaFileObjectImpl(className, javaSource); sources.add(source); // Store the source file in the FileManager via package/class // name. // For source files, we add a .java extension javaFileManager.putFileForInput(StandardLocation.SOURCE_PATH, packageName, className + JAVA_EXTENSION, source); } } // Get a CompliationTask from the compiler and compile the sources final JavaCompiler.CompilationTask task = compiler.getTask(null, javaFileManager, diagnostics, options, null, sources); final Boolean result = task.call(); if (result == null || !result) { StringBuilder cause = new StringBuilder("\n"); for (Diagnostic d : diagnostics.getDiagnostics()) { cause.append(d).append(" "); } throw new CharSequenceCompilerException("Compilation failed. Causes: " + cause, classes .keySet(), diagnostics); } try { // For each class name in the input map, get its compiled // class and put it in the output map Map<String, Class<T>> compiled = new HashMap<String, Class<T>>(); for (String qualifiedClassName : classLoader.classNames()) { final Class<T> newClass = loadClass(qualifiedClassName); compiled.put(qualifiedClassName, newClass); } return compiled; } catch (ClassNotFoundException e) { throw new CharSequenceCompilerException(classes.keySet(), e, diagnostics); } catch (IllegalArgumentException e) { throw new CharSequenceCompilerException(classes.keySet(), e, diagnostics); } catch (SecurityException e) { throw new CharSequenceCompilerException(classes.keySet(), e, diagnostics); } } ...... }

これはどのように役立ちますか？

この記事では、 Spring MVCで小さなアプリケーションを作成し、そこでクラスローダーを使用しました。

このアプリは、動的コンパイルのメリットを実演します。

WelcomeControllerとSpring-bean SomeBeanは、アプリケーションで宣言されています。コントローラーはSomeBean.get（）メソッドを使用し、結果を表示レベルに戻します。

次に、クラスローダーを使用して、アプリケーションを停止せずにSomeBeanImplとWelcomeControllerの実装を変更する方法を示します。まず、アプリケーションをデプロイし（ビルドするにはgradleが必要です）、 localhostに切り替えます：8080 / mvcclassloader / hello。

答えは、WelcomeControllerからこんにちは。 バージョン：リロードされていません。

次に、SomeBeanImplの実装を少し変更しましょう。

 @Component("someBean") public class SomeBeanImpl implements SomeBean { @Override public String get() { return "reloaded";//  not reloaded } }

ファイルをサーバー上のフォルダーtomcat / conf / com / haulmont / mvcclassloaderに配置します（クラスローダーがソースコードを検索するフォルダーは、mvc-dispatcher-servlet.xmlファイルで構成されます）。次に、クラスのロードを呼び出す必要があります。これを行うために、別のコントローラー-ReloadControllerを作成しました。実際には、変化はさまざまな方法で検出できますが、これはデモンストレーションに適しています。 ReloadControllerは、アプリケーションの2つのクラスをリロードします。リンクlocalhost ：8080 / mvcclassloader / reloadをクリックして、コントローラーを呼び出すことができます。

その後、再度localhostに切り替えます：8080 / mvcclassloader / hello：

WelcomeControllerからこんにちは。 バージョン：再読み込み。

しかし、それだけではありません。 WebControllerのコードを変更することもできます。やってみましょう。

 @Controller("welcomeController") public class WelcomeController { @Autowired protected SomeBean someBean; @RequestMapping(value = "/hello", method = RequestMethod.GET) public ModelAndView welcome() { ModelAndView model = new ModelAndView(); model.setViewName("index"); model.addObject("version", someBean.get() + " a bit more");// a bit more return model; } }

クラスのリロードを呼び出してメインコントローラーにアクセスすると、次のように表示されます。

WelcomeControllerからこんにちは。 バージョン：もう少しリロードしました。

このアプリケーションでは、クラスローダーはクラスをコンパイルするたびにコンテキストを完全にリロードします。大規模なアプリケーションの場合、これにはかなりの時間がかかる可能性があるため、別の方法があります-コンパイルされたコンテキスト内のクラスのみを変更できます。この機会はDefaultListableBeanFactoryによって提供されます。たとえば、CUBAプラットフォームでは、Springコンテキストのクラス置換は次のように実装されます。

 private void updateSpringContext(Collection<Class> classes) { if (beanFactory != null) { for (Class clazz : classes) { Service serviceAnnotation = (Service) clazz.getAnnotation(Service.class); ManagedBean managedBeanAnnotation = (ManagedBean) clazz.getAnnotation(ManagedBean.class); Component componentAnnotation = (Component) clazz.getAnnotation(Component.class); Controller controllerAnnotation = (Controller) clazz.getAnnotation(Controller.class); String beanName = null; if (serviceAnnotation != null) { beanName = serviceAnnotation.value(); } else if (managedBeanAnnotation != null) { beanName = managedBeanAnnotation.value(); } else if (componentAnnotation != null) { beanName = componentAnnotation.value(); } else if (controllerAnnotation != null) { beanName = controllerAnnotation.value(); } if (StringUtils.isNotBlank(beanName)) { GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); beanDefinition.setBeanClass(clazz); beanFactory.registerBeanDefinition(beanName, beanDefinition); } } } }

ここでのキーは、文字列beanFactory.registerBeanDefinition（beanName、beanDefinition）です。

ここには微妙な点が1つあります-DefaultListableBeanFactoryはデフォルトで依存Beanをオーバーロードしないため、少し調整する必要がありました。

 public class CubaDefaultListableBeanFactory extends DefaultListableBeanFactory { ..... /** * Reset all bean definition caches for the given bean, * including the caches of beans that depends on it. * * @param beanName the name of the bean to reset */ protected void resetBeanDefinition(String beanName) { String[] dependentBeans = getDependentBeans(beanName); super.resetBeanDefinition(beanName); if (dependentBeans != null) { for (String dependentBean : dependentBeans) { resetBeanDefinition(dependentBean); registerDependentBean(beanName, dependentBean); } } } }

サーバーに変更を迅速に配信する方法

サーバーを再起動せずにサーバー側のJavaアプリケーションに変更を配信するには、いくつかの方法があります。

最初の方法は、もちろん標準のJavaデバッガーによって提供されるホットスワップです。それには明らかな欠点があります-クラスの構造を変更（メソッドやフィールドの追加、変更）することはできません。「バトル」サーバーで使用することは非常に問題です。

2番目の方法は、サーブレットコンテナによって提供されるホットデプロイです。単にwarファイルをサーバーにアップロードすると、アプリケーションが再び起動します。この方法には欠点もあります。まず、アプリケーション全体を停止します。つまり、しばらく利用できないことを意味します（アプリケーションの展開時間はコンテンツによって異なり、かなりの時間がかかる場合があります）。第二に、プロジェクト全体の組み立てにはそれ自体かなりの時間がかかります。第三に、変更を正確に制御する能力がないため、どこかでミスをした場合、アプリケーションを再度デプロイする必要があります。

3番目の方法は、2番目の方法のバリエーションと考えることができます。クラスファイルをweb-inf / classesフォルダー（Webアプリケーション用）に配置すると、サーバーで使用可能なクラスがオーバーライドされます。このアプローチには、既存のクラスとのバイナリ非互換性を作成する可能性があり、アプリケーションの一部が動作しなくなる可能性があります。

4番目の方法はJRebelです。顧客のサーバーでも使用している人もいると聞きましたが、自分ではしません。同時に、開発にも最適です。彼には1つの欠点があります-それにはかなりのお金がかかります。

5番目の方法は、Spring Loadedです。 javaagentを介して機能します。無料です。ただし、Springでのみ機能し、クラス階層、コンストラクタなどを変更することもできません。

そしてもちろん、動的にコンパイルされた言語（Groovyなど）もあります。最初にそれらについて書いた。

私たちのアプローチの強みは何ですか

変更の配信は非常に高速で、再起動もアプリケーションも利用できません
動的にコンパイルされたクラスの構造を任意に変更できます（クラス階層、インターフェースなどを変更します）。
ソースコードはクリアテキストでサーバー上にあるため、（たとえばdiffを使用して）正確に変更された内容をいつでも確認できます。
クラスを置き換えるプロセスを完全に制御します。たとえば、新しいソースコードがコンパイルされない場合は、クラスの古いバージョンを返すことができます。
サーバー上でバグを直接簡単に修正できます（そのような場合があります）
開発者のサーバーに変更を配信する機能をIDEに実装するのは非常に簡単です（ソースコードをコピーするだけで）
あなたは一銭も使いません

もちろん、欠点もあります。設定変更のメカニズムはより複雑になっています。一般的なケースでは、実装をその場で変更できるようにアプリケーションアーキテクチャを構築する必要があります（たとえば、コンストラクターを使用せず、名前でクラスを取得し、リフレクションを使用してオブジェクトを作成します）。クラスローダからクラスを取得するのにかかる時間はわずかに増加します（ファイルシステムのチェックのため）。

ただし、適切なアプローチでは、利点は欠点をカバーする以上のものです。

結論として、私たちはアプリケーションでこのアプローチを約5年間使用していると言いたいと思います。彼は開発中の時間を大幅に節約し、バトルサーバーのエラーを修正するのに多くの神経を使いました。

Javaコードの日曜大工の動的コンパイル

背景

実装

これはどのように役立ちますか？

サーバーに変更を迅速に配信する方法

私たちのアプローチの強みは何ですか

More articles: