|
Reloader -- Class Loading Utility
Reloader is a Java utility that provides some advanced class loading
capabilities not found in standard Java class loaders, such as URLClassLoader.
Reloading comes handy when a new version of a class needs to be loaded without
stopping the process where the class is running. All servlet/JSP engines and
application servers use reloading extensively. Reloading is an invaluable
feature for testing/debugging, but it is can also be useful for the production
application since it allows for hot-swapping of application components.
The main problem of using URLClassLoader or JVM system
loader for dynamic class loading is that they cache all loaded classes in
memory and JDK does not provide API to explicitly discard these cached classes. So,
a new class loader should be created every time when a class needs to be reloaded.
But, since class loader is part of the class type (meaning that two versions of
the same class loaded by different class loaders are treated as two incompatible
data types), it is very easy to run into a problem with ClassCastException.
The related problem is that class loaders always delegate the loading request to
the parent class loader first. It means that classes on the system class path
can't be reloaded since the system loader (parent of all class loaders) is always
going to satisfy the request with the cached version of a class.
Reloader cures the problems of URLClassLoader and the
likes and provides the following capabilities:
-
Reloads classes from the JVM classpath (system classpath). No need to put all
reloadable classes into a separate directory outside of the system classpath (standard
approach employed by most app servers and JSP/servlet engines).
-
Fine-grained control over what classes should or should not be reloaded. For
example,
Reloader can be provided with a list of classes that should be
loaded. Alternatively, the list of "exception" classes (to load all classes
other than exceptions) can be provided. Another option is to put reloadable
classes into separate packages, in which case Reloader would load
only classes from these packages. Standard approach with putting reloadable
classes on the special class path not available to the system loader is, of course, also
supported.
-
Extensive logging using event-notification mechanism.
Reloader can
log various events, such as "before loading", "after loading", "parent class
loader loading" and so on.
-
Loading and logging can be turned on and off dynamically either using provided
API or JVM system property.
For more information on class loaders, see:
|