001/** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.camel.impl; 018 019import java.io.InputStream; 020import java.net.URL; 021import java.util.Enumeration; 022 023import org.apache.camel.CamelContext; 024import org.apache.camel.CamelContextAware; 025import org.apache.camel.spi.ClassResolver; 026import org.apache.camel.util.CastUtils; 027import org.apache.camel.util.ObjectHelper; 028import org.apache.camel.util.StringHelper; 029 030/** 031 * Default class resolver that uses regular class loader to load classes. 032 */ 033public class DefaultClassResolver implements ClassResolver, CamelContextAware { 034 035 private CamelContext camelContext; 036 037 public DefaultClassResolver() { 038 } 039 040 public DefaultClassResolver(CamelContext camelContext) { 041 this.camelContext = camelContext; 042 } 043 044 public void setCamelContext(CamelContext camelContext) { 045 this.camelContext = camelContext; 046 } 047 048 public CamelContext getCamelContext() { 049 return camelContext; 050 } 051 052 public Class<?> resolveClass(String name) { 053 Class<?> answer = loadClass(name, DefaultClassResolver.class.getClassLoader()); 054 if (answer == null && getApplicationContextClassLoader() != null) { 055 // fallback and use application context class loader 056 answer = loadClass(name, getApplicationContextClassLoader()); 057 } 058 return answer; 059 } 060 061 public <T> Class<T> resolveClass(String name, Class<T> type) { 062 Class<T> answer = CastUtils.cast(loadClass(name, DefaultClassResolver.class.getClassLoader())); 063 if (answer == null && getApplicationContextClassLoader() != null) { 064 // fallback and use application context class loader 065 answer = CastUtils.cast(loadClass(name, getApplicationContextClassLoader())); 066 } 067 return answer; 068 } 069 070 public Class<?> resolveClass(String name, ClassLoader loader) { 071 return loadClass(name, loader); 072 } 073 074 public <T> Class<T> resolveClass(String name, Class<T> type, ClassLoader loader) { 075 return CastUtils.cast(loadClass(name, loader)); 076 } 077 078 public Class<?> resolveMandatoryClass(String name) throws ClassNotFoundException { 079 Class<?> answer = resolveClass(name); 080 if (answer == null) { 081 throw new ClassNotFoundException(name); 082 } 083 return answer; 084 } 085 086 public <T> Class<T> resolveMandatoryClass(String name, Class<T> type) throws ClassNotFoundException { 087 Class<T> answer = resolveClass(name, type); 088 if (answer == null) { 089 throw new ClassNotFoundException(name); 090 } 091 return answer; 092 } 093 094 public Class<?> resolveMandatoryClass(String name, ClassLoader loader) throws ClassNotFoundException { 095 Class<?> answer = resolveClass(name, loader); 096 if (answer == null) { 097 throw new ClassNotFoundException(name); 098 } 099 return answer; 100 } 101 102 public <T> Class<T> resolveMandatoryClass(String name, Class<T> type, ClassLoader loader) throws ClassNotFoundException { 103 Class<T> answer = resolveClass(name, type, loader); 104 if (answer == null) { 105 throw new ClassNotFoundException(name); 106 } 107 return answer; 108 } 109 110 public InputStream loadResourceAsStream(String uri) { 111 StringHelper.notEmpty(uri, "uri"); 112 return ObjectHelper.loadResourceAsStream(uri, getApplicationContextClassLoader()); 113 } 114 115 public URL loadResourceAsURL(String uri) { 116 StringHelper.notEmpty(uri, "uri"); 117 return ObjectHelper.loadResourceAsURL(uri, getApplicationContextClassLoader()); 118 } 119 120 public Enumeration<URL> loadResourcesAsURL(String uri) { 121 return loadAllResourcesAsURL(uri); 122 } 123 124 public Enumeration<URL> loadAllResourcesAsURL(String uri) { 125 StringHelper.notEmpty(uri, "uri"); 126 return ObjectHelper.loadResourcesAsURL(uri); 127 } 128 129 protected Class<?> loadClass(String name, ClassLoader loader) { 130 StringHelper.notEmpty(name, "name"); 131 return ObjectHelper.loadClass(name, loader); 132 } 133 134 protected ClassLoader getApplicationContextClassLoader() { 135 return camelContext != null ? camelContext.getApplicationContextClassLoader() : null; 136 } 137 138}