All Downloads are FREE. Search and download functionalities are using the official Maven repository.

javassist.ClassPool Maven / Gradle / Ivy

There is a newer version: 2.22.2
Show newest version
/*
 * Javassist, a Java-bytecode translator toolkit.
 * Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License.  Alternatively, the contents of this file may be used under
 * the terms of the GNU Lesser General Public License Version 2.1 or later,
 * or the Apache License Version 2.0.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 */

package javassist;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.security.ProtectionDomain;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.Enumeration;
import javassist.bytecode.Descriptor;

/**
 * A container of CtClass objects.
 * A CtClass object must be obtained from this object.
 * If get() is called on this object,
 * it searches various sources represented by ClassPath
 * to find a class file and then it creates a CtClass object
 * representing that class file.  The created object is returned to the
 * caller.
 *
 * 

Memory consumption memo: * *

ClassPool objects hold all the CtClasses * that have been created so that the consistency among modified classes * can be guaranteed. Thus if a large number of CtClasses * are processed, the ClassPool will consume a huge amount * of memory. To avoid this, a ClassPool object * should be recreated, for example, every hundred classes processed. * Note that getDefault() is a singleton factory. * Otherwise, detach() in CtClass should be used * to avoid huge memory consumption. * *

ClassPool hierarchy: * *

ClassPools can make a parent-child hierarchy as * java.lang.ClassLoaders. If a ClassPool has * a parent pool, get() first asks the parent pool to find * a class file. Only if the parent could not find the class file, * get() searches the ClassPaths of * the child ClassPool. This search order is reversed if * ClassPath.childFirstLookup is true. * * @see javassist.CtClass * @see javassist.ClassPath */ public class ClassPool { // used by toClass(). private static java.lang.reflect.Method defineClass1, defineClass2; private static java.lang.reflect.Method definePackage; static { try { AccessController.doPrivileged(new PrivilegedExceptionAction(){ public Object run() throws Exception{ Class cl = Class.forName("java.lang.ClassLoader"); defineClass1 = cl.getDeclaredMethod("defineClass", new Class[] { String.class, byte[].class, int.class, int.class }); defineClass2 = cl.getDeclaredMethod("defineClass", new Class[] { String.class, byte[].class, int.class, int.class, ProtectionDomain.class }); definePackage = cl.getDeclaredMethod("definePackage", new Class[] { String.class, String.class, String.class, String.class, String.class, String.class, String.class, java.net.URL.class }); return null; } }); } catch (PrivilegedActionException pae) { throw new RuntimeException("cannot initialize ClassPool", pae.getException()); } } /** * Determines the search order. * *

If this field is true, get() first searches the * class path associated to this ClassPool and then * the class path associated with the parent ClassPool. * Otherwise, the class path associated with the parent is searched * first. * *

The default value is false. */ public boolean childFirstLookup = false; /** * Turning the automatic pruning on/off. * *

If this field is true, CtClass objects are * automatically pruned by default when toBytecode() etc. * are called. The automatic pruning can be turned on/off individually * for each CtClass object. * *

The initial value is false. * * @see CtClass#prune() * @see CtClass#stopPruning(boolean) * @see CtClass#detach() */ public static boolean doPruning = false; private int compressCount; private static final int COMPRESS_THRESHOLD = 100; /* releaseUnmodifiedClassFile was introduced for avoiding a bug of JBoss AOP. So the value should be true except for JBoss AOP. */ /** * If true, unmodified and not-recently-used class files are * periodically released for saving memory. * *

The initial value is true. */ public static boolean releaseUnmodifiedClassFile = true; protected ClassPoolTail source; protected ClassPool parent; protected Hashtable classes; // should be synchronous /** * Table of registered cflow variables. */ private Hashtable cflow = null; // should be synchronous. private static final int INIT_HASH_SIZE = 191; private ArrayList importedPackages; /** * Creates a root class pool. No parent class pool is specified. */ public ClassPool() { this(null); } /** * Creates a root class pool. If useDefaultPath is * true, appendSystemPath() is called. Otherwise, * this constructor is equivalent to the constructor taking no * parameter. * * @param useDefaultPath true if the system search path is * appended. */ public ClassPool(boolean useDefaultPath) { this(null); if (useDefaultPath) appendSystemPath(); } /** * Creates a class pool. * * @param parent the parent of this class pool. If this is a root * class pool, this parameter must be null. * @see javassist.ClassPool#getDefault() */ public ClassPool(ClassPool parent) { this.classes = new Hashtable(INIT_HASH_SIZE); this.source = new ClassPoolTail(); this.parent = parent; if (parent == null) { CtClass[] pt = CtClass.primitiveTypes; for (int i = 0; i < pt.length; ++i) classes.put(pt[i].getName(), pt[i]); } this.cflow = null; this.compressCount = 0; clearImportedPackages(); } /** * Returns the default class pool. * The returned object is always identical since this method is * a singleton factory. * *

The default class pool searches the system search path, * which usually includes the platform library, extension * libraries, and the search path specified by the * -classpath option or the CLASSPATH * environment variable. * *

When this method is called for the first time, the default * class pool is created with the following code snippet: * *

    ClassPool cp = new ClassPool(); * cp.appendSystemPath(); *
* *

If the default class pool cannot find any class files, * try ClassClassPath and LoaderClassPath. * * @see ClassClassPath * @see LoaderClassPath */ public static synchronized ClassPool getDefault() { if (defaultPool == null) { defaultPool = new ClassPool(null); defaultPool.appendSystemPath(); } return defaultPool; } private static ClassPool defaultPool = null; /** * Provide a hook so that subclasses can do their own * caching of classes. * * @see #cacheCtClass(String,CtClass,boolean) * @see #removeCached(String) */ protected CtClass getCached(String classname) { return (CtClass)classes.get(classname); } /** * Provides a hook so that subclasses can do their own * caching of classes. * * @see #getCached(String) * @see #removeCached(String,CtClass) */ protected void cacheCtClass(String classname, CtClass c, boolean dynamic) { classes.put(classname, c); } /** * Provide a hook so that subclasses can do their own * caching of classes. * * @see #getCached(String) * @see #cacheCtClass(String,CtClass,boolean) */ protected CtClass removeCached(String classname) { return (CtClass)classes.remove(classname); } /** * Returns the class search path. */ public String toString() { return source.toString(); } /** * This method is periodically invoked so that memory * footprint will be minimized. */ void compress() { if (compressCount++ > COMPRESS_THRESHOLD) { compressCount = 0; Enumeration e = classes.elements(); while (e.hasMoreElements()) ((CtClass)e.nextElement()).compress(); } } /** * Record a package name so that the Javassist compiler searches * the package to resolve a class name. * Don't record the java.lang package, which has * been implicitly recorded by default. * *

Since version 3.14, packageName can be a * fully-qualified class name. * *

Note that get() in ClassPool does * not search the recorded package. Only the compiler searches it. * * @param packageName the package name. * It must not include the last '.' (dot). * For example, "java.util" is valid but "java.util." is wrong. * @since 3.1 */ public void importPackage(String packageName) { importedPackages.add(packageName); } /** * Clear all the package names recorded by importPackage(). * The java.lang package is not removed. * * @see #importPackage(String) * @since 3.1 */ public void clearImportedPackages() { importedPackages = new ArrayList(); importedPackages.add("java.lang"); } /** * Returns all the package names recorded by importPackage(). * * @see #importPackage(String) * @since 3.1 */ public Iterator getImportedPackages() { return importedPackages.iterator(); } /** * Records a class name that never exists. * For example, a package name can be recorded by this method. * This would improve execution performance * since get() quickly throw an exception * without searching the class path at all * if the given name is an invalid name recorded by this method. * Note that searching the class path takes relatively long time. * *

The current implementation of this method performs nothing. * * @param name an invalid class name (separeted by dots). * @deprecated */ public void recordInvalidClassName(String name) { // source.recordInvalidClassName(name); } /** * Records the $cflow variable for the field specified * by cname and fname. * * @param name variable name * @param cname class name * @param fname field name */ void recordCflow(String name, String cname, String fname) { if (cflow == null) cflow = new Hashtable(); cflow.put(name, new Object[] { cname, fname }); } /** * Undocumented method. Do not use; internal-use only. * * @param name the name of $cflow variable */ public Object[] lookupCflow(String name) { if (cflow == null) cflow = new Hashtable(); return (Object[])cflow.get(name); } /** * Reads a class file and constructs a CtClass * object with a new name. * This method is useful if you want to generate a new class as a copy * of another class (except the class name). For example, * *

         * getAndRename("Point", "Pair")
         * 
* * returns a CtClass object representing Pair * class. The definition of Pair is the same as that of * Point class except the class name since Pair * is defined by reading Point.class. * * @param orgName the original (fully-qualified) class name * @param newName the new class name */ public CtClass getAndRename(String orgName, String newName) throws NotFoundException { CtClass clazz = get0(orgName, false); if (clazz == null) throw new NotFoundException(orgName); if (clazz instanceof CtClassType) ((CtClassType)clazz).setClassPool(this); clazz.setName(newName); // indirectly calls // classNameChanged() in this class return clazz; } /* * This method is invoked by CtClassType.setName(). It removes a * CtClass object from the hash table and inserts it with the new * name. Don't delegate to the parent. */ synchronized void classNameChanged(String oldname, CtClass clazz) { CtClass c = (CtClass)getCached(oldname); if (c == clazz) // must check this equation. removeCached(oldname); // see getAndRename(). String newName = clazz.getName(); checkNotFrozen(newName); cacheCtClass(newName, clazz, false); } /** * Reads a class file from the source and returns a reference * to the CtClass * object representing that class file. If that class file has been * already read, this method returns a reference to the * CtClass created when that class file was read at the * first time. * *

If classname ends with "[]", then this method * returns a CtClass object for that array type. * *

To obtain an inner class, use "$" instead of "." for separating * the enclosing class name and the inner class name. * * @param classname a fully-qualified class name. */ public CtClass get(String classname) throws NotFoundException { CtClass clazz; if (classname == null) clazz = null; else clazz = get0(classname, true); if (clazz == null) throw new NotFoundException(classname); else { clazz.incGetCounter(); return clazz; } } /** * Reads a class file from the source and returns a reference * to the CtClass * object representing that class file. * This method is equivalent to get except * that it returns null when a class file is * not found and it never throws an exception. * * @param classname a fully-qualified class name. * @return a CtClass object or null. * @see #get(String) * @see #find(String) * @since 3.13 */ public CtClass getOrNull(String classname) { CtClass clazz = null; if (classname == null) clazz = null; else try { /* ClassPool.get0() never throws an exception but its subclass may implement get0 that may throw an exception. */ clazz = get0(classname, true); } catch (NotFoundException e){} if (clazz != null) clazz.incGetCounter(); return clazz; } /** * Returns a CtClass object with the given name. * This is almost equivalent to get(String) except * that classname can be an array-type "descriptor" (an encoded * type name) such as [Ljava/lang/Object;. * *

Using this method is not recommended; this method should be * used only to obtain the CtClass object * with a name returned from getClassInfo in * javassist.bytecode.ClassPool. getClassInfo * returns a fully-qualified class name but, if the class is an array * type, it returns a descriptor. * * @param classname a fully-qualified class name or a descriptor * representing an array type. * @see #get(String) * @see javassist.bytecode.ConstPool#getClassInfo(int) * @see javassist.bytecode.Descriptor#toCtClass(String, ClassPool) * @since 3.8.1 */ public CtClass getCtClass(String classname) throws NotFoundException { if (classname.charAt(0) == '[') return Descriptor.toCtClass(classname, this); else return get(classname); } /** * @param useCache false if the cached CtClass must be ignored. * @param searchParent false if the parent class pool is not searched. * @return null if the class could not be found. */ protected synchronized CtClass get0(String classname, boolean useCache) throws NotFoundException { CtClass clazz = null; if (useCache) { clazz = getCached(classname); if (clazz != null) return clazz; } if (!childFirstLookup && parent != null) { clazz = parent.get0(classname, useCache); if (clazz != null) return clazz; } clazz = createCtClass(classname, useCache); if (clazz != null) { // clazz.getName() != classname if classname is "[L;". if (useCache) cacheCtClass(clazz.getName(), clazz, false); return clazz; } if (childFirstLookup && parent != null) clazz = parent.get0(classname, useCache); return clazz; } /** * Creates a CtClass object representing the specified class. * It first examines whether or not the corresponding class * file exists. If yes, it creates a CtClass object. * * @return null if the class file could not be found. */ protected CtClass createCtClass(String classname, boolean useCache) { // accept "[L;" as a class name. if (classname.charAt(0) == '[') classname = Descriptor.toClassName(classname); if (classname.endsWith("[]")) { String base = classname.substring(0, classname.indexOf('[')); if ((!useCache || getCached(base) == null) && find(base) == null) return null; else return new CtArray(classname, this); } else if (find(classname) == null) return null; else return new CtClassType(classname, this); } /** * Searches the class path to obtain the URL of the class file * specified by classname. It is also used to determine whether * the class file exists. * * @param classname a fully-qualified class name. * @return null if the class file could not be found. * @see CtClass#getURL() */ public URL find(String classname) { return source.find(classname); } /* * Is invoked by CtClassType.setName() and methods in this class. * This method throws an exception if the class is already frozen or * if this class pool cannot edit the class since it is in a parent * class pool. * * @see checkNotExists(String) */ void checkNotFrozen(String classname) throws RuntimeException { CtClass clazz = getCached(classname); if (clazz == null) { if (!childFirstLookup && parent != null) { try { clazz = parent.get0(classname, true); } catch (NotFoundException e) {} if (clazz != null) throw new RuntimeException(classname + " is in a parent ClassPool. Use the parent."); } } else if (clazz.isFrozen()) throw new RuntimeException(classname + ": frozen class (cannot edit)"); } /* * This method returns null if this or its parent class pool does * not contain a CtClass object with the class name. * * @see checkNotFrozen(String) */ CtClass checkNotExists(String classname) { CtClass clazz = getCached(classname); if (clazz == null) if (!childFirstLookup && parent != null) { try { clazz = parent.get0(classname, true); } catch (NotFoundException e) {} } return clazz; } /* for CtClassType.getClassFile2(). Don't delegate to the parent. */ InputStream openClassfile(String classname) throws NotFoundException { return source.openClassfile(classname); } void writeClassfile(String classname, OutputStream out) throws NotFoundException, IOException, CannotCompileException { source.writeClassfile(classname, out); } /** * Reads class files from the source and returns an array of * CtClass * objects representing those class files. * *

If an element of classnames ends with "[]", * then this method * returns a CtClass object for that array type. * * @param classnames an array of fully-qualified class name. */ public CtClass[] get(String[] classnames) throws NotFoundException { if (classnames == null) return new CtClass[0]; int num = classnames.length; CtClass[] result = new CtClass[num]; for (int i = 0; i < num; ++i) result[i] = get(classnames[i]); return result; } /** * Reads a class file and obtains a compile-time method. * * @param classname the class name * @param methodname the method name * @see CtClass#getDeclaredMethod(String) */ public CtMethod getMethod(String classname, String methodname) throws NotFoundException { CtClass c = get(classname); return c.getDeclaredMethod(methodname); } /** * Creates a new class (or interface) from the given class file. * If there already exists a class with the same name, the new class * overwrites that previous class. * *

This method is used for creating a CtClass object * directly from a class file. The qualified class name is obtained * from the class file; you do not have to explicitly give the name. * * @param classfile class file. * @throws RuntimeException if there is a frozen class with the * the same name. * @see #makeClassIfNew(InputStream) * @see javassist.ByteArrayClassPath */ public CtClass makeClass(InputStream classfile) throws IOException, RuntimeException { return makeClass(classfile, true); } /** * Creates a new class (or interface) from the given class file. * If there already exists a class with the same name, the new class * overwrites that previous class. * *

This method is used for creating a CtClass object * directly from a class file. The qualified class name is obtained * from the class file; you do not have to explicitly give the name. * * @param classfile class file. * @param ifNotFrozen throws a RuntimeException if this parameter is true * and there is a frozen class with the same name. * @see javassist.ByteArrayClassPath */ public CtClass makeClass(InputStream classfile, boolean ifNotFrozen) throws IOException, RuntimeException { compress(); classfile = new BufferedInputStream(classfile); CtClass clazz = new CtClassType(classfile, this); clazz.checkModify(); String classname = clazz.getName(); if (ifNotFrozen) checkNotFrozen(classname); cacheCtClass(classname, clazz, true); return clazz; } /** * Creates a new class (or interface) from the given class file. * If there already exists a class with the same name, this method * returns the existing class; a new class is never created from * the given class file. * *

This method is used for creating a CtClass object * directly from a class file. The qualified class name is obtained * from the class file; you do not have to explicitly give the name. * * @param classfile the class file. * @see #makeClass(InputStream) * @see javassist.ByteArrayClassPath * @since 3.9 */ public CtClass makeClassIfNew(InputStream classfile) throws IOException, RuntimeException { compress(); classfile = new BufferedInputStream(classfile); CtClass clazz = new CtClassType(classfile, this); clazz.checkModify(); String classname = clazz.getName(); CtClass found = checkNotExists(classname); if (found != null) return found; else { cacheCtClass(classname, clazz, true); return clazz; } } /** * Creates a new public class. * If there already exists a class with the same name, the new class * overwrites that previous class. * *

If no constructor is explicitly added to the created new * class, Javassist generates constructors and adds it when * the class file is generated. It generates a new constructor * for each constructor of the super class. The new constructor * takes the same set of parameters and invokes the * corresponding constructor of the super class. All the received * parameters are passed to it. * * @param classname a fully-qualified class name. * @throws RuntimeException if the existing class is frozen. */ public CtClass makeClass(String classname) throws RuntimeException { return makeClass(classname, null); } /** * Creates a new public class. * If there already exists a class/interface with the same name, * the new class overwrites that previous class. * *

If no constructor is explicitly added to the created new * class, Javassist generates constructors and adds it when * the class file is generated. It generates a new constructor * for each constructor of the super class. The new constructor * takes the same set of parameters and invokes the * corresponding constructor of the super class. All the received * parameters are passed to it. * * @param classname a fully-qualified class name. * @param superclass the super class. * @throws RuntimeException if the existing class is frozen. */ public synchronized CtClass makeClass(String classname, CtClass superclass) throws RuntimeException { checkNotFrozen(classname); CtClass clazz = new CtNewClass(classname, this, false, superclass); cacheCtClass(classname, clazz, true); return clazz; } /** * Creates a new public nested class. * This method is called by CtClassType.makeNestedClass(). * * @param classname a fully-qualified class name. * @return the nested class. */ synchronized CtClass makeNestedClass(String classname) { checkNotFrozen(classname); CtClass clazz = new CtNewNestedClass(classname, this, false, null); cacheCtClass(classname, clazz, true); return clazz; } /** * Creates a new public interface. * If there already exists a class/interface with the same name, * the new interface overwrites that previous one. * * @param name a fully-qualified interface name. * @throws RuntimeException if the existing interface is frozen. */ public CtClass makeInterface(String name) throws RuntimeException { return makeInterface(name, null); } /** * Creates a new public interface. * If there already exists a class/interface with the same name, * the new interface overwrites that previous one. * * @param name a fully-qualified interface name. * @param superclass the super interface. * @throws RuntimeException if the existing interface is frozen. */ public synchronized CtClass makeInterface(String name, CtClass superclass) throws RuntimeException { checkNotFrozen(name); CtClass clazz = new CtNewClass(name, this, true, superclass); cacheCtClass(name, clazz, true); return clazz; } /** * Appends the system search path to the end of the * search path. The system search path * usually includes the platform library, extension * libraries, and the search path specified by the * -classpath option or the CLASSPATH * environment variable. * * @return the appended class path. */ public ClassPath appendSystemPath() { return source.appendSystemPath(); } /** * Insert a ClassPath object at the head of the * search path. * * @return the inserted class path. * @see javassist.ClassPath * @see javassist.URLClassPath * @see javassist.ByteArrayClassPath */ public ClassPath insertClassPath(ClassPath cp) { return source.insertClassPath(cp); } /** * Appends a ClassPath object to the end of the * search path. * * @return the appended class path. * @see javassist.ClassPath * @see javassist.URLClassPath * @see javassist.ByteArrayClassPath */ public ClassPath appendClassPath(ClassPath cp) { return source.appendClassPath(cp); } /** * Inserts a directory or a jar (or zip) file at the head of the * search path. * * @param pathname the path name of the directory or jar file. * It must not end with a path separator ("/"). * If the path name ends with "/*", then all the * jar files matching the path name are inserted. * * @return the inserted class path. * @throws NotFoundException if the jar file is not found. */ public ClassPath insertClassPath(String pathname) throws NotFoundException { return source.insertClassPath(pathname); } /** * Appends a directory or a jar (or zip) file to the end of the * search path. * * @param pathname the path name of the directory or jar file. * It must not end with a path separator ("/"). * If the path name ends with "/*", then all the * jar files matching the path name are appended. * * @return the appended class path. * @throws NotFoundException if the jar file is not found. */ public ClassPath appendClassPath(String pathname) throws NotFoundException { return source.appendClassPath(pathname); } /** * Detatches the ClassPath object from the search path. * The detached ClassPath object cannot be added * to the path again. */ public void removeClassPath(ClassPath cp) { source.removeClassPath(cp); } /** * Appends directories and jar files for search. * *

The elements of the given path list must be separated by colons * in Unix or semi-colons in Windows. * * @param pathlist a (semi)colon-separated list of * the path names of directories and jar files. * The directory name must not end with a path * separator ("/"). * @throws NotFoundException if a jar file is not found. */ public void appendPathList(String pathlist) throws NotFoundException { char sep = File.pathSeparatorChar; int i = 0; for (;;) { int j = pathlist.indexOf(sep, i); if (j < 0) { appendClassPath(pathlist.substring(i)); break; } else { appendClassPath(pathlist.substring(i, j)); i = j + 1; } } } /** * Converts the given class to a java.lang.Class object. * Once this method is called, further modifications are not * allowed any more. * To load the class, this method uses the context class loader * of the current thread. It is obtained by calling * getClassLoader(). * *

This behavior can be changed by subclassing the pool and changing * the getClassLoader() method. * If the program is running on some application * server, the context class loader might be inappropriate to load the * class. * *

This method is provided for convenience. If you need more * complex functionality, you should write your own class loader. * *

Warining: A Class object returned by this method may not * work with a security manager or a signed jar file because a * protection domain is not specified. * * @see #toClass(CtClass, java.lang.ClassLoader, ProtectionDomain) * @see #getClassLoader() */ public Class toClass(CtClass clazz) throws CannotCompileException { // Some subclasses of ClassPool may override toClass(CtClass,ClassLoader). // So we should call that method instead of toClass(.., ProtectionDomain). return toClass(clazz, getClassLoader()); } /** * Get the classloader for toClass(), getAnnotations() in * CtClass, etc. * *

The default is the context class loader. * * @return the classloader for the pool * @see #toClass(CtClass) * @see CtClass#getAnnotations() */ public ClassLoader getClassLoader() { return getContextClassLoader(); } /** * Obtains a class loader that seems appropriate to look up a class * by name. */ static ClassLoader getContextClassLoader() { return Thread.currentThread().getContextClassLoader(); } /** * Converts the class to a java.lang.Class object. * Do not override this method any more at a subclass because * toClass(CtClass) never calls this method. * *

Warining: A Class object returned by this method may not * work with a security manager or a signed jar file because a * protection domain is not specified. * * @deprecated Replaced by {@link #toClass(CtClass,ClassLoader,ProtectionDomain)}. * A subclass of ClassPool that has been * overriding this method should be modified. It should override * {@link #toClass(CtClass,ClassLoader,ProtectionDomain)}. */ public Class toClass(CtClass ct, ClassLoader loader) throws CannotCompileException { return toClass(ct, loader, null); } /** * Converts the class to a java.lang.Class object. * Once this method is called, further modifications are not allowed * any more. * *

The class file represented by the given CtClass is * loaded by the given class loader to construct a * java.lang.Class object. Since a private method * on the class loader is invoked through the reflection API, * the caller must have permissions to do that. * *

An easy way to obtain ProtectionDomain object is * to call getProtectionDomain() * in java.lang.Class. It returns the domain that the * class belongs to. * *

This method is provided for convenience. If you need more * complex functionality, you should write your own class loader. * * @param loader the class loader used to load this class. * For example, the loader returned by * getClassLoader() can be used * for this parameter. * @param domain the protection domain for the class. * If it is null, the default domain created * by java.lang.ClassLoader is used. * * @see #getClassLoader() * @since 3.3 */ public Class toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain) throws CannotCompileException { try { byte[] b = ct.toBytecode(); java.lang.reflect.Method method; Object[] args; if (domain == null) { method = defineClass1; args = new Object[] { ct.getName(), b, new Integer(0), new Integer(b.length)}; } else { method = defineClass2; args = new Object[] { ct.getName(), b, new Integer(0), new Integer(b.length), domain}; } return (Class)toClass2(method, loader, args); } catch (RuntimeException e) { throw e; } catch (java.lang.reflect.InvocationTargetException e) { throw new CannotCompileException(e.getTargetException()); } catch (Exception e) { throw new CannotCompileException(e); } } private static synchronized Object toClass2(Method method, ClassLoader loader, Object[] args) throws Exception { method.setAccessible(true); try { return method.invoke(loader, args); } finally { method.setAccessible(false); } } /** * Defines a new package. If the package is already defined, this method * performs nothing. * *

You do not necessarily need to * call this method. If this method is called, then * getPackage() on the Class object returned * by toClass() will return a non-null object. * * @param loader the class loader passed to toClass() or * the default one obtained by getClassLoader(). * @param name the package name. * @see #getClassLoader() * @see #toClass(CtClass) * @see CtClass#toClass() * @since 3.16 */ public void makePackage(ClassLoader loader, String name) throws CannotCompileException { Object[] args = new Object[] { name, null, null, null, null, null, null, null }; Throwable t; try { toClass2(definePackage, loader, args); return; } catch (java.lang.reflect.InvocationTargetException e) { t = e.getTargetException(); if (t == null) t = e; else if (t instanceof IllegalArgumentException) { // if the package is already defined, an IllegalArgumentException // is thrown. return; } } catch (Exception e) { t = e; } throw new CannotCompileException(t); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy