org.springframework.core.DecoratingClassLoader Java Examples

The following examples show how to use org.springframework.core.DecoratingClassLoader. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: AbstractBeanFactory.java    From blog_demos with Apache License 2.0 6 votes vote down vote up
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) throws ClassNotFoundException {
	if (!ObjectUtils.isEmpty(typesToMatch)) {
		ClassLoader tempClassLoader = getTempClassLoader();
		if (tempClassLoader != null) {
			if (tempClassLoader instanceof DecoratingClassLoader) {
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
			String className = mbd.getBeanClassName();
			return (className != null ? ClassUtils.forName(className, tempClassLoader) : null);
		}
	}
	return mbd.resolveBeanClass(getBeanClassLoader());
}
 
Example #2
Source File: ReflectiveLoadTimeWeaver.java    From spring-analysis-note with MIT License 5 votes vote down vote up
@Override
public ClassLoader getThrowawayClassLoader() {
	if (this.getThrowawayClassLoaderMethod != null) {
		ClassLoader target = (ClassLoader)
				ReflectionUtils.invokeMethod(this.getThrowawayClassLoaderMethod, this.classLoader);
		return (target instanceof DecoratingClassLoader ? target :
				new OverridingClassLoader(this.classLoader, target));
	}
	else {
		return new SimpleThrowawayClassLoader(this.classLoader);
	}
}
 
Example #3
Source File: SpringPersistenceUnitInfo.java    From spring-analysis-note with MIT License 5 votes vote down vote up
/**
 * This implementation delegates to the LoadTimeWeaver, if specified.
 */
@Override
public ClassLoader getNewTempClassLoader() {
	ClassLoader tcl = (this.loadTimeWeaver != null ? this.loadTimeWeaver.getThrowawayClassLoader() :
			new SimpleThrowawayClassLoader(this.classLoader));
	String packageToExclude = getPersistenceProviderPackageName();
	if (packageToExclude != null && tcl instanceof DecoratingClassLoader) {
		((DecoratingClassLoader) tcl).excludePackage(packageToExclude);
	}
	return tcl;
}
 
Example #4
Source File: ReflectiveLoadTimeWeaver.java    From java-technology-stack with MIT License 5 votes vote down vote up
@Override
public ClassLoader getThrowawayClassLoader() {
	if (this.getThrowawayClassLoaderMethod != null) {
		ClassLoader target = (ClassLoader)
				ReflectionUtils.invokeMethod(this.getThrowawayClassLoaderMethod, this.classLoader);
		return (target instanceof DecoratingClassLoader ? target :
				new OverridingClassLoader(this.classLoader, target));
	}
	else {
		return new SimpleThrowawayClassLoader(this.classLoader);
	}
}
 
Example #5
Source File: SpringPersistenceUnitInfo.java    From java-technology-stack with MIT License 5 votes vote down vote up
/**
 * This implementation delegates to the LoadTimeWeaver, if specified.
 */
@Override
public ClassLoader getNewTempClassLoader() {
	ClassLoader tcl = (this.loadTimeWeaver != null ? this.loadTimeWeaver.getThrowawayClassLoader() :
			new SimpleThrowawayClassLoader(this.classLoader));
	String packageToExclude = getPersistenceProviderPackageName();
	if (packageToExclude != null && tcl instanceof DecoratingClassLoader) {
		((DecoratingClassLoader) tcl).excludePackage(packageToExclude);
	}
	return tcl;
}
 
Example #6
Source File: ReflectiveLoadTimeWeaver.java    From lams with GNU General Public License v2.0 5 votes vote down vote up
@Override
public ClassLoader getThrowawayClassLoader() {
	if (this.getThrowawayClassLoaderMethod != null) {
		ClassLoader target = (ClassLoader)
				ReflectionUtils.invokeMethod(this.getThrowawayClassLoaderMethod, this.classLoader);
		return (target instanceof DecoratingClassLoader ? target :
				new OverridingClassLoader(this.classLoader, target));
	}
	else {
		return new SimpleThrowawayClassLoader(this.classLoader);
	}
}
 
Example #7
Source File: SpringPersistenceUnitInfo.java    From lams with GNU General Public License v2.0 5 votes vote down vote up
/**
 * This implementation delegates to the LoadTimeWeaver, if specified.
 */
@Override
public ClassLoader getNewTempClassLoader() {
	ClassLoader tcl = (this.loadTimeWeaver != null ? this.loadTimeWeaver.getThrowawayClassLoader() :
			new SimpleThrowawayClassLoader(this.classLoader));
	String packageToExclude = getPersistenceProviderPackageName();
	if (packageToExclude != null && tcl instanceof DecoratingClassLoader) {
		((DecoratingClassLoader) tcl).excludePackage(packageToExclude);
	}
	return tcl;
}
 
Example #8
Source File: SpringPersistenceUnitInfo.java    From spring4-understanding with Apache License 2.0 5 votes vote down vote up
/**
 * This implementation delegates to the LoadTimeWeaver, if specified.
 */
@Override
public ClassLoader getNewTempClassLoader() {
	ClassLoader tcl = (this.loadTimeWeaver != null ? this.loadTimeWeaver.getThrowawayClassLoader() :
			new SimpleThrowawayClassLoader(this.classLoader));
	String packageToExclude = getPersistenceProviderPackageName();
	if (packageToExclude != null && tcl instanceof DecoratingClassLoader) {
		((DecoratingClassLoader) tcl).excludePackage(packageToExclude);
	}
	return tcl;
}
 
Example #9
Source File: AbstractBeanFactory.java    From spring4-understanding with Apache License 2.0 5 votes vote down vote up
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) throws ClassNotFoundException {
	ClassLoader beanClassLoader = getBeanClassLoader();
	ClassLoader classLoaderToUse = beanClassLoader;
	if (!ObjectUtils.isEmpty(typesToMatch)) {
		// When just doing type checks (i.e. not creating an actual instance yet),
		// use the specified temporary class loader (e.g. in a weaving scenario).
		ClassLoader tempClassLoader = getTempClassLoader();
		if (tempClassLoader != null) {
			classLoaderToUse = tempClassLoader;
			if (tempClassLoader instanceof DecoratingClassLoader) {
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
		}
	}
	String className = mbd.getBeanClassName();
	if (className != null) {
		Object evaluated = evaluateBeanDefinitionString(className, mbd);
		if (!className.equals(evaluated)) {
			// A dynamically resolved expression, supported as of 4.2...
			if (evaluated instanceof Class) {
				return (Class<?>) evaluated;
			}
			else if (evaluated instanceof String) {
				return ClassUtils.forName((String) evaluated, classLoaderToUse);
			}
			else {
				throw new IllegalStateException("Invalid class name expression result: " + evaluated);
			}
		}
		// When resolving against a temporary class loader, exit early in order
		// to avoid storing the resolved Class in the bean definition.
		if (classLoaderToUse != beanClassLoader) {
			return ClassUtils.forName(className, classLoaderToUse);
		}
	}
	return mbd.resolveBeanClass(beanClassLoader);
}
 
Example #10
Source File: AbstractBeanFactory.java    From spring-analysis-note with MIT License 4 votes vote down vote up
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
		throws ClassNotFoundException {

	ClassLoader beanClassLoader = getBeanClassLoader();
	ClassLoader dynamicLoader = beanClassLoader;
	boolean freshResolve = false;

	if (!ObjectUtils.isEmpty(typesToMatch)) {
		// When just doing type checks (i.e. not creating an actual instance yet),
		// use the specified temporary class loader (e.g. in a weaving scenario).
		ClassLoader tempClassLoader = getTempClassLoader();
		if (tempClassLoader != null) {
			dynamicLoader = tempClassLoader;
			freshResolve = true;
			if (tempClassLoader instanceof DecoratingClassLoader) {
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
		}
	}

	String className = mbd.getBeanClassName();
	if (className != null) {
		Object evaluated = evaluateBeanDefinitionString(className, mbd);
		if (!className.equals(evaluated)) {
			// A dynamically resolved expression, supported as of 4.2...
			if (evaluated instanceof Class) {
				return (Class<?>) evaluated;
			}
			else if (evaluated instanceof String) {
				className = (String) evaluated;
				freshResolve = true;
			}
			else {
				throw new IllegalStateException("Invalid class name expression result: " + evaluated);
			}
		}
		if (freshResolve) {
			// When resolving against a temporary class loader, exit early in order
			// to avoid storing the resolved Class in the bean definition.
			if (dynamicLoader != null) {
				try {
					return dynamicLoader.loadClass(className);
				}
				catch (ClassNotFoundException ex) {
					if (logger.isTraceEnabled()) {
						logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
					}
				}
			}
			return ClassUtils.forName(className, dynamicLoader);
		}
	}

	// Resolve regularly, caching the result in the BeanDefinition...
	return mbd.resolveBeanClass(beanClassLoader);
}
 
Example #11
Source File: AbstractBeanFactory.java    From java-technology-stack with MIT License 4 votes vote down vote up
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
		throws ClassNotFoundException {

	ClassLoader beanClassLoader = getBeanClassLoader();
	ClassLoader dynamicLoader = beanClassLoader;
	boolean freshResolve = false;

	if (!ObjectUtils.isEmpty(typesToMatch)) {
		// When just doing type checks (i.e. not creating an actual instance yet),
		// use the specified temporary class loader (e.g. in a weaving scenario).
		ClassLoader tempClassLoader = getTempClassLoader();
		if (tempClassLoader != null) {
			dynamicLoader = tempClassLoader;
			freshResolve = true;
			if (tempClassLoader instanceof DecoratingClassLoader) {
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
		}
	}

	String className = mbd.getBeanClassName();
	if (className != null) {
		Object evaluated = evaluateBeanDefinitionString(className, mbd);
		if (!className.equals(evaluated)) {
			// A dynamically resolved expression, supported as of 4.2...
			if (evaluated instanceof Class) {
				return (Class<?>) evaluated;
			}
			else if (evaluated instanceof String) {
				className = (String) evaluated;
				freshResolve = true;
			}
			else {
				throw new IllegalStateException("Invalid class name expression result: " + evaluated);
			}
		}
		if (freshResolve) {
			// When resolving against a temporary class loader, exit early in order
			// to avoid storing the resolved Class in the bean definition.
			if (dynamicLoader != null) {
				try {
					return dynamicLoader.loadClass(className);
				}
				catch (ClassNotFoundException ex) {
					if (logger.isTraceEnabled()) {
						logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
					}
				}
			}
			return ClassUtils.forName(className, dynamicLoader);
		}
	}

	// Resolve regularly, caching the result in the BeanDefinition...
	return mbd.resolveBeanClass(beanClassLoader);
}
 
Example #12
Source File: AbstractBeanFactory.java    From lams with GNU General Public License v2.0 4 votes vote down vote up
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
		throws ClassNotFoundException {

	ClassLoader beanClassLoader = getBeanClassLoader();
	ClassLoader classLoaderToUse = beanClassLoader;
	if (!ObjectUtils.isEmpty(typesToMatch)) {
		// When just doing type checks (i.e. not creating an actual instance yet),
		// use the specified temporary class loader (e.g. in a weaving scenario).
		ClassLoader tempClassLoader = getTempClassLoader();
		if (tempClassLoader != null) {
			classLoaderToUse = tempClassLoader;
			if (tempClassLoader instanceof DecoratingClassLoader) {
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
		}
	}
	String className = mbd.getBeanClassName();
	if (className != null) {
		Object evaluated = evaluateBeanDefinitionString(className, mbd);
		if (!className.equals(evaluated)) {
			// A dynamically resolved expression, supported as of 4.2...
			if (evaluated instanceof Class) {
				return (Class<?>) evaluated;
			}
			else if (evaluated instanceof String) {
				return ClassUtils.forName((String) evaluated, classLoaderToUse);
			}
			else {
				throw new IllegalStateException("Invalid class name expression result: " + evaluated);
			}
		}
		// When resolving against a temporary class loader, exit early in order
		// to avoid storing the resolved Class in the bean definition.
		if (classLoaderToUse != beanClassLoader) {
			return ClassUtils.forName(className, classLoaderToUse);
		}
	}
	return mbd.resolveBeanClass(beanClassLoader);
}