javassist
public class ClassPool extends Object
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 CtClass
es
that have been created so that the consistency among modified classes
can be guaranteed. Thus if a large number of CtClass
es
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:
ClassPool
s can make a parent-child hierarchy as
java.lang.ClassLoader
s. 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 ClassPath
s of
the child ClassPool
. This search order is reversed if
ClassPath.childFirstLookup
is true
.
Field Summary | |
---|---|
boolean | childFirstLookup
Determines the search order.
|
static boolean | doPruning
Turning the automatic pruning on/off.
|
static boolean | releaseUnmodifiedClassFile
If true, unmodified and not-recently-used class files are
periodically released for saving memory.
|
Constructor Summary | |
---|---|
ClassPool()
Creates a root class pool. | |
ClassPool(boolean useDefaultPath)
Creates a root class pool. | |
ClassPool(ClassPool parent)
Creates a class pool.
|
Method Summary | |
---|---|
ClassPath | appendClassPath(ClassPath cp)
Appends a ClassPath object to the end of the
search path.
|
ClassPath | appendClassPath(String pathname)
Appends a directory or a jar (or zip) file to the end of the
search path.
|
void | appendPathList(String pathlist)
Appends directories and jar files for search.
|
ClassPath | appendSystemPath()
Appends the system search path to the end of the
search path. |
void | clearImportedPackages()
Clear all the package names recorded by importPackage() .
|
URL | find(String classname)
Searches the class path to obtain the URL of the class file
specified by classname. |
CtClass | get(String classname)
Reads a class file from the source and returns a reference
to the CtClass
object representing that class file. |
CtClass[] | get(String[] classnames)
Reads class files from the source and returns an array of
CtClass
objects representing those class files.
|
CtClass | getAndRename(String orgName, String newName)
Reads a class file and constructs a CtClass
object with a new name.
|
ClassLoader | getClassLoader()
Get the classloader for toClass() , getAnnotations() in
CtClass , etc.
|
static ClassPool | getDefault()
Returns the default class pool.
|
Iterator | getImportedPackages()
Returns all the package names recorded by importPackage() .
|
CtMethod | getMethod(String classname, String methodname)
Reads a class file and obtains a compile-time method.
|
void | importPackage(String packageName)
Record a package name so that the Javassist compiler searches
the package to resolve a class name.
|
ClassPath | insertClassPath(ClassPath cp)
Insert a ClassPath object at the head of the
search path.
|
ClassPath | insertClassPath(String pathname)
Inserts a directory or a jar (or zip) file at the head of the
search path.
|
Object[] | lookupCflow(String name)
Undocumented method. |
CtClass | makeClass(InputStream classfile)
Creates a new class (or interface) from the given class file.
|
CtClass | makeClass(String classname)
Creates a new public class.
|
CtClass | makeClass(String classname, CtClass superclass)
Creates a new public class.
|
CtClass | makeInterface(String name)
Creates a new public interface.
|
CtClass | makeInterface(String name, CtClass superclass)
Creates a new public interface.
|
void | recordInvalidClassName(String name)
Records a name that never exists.
|
void | removeClassPath(ClassPath cp)
Detatches the ClassPath object from the search path.
|
Class | toClass(CtClass clazz)
Converts the given class to a java.lang.Class object.
|
Class | toClass(CtClass ct, ClassLoader loader)
Converts the class to a java.lang.Class object.
|
Class | toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)
Converts the class to a java.lang.Class object.
|
String | toString()
Returns the class search path. |
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.
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.
The initial value is true.
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 is appended.
Parameters: parent the parent of this class pool. If this is a root
class pool, this parameter must be null
.
See Also: getDefault
ClassPath
object to the end of the
search path.
Returns: the appended class path.
See Also: ClassPath URLClassPath ByteArrayClassPath
Parameters: pathname the path name of the directory or jar file. It must not end with a path separator ("/").
Returns: the appended class path.
Throws: NotFoundException if the jar file is not found.
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 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.
-classpath
option or the CLASSPATH
environment variable.
Returns: the appended class path.
importPackage()
.
The java.lang
package is not removed.
Since: 3.1
See Also: importPackage
Parameters: classname a fully-qualified class name.
Returns: null if the class file could not be found.
See Also: getURL
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.
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.
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 newName the new class name
toClass()
, getAnnotations()
in
CtClass
, etc.
The default is the context class loader.
Returns: the classloader for the pool
See Also: toClass getAnnotations
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 LoaderClassPath
Parameters: classname the class name methodname the method name
See Also: getDeclaredMethod
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
ClassPath
object at the head of the
search path.
Returns: the inserted class path.
See Also: ClassPath URLClassPath ByteArrayClassPath
Parameters: pathname the path name of the directory or jar file. It must not end with a path separator ("/").
Returns: the inserted class path.
Throws: NotFoundException if the jar file is not found.
Parameters: name the name of $cflow
variable
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 the the same name.
See Also: ByteArrayClassPath
Parameters: classname a fully-qualified class name.
Throws: RuntimeException if the existing class is frozen.
Parameters: classname a fully-qualified class name. superclass the super class.
Throws: RuntimeException if the existing class is frozen.
Parameters: name a fully-qualified interface name.
Throws: RuntimeException if the existing interface is frozen.
Parameters: name a fully-qualified interface name. superclass the super interface.
Throws: RuntimeException if the existing interface is frozen.
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).
ClassPath
object from the search path.
The detached ClassPath
object cannot be added
to the pathagain.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 getClassLoader
Deprecated: Replaced by toClass.
A subclass of ClassPool
that has been
overriding this method should be modified. It should override
toClass.
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.
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 by
getClassLoader()
can be used
for this parameter. domain the protection domain for the class.
If it is null, the default domain created
by java.lang.ClassLoader
is used.
Since: 3.3
See Also: getClassLoader