org.glowroot.container.impl.IsolatedClassLoader Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2015 the original author or authors.
*
* Licensed 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.glowroot.container.impl;
import java.io.IOException;
import java.net.URL;
import java.util.List;
import java.util.Map;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import com.google.common.io.Resources;
import com.google.common.reflect.Reflection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.glowroot.common.ClassNames;
import org.glowroot.plugin.api.Agent;
public class IsolatedClassLoader extends ClassLoader {
private static final Logger logger = LoggerFactory.getLogger(IsolatedClassLoader.class);
// bridge classes can be either interfaces or base classes
private final ImmutableList> bridgeClasses;
private final ImmutableList excludePackages;
private final Map> classes = Maps.newConcurrentMap();
IsolatedClassLoader(List> bridgeClasses, List excludePackages) {
super(IsolatedClassLoader.class.getClassLoader());
this.bridgeClasses = ImmutableList.>builder()
.addAll(bridgeClasses)
.add(IsolatedClassLoader.class)
.build();
this.excludePackages = ImmutableList.copyOf(excludePackages);
}
public S newInstance(Class implClass, Class bridgeClass)
throws Exception {
validateBridgeable(bridgeClass.getName());
return bridgeClass.cast(loadClass(implClass.getName()).newInstance());
}
@Override
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
if (loadWithParentClassLoader(name)) {
return super.loadClass(name, resolve);
}
Class c = classes.get(name);
if (c != null) {
return c;
}
c = findClass(name);
classes.put(name, c);
return c;
}
@Override
protected Class findClass(String name) throws ClassNotFoundException {
for (Class bridgeClass : bridgeClasses) {
if (bridgeClass.getName().equals(name)) {
return bridgeClass;
}
}
String resourceName = ClassNames.toInternalName(name) + ".class";
URL url = getResource(resourceName);
if (url == null) {
throw new ClassNotFoundException(name);
}
byte[] bytes;
try {
bytes = Resources.toByteArray(url);
} catch (IOException e) {
throw new ClassNotFoundException("Error loading class", e);
}
return weaveAndDefineClass(name, bytes);
}
public Class weaveAndDefineClass(String name, byte[] bytes) {
String packageName = Reflection.getPackageName(name);
if (getPackage(packageName) == null) {
definePackage(packageName, null, null, null, null, null, null, null);
}
return super.defineClass(name, bytes, 0, bytes.length);
}
private void validateBridgeable(String name) {
if (isInBootstrapClassLoader(name)) {
return;
}
for (Class bridgeClass : bridgeClasses) {
if (bridgeClass.getName().equals(name)) {
return;
}
}
throw new IllegalStateException("Class '" + name + "' is not bridgeable");
}
private boolean loadWithParentClassLoader(String name) {
if (name.startsWith(Agent.class.getName())) {
return false;
}
if (isInBootstrapClassLoader(name)) {
return true;
}
for (String excludePackage : excludePackages) {
if (name.startsWith(excludePackage + ".")) {
return true;
}
}
return false;
}
private static boolean isInBootstrapClassLoader(String name) {
try {
Class cls = Class.forName(name, false, ClassLoader.getSystemClassLoader());
return cls.getClassLoader() == null;
} catch (ClassNotFoundException e) {
// log exception at trace level
logger.trace(e.getMessage(), e);
return false;
}
}
}