RIVER-272 Bantam ClassDepAnalyzer.java

[Peter Firmstone <ji...@zeus.net.au>]

Just thought I'd post the source of the Bantam ClassDepAnalyzer for 
discussion:

The Bantam Class Dependency Analyser is much smaller that I expected, 
considering the small size, were probably better rolling our own, this 
is interesting though:

-Peter.

/**
 * 
 * Copyright 2006 Skill Corporation
 * 
 * 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 com.skillcorp.bantam.startup.annotation;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.rmi.RemoteException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.logging.Logger;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;

public class ClassDepAnalyzer extends ClassLoader {
	private static final Logger logger = Logger.getLogger("com.skillcorp.bantam.startup.annotation");

	public ClassDepAnalyzer() {
		super();
	}

	public static void main(String[] args) throws Exception {
		Set<String> mainClasses = new HashSet<String>();
		mainClasses.add("com.skillcorp.bantam.service.examples.admin.TestInterface");
		mainClasses.add("com.skillcorp.bantam.service.examples.admin.TestAdminInterface");
		Set<String> includedPackages = new HashSet<String>();
		Set<String> excludedPackages = new HashSet<String>();
		excludedPackages.addAll(Arrays.asList(new String[] { "java", "javax", "com.sun", "net.jini" }));
		includedPackages.addAll(Arrays.asList(new String[] { "com.skillcorp.bantam.service", }));
		URLClassLoader urlc = new URLClassLoader(new URL[] { new File(
				"c:\\workspaces\\mayflowerClean\\bantam.dev.java.net\\bantam-examples\\build\\WEB-INF\\classes\\")
				.toURL() }, ClassDepAnalyzer.class.getClass().getClassLoader());
		new ClassDepAnalyzer().createClassDepJar("test.jar", includedPackages, excludedPackages, mainClasses, urlc);
	}

	public void test(final Class classToRemote) throws IOException {
		String className = classToRemote.getName() + "Intfc";
		String jarName = classToRemote.getSimpleName() + "-dl.jar";
		createRemoteAndJar(className, classToRemote, jarName);
		try {
			File createdJarFile = new File(jarName);
			URLClassLoader u = new URLClassLoader(new URL[] { createdJarFile.toURL() }, null);
			u.loadClass(className);
		}
		catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public String createRemoteAndJar(Class classToRemote) throws ClassFormatError, FileNotFoundException, IOException {
		return createRemoteAndJar(null, classToRemote, null);
	}

	public String createRemoteAndJar(String remoteName, final Class classToRemote, String jarName)
			throws ClassFormatError, IOException, FileNotFoundException {
		if (remoteName == null) {
			remoteName = classToRemote.getName() + "Intfc";
		}
		if (jarName == null) {
			jarName = classToRemote.getSimpleName() + "-dl.jar";
		}
		byte[] classBytes = createRemote(remoteName, classToRemote);
		Class remoteClass = defineClass(remoteName, classBytes, 0, classBytes.length);
		assert (java.rmi.Remote.class.isAssignableFrom(remoteClass));
		Map<String, byte[]> createdResources = new HashMap<String, byte[]>();
		createdResources.put(remoteName.replace('.', '/'), classBytes);
		InputStream classStream = new ByteArrayInputStream(classBytes);
		createClassDepJar(jarName, createdResources, classStream);
		return jarName;
	}

	private void createClassDepJar(String jarName, Map<String, byte[]> createdResources, InputStream classStream)
			throws IOException, FileNotFoundException {
		Set<String> classes = analyzeDependencies(classStream, null, null, Thread.currentThread()
				.getContextClassLoader());
		logger.fine("jar contents: " + classes.toString());
		createJar(jarName, classes, createdResources, Thread.currentThread().getContextClassLoader());
	}

	public void createClassDepJar(String jarName, Set<String> includePackages, Set<String> excludePackages,
			Set<String> mainClasses, ClassLoader cl) throws IOException {
		Set<String> allDependencies = new HashSet<String>();
		for (String mainClass : mainClasses) {
			logger.fine("analyzing main class " + mainClass);
			String resourceName = mainClass.replace('.', '/') + ".class";
			Set<String> dependencies = analyzeDependencies(cl.getResourceAsStream(resourceName), includePackages,
					excludePackages, cl);
			allDependencies.addAll(dependencies);
		}
		logger.fine("jar contents: " + allDependencies.toString());
		Map<String, byte[]> empty = Collections.emptyMap();
		createJar(jarName, allDependencies, empty, cl);
	}

	private byte[] createRemote(String remoteName, final Class classToRemote) {
		ClassWriter cw = new ClassWriter(false);
		String remoteResourceName = remoteName.replace('.', '/');
		cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT + Opcodes.ACC_INTERFACE, remoteResourceName,
				null, "java/lang/Object", new String[] { "java/rmi/Remote" });
		Method[] methods = classToRemote.getDeclaredMethods();
		for (Method method : methods) {
			if (Modifier.isPublic(method.getModifiers())) {
				Class[] exceptionTypes = method.getExceptionTypes();
				String[] exceptions = new String[exceptionTypes.length];
				boolean throwsRemote = false;
				for (int j = 0; j < exceptionTypes.length; j++) {
					Class ex = exceptionTypes[j];
					if (ex.equals(RemoteException.class)) {
						throwsRemote = true;
					}
					exceptions[j] = ex.getName().replace('.', '/');
				}
				if (!throwsRemote) {
					String[] moreExceptions = new String[exceptions.length + 1];
					System.arraycopy(exceptions, 0, moreExceptions, 0, exceptions.length);
					moreExceptions[exceptions.length] = RemoteException.class.getName().replace('.', '/');
					exceptions = moreExceptions;
				}
				cw.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT, method.getName(), Type
						.getMethodDescriptor(method), null, exceptions);
			}
		}
		cw.visitEnd();
		return cw.toByteArray();
	}

	private Set<String> analyzeDependencies(InputStream classStream, Set<String> includedPackages,
			Set<String> excludedPackages, ClassLoader cl) throws IOException {
		DependencyVisitor v = new DependencyVisitor(includedPackages, excludedPackages);
		new ClassReader(classStream).accept(v, false);
		Set<String> dependentClasses = new HashSet<String>(v.getDependencies());
		Set<String> newDependentClasses = new HashSet<String>(dependentClasses);
		Set<String> evaluatedClasses = new HashSet<String>();
		while (!newDependentClasses.isEmpty()) {
			for (String dependency : dependentClasses) {
				if (!evaluatedClasses.contains(dependency)) {
					String dependentClass = dependency + ".class";
					InputStream is = cl.getResourceAsStream(dependentClass);
					if (is != null) {
						new ClassReader(is).accept(v, false);
						newDependentClasses.addAll(v.getDependencies());
					}
					evaluatedClasses.add(dependency);
				}
			}
			newDependentClasses.removeAll(dependentClasses);
			dependentClasses.addAll(newDependentClasses);
		}
		return v.getDependencies();
	}

	private void createJar(String jarName, Set<String> includedClasses, Map<String, byte[]> createdResources,
			ClassLoader cl) throws IOException, FileNotFoundException {
		JarOutputStream jos = new JarOutputStream(new FileOutputStream(jarName));
		byte[] buf = new byte[1024];
		for (String dependency : includedClasses) {
			String resourceName = dependency + ".class";
			InputStream is = cl.getResourceAsStream(resourceName);
			int br = 0;
			if (is != null) {
				JarEntry entry = new JarEntry(resourceName);
				jos.putNextEntry(entry);
				while ((br = is.read(buf, 0, buf.length)) != -1) {
					jos.write(buf, 0, br);
				}
				is.close();
			}
			else if (createdResources.containsKey(dependency)) {
				JarEntry entry = new JarEntry(resourceName);
				jos.putNextEntry(entry);
				jos.write(createdResources.get(dependency));
			}
			jos.closeEntry();
		}
		jos.close();
	}
}