Java tutorial
package com.temenos.interaction.loader.classloader; /* * #%L * * interaction-dynamic-loader * * * %% * Copyright (C) 2012 - 2015 Temenos Holdings N.V. * * * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * #L% */ import java.io.File; import java.io.IOException; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; import java.security.MessageDigest; import java.util.Collection; import java.util.HashSet; import java.util.Set; import org.apache.commons.codec.binary.Hex; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.io.FileUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.primitives.Longs; import com.temenos.interaction.core.loader.FileEvent; import com.temenos.interaction.loader.objectcreation.ParameterizedFactory; /** * This class manages the creation of URLClassLoaders, which are responsible for making new * InteractionCommands available. * It maintains a hashed state of the last jar file dynamically loaded based on the modified time. * If an event arrives with information about new jars being available, the hash is calculated for the * new jars and compared to the stored hash. If the hash values are equal, the cached URLClassLoader is * simply returned. * If the hash values are not equal a temporary directory is created and the jar files are copied to this directory. * This circumvents the problem of the URLClassLoader holding the jar file open, making it impossible to replace it * with a new version. A ParentLastURLClassloader is created to load the jars and the hash value is stored for future * comparisons. * * @author trojanbug */ public class CachingParentLastURLClassloaderFactory implements ParameterizedFactory<FileEvent<File>, ClassLoader> { private static final Logger LOGGER = LoggerFactory.getLogger(CachingParentLastURLClassloaderFactory.class); private URLClassLoader cache = null; private Object lastState = null; private File lastClassloaderTempDir = null; @Override public synchronized ClassLoader getForObject(FileEvent<File> param) { Object state = calculateCurrentState(param); if (lastState == null || (!lastState.equals(state))) { LOGGER.debug("Detected state change, creating new classloader"); Object previousState = lastState; URLClassLoader previousCL = cache; File previousTempDir = lastClassloaderTempDir; cleanupClassloaderResources(previousCL, previousTempDir); //TODO add listeners to inform about classloader creation and "destruction" lastState = state; cache = createClassLoader(state, param); } return cache; } protected synchronized URLClassLoader createClassLoader(Object currentState, FileEvent<File> param) { try { LOGGER.debug( "Classloader requested from CachingParentLastURLClassloaderFactory, based on FileEvent reflecting change in {}", param.getResource().getAbsolutePath()); Set<URL> urls = new HashSet<URL>(); File newTempDir = new File(FileUtils.getTempDirectory(), currentState.toString()); FileUtils.forceMkdir(newTempDir); Collection<File> files = FileUtils.listFiles(param.getResource(), new String[] { "jar" }, true); for (File f : files) { try { LOGGER.trace("Adding {} to list of URLs to create classloader from", f.toURI().toURL()); FileUtils.copyFileToDirectory(f, newTempDir); urls.add(new File(newTempDir, f.getName()).toURI().toURL()); } catch (MalformedURLException ex) { // should not happen, we do have the file there // but if, what can we do - just log it LOGGER.warn("Trying to intilialize classloader based on URL failed!", ex); } } lastClassloaderTempDir = newTempDir; URLClassLoader classloader = new ParentLastURLClassloader(urls.toArray(new URL[] {}), Thread.currentThread().getContextClassLoader()); return classloader; } catch (IOException ex) { throw new RuntimeException("Unexpected error trying to create new classloader.", ex); } } protected Object calculateCurrentState(FileEvent<File> param) { Collection<File> files = FileUtils.listFiles(param.getResource(), new String[] { "jar" }, true); MessageDigest md = DigestUtils.getMd5Digest(); for (File f : files) { md.update(Longs.toByteArray(f.lastModified())); } Object state = Hex.encodeHexString(md.digest()); LOGGER.trace( "Calculated representation /hash/ of state of collection of URLs for classloader creation to: {}", state); return state; } private void cleanupClassloaderResources(URLClassLoader previousCL, File previousTempDir) { try { if (previousCL != null) { previousCL.close(); } } catch (IOException ex) { LOGGER.error("Failed to close classloader - potential resource and memory leak!", ex); } try { if (previousTempDir != null) { FileUtils.forceDelete(previousTempDir); } } catch (IOException ex) { LOGGER.error("Failed to delete temporary directory, possible resource leak!", ex); } } }