@Override protected URLClassLoader createUrlClassLoader( URL jarFileUrl, ClassLoader classLoader ) { return new KettleURLClassLoader( new URL[]{ jarFileUrl }, classLoader ); }
@Override protected synchronized Class<?> loadClass( String arg0, boolean arg1 ) throws ClassNotFoundException { for ( Pattern pattern : patterns ) { if ( pattern.matcher( arg0 ).matches() ) { return loadClassParentFirst( arg0, arg1 ); } } return super.loadClass( arg0, arg1 ); } }
protected Class<?> loadClassFromThisLoader( String arg0, boolean arg1 ) throws ClassNotFoundException { Class<?> clz; if ( ( clz = findLoadedClass( arg0 ) ) != null ) { if ( arg1 ) { resolveClass( clz ); } return clz; } if ( ( clz = findClass( arg0 ) ) != null ) { if ( arg1 ) { resolveClass( clz ); } return clz; } return clz; }
@Override public URL getResource( String name ) { URL url; url = findResource( name ); if ( url == null && getParent() != null ) { url = getParent().getResource( name ); } return url; } }
protected Class<?> loadClassFromParent( String arg0, boolean arg1 ) throws ClassNotFoundException { Class<?> clz; if ( ( clz = getParent().loadClass( arg0 ) ) != null ) { if ( arg1 ) { resolveClass( clz ); } return clz; } throw new ClassNotFoundException( "Could not find :" + arg0 ); }
private static Class<?> LoadAdditionalClass( String strJar, String strClassName ) throws KettleException { try { Thread t = Thread.currentThread(); ClassLoader cl = t.getContextClassLoader(); URL u = new URL( "jar:file:" + strJar + "!/" ); // We never know what else the script wants to load with the class loader, so lets not close it just like that. @SuppressWarnings( "resource" ) KettleURLClassLoader kl = new KettleURLClassLoader( new URL[] { u }, cl ); Class<?> toRun = kl.loadClass( strClassName ); return toRun; } catch ( Exception e ) { throw new KettleException( BaseMessages.getString( PKG, "ScriptMeta.Exception.UnableToLoadAdditionalClass" ), e ); } }
public Class<?> loadClass( String name, ProtectionDomain protectionDomain ) { Class<?> loaded = findLoadedClass( name ); if ( loaded == null ) { // Get the jar, load the bytes from the jar file, construct class from scratch as in snippet below... /* * * loaded = super.findClass(name); * * URL url = super.findResource(newName); * * InputStream clis = getResourceAsStream(newName); */ String newName = name.replace( '.', '/' ); InputStream is = getResourceAsStream( newName ); byte[] driverBytes = toBytes( is ); loaded = super.defineClass( name, driverBytes, 0, driverBytes.length, protectionDomain ); } return loaded; }
private void addToClassLoader( PluginInterface plugin, KettleURLClassLoader ucl ) throws MalformedURLException, UnsupportedEncodingException { String[] patterns = parentClassloaderPatternMap.get( plugin ); if ( ucl instanceof KettleSelectiveParentFirstClassLoader ) { ( (KettleSelectiveParentFirstClassLoader) ucl ).addPatterns( patterns ); } for ( String jarFile : plugin.getLibraries() ) { File jarfile = new File( jarFile ); ucl.addURL( new URL( URLDecoder.decode( jarfile.toURI().toURL().toString(), "UTF-8" ) ) ); } }
HashSet<String> closedFiles = new HashSet<>(); try { Object obj = getFieldObject( URLClassLoader.class, "ucp", this ); ArrayList<?> loaders = (ArrayList<?>) getFieldObject( obj.getClass(), "loaders", obj ); for ( Object ldr : loaders ) { try { JarFile file = (JarFile) getFieldObject( ldr.getClass(), "jar", ldr ); closedFiles.add( file.getName() ); file.close(); Vector<?> nativeLibArr = (Vector<?>) getFieldObject( ClassLoader.class, "nativeLibraries", this ); for ( Object lib : nativeLibArr ) { try { jarUrlConnClass = Class.forName( "sun.net.www.protocol.jar.JarURLConnection" ); Class<?> factory = getFieldObject( jarUrlConnClass, "factory", null ).getClass(); try { fCache = (HashMap<?, ?>) getFieldObject( factory, "fileCache", null ); } catch ( Exception e ) { uCache = (HashMap<?, ?>) getFieldObject( factory, "urlCache", null ); } catch ( Exception e ) {
protected void registerPluginJars() throws KettlePluginException { List<JarFileAnnotationPlugin> jarFilePlugins = findAnnotatedClassFiles( pluginType.getName() ); for ( JarFileAnnotationPlugin jarFilePlugin : jarFilePlugins ) { URLClassLoader urlClassLoader = createUrlClassLoader( jarFilePlugin.getJarFile(), getClass().getClassLoader() ); try { Class<?> clazz = urlClassLoader.loadClass( jarFilePlugin.getClassName() ); if ( clazz == null ) { throw new KettlePluginException( "Unable to load class: " + jarFilePlugin.getClassName() ); } List<String> libraries = Arrays.stream( urlClassLoader.getURLs() ) .map( URL::getFile ) .collect( Collectors.toList() ); Annotation annotation = clazz.getAnnotation( pluginType ); handlePluginAnnotation( clazz, annotation, libraries, false, jarFilePlugin.getPluginFolder() ); } catch ( Exception e ) { // Ignore for now, don't know if it's even possible. LogChannel.GENERAL.logError( "Unexpected error registering jar plugin file: " + jarFilePlugin.getJarFile(), e ); } finally { if ( urlClassLoader != null && urlClassLoader instanceof KettleURLClassLoader ) { ( (KettleURLClassLoader) urlClassLoader ).closeClassLoader(); } } } }
private static Class<?> LoadAdditionalClass( String strJar, String strClassName ) throws KettleException { try { Thread t = Thread.currentThread(); ClassLoader cl = t.getContextClassLoader(); URL u = new URL( "jar:file:" + strJar + "!/" ); // We never know what else the script wants to load with the class loader, so lets not close it just like that. @SuppressWarnings( "resource" ) KettleURLClassLoader kl = new KettleURLClassLoader( new URL[] { u }, cl ); Class<?> toRun = kl.loadClass( strClassName ); return toRun; } catch ( Exception e ) { throw new KettleException( BaseMessages.getString( PKG, "ScriptValuesMetaMod.Exception.UnableToLoadAdditionalClass" ), e ); } }
private KettleURLClassLoader createClassLoader( PluginInterface plugin ) throws MalformedURLException, UnsupportedEncodingException { List<String> jarFiles = plugin.getLibraries(); URL[] urls = new URL[jarFiles.size()]; for ( int i = 0; i < jarFiles.size(); i++ ) { File jarfile = new File( jarFiles.get( i ) ); urls[i] = new URL( URLDecoder.decode( jarfile.toURI().toURL().toString(), "UTF-8" ) ); } ClassLoader classLoader = getClass().getClassLoader(); String[] patterns = parentClassloaderPatternMap.get( plugin ); if ( patterns != null ) { return new KettleSelectiveParentFirstClassLoader( urls, classLoader, plugin.getDescription(), patterns ); } else { return new KettleURLClassLoader( urls, classLoader, plugin.getDescription() ); } }
return new KettleURLClassLoader( urls.toArray( new URL[urls.size()] ), classLoader );
classLoader = new KettleURLClassLoader( jarFiles, getClass().getClassLoader() );
if ( classloader == null ) { classloader = new KettleURLClassLoader( urls, HadoopConfigurationBootstrap.getHadoopConfigurationProvider() .getActiveConfiguration().getHadoopShim().getClass().getClassLoader() ); classLoaderMap.put( librarySet, classloader );