Class.forName : Java Glossary

Uses of Class.forName

• You want write a program such as the Holiday calculator which comes with modules for computing a few dozen Holidays. You want to make it possible for users of the program to easily add more holiday calculator plug-ins for obscure holidays without having to look at, modify or recompile any source code.

  When you want code to work with a class that does not yet exist, or is not available, at the time of compilation, you define an interface. The base code references only that interface. You tell your clients that any new code must implement that interface. Then at runtime you use Class.forName to load the new class, then use its methods via the interface methods. The Holiday calculator works this way. You can plug in you own code for new holidays without recompiling. Other places you see this provider/plug-in approach are JDBC (Java Data Base Connectivity) drivers and JCE providers.

• You want to write a program that composes Java programs, compiles them, then executes them, on the fly, without human intervention. It might generate thousands of such little programs. You need to be able to execute class files that did not exist when your calling code was written.
• You want to write a program that generates JVM (Java Virtual Machine) byte codes, class file images in RAM (Random Access Memory), then executes them, without ever writing the *.class file to disk. For this you also need to write a custom ClassLoader since the standard one does not look in RAM, only on disk in the classpath.
• You want to write a BeanBox editor that can take any Bean-compliant class and execute it and edit its fields. For this you also need Reflection to find out what get/set methods are available.
• You want to write a spreadsheet amanuensis, a simple, flexible, high performance spreadsheet component.

Under the Hood

Now let’s look under the hood to understand how the various tools work. There are Class objects (objects of class Class) that represent classes (including arrays), interfaces and primitives. The Class.newInstance method lets you create new objects of that class without requiring a variable declared specifically of that class. You are using the default public no arg constructor. Your class had better have one. This allows code to be much more open ended than in other languages, with new variants added dynamically. The Class.getName method lets you display the class name. There are also methods to discover the details of the fields and methods associated with the class in the java.lang.reflect.* package. Class.forName eagerly loads the class if it not already loaded. Inside the JVM there is a HashMap of all the classes that have been previously loaded. So Class.forName takes under a millisecond if the class you have want is already loaded, If not, it might take 15 milliseconds or so to load it. You pay this time penalty only the first time you use the class. Class.forName is still slower than hard coding the name of the class into your code. With hard coding, you avoid repeated HashMap lookups.

Creating Class Objects

Class.forName is oblivious to any import statements, so you must fully qualify your class names.

The .class syntax is a kludge, especially double.class. It behaves as though it were a read-only static field even though there is no such field, though obviously there must a hidden pointer in the Class object to the class name.

Class Instance Methods

Nested Classes

Class Names

Dynamic Class Loading

To keep thing simple, when you have variable classes, they all implement some interface, abstract class or base class, in this case HolInfo:

To go the other way, to get the class name from an object, use obj.getClass().getName().

For a practical example of the technique,

Sample Code to Dynamically Load Classes

Here is some code that dynamically loads classes, given just the unqualified class name. It looks in two different packages. It caches the classes it finds. The public method returns instances of the named class that implement the Macro interface, not Class objects. This code is the guts of the HTML (Hypertext Markup Language) Static Macros engine. The key tools are Class.forName and Class.

Finding Classes

Warning

• Don’t go frivolously using Class.forName since it will allocate the statics and load all the methods for that class.
• Class.forName just loads the class. It does not run the static initialisation code. To trigger the static init code, execute some dummy static method.

Limitations

When I first encountered Java, I was very excited about the notion of interfaces and dynamic loading. I thought it would let people plug in their own code to every conceivable utility.

There are two catches:

1. arranging that java.exe will look for your dynamic class in the place where it is. It will not usually be bundled in the original jar.
2. arranging that java.exe will look for any auxiliary classes your plug-in needs in the place where they live.

A garden variety jar without a Class-Path entry in the manifest, prevents java from looking anywhere else for classes. The same problem applies to java on other platforms, Java Webstart and the Java Applet plug-in.

How can you get around the problem?

• Skirt the problem by putting all classes in the original jar. This is not very dynamic or open.
• You can put a classpath inside the jar. You can use that to do relative references, i.e. via same directory or URL that hosts the referencing jar. Here is what the manifest entry might look like

  Class-Path: lib/antlr-runtime-3.0.jar lib/core-3.2.3.v_686_R32x.jar li
   b/derby.jar lib/drools-compiler-4.0.7.jar lib/drools-core-4.0.7.jar l
   ib/mvel-1.3.1-java1.4.jar lib/mysql-connector-java-5.1.7-bin.jar lib/
   ojdbc5.jar lib/postgresql-8.3-603.jdbc3.jar

  There are a number of weirdnesses:

  • Lines cannot be longer than 72 characters
  • The path entries are separated by spaces
  • Lines are wrapped and indented by one space.
  • Relative paths are relative to where the jar is stored and executed from.
  • Class-Path contains a dash and capital letters.

  This is one of the ugliest file formats I have ever encountered, however, ANT (A Neat Tool) will build it for you.

• For more advanced cases, you can instantiate a URLClassLoader with the URL for where to look for dynamic loaded classes.
• Use a JEE containers or Tomcat. They have dynamic loading built-in.

Dynamic class loaders bring with them their own set of problems:

• Class.equals() will fail on classes loaded by different classloaders, as will Object.equals().
• You can’t unload a class just like that, as the ClassLoader keeps references to all loaded classes. You need to unload the ClassLoader too. This makes it tricky to reload plug-ins without a JVM restart.

Learning More