It turns out, you can get access to fields and methods in JDK classes declared as 'private' through reflection. I don't recommend this and prefer not to use what I'm about to describe. In fact, I consider what I'm about to describe as an option of last resort.
Recently, I ran into bug 6526376 which describes a memory leak in the JDK that impacts products that use java.io.File.deleteOnExit(). This method tracks the file that will be deleted in a statically defined Set in class java.io.DeleteOnExitHook. This set grows, but never shrinks during the life of the JVM, creating a memory leak.
While this bug is marked as fixed in the latest release of the JDK, upgrading to the latest release wasn't an option. Furthermore, this Set is defined as 'private' with no way to get access to its contents and clear the Set (after doing its work), or so I thought. Upon reading a post from Cedriks weblog, I realized that there was a way to access the files listed in this private Set and perform its work through a batch job.
The secret ingredient for this solution is the following four lines:
Class<?> exitHookClass = Class.forName("java.io.DeleteOnExitHook");
Field privateField = exitHookClass.getDeclaredField("files");
LinkedHashSet<String> fileSet = (LinkedHashSet<String>) privateField.get(null);
// You then have full access to the privately defined Set and can modify its content.
With this particular solution, you do want to take care to synchronize access to the Set and not to delete files that are currently in use. I haven't tried this trick to execute private methods yet, but I see no reason why it wouldn't work. Furthermore, these four lines could easily be abstracted and consolidated into a utility class somewhere and re-used in other situations.
I've mixed feelings about this solution. I'm glad that I was able to work around the memory leak with a short amount of code. We would have been stuck recycling our containers periodically, otherwise. I've run into bugs with open source products where this solution could conceivably be used as well.
On the other hand, this breaks encapsulation and leaves developers no way to really guard against unauthorized access to private fields and methods. An architecture principle I try to follow is 'Swim with the stream'. That is, use products as they are intended to be used. This hack definitely breaks this principle. Should we really be able to do this?
There is no question that this is a dangerous tactic. Private methods and fields are effectively unpublished from the perspective of the developers who wrote the code in question. Those developers, can and should feel completely free to refactor (e.g. change or even remove) those private methods and fields with the understanding that they aren't directly affecting calling code. These private fields/methods may disappear in future releases of the code being accessed this way or their intended use may be drastically changed. My solution is fragile and will likely break with a future release of the JDK.
It's possible that developers using this tactic to break into sections of code they weren't given access to might not understand the full context of the fields and methods being used; there may be unintended runtime consequences to accessing and changing private data that hasn't been considered. In my case, how can I really tell if a File listed in the shutdown hook isn't still being used? I elected to address this issue by not deleting any file until an hour after last update or later, but this isn't fool-proof. It's possible that by deleting these files early and removing the set entry, I've created a derivative bug somewhere that will likely be much harder now to find and fix.
On further consideration, the creators of the JDK were wise to allow this. It gives us options when dealing with bugs like this. If I've a developer on staff that routinely uses fragile solutions like this, I've got larger issues. Changing the JDK to prevent this type of unauthorized access to private fields/methods won't save me from the other damage a developer like that can cause.