KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > adventnet > jmx > DefaultClassLoader


1 /**
2 * The XMOJO Project 5
3 * Copyright © 2003 XMOJO.org. All rights reserved.
4
5 * NO WARRANTY
6
7 * BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
8 * THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
9 * OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
10 * PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
11 * OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
13 * TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE
14 * LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
15 * REPAIR OR CORRECTION.
16
17 * IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
18 * ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
19 * THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
20 * GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
21 * USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF
22 * DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
23 * PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE),
24 * EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGES.
26 **/
27
28 package com.adventnet.jmx;
29
30 import java.io.File JavaDoc;
31 import java.io.FileInputStream JavaDoc;
32 import java.util.Hashtable JavaDoc;
33
34 import com.adventnet.agent.logging.Log;
35 import com.adventnet.agent.logging.LogFactory;
36
37 /**
38  * A simple test class loader capable of loading from multiple sources,
39  * such as local files or a URL. Must be subclassed and the abstract method
40  * loadClassBytes() implemented to provide the preferred source.
41  *
42  */
43 public class DefaultClassLoader extends ClassLoader JavaDoc
44 {
45     //---------- Fields --------------------------------------
46 private Hashtable JavaDoc classes = new Hashtable JavaDoc();
47     private char classNameReplacementChar;
48
49     protected boolean monitorOn = false;
50     protected boolean sourceMonitorOn = true;
51
52     private String JavaDoc filePrefix = File.separator;
53     private Log log = null;
54
55     //---------- Initialization ------------------------------
56 public DefaultClassLoader()
57     {
58         try
59         {
60             log = LogFactory.getInstance("JMX");
61         }
62         catch(Exception JavaDoc e)
63         {
64             e.printStackTrace();
65         }
66     }
67
68     //---------- Public Methods ------------------------------
69
70     //---------- Superclass Overrides ------------------------
71
72     /**
73      * This is a simple version for external clients since they
74      * will always want the class resolved before it is returned
75      * to them.
76      */
77     public Class JavaDoc loadClass(String JavaDoc className) throws ClassNotFoundException JavaDoc
78     {
79         return (loadClass(className, true));
80     }
81
82     //---------- Abstract Implementation ---------------------
83 public synchronized Class JavaDoc loadClass(String JavaDoc className, boolean resolveIt)
84                                             throws ClassNotFoundException JavaDoc
85     {
86         Class JavaDoc result;
87         byte[] classBytes;
88
89         //----- Check our local cache of classes
90 result = (Class JavaDoc)classes.get(className);
91         if (result != null)
92         {
93             return result;
94         }
95
96         //----- Check with the primordial class loader
97 try
98         {
99             result = super.findSystemClass(className);
100
101             return result;
102         }
103         catch (ClassNotFoundException JavaDoc e)
104         {
105             log.debug(">> Not a system class.");
106         }
107
108         //----- Try to load it from preferred source
109 // Note loadClassBytes() is an abstract method
110 classBytes = loadClassBytes(className);
111
112         if (classBytes == null)
113         {
114             throw new ClassNotFoundException JavaDoc();
115         }
116
117         //----- Define it (parse the class file)
118 result = defineClass(null, classBytes, 0, classBytes.length);
119         if (result == null)
120         {
121             throw new ClassFormatError JavaDoc();
122         }
123
124         //----- Resolve if necessary
125 if (resolveIt) resolveClass(result);
126
127         // Done
128 classes.put(className, result);
129         log.debug(">> Returning newly loaded class.");
130
131         return result;
132     }
133
134     /**
135      * This optional call allows a class name such as "COM.test.Hello" to be
136      * changed to "COM_test_Hello", which is useful for storing classes from
137      * different packages in the same retrival directory.
138      * In the above example the char would be '_'.
139      */
140     public void setClassNameReplacementChar(char replacement)
141     {
142         classNameReplacementChar = replacement;
143     }
144
145     private byte[] loadClassBytes(String JavaDoc className)
146     {
147         className = formatClassName(className);
148
149         byte result[];
150         String JavaDoc fileName = filePrefix + className;
151         //String fileName = className;
152
153         try
154         {
155             FileInputStream JavaDoc inStream = new FileInputStream JavaDoc(fileName);
156
157             result = new byte[inStream.available()];
158             inStream.read(result);
159             inStream.close();
160
161             return result;
162         }
163         catch (Exception JavaDoc e)
164         {
165             // If we caught an exception, either the class
166 // wasn't found or it was unreadable by our process.
167 log.debug("loadClassBytes",e);
168             return null;
169         }
170     }
171
172     protected String JavaDoc formatClassName(String JavaDoc className)
173     {
174         if (classNameReplacementChar == '\u0000')
175         {
176             // '/' is used to map the package to the path
177 return className.replace('.', '/') + ".class";
178         }
179         else
180         {
181             // Replace '.' with custom char, such as '_'
182 return className.replace('.',
183                 classNameReplacementChar) + ".class";
184         }
185     }
186 } // End class
Popular Tags