Do-it-yourself dynamic compilation of Java code

public class JavaClassLoader extends URLClassLoader implements ApplicationContextAware {
     .....
    protected final Map compiled = new ConcurrentHashMap<>();
    protected final ConcurrentHashMap 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 errs = new DiagnosticCollector<>();
                SourcesAndDependencies sourcesAndDependencies = new SourcesAndDependencies(rootDir, this);
                sourcesAndDependencies.putSource(containerClassName, src);
                sourcesAndDependencies.collectDependencies(containerClassName);
                Map sourcesForCompilation = sourcesAndDependencies.collectSourcesForCompilation(containerClassName);
                @SuppressWarnings("unchecked")
                Map compiledClasses = createCompiler().compile(sourcesForCompilation, errs);
                Map 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 compiledTimestampClasses, Multimap dependecies) {
        for (Map.Entry entry : compiledTimestampClasses.entrySet()) {
            String className = entry.getKey();
            TimestampClass timestampClass = entry.getValue();
            Collection 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);
                }
            }
        }
    }
   .....
}

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 sources = new HashMap<>();
    final Multimap 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 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 collectSourcesForCompilation(String rootClassName) throws ClassNotFoundException, IOException {
        Map 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 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 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 getDynamicallyLoadedImports(CharSequence src) {
        List importedClassNames = new ArrayList<>();
        List 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 getMatchedStrings(CharSequence source, String pattern, int groupNumber) {
        ArrayList 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;
    }
}

public class CharSequenceCompiler {
    .....
    // The compiler instance that this facade uses.
    private final JavaCompiler compiler;
    public CharSequenceCompiler(ProxyClassLoader loader, Iterable 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> compile(
            final Map classes,
            final DiagnosticCollector diagnosticsList)
            throws CharSequenceCompilerException {
        List sources = new ArrayList();
        for (Map.Entry 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> compiled = new HashMap>();
            for (String qualifiedClassName : classLoader.classNames()) {
                final Class 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);
        }
    }
  ......
}