Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Fabric3
   * Copyright (c) 2009 Metaform Systems
   *
   * Fabric3 is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as
   * published by the Free Software Foundation, either version 3 of
   * the License, or (at your option) any later version, with the
   * following exception:
  *
  * Linking this software statically or dynamically with other
  * modules is making a combined work based on this software.
  * Thus, the terms and conditions of the GNU General Public
  * License cover the whole combination.
  *
  * As a special exception, the copyright holders of this software
  * give you permission to link this software with independent
  * modules to produce an executable, regardless of the license
  * terms of these independent modules, and to copy and distribute
  * the resulting executable under terms of your choice, provided
  * that you also meet, for each linked independent module, the
  * terms and conditions of the license of that module. An
  * independent module is a module which is not derived from or
  * based on this software. If you modify this software, you may
  * extend this exception to your version of the software, but
  * you are not obligated to do so. If you do not wish to do so,
  * delete this exception statement from your version.
  *
  * Fabric3 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 General Public License along with Fabric3.
  * If not, see <http://www.gnu.org/licenses/>.
  *
  * ----------------------------------------------------
  *
  * Portions originally based on Apache Tuscany 2007
  * licensed under the Apache 2.0 license.
  *
  */
 package org.fabric3.fabric.builder.classloader;
 
 import java.net.URI;
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
 
 
 import static org.fabric3.host.Names.HOST_CONTRIBUTION;
Default implementation of ClassLoaderBuilder.

Version:
$Rev: 7804 $ $Date: 2009-11-09 23:58:20 +0100 (Mon, 09 Nov 2009) $
 
 public class ClassLoaderBuilderImpl implements ClassLoaderBuilder {
 
     private boolean classLoaderIsolation;
 
                                   @Reference ClassLoaderRegistry classLoaderRegistry,
                                   @Reference ClasspathProcessorRegistry classpathProcessorRegistry,
                                   @Reference ComponentManager componentManager,
                                   @Reference HostInfo info) {
         this. = wireBuilder;
         this. = classLoaderRegistry;
         this. = classpathProcessorRegistry;
         this. = componentManager;
     }

    
Lazily injects the contribution URI resolvers that may be supplied by extensions.

Parameters:
resolvers the resolvers keyed by URI scheme
    @Reference
    public void setContributionUriResolver(Map<StringContributionUriResolverresolvers) {
        this. = resolvers;
    }
    public void build(PhysicalClassLoaderDefinition definitionthrows ClassLoaderBuilderException {
        URI uri = definition.getUri();
        if (.getClassLoader(uri) != null) {
            /*
             The classloader was already loaded. The classloader will already be created if: it is the boot classloader; the environment is
             single-VM as classloaders are shared between the contribution and runtime infrastructure; two composites are deployed individually
             from the same contribution.
             */
            return;
        }
        if () {
            buildIsolatedClassLoaderEnvironment(definition);
        } else {
            buildCommonClassLoaderEnvironment(definition);
        }
    }
        URI uri = definition.getUri();
        // Create an alias to the host classloader which contains all contribution artifacts in a non-isolated environment.
        // This simulates multiple classloaders
        .register(urihostClassLoader);
    }
        URI uri = definition.getUri();
        URL[] classpath = resolveClasspath(definition.getContributionUri());
        // build the classloader using the locally cached resources
        MultiParentClassLoader loader = new MultiParentClassLoader(uriclasspathhostClassLoader);
        for (PhysicalClassLoaderWireDefinition wireDefinition : definition.getWireDefinitions()) {
            .build(loaderwireDefinition);
        }
        .register(uriloader);
    }
    public void destroy(URI urithrows ClassLoaderBuilderException {
        ClassLoader loader = .getClassLoader(uri);
        assert loader != null;
        List<Componentcomponents = .getComponents();
        // remove the classloader if there are no components that reference it
        for (Component component : components) {
            if (uri.equals(component.getClassLoaderId())) {
                return;
            }
        }
        try {
            ContributionUriResolver resolver = getResolver(uri);
            // release the previously resolved contribution
            resolver.release(uri);
        } catch (ResolutionException e) {
            throw new ClassLoaderBuilderException("Error releasing artifact: " + uri.toString(), e);
        }
        .unregister(uri);
    }

    
Resolves classpath urls.

Parameters:
uri uri to resolve
Returns:
the resolved classpath urls
Throws:
ClassLoaderBuilderException if an error occurs resolving a url
    private URL[] resolveClasspath(URI urithrows ClassLoaderBuilderException {
        List<URLclasspath = new ArrayList<URL>();
        try {
            // resolve the remote contributions and cache them locally
            ContributionUriResolver resolver = getResolver(uri);
            URL resolvedUrl = resolver.resolve(uri);
            // introspect and expand if necessary
            classpath.addAll(.process(resolvedUrl));
        } catch (ResolutionException e) {
            throw new ClassLoaderBuilderException("Error resolving artifact: " + uri.toString(), e);
        } catch (IOException e) {
            throw new ClassLoaderBuilderException("Error processing: " + uri.toString(), e);
        }
        return classpath.toArray(new URL[classpath.size()]);
    }
        String scheme = uri.getScheme();
        if (scheme == null) {
            scheme = .;
        }
        ContributionUriResolver resolver = .get(scheme);
        if (resolver == null) {
            throw new ClassLoaderBuilderException("Contribution resolver for scheme not found: " + scheme);
        }
        return resolver;
    }
New to GrepCode? Check out our FAQ X