Java > Open Source Codes > com > sun > jmx > mbeanserver > MBeanSupport


1 /*
2  * @(#)MBeanSupport.java 1.6 05/11/17
3  *
4  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7
8 package com.sun.jmx.mbeanserver;
9
10 import static com.sun.jmx.mbeanserver.Util.*;
11 import java.lang.annotation.Annotation ;
12 import java.lang.ref.WeakReference ;
13 import java.lang.reflect.Constructor ;
14 import java.lang.reflect.GenericArrayType ;
15 import java.lang.reflect.InvocationTargetException ;
16 import java.lang.reflect.Method ;
17 import java.lang.reflect.Type ;
18 import java.util.Arrays ;
19 import java.util.Collections ;
20 import java.util.Iterator ;
21 import java.util.List ;
22 import java.util.Map ;
23 import java.util.Set ;
24 import java.util.WeakHashMap ;
25 import javax.management.Attribute ;
26 import javax.management.AttributeList ;
27 import javax.management.AttributeNotFoundException ;
28 import javax.management.Descriptor ;
29 import javax.management.DynamicMBean ;
30 import javax.management.ImmutableDescriptor ;
31 import javax.management.InstanceAlreadyExistsException ;
32 import javax.management.InvalidAttributeValueException ;
33 import javax.management.JMX ;
34 import javax.management.MBeanAttributeInfo ;
35 import javax.management.MBeanConstructorInfo ;
36 import javax.management.MBeanException ;
37 import javax.management.MBeanInfo ;
38 import javax.management.MBeanNotificationInfo ;
39 import javax.management.MBeanOperationInfo ;
40 import javax.management.MBeanParameterInfo ;
41 import javax.management.MBeanRegistration ;
42 import javax.management.MBeanServer ;
43 import javax.management.NotCompliantMBeanException ;
44 import javax.management.NotificationBroadcaster ;
45 import javax.management.ObjectName ;
46 import javax.management.ReflectionException ;
47 import javax.management.openmbean.OpenMBeanAttributeInfoSupport ;
48 import javax.management.openmbean.OpenMBeanOperationInfoSupport ;
49 import javax.management.openmbean.OpenMBeanParameterInfo ;
50 import javax.management.openmbean.OpenMBeanParameterInfoSupport ;
51 import javax.management.openmbean.OpenType ;
52
53 /**
54  * Base class for MBeans. There is one instance of this class for
55  * every Standard MBean and every MXBean. We try to limit the amount
56  * of information per instance so we can handle very large numbers of
57  * MBeans confortably.
58  *
59  * @param <M> either Method or ConvertingMethod, for Standard MBeans
60  * and MXBeans respectively.
61  *
62  * @since 1.6
63  */
64 /*
65  * We maintain a couple of caches to increase sharing between
66  * different MBeans of the same type and also to reduce creation time
67  * for the second and subsequent instances of the same type.
68  *
69  * The first cache maps from an MBean interface to a PerInterface
70  * object containing information parsed out of the interface. The
71  * interface is either a Standard MBean interface or an MXBean
72  * interface, and there is one cache for each case.
73  *
74  * The PerInterface includes an MBeanInfo. This contains the
75  * attributes and operations parsed out of the interface's methods,
76  * plus a basic Descriptor for the interface containing at least the
77  * interfaceClassName field and any fields derived from annotations on
78  * the interface. This MBeanInfo can never be the MBeanInfo for any
79  * actual MBean, because an MBeanInfo's getClassName() is the name of
80  * a concrete class and we don't know what the class will be.
81  * Furthermore a real MBeanInfo may need to add constructors and/or
82  * notifications to the MBeanInfo.
83  *
84  * The PerInterface also contains an MBeanDispatcher which is able to
85  * route getAttribute, setAttribute, and invoke to the appropriate
86  * method of the interface, including doing any necessary translation
87  * of parameters and return values for MXBeans.
88  *
89  * The PerInterface also contains the original Class for the interface.
90  *
91  * We need to be careful about references. When there are no MBeans
92  * with a given interface, there must not be any strong references to
93  * the interface Class. Otherwise it could never be garbage collected,
94  * and neither could its ClassLoader or any other classes loaded by
95  * its ClassLoader. Therefore the cache must wrap the PerInterface
96  * in a WeakReference. Each instance of MBeanSupport has a strong
97  * reference to its PerInterface, which prevents PerInterface instances
98  * from being garbage-collected prematurely.
99  *
100  * The second cache maps from a concrete class and an MBean interface
101  * that that class implements to the MBeanInfo for that class and
102  * interface. (The ability to specify an interface separately comes
103  * from the class StandardMBean. MBeans registered directly in the
104  * MBean Server will always have the same interface here.)
105  *
106  * The MBeanInfo in this second cache will be the MBeanInfo from the
107  * PerInterface cache for the given itnerface, but with the
108  * getClassName() having the concrete class's name, and the public
109  * constructors based on the concrete class's constructors. This
110  * MBeanInfo can be shared between all instances of the concrete class
111  * specifying the same interface, except instances that are
112  * NotificationBroadcasters. NotificationBroadcasters supply the
113  * MBeanNotificationInfo[] in the MBeanInfo based on the instance
114  * method NotificationBroadcaster.getNotificationInfo(), so two
115  * instances of the same concrete class do not necessarily have the
116  * same MBeanNotificationInfo[]. Currently we do not try to detect
117  * when they do, although it would probably be worthwhile doing that
118  * since it is a very common case.
119  *
120  * Standard MBeans additionally have the property that
121  * getNotificationInfo() must in principle be called every time
122  * getMBeanInfo() is called for the MBean, since the returned array is
123  * allowed to change over time. We attempt to reduce the cost of
124  * doing this by detecting when the Standard MBean is a subclass of
125  * NotificationBroadcasterSupport that does not override
126  * getNotificationInfo(), meaning that the MBeanNotificationInfo[] is
127  * the one that was supplied to the constructor. MXBeans do not have
128  * this problem because their getNotificationInfo() method is called
129  * only once.
130  *
131  */
132 public abstract class MBeanSupport<M>
133         implements DynamicMBean2, MBeanRegistration {
134
135     <T> MBeanSupport(T resource, Class <T> mbeanInterface)
136             throws NotCompliantMBeanException {
137     if (mbeanInterface == null)
138         throw new NotCompliantMBeanException ("Null MBean interface");
139     if (!mbeanInterface.isInstance(resource)) {
140         final String msg =
141         "Resource class " + resource.getClass().getName() +
142         " is not an instance of " + mbeanInterface.getName();
143         throw new NotCompliantMBeanException (msg);
144     }
145     this.resource = resource;
146         MBeanIntrospector introspector = getMBeanIntrospector();
147         this.perInterface = introspector.getPerInterface(mbeanInterface);
148     this.mbeanInfo = introspector.getMBeanInfo(resource, perInterface);
149     }
150
151     /** Return the appropriate introspector for this type of MBean. */
152     abstract MBeanIntrospector<M> getMBeanIntrospector();
153     
154     /**
155      * Return a cookie for this MBean. This cookie will be passed to
156      * MBean method invocations where it can supply additional information
157      * to the invocation. For example, with MXBeans it can be used to
158      * supply the MXBeanLookup context for resolving inter-MXBean references.
159      */
160     abstract Object getCookie();
161
162     public final boolean isMXBean() {
163     return perInterface.isMXBean();
164     }
165
166     // Methods that javax.management.StandardMBean should call from its
167 // preRegister and postRegister, given that it is not supposed to
168 // call the contained object's preRegister etc methods even if it has them
169 public abstract void register(MBeanServer mbs, ObjectName name)
170             throws Exception ;
171     public abstract void unregister();
172
173     public final ObjectName preRegister(MBeanServer server, ObjectName name)
174             throws Exception {
175         if (resource instanceof MBeanRegistration )
176             return ((MBeanRegistration ) resource).preRegister(server, name);
177         else
178             return name;
179     }
180     
181     public final void preRegister2(MBeanServer server, ObjectName name)
182             throws Exception {
183         register(server, name);
184     }
185     
186     public final void registerFailed() {
187         unregister();
188     }
189
190     public final void postRegister(Boolean registrationDone) {
191         if (resource instanceof MBeanRegistration )
192             ((MBeanRegistration ) resource).postRegister(registrationDone);
193     }
194     
195     public final void preDeregister() throws Exception {
196         if (resource instanceof MBeanRegistration )
197             ((MBeanRegistration ) resource).preDeregister();
198     }
199
200     public final void postDeregister() {
201         // Undo any work from registration. We do this in postDeregister
202 // not preDeregister, because if the user preDeregister throws an
203 // exception then the MBean is not unregistered.
204 try {
205             unregister();
206         } finally {
207             if (resource instanceof MBeanRegistration )
208                 ((MBeanRegistration ) resource).postDeregister();
209         }
210     }
211
212     public final Object getAttribute(String attribute)
213         throws AttributeNotFoundException ,
214            MBeanException ,
215            ReflectionException {
216     return perInterface.getAttribute(resource, attribute, getCookie());
217     }
218
219     public final AttributeList getAttributes(String [] attributes) {
220     final AttributeList result = new AttributeList (attributes.length);
221     for (String attrName : attributes) {
222         try {
223         final Object attrValue = getAttribute(attrName);
224         result.add(new Attribute (attrName, attrValue));
225         } catch (Exception e) {
226         // OK: attribute is not included in returned list, per spec
227 // XXX: log the exception
228 }
229     }
230     return result;
231     }
232
233     public final void setAttribute(Attribute attribute)
234         throws AttributeNotFoundException ,
235            InvalidAttributeValueException ,
236            MBeanException ,
237            ReflectionException {
238     final String name = attribute.getName();
239     final Object value = attribute.getValue();
240     perInterface.setAttribute(resource, name, value, getCookie());
241     }
242
243     public final AttributeList setAttributes(AttributeList attributes) {
244     final AttributeList result = new AttributeList (attributes.size());
245     for (Object attrObj : attributes) {
246         // We can't use AttributeList.asList because it has side-effects
247 Attribute attr = (Attribute ) attrObj;
248         try {
249         setAttribute(attr);
250         result.add(new Attribute (attr.getName(), attr.getValue()));
251         } catch (Exception e) {
252         // OK: attribute is not included in returned list, per spec
253 // XXX: log the exception
254 }
255     }
256     return result;
257     }
258
259     public final Object invoke(String operation, Object [] params,
260              String [] signature)
261         throws MBeanException , ReflectionException {
262     return perInterface.invoke(resource, operation, params, signature,
263                    getCookie());
264     }
265
266     // Overridden by StandardMBeanSupport
267 public MBeanInfo getMBeanInfo() {
268     return mbeanInfo;
269     }
270     
271     public final String getClassName() {
272         return resource.getClass().getName();
273     }
274
275     public final Object getResource() {
276     return resource;
277     }
278     
279     public final Class <?> getMBeanInterface() {
280         return perInterface.getMBeanInterface();
281     }
282
283     private final MBeanInfo mbeanInfo;
284     private final Object resource;
285     private final PerInterface<M> perInterface;
286 }
287

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags