Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   * 
  *   http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.    
  */
 
 package org.apache.tuscany.sca.contribution.java.impl;
 
 import java.net.URL;
 
 
 
 public class ContributionClassLoader extends URLClassLoader {
 // public class ContributionClassLoader  {
     
     private Contribution contribution;
     // private b urlClassLoader;
     
    
Constructor for contribution ClassLoader

Parameters:
contribution
parent
Throws:
java.net.MalformedURLException
 
     public ContributionClassLoader(Contribution contributionfinal ClassLoader parent) {
         super(new URL[0], parent);
         // Note that privileged use of getContextClassLoader have been promoted to callers.
         // super(new URL[0], parent == null?Thread.currentThread().getContextClassLoader(): null);
         this. = contribution;
         if (contribution.getLocation() != null) {
             try {
                 this.addURL(new URL(contribution.getLocation()));
                 for (URL url : ContributionHelper.getNestedJarUrls(contribution)) {
                     this.addURL(url);
                 }
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
         }
     }
 
     /*
      * Return the ClassLoader corresponding to a contribution providing an export
      * Create a new ClassLoader for the contribution if one does not exist
      */
     private ClassLoader getExportClassLoader(Contribution exportingContribution) {
     	ClassLoader cl = exportingContribution.getClassLoader();
         if (!(cl instanceof ContributionClassLoader)) {
             if (cl == null) {
                 cl = getParent();
             }
 
             cl = new ContributionClassLoader(exportingContributioncl);
             exportingContribution.setClassLoader(cl);
         }
         return cl;
     }
     
     /* (non-Javadoc)
      * @see java.net.URLClassLoader#findClass(java.lang.String)
      * 
      * Search path for class:
      *     This contribution
      *     Imported contributions
      */
     @Override   
     protected Class<?> findClass(String classNamethrows ClassNotFoundException {
         
         Class<?> clazz = null;
         try {
             clazz = findClassFromContribution(className);
         } catch (ClassNotFoundException e) {
                 
             for (Import import_ : this..getImports()) {
                if (classNameMatchesImport(classNameimport_)) {
                    // Delegate the resolution to the imported contribution
                    for (Contribution exportingContribution : ((JavaImportModelResolver)import_.getModelResolver()).getExportContributions()) {
                                    
                        ClassLoader exportClassLoader = getExportClassLoader(exportingContribution);
                        if (exportClassLoader instanceof ContributionClassLoader) {
                            
                            for (Export export : exportingContribution.getExports()) {
                                try {
                                    if (import_.match(export)) {
                                        clazz = ((ContributionClassLoader)exportClassLoader).findClassFromContribution(className);
                                        break;
                                    }
                                } catch (ClassNotFoundException e1) { 
                                    continue;
                                }
                                    
                            }
                            if (clazz != null)  break;
                        }
                    }
                    if (clazz != nullbreak;
                }
            }
            if (clazz == nullthrow e;
        }
        return clazz;
    }
    
    /* (non-Javadoc)
     * @see java.lang.ClassLoader#loadClass(java.lang.String, boolean)
     * 
     * Search path for class:
     *     Parent ClassLoader
     *     This contribution
     *     Imported contributions
     *     
     */
    @Override
    protected synchronized Class<?> loadClass(String classNameboolean resolveClass
        throws ClassNotFoundException {
       
        Class<?> clazz = null;
        try {
            
            if (this.getParent() != null)
                clazz = this.getParent().loadClass(className);
            
        } catch (ClassNotFoundException e) {
        }
        if (clazz == null)
            clazz = findClass(className);
        if (resolveClass)
            this.resolveClass(clazz);
        return clazz;
        
    }
   
    /*
     * (non-Javadoc)
     * 
     * @see java.net.URLClassLoader#findResource(java.lang.String)
     */
    @Override
    public URL findResource(String name) {
        
        URL url = findResourceFromContribution(name);
        
        if (url == null) {
            for (Import import_ : this..getImports()) {
                if (resourceNameMatchesImport(nameimport_)) {
                    // Delegate the resolution to the imported contribution
                    for (Contribution exportingContribution : ((JavaImportModelResolver)import_.getModelResolver()).getExportContributions()) {
                                
                        ClassLoader exportClassLoader = getExportClassLoader(exportingContribution);
                        if (exportClassLoader instanceof ContributionClassLoader) {
                            for (Export export : exportingContribution.getExports()) {
                                if (import_.match(export)) {
                                    url = ((ContributionClassLoader)exportClassLoader).findResourceFromContribution(name);
                                    if (url != nullbreak;
                                }
                            }
                            if (url != null)  break;
                        }
                    }
                    if (url != nullbreak;
                }
            }
        }
        return url;
    }
    /* (non-Javadoc)
     * @see java.net.URLClassLoader#findResources(java.lang.String)
     */
    @Override
    public Enumeration<URLfindResources(String namethrows IOException {
              
        return Collections.enumeration(findResourceSet(name));
    }
    
    
    
    /* (non-Javadoc)
     * @see java.lang.ClassLoader#getResource(java.lang.String)
     * 
     * Find a resource. 
     * Search path for resource:
     *     Parent ClassLoader
     *     This contribution
     *     Imported contributions
     */
    @Override
    public URL getResource(String resName) {
 
        URL resource  = null;
        
        if (this.getParent() != null) {
            resource  = this.getParent().getResource(resName);
        }        
        if (resource == null)
            resource  = findResource(resName);
        
        return resource;
    }
    
    /* (non-Javadoc)
     * @see java.lang.ClassLoader#getResources(java.lang.String)
     * 
     * Return list of resources from this contribution, resources
     * imported through imported contributions and resources from parent 
     * ClassLoader.
     */
    @Override
    public Enumeration<URLgetResources(String resNamethrows IOException {
       
        HashSet<URLresourceSet = findResourceSet(resName);
        addEnumerationToCollection(resourceSetsuper.getResources(resName));
        
        return Collections.enumeration(resourceSet);
    }
    
    /*
     * Find set of resources
     */
    private HashSet<URLfindResourceSet(String namethrows IOException {
        
        HashSet<URLresources = new HashSet<URL>();
        addEnumerationToCollection(resourcessuper.findResources(name));
        
        for (Import import_ : this..getImports()) {
            if (!(import_ instanceof JavaImport)) {
                continue;
            }
            if (resourceNameMatchesImport(nameimport_)) {
                // Delegate the resolution to the imported contribution
                for (Contribution exportingContribution : ((JavaImportModelResolver)import_.getModelResolver()).getExportContributions()) {
                                
                    ClassLoader exportClassLoader = getExportClassLoader(exportingContribution);
                    if (exportClassLoader instanceof ContributionClassLoader) {
                        for (Export export : exportingContribution.getExports()) {
                            if (import_.match(export)) {
                                addEnumerationToCollection(resources,
                                        ((ContributionClassLoader)exportClassLoader).findResources(name));
                            }
                        }
                    }
                }
            }
         }
        return resources;
    }
    /*
     * Find class from contribution. If class has already been loaded, return loaded class.
     */
    private Class<?> findClassFromContribution(String classNamethrows ClassNotFoundException {
        
        Class<?> clazz = findLoadedClass(className);
        if (clazz == null)
            clazz =  super.findClass(className);
        return clazz;
       
    }
    
    /*
     * Find resource from contribution.
     */
    private URL findResourceFromContribution(String name) {
        
        return super.findResource(name);
    }
    
    
Check if a class name matches an import statement. Class matches if the package name used in <import.java/> matches

Parameters:
name Name of class
import_ SCA contribution import
Returns:
true if this is a matching import
    private boolean classNameMatchesImport(String nameImport import_) {
        
        if (import_ instanceof JavaImport && name != null && name.lastIndexOf('.') > 0) {
            JavaImport javaImport = (JavaImportimport_;
                
            String packageName = name.substring(0, name.lastIndexOf('.'));
            if (javaImport.getPackage().endsWith(".*")) {
                String prefix = javaImport.getPackage().substring(0, javaImport.getPackage().length() -1);
                 if (packageName.startsWith(prefix)) {
                    return true;
                }
            } else {
                return packageName.equals(javaImport.getPackage());
            }
        }
        
        return false;
    }
    
    
Check if a resource name matches an import statement. Resource matches if package/namespace match the directory of resource.

Parameters:
name Name of resource
import_ SCA contribution import
Returns:
true if this is a matching import
    private boolean resourceNameMatchesImport(String nameImport import_) {
        
       
        if (name == null || name.lastIndexOf('/') <= 0)
            return false;
        else if (import_ instanceof JavaImport) {
            JavaImport javaImport = (JavaImportimport_;
            
            if (javaImport.getPackage().endsWith(".*")) {
                String packageName = name.substring(0, name.lastIndexOf('/')).replace('/''.');
                String prefix = javaImport.getPackage().substring(0, javaImport.getPackage().length() -1);
                if (packageName.startsWith(prefix)) {
                    return true;
                }
            } else {
                // 'name' is a resource : contains "/" as separators
                // Get package name from resource name
                String packageName = name.substring(0, name.lastIndexOf('/'));
                 return packageName.equals(javaImport.getPackage().replaceAll("\\.""/"));
            }
        } 
        return false;
    }
    
    /*
     * Add an enumeration to a Collection
     */
    private <T extends Objectvoid addEnumerationToCollection(Collection<T> collectionEnumeration<T> enumeration) {
        
        while (enumeration.hasMoreElements())
            collection.add(enumeration.nextElement());
    }
    
    
    @Override
    public String toString() {
        return "SCA Contribution ClassLoader location: " + .getLocation() + " parent ClassLoader: " + getParent();
    }
    
    
New to GrepCode? Check out our FAQ X