Coverage report

  %line %branch
org.apache.commons.jelly.impl.DefaultTagLibraryResolver
0% 
0% 

 1  
 /*
 2  
  * Copyright 2002,2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *      http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 package org.apache.commons.jelly.impl;
 17  
 
 18  
 import org.apache.commons.discovery.ResourceClass;
 19  
 import org.apache.commons.discovery.ResourceClassIterator;
 20  
 import org.apache.commons.discovery.resource.ClassLoaders;
 21  
 import org.apache.commons.discovery.resource.classes.DiscoverClasses;
 22  
 import org.apache.commons.jelly.TagLibrary;
 23  
 import org.apache.commons.jelly.util.ClassLoaderUtils;
 24  
 import org.apache.commons.logging.Log;
 25  
 import org.apache.commons.logging.LogFactory;
 26  
 
 27  
 
 28  
 /**
 29  
  * <p><code>DefaultTagLibraryResolver</code> is a default implemenation
 30  
  * which attempts to interpret the URI as a String called 'jelly:className'
 31  
  * and class load the given Java class. Otherwise META-INF/services/jelly/uri
 32  
  * is searched for on the thread context's class path and, if found, that
 33  
  * class will be loaded.</p>
 34  
  *
 35  
  * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
 36  
  * @version $Revision: 155420 $
 37  
  */
 38  
 public class DefaultTagLibraryResolver implements TagLibraryResolver {
 39  
 
 40  
     /** The Log to which logging calls will be made. */
 41  0
     private static final Log log = LogFactory.getLog(DefaultTagLibraryResolver.class);
 42  
 
 43  
     private DiscoverClasses discovery;
 44  
 
 45  
     /**
 46  
      * The class loader to use for instantiating application objects.
 47  
      * If not specified, the context class loader, or the class loader
 48  
      * used to load this class itself, is used, based on the value of the
 49  
      * <code>useContextClassLoader</code> variable.
 50  
      */
 51  
     private ClassLoader classLoader;
 52  
 
 53  
     /**
 54  
      * Do we want to use the Context ClassLoader when loading classes
 55  
      * for instantiating new objects?  Default is <code>false</code>.
 56  
      */
 57  0
     private boolean useContextClassLoader = false;
 58  
 
 59  
 
 60  0
     public DefaultTagLibraryResolver() {
 61  0
     }
 62  
 
 63  
 
 64  
     // TagLibraryResolver interface
 65  
     //-------------------------------------------------------------------------
 66  
 
 67  
     /**
 68  
      * Attempts to resolve the given URI to be associated with a TagLibrary
 69  
      * otherwise null is returned to indicate no tag library could be found
 70  
      * so that the namespace URI should be treated as just vanilla XML.
 71  
      */
 72  
     public TagLibrary resolveTagLibrary(String uri) {
 73  0
         DiscoverClasses discovery = getDiscoverClasses();
 74  0
         String name = uri;
 75  0
         if ( uri.startsWith( "jelly:" ) ) {
 76  0
             name = "jelly." + uri.substring(6);
 77  
         }
 78  
 
 79  0
         log.info( "Looking up service name: " + name );
 80  
 
 81  
 /*
 82  
         ClassLoaders loaders = ClassLoaders.getAppLoaders(TagLibrary.class, getClass(), false);
 83  
 
 84  
         DiscoverClass discover = new DiscoverClass(loaders);
 85  
         Class implClass = discover.find(TestInterface2.class);
 86  
 
 87  
 
 88  
 
 89  
         TagLibrary answer = null;
 90  
         try {
 91  
             answer = (TagLibrary) DiscoverSingleton.find(TagLibrary.class, name);
 92  
         }
 93  
         catch (Exception e) {
 94  
             log.error( "Could not load service: " + name );
 95  
         }
 96  
         return answer;
 97  
 */
 98  0
         ResourceClassIterator iter = discovery.findResourceClasses(name);
 99  0
         while (iter.hasNext()) {
 100  0
             ResourceClass resource = iter.nextResourceClass();
 101  
             try {
 102  0
                 Class typeClass = resource.loadClass();
 103  0
                 if ( typeClass != null ) {
 104  0
                     return newInstance(uri, typeClass);
 105  
                 }
 106  
             }
 107  0
             catch (Exception e) {
 108  0
                 log.error( "Could not load service: " + resource );
 109  0
             }
 110  0
         }
 111  0
         log.info( "Could not find any services for name: " + name );
 112  0
         return null;
 113  
     }
 114  
 
 115  
     // Properties
 116  
     //-------------------------------------------------------------------------
 117  
 
 118  
     /**
 119  
      * Return the class loader to be used for instantiating application objects
 120  
      * when required.  This is determined based upon the following rules:
 121  
      * <ul>
 122  
      * <li>The class loader set by <code>setClassLoader()</code>, if any</li>
 123  
      * <li>The thread context class loader, if it exists and the
 124  
      *     <code>useContextClassLoader</code> property is set to true</li>
 125  
      * <li>The class loader used to load the XMLParser class itself.
 126  
      * </ul>
 127  
      */
 128  
     public ClassLoader getClassLoader() {
 129  0
         return ClassLoaderUtils.getClassLoader(classLoader, useContextClassLoader, getClass());
 130  
     }
 131  
 
 132  
     /**
 133  
      * Set the class loader to be used for instantiating application objects
 134  
      * when required.
 135  
      *
 136  
      * @param classLoader The new class loader to use, or <code>null</code>
 137  
      *  to revert to the standard rules
 138  
      */
 139  
     public void setClassLoader(ClassLoader classLoader) {
 140  0
         this.classLoader = classLoader;
 141  0
     }
 142  
 
 143  
     /**
 144  
      * Return the boolean as to whether the context classloader should be used.
 145  
      */
 146  
     public boolean getUseContextClassLoader() {
 147  0
         return useContextClassLoader;
 148  
     }
 149  
 
 150  
     /**
 151  
      * Determine whether to use the Context ClassLoader (the one found by
 152  
      * calling <code>Thread.currentThread().getContextClassLoader()</code>)
 153  
      * to resolve/load classes.  If not
 154  
      * using Context ClassLoader, then the class-loading defaults to
 155  
      * using the calling-class' ClassLoader.
 156  
      *
 157  
      * @param boolean determines whether to use JellyContext ClassLoader.
 158  
      */
 159  
     public void setUseContextClassLoader(boolean use) {
 160  0
         useContextClassLoader = use;
 161  0
     }
 162  
 
 163  
     /**
 164  
      * @return the DiscoverClasses instance to use to locate services.
 165  
      *  This object is lazily created if it has not been configured.
 166  
      */
 167  
     public DiscoverClasses getDiscoverClasses() {
 168  0
         if ( discovery == null ) {
 169  0
             ClassLoaders loaders = ClassLoaders.getAppLoaders(TagLibrary.class, getClass(), false);
 170  0
             discovery = new DiscoverClasses(loaders);
 171  
         }
 172  0
         return discovery;
 173  
     }
 174  
 
 175  
     /**
 176  
      * Sets the fully configured DiscoverClasses instance to be used to
 177  
      * lookup services
 178  
      */
 179  
     public void setDiscoverClasses(DiscoverClasses discovery) {
 180  0
         this.discovery = discovery;
 181  0
     }
 182  
 
 183  
     // Implementation methods
 184  
     //-------------------------------------------------------------------------
 185  
 
 186  
     /**
 187  
      * Instantiates the given class name. Otherwise an exception is logged
 188  
      * and null is returned
 189  
      */
 190  
     protected TagLibrary loadClass(String uri, String className) {
 191  
         try {
 192  0
             Class theClass = getClassLoader().loadClass(className);
 193  0
             if ( theClass != null ) {
 194  0
                 return newInstance(uri, theClass);
 195  
             }
 196  
         }
 197  0
         catch (ClassNotFoundException e) {
 198  0
             log.error("Could not find the class: " + className + " when trying to resolve URI: " + uri, e);
 199  0
         }
 200  0
         return null;
 201  
     }
 202  
 
 203  
 
 204  
     /**
 205  
      * Creates a new instance of the given TagLibrary class or
 206  
      * return null if it could not be instantiated.
 207  
      */
 208  
     protected TagLibrary newInstance(String uri, Class theClass) {
 209  
         try {
 210  0
             Object object = theClass.newInstance();
 211  0
             if (object instanceof TagLibrary) {
 212  0
                 return (TagLibrary) object;
 213  
             }
 214  
             else {
 215  0
                 log.error(
 216  
                     "The tag library object mapped to: "
 217  
                         + uri
 218  
                         + " is not a TagLibrary. Object = "
 219  
                         + object);
 220  
             }
 221  
         }
 222  0
         catch (Exception e) {
 223  0
             log.error(
 224  
                 "Could not instantiate instance of class: " + theClass.getName() + ". Reason: " + e,
 225  
                 e);
 226  0
         }
 227  0
         return null;
 228  
     }
 229  
 
 230  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.