| java.lang.Object
 javassist.ClassPool
All known Subclasses: javassist.scopedpool.ScopedClassPool,
| ClassPool | | public class ClassPool (Code) | | 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 Also: javassist.CtClass
See Also: javassist.ClassPath
|
| Constructor Summary | |
| public | ClassPool()
Creates a root class pool. | | public | ClassPool(boolean useDefaultPath)
Creates a root class pool. | | public | ClassPool(ClassPool parent)
Creates a class pool.
Parameters:
parent - the parent of this class pool. |
| Method Summary | |
| public ClassPath | appendClassPath(ClassPath cp)
Appends a ClassPath object to the end of the
search path. | | public ClassPath | appendClassPath(String pathname)
Appends a directory or a jar (or zip) file to the end of the
search path.
Parameters:
pathname - the path name of the directory or jar file.It must not end with a path separator ("/"). | | public void | appendPathList(String pathlist)
Appends directories and jar files for search. | | public ClassPath | appendSystemPath()
Appends the system search path to the end of the
search path. | | protected void | cacheCtClass(String classname, CtClass c, boolean dynamic)
Provides a hook so that subclasses can do their own
caching of classes. | | void | checkNotFrozen(String classname)
| | synchronized void | classNameChanged(String oldname, CtClass clazz)
| | public void | clearImportedPackages()
Clear all the package names recorded by importPackage(). | | protected CtClass | createCtClass(String classname, boolean useCache)
Creates a CtClass object representing the specified class.
It first examines whether or not the corresponding class
file exists. | | public URL | find(String classname)
Searches the class path to obtain the URL of the class file
specified by classname. | | public CtClass | get(String classname)
Reads a class file from the source and returns a reference
to the CtClass
object representing that class file. | | public CtClass[] | get(String[] classnames)
Reads class files from the source and returns an array of
CtClass
objects representing those class files. | | protected synchronized CtClass | get0(String classname, boolean useCache)
Parameters:
useCache - false if the cached CtClass must be ignored.
Parameters:
searchParent - false if the parent class pool is not searched. | | public CtClass | getAndRename(String orgName, String newName)
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). | | protected CtClass | getCached(String classname)
Provide a hook so that subclasses can do their own
caching of classes. | | public ClassLoader | getClassLoader()
Get the classloader for toClass(), getAnnotations() in
CtClass, etc. | | static ClassLoader | getContextClassLoader()
Obtains a class loader that seems appropriate to look up a class
by name. | | public static synchronized ClassPool | getDefault()
Returns the default class pool. | | public Iterator | getImportedPackages()
Returns all the package names recorded by importPackage(). | | public CtMethod | getMethod(String classname, String methodname)
Reads a class file and obtains a compile-time method. | | public void | importPackage(String packageName)
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.
Note that get() in ClassPool does
not search the recorded package. | | public ClassPath | insertClassPath(ClassPath cp)
Insert a ClassPath object at the head of the
search path. | | public ClassPath | insertClassPath(String pathname)
Inserts a directory or a jar (or zip) file at the head of the
search path.
Parameters:
pathname - the path name of the directory or jar file.It must not end with a path separator ("/"). | | public Object[] | lookupCflow(String name)
Undocumented method. | | public CtClass | makeClass(InputStream classfile)
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. | | public CtClass | makeClass(String classname)
Creates a new public class. | | public synchronized CtClass | makeClass(String classname, CtClass superclass)
Creates a new public class. | | public CtClass | makeInterface(String name)
Creates a new public interface. | | public synchronized CtClass | makeInterface(String name, CtClass superclass)
Creates a new public interface. | | synchronized CtClass | makeNestedClass(String classname)
Creates a new public nested class.
This method is called by CtClassType.makeNestedClass().
Parameters:
classname - a fully-qualified class name. | | InputStream | openClassfile(String classname)
| | void | recordCflow(String name, String cname, String fname)
Records the $cflow variable for the field specified
by cname and fname. | | public void | recordInvalidClassName(String name)
Records a name that never exists. | | protected CtClass | removeCached(String classname)
Provide a hook so that subclasses can do their own
caching of classes. | | public void | removeClassPath(ClassPath cp)
Detatches the ClassPath object from the search path. | | public Class | toClass(CtClass clazz)
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. | | public Class | toClass(CtClass ct, ClassLoader loader)
Converts the class to a java.lang.Class object. | | public Class | toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)
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. | | public String | toString()
Returns the class search path. | | void | writeClassfile(String classname, OutputStream out)
|
| childFirstLookup | | public boolean childFirstLookup(Code) | | 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.
|
| doPruning | | public static boolean doPruning(Code) | | 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 true.
See Also: CtClass.prune
See Also: CtClass.stopPruning(boolean) |
| releaseUnmodifiedClassFile | | public static boolean releaseUnmodifiedClassFile(Code) | | If true, unmodified and not-recently-used class files are
periodically released for saving memory.
The initial value is true.
|
| ClassPool | | public ClassPool()(Code) | | Creates a root class pool. No parent class pool is specified.
|
| ClassPool | | public ClassPool(boolean useDefaultPath)(Code) | | Creates a root class pool. If useDefaultPath is
true, appendSystemPath() is called. Otherwise,
this constructor is equivalent to the constructor taking no
parameter.
Parameters:
useDefaultPath - true if the system search path isappended. |
| appendClassPath | | public ClassPath appendClassPath(String pathname) throws NotFoundException(Code) | | Appends a directory or a jar (or zip) file to the end of the
search path.
Parameters:
pathname - the path name of the directory or jar file.It must not end with a path separator ("/"). the appended class path.
throws:
NotFoundException - if the jar file is not found. |
| appendPathList | | public void appendPathList(String pathlist) throws NotFoundException(Code) | | 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.
Parameters:
pathlist - a (semi)colon-separated list ofthe path names of directories and jar files.The directory name must not end with a pathseparator ("/").
throws:
NotFoundException - if a jar file is not found. |
| appendSystemPath | | public ClassPath appendSystemPath()(Code) | | 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.
the appended class path. |
| clearImportedPackages | | public void clearImportedPackages()(Code) | | Clear all the package names recorded by importPackage().
The java.lang package is not removed.
See Also: ClassPool.importPackage(String)
since:
3.1 |
| createCtClass | | protected CtClass createCtClass(String classname, boolean useCache)(Code) | | 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.
null if the class file could not be found. |
| find | | public URL find(String classname)(Code) | | 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.
Parameters:
classname - a fully-qualified class name. null if the class file could not be found.
See Also: CtClass.getURL |
| get | | public CtClass get(String classname) throws NotFoundException(Code) | | 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.
Parameters:
classname - a fully-qualified class name. |
| get | | public CtClass[] get(String[] classnames) throws NotFoundException(Code) | | 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.
Parameters:
classnames - an array of fully-qualified class name. |
| get0 | | protected synchronized CtClass get0(String classname, boolean useCache) throws NotFoundException(Code) | |
Parameters:
useCache - false if the cached CtClass must be ignored.
Parameters:
searchParent - false if the parent class pool is not searched. null if the class could not be found. |
| getAndRename | | public CtClass getAndRename(String orgName, String newName) throws NotFoundException(Code) | | 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.
Parameters:
orgName - the original (fully-qualified) class name
Parameters:
newName - the new class name |
| getContextClassLoader | | static ClassLoader getContextClassLoader()(Code) | | Obtains a class loader that seems appropriate to look up a class
by name.
|
| getDefault | | public static synchronized ClassPool getDefault()(Code) | | 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 Also: ClassClassPath
See Also: LoaderClassPath |
| importPackage | | public void importPackage(String packageName)(Code) | | 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.
Note that get() in ClassPool does
not search the recorded package. Only the compiler searches it.
Parameters:
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 |
| insertClassPath | | public ClassPath insertClassPath(String pathname) throws NotFoundException(Code) | | Inserts a directory or a jar (or zip) file at the head of the
search path.
Parameters:
pathname - the path name of the directory or jar file.It must not end with a path separator ("/"). the inserted class path.
throws:
NotFoundException - if the jar file is not found. |
| lookupCflow | | public Object[] lookupCflow(String name)(Code) | | Undocumented method. Do not use; internal-use only.
Parameters:
name - the name of $cflow variable |
| makeClass | | public CtClass makeClass(InputStream classfile) throws IOException, RuntimeException(Code) | | 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.
Parameters:
classfile - class file.
throws:
RuntimeException - if there is a frozen class with thethe same name.
See Also: javassist.ByteArrayClassPath |
| makeClass | | public CtClass makeClass(String classname) throws RuntimeException(Code) | | Creates a new public class.
If there already exists a class with the same name, the new class
overwrites that previous class.
Parameters:
classname - a fully-qualified class name.
throws:
RuntimeException - if the existing class is frozen. |
| makeClass | | public synchronized CtClass makeClass(String classname, CtClass superclass) throws RuntimeException(Code) | | Creates a new public class.
If there already exists a class/interface with the same name,
the new class overwrites that previous class.
Parameters:
classname - a fully-qualified class name.
Parameters:
superclass - the super class.
throws:
RuntimeException - if the existing class is frozen. |
| makeInterface | | public CtClass makeInterface(String name) throws RuntimeException(Code) | | Creates a new public interface.
If there already exists a class/interface with the same name,
the new interface overwrites that previous one.
Parameters:
name - a fully-qualified interface name.
throws:
RuntimeException - if the existing interface is frozen. |
| makeInterface | | public synchronized CtClass makeInterface(String name, CtClass superclass) throws RuntimeException(Code) | | Creates a new public interface.
If there already exists a class/interface with the same name,
the new interface overwrites that previous one.
Parameters:
name - a fully-qualified interface name.
Parameters:
superclass - the super interface.
throws:
RuntimeException - if the existing interface is frozen. |
| makeNestedClass | | synchronized CtClass makeNestedClass(String classname)(Code) | | Creates a new public nested class.
This method is called by CtClassType.makeNestedClass().
Parameters:
classname - a fully-qualified class name. the nested class. |
| recordCflow | | void recordCflow(String name, String cname, String fname)(Code) | | Records the $cflow variable for the field specified
by cname and fname.
Parameters:
name - variable name
Parameters:
cname - class name
Parameters:
fname - field name |
| recordInvalidClassName | | public void recordInvalidClassName(String name)(Code) | | Records a name that never exists.
For example, a package name can be recorded by this method.
This would improve execution performance
since get() does not search 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.
Parameters:
name - a class name (separeted by dot). |
| removeClassPath | | public void removeClassPath(ClassPath cp)(Code) | | Detatches the ClassPath object from the search path.
The detached ClassPath object cannot be added
to the pathagain.
|
| toClass | | public Class toClass(CtClass clazz) throws CannotCompileException(Code) | | 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 Also: ClassPool.toClass(CtClass,java.lang.ClassLoader,ProtectionDomain)
See Also: ClassPool.getClassLoader() |
| toClass | | public Class toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain) throws CannotCompileException(Code) | | 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.
Parameters:
loader - the class loader used to load this class.For example, the loader returned bygetClassLoader() can be usedfor this parameter.
Parameters:
domain - the protection domain for the class.If it is null, the default domain createdby java.lang.ClassLoader is used.
See Also: ClassPool.getClassLoader()
since:
3.3 |
| toString | | public String toString()(Code) | | Returns the class search path.
|
|
|