Java > Open Source Codes > org > apache > tomcat > util > modeler > ManagedBean


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18
19 package org.apache.tomcat.util.modeler;
20
21
22 import java.lang.reflect.Method ;
23 import java.util.HashMap ;
24 import java.util.Map ;
25
26 import javax.management.AttributeNotFoundException ;
27 import javax.management.DynamicMBean ;
28 import javax.management.InstanceNotFoundException ;
29 import javax.management.MBeanAttributeInfo ;
30 import javax.management.MBeanConstructorInfo ;
31 import javax.management.MBeanException ;
32 import javax.management.MBeanInfo ;
33 import javax.management.MBeanNotificationInfo ;
34 import javax.management.MBeanOperationInfo ;
35 import javax.management.ReflectionException ;
36 import javax.management.RuntimeOperationsException ;
37 import javax.management.ServiceNotFoundException ;
38 //import javax.management.modelmbean.InvalidTargetObjectTypeException;
39
40
41 /**
42  * <p>Internal configuration information for a managed bean (MBean)
43  * descriptor.</p>
44  *
45  * @author Craig R. McClanahan
46  * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
47  */
48
49 public class ManagedBean implements java.io.Serializable
50 {
51     private static final String BASE_MBEAN = "org.apache.tomcat.util.modeler.BaseModelMBean";
52     // ----------------------------------------------------- Instance Variables
53 static final Object [] NO_ARGS_PARAM=new Object [0];
54     static final Class [] NO_ARGS_PARAM_SIG=new Class [0];
55
56
57     /**
58      * The <code>ModelMBeanInfo</code> object that corresponds
59      * to this <code>ManagedBean</code> instance.
60      */
61     transient MBeanInfo info = null;
62     // Map<AttributeInfo>
63 private Map attributes = new HashMap ();
64     //Map<OperationInfo>
65 private Map operations = new HashMap ();
66     
67     protected String className = BASE_MBEAN;
68     //protected ConstructorInfo constructors[] = new ConstructorInfo[0];
69 protected String description = null;
70     protected String domain = null;
71     protected String group = null;
72     protected String name = null;
73
74     //protected List fields = new ArrayList();
75 protected NotificationInfo notifications[] = new NotificationInfo[0];
76     protected String type = null;
77
78     /** Constructor. Will add default attributes.
79      *
80      */
81     public ManagedBean() {
82         AttributeInfo ai=new AttributeInfo();
83         ai.setName("modelerType");
84         ai.setDescription("Type of the modeled resource. Can be set only once");
85         ai.setType("java.lang.String");
86         ai.setWriteable(false);
87         addAttribute(ai);
88     }
89     
90     // ------------------------------------------------------------- Properties
91
92
93     /**
94      * The collection of attributes for this MBean.
95      */
96     public AttributeInfo[] getAttributes() {
97         AttributeInfo result[] = new AttributeInfo[attributes.size()];
98         attributes.values().toArray(result);
99         return result;
100     }
101
102
103     /**
104      * The fully qualified name of the Java class of the MBean
105      * described by this descriptor. If not specified, the standard JMX
106      * class (<code>javax.management.modelmbean.RequiredModeLMBean</code>)
107      * will be utilized.
108      */
109     public String getClassName() {
110         return (this.className);
111     }
112
113     public void setClassName(String className) {
114         this.className = className;
115         this.info = null;
116     }
117
118
119 // /**
120 // * The collection of constructors for this MBean.
121 // */
122 // public ConstructorInfo[] getConstructors() {
123 // return (this.constructors);
124 // }
125
126
127     /**
128      * The human-readable description of this MBean.
129      */
130     public String getDescription() {
131         return (this.description);
132     }
133
134     public void setDescription(String description) {
135         this.description = description;
136         this.info = null;
137     }
138
139
140     /**
141      * The (optional) <code>ObjectName</code> domain in which this MBean
142      * should be registered in the MBeanServer.
143      */
144     public String getDomain() {
145         return (this.domain);
146     }
147
148     public void setDomain(String domain) {
149         this.domain = domain;
150     }
151
152
153     /**
154      * <p>Return a <code>List</code> of the {@link FieldInfo} objects for
155      * the name/value pairs that should be
156      * added to the Descriptor created from this metadata.</p>
157      */
158 // public List getFields() {
159 // return (this.fields);
160 // }
161 //
162
163     /**
164      * The (optional) group to which this MBean belongs.
165      */
166     public String getGroup() {
167         return (this.group);
168     }
169
170     public void setGroup(String group) {
171         this.group = group;
172     }
173
174
175     /**
176      * The name of this managed bean, which must be unique among all
177      * MBeans managed by a particular MBeans server.
178      */
179     public String getName() {
180         return (this.name);
181     }
182
183     public void setName(String name) {
184         this.name = name;
185         this.info = null;
186     }
187
188
189     /**
190      * The collection of notifications for this MBean.
191      */
192     public NotificationInfo[] getNotifications() {
193         return (this.notifications);
194     }
195
196
197     /**
198      * The collection of operations for this MBean.
199      */
200     public OperationInfo[] getOperations() {
201         OperationInfo[] result = new OperationInfo[operations.size()];
202         operations.values().toArray(result);
203         return result;
204     }
205
206
207     /**
208      * The fully qualified name of the Java class of the resource
209      * implementation class described by the managed bean described
210      * by this descriptor.
211      */
212     public String getType() {
213         return (this.type);
214     }
215
216     public void setType(String type) {
217         this.type = type;
218         this.info = null;
219     }
220
221
222     // --------------------------------------------------------- Public Methods
223
224
225     /**
226      * Add a new attribute to the set of attributes for this MBean.
227      *
228      * @param attribute The new attribute descriptor
229      */
230     public void addAttribute(AttributeInfo attribute) {
231         attributes.put(attribute.getName(), attribute);
232     }
233
234
235     /**
236      * Add a new constructor to the set of constructors for this MBean.
237      *
238      * @param constructor The new constructor descriptor
239      */
240 // public void addConstructor(ConstructorInfo constructor) {
241 //
242 // synchronized (constructors) {
243 // ConstructorInfo results[] =
244 // new ConstructorInfo[constructors.length + 1];
245 // System.arraycopy(constructors, 0, results, 0, constructors.length);
246 // results[constructors.length] = constructor;
247 // constructors = results;
248 // this.info = null;
249 // }
250 //
251 // }
252
253
254     /**
255      * <p>Add a new field to the fields associated with the
256      * Descriptor that will be created from this metadata.</p>
257      *
258      * @param field The field to be added
259      */
260 // public void addField(FieldInfo field) {
261 // fields.add(field);
262 // }
263
264
265     /**
266      * Add a new notification to the set of notifications for this MBean.
267      *
268      * @param notification The new notification descriptor
269      */
270     public void addNotification(NotificationInfo notification) {
271
272         synchronized (notifications) {
273             NotificationInfo results[] =
274                 new NotificationInfo[notifications.length + 1];
275             System.arraycopy(notifications, 0, results, 0,
276                              notifications.length);
277             results[notifications.length] = notification;
278             notifications = results;
279             this.info = null;
280         }
281
282     }
283
284
285     /**
286      * Add a new operation to the set of operations for this MBean.
287      *
288      * @param operation The new operation descriptor
289      */
290     public void addOperation(OperationInfo operation) {
291         operations.put(operation.getName(), operation);
292     }
293
294
295     /**
296      * Create and return a <code>ModelMBean</code> that has been
297      * preconfigured with the <code>ModelMBeanInfo</code> information
298      * for this managed bean, but is not associated with any particular
299      * managed resource. The returned <code>ModelMBean</code> will
300      * <strong>NOT</strong> have been registered with our
301      * <code>MBeanServer</code>.
302      *
303      * @exception InstanceNotFoundException if the managed resource
304      * object cannot be found
305      * @exception InvalidTargetObjectTypeException if our MBean cannot
306      * handle object references (should never happen)
307      * @exception MBeanException if a problem occurs instantiating the
308      * <code>ModelMBean</code> instance
309      * @exception RuntimeOperationsException if a JMX runtime error occurs
310      */
311     public DynamicMBean createMBean()
312         throws InstanceNotFoundException ,
313         MBeanException , RuntimeOperationsException {
314
315         return (createMBean(null));
316
317     }
318
319
320     /**
321      * Create and return a <code>ModelMBean</code> that has been
322      * preconfigured with the <code>ModelMBeanInfo</code> information
323      * for this managed bean, and is associated with the specified
324      * managed object instance. The returned <code>ModelMBean</code>
325      * will <strong>NOT</strong> have been registered with our
326      * <code>MBeanServer</code>.
327      *
328      * @param instance Instanced of the managed object, or <code>null</code>
329      * for no associated instance
330      *
331      * @exception InstanceNotFoundException if the managed resource
332      * object cannot be found
333      * @exception InvalidTargetObjectTypeException if our MBean cannot
334      * handle object references (should never happen)
335      * @exception MBeanException if a problem occurs instantiating the
336      * <code>ModelMBean</code> instance
337      * @exception RuntimeOperationsException if a JMX runtime error occurs
338      */
339     public DynamicMBean createMBean(Object instance)
340         throws InstanceNotFoundException ,
341         MBeanException , RuntimeOperationsException {
342
343         BaseModelMBean mbean = null;
344
345         // Load the ModelMBean implementation class
346 if(getClassName().equals(BASE_MBEAN)) {
347             // Skip introspection
348 mbean = new BaseModelMBean();
349         } else {
350             Class clazz = null;
351             Exception ex = null;
352             try {
353                 clazz = Class.forName(getClassName());
354             } catch (Exception e) {
355             }
356           
357             if( clazz==null ) {
358                 try {
359                     ClassLoader cl= Thread.currentThread().getContextClassLoader();
360                     if ( cl != null)
361                         clazz= cl.loadClass(getClassName());
362                 } catch (Exception e) {
363                     ex=e;
364                 }
365             }
366     
367             if( clazz==null) {
368                 throw new MBeanException
369                     (ex, "Cannot load ModelMBean class " + getClassName());
370             }
371             try {
372                 // Stupid - this will set the default minfo first....
373 mbean = (BaseModelMBean) clazz.newInstance();
374             } catch (RuntimeOperationsException e) {
375                 throw e;
376             } catch (Exception e) {
377                 throw new MBeanException
378                     (e, "Cannot instantiate ModelMBean of class " +
379                      getClassName());
380             }
381         }
382         
383         mbean.setManagedBean(this);
384         
385         // Set the managed resource (if any)
386 try {
387             if (instance != null)
388                 mbean.setManagedResource(instance, "ObjectReference");
389         } catch (InstanceNotFoundException e) {
390             throw e;
391         }
392         return (mbean);
393
394     }
395
396
397     /**
398      * Create and return a <code>ModelMBeanInfo</code> object that
399      * describes this entire managed bean.
400      */
401     MBeanInfo getMBeanInfo() {
402
403         // Return our cached information (if any)
404 if (info != null)
405             return (info);
406
407         // Create subordinate information descriptors as required
408 AttributeInfo attrs[] = getAttributes();
409         MBeanAttributeInfo attributes[] =
410             new MBeanAttributeInfo [attrs.length];
411         for (int i = 0; i < attrs.length; i++)
412             attributes[i] = attrs[i].createAttributeInfo();
413
414         OperationInfo opers[] = getOperations();
415         MBeanOperationInfo operations[] =
416             new MBeanOperationInfo [opers.length];
417         for (int i = 0; i < opers.length; i++)
418             operations[i] = opers[i].createOperationInfo();
419
420
421 // ConstructorInfo consts[] = getConstructors();
422 // ModelMBeanConstructorInfo constructors[] =
423 // new ModelMBeanConstructorInfo[consts.length];
424 // for (int i = 0; i < consts.length; i++)
425 // constructors[i] = consts[i].createConstructorInfo();
426
427         NotificationInfo notifs[] = getNotifications();
428         MBeanNotificationInfo notifications[] =
429             new MBeanNotificationInfo [notifs.length];
430         for (int i = 0; i < notifs.length; i++)
431             notifications[i] = notifs[i].createNotificationInfo();
432
433         
434         // Construct and return a new ModelMBeanInfo object
435 info = new MBeanInfo (getClassName(),
436                              getDescription(),
437                              attributes,
438                              new MBeanConstructorInfo [] {},
439                              operations,
440                              notifications);
441 // try {
442 // Descriptor descriptor = info.getMBeanDescriptor();
443 // Iterator fields = getFields().iterator();
444 // while (fields.hasNext()) {
445 // FieldInfo field = (FieldInfo) fields.next();
446 // descriptor.setField(field.getName(), field.getValue());
447 // }
448 // info.setMBeanDescriptor(descriptor);
449 // } catch (MBeanException e) {
450 // ;
451 // }
452
453         return (info);
454
455     }
456
457
458     /**
459      * Return a string representation of this managed bean.
460      */
461     public String toString() {
462
463         StringBuffer sb = new StringBuffer ("ManagedBean[");
464         sb.append("name=");
465         sb.append(name);
466         sb.append(", className=");
467         sb.append(className);
468         sb.append(", description=");
469         sb.append(description);
470         if (group != null) {
471             sb.append(", group=");
472             sb.append(group);
473         }
474         sb.append(", type=");
475         sb.append(type);
476         sb.append("]");
477         return (sb.toString());
478
479     }
480
481     Method getGetter(String aname, BaseModelMBean mbean, Object resource)
482             throws AttributeNotFoundException , MBeanException , ReflectionException {
483         // TODO: do we need caching ? JMX is for management, it's not supposed to require lots of performance.
484 Method m=null; // (Method)getAttMap.get( name );
485
486         if( m==null ) {
487             AttributeInfo attrInfo = (AttributeInfo)attributes.get(aname);
488             // Look up the actual operation to be used
489 if (attrInfo == null)
490                 throw new AttributeNotFoundException (" Cannot find attribute " + aname + " for " + resource);
491             
492             String getMethod = attrInfo.getGetMethod();
493             if (getMethod == null)
494                 throw new AttributeNotFoundException ("Cannot find attribute " + aname + " get method name");
495
496             Object object = null;
497             NoSuchMethodException exception = null;
498             try {
499                 object = mbean;
500                 m = object.getClass().getMethod(getMethod, NO_ARGS_PARAM_SIG);
501             } catch (NoSuchMethodException e) {
502                 exception = e;;
503             }
504             if( m== null && resource != null ) {
505                 try {
506                     object = resource;
507                     m = object.getClass().getMethod(getMethod, NO_ARGS_PARAM_SIG);
508                     exception=null;
509                 } catch (NoSuchMethodException e) {
510                     exception = e;
511                 }
512             }
513             if( exception != null )
514                 throw new ReflectionException (exception,
515                                               "Cannot find getter method " + getMethod);
516             //getAttMap.put( name, m );
517 }
518
519         return m;
520     }
521
522     public Method getSetter(String aname, BaseModelMBean bean, Object resource)
523             throws AttributeNotFoundException , MBeanException , ReflectionException {
524         // Cache may be needed for getters, but it is a really bad idea for setters, this is far
525 // less frequent.
526 Method m=null;//(Method)setAttMap.get( name );
527
528         if( m==null ) {
529             AttributeInfo attrInfo = (AttributeInfo)attributes.get(aname);
530             if (attrInfo == null)
531                 throw new AttributeNotFoundException (" Cannot find attribute " + aname);
532
533             // Look up the actual operation to be used
534 String setMethod = attrInfo.getSetMethod();
535             if (setMethod == null)
536                 throw new AttributeNotFoundException ("Cannot find attribute " + aname + " set method name");
537
538             String argType=attrInfo.getType();
539
540             Class signature[] = new Class [] { BaseModelMBean.getAttributeClass( argType ) };
541
542             Object object = null;
543             NoSuchMethodException exception = null;
544             try {
545                 object = this;
546                 m = object.getClass().getMethod(setMethod, signature);
547             } catch (NoSuchMethodException e) {
548                 exception = e;;
549             }
550             if( m== null && resource != null ) {
551                 try {
552                     object = resource;
553                     m = object.getClass().getMethod(setMethod, signature);
554                     exception=null;
555                 } catch (NoSuchMethodException e) {
556                     exception = e;
557                 }
558             }
559             if( exception != null )
560                 throw new ReflectionException (exception,
561                                               "Cannot find setter method " + setMethod +
562                         " " + resource);
563             //setAttMap.put( name, m );
564 }
565
566         return m;
567     }
568
569     public Method getInvoke(String aname, Object [] params, String [] signature, BaseModelMBean bean, Object resource)
570             throws MBeanException , ReflectionException {
571         Method method = null;
572         if (method == null) {
573             if (params == null)
574                 params = new Object [0];
575             if (signature == null)
576                 signature = new String [0];
577             if (params.length != signature.length)
578                 throw new RuntimeOperationsException (
579                         new IllegalArgumentException (
580                                 "Inconsistent arguments and signature"),
581                         "Inconsistent arguments and signature");
582
583             // Acquire the ModelMBeanOperationInfo information for
584 // the requested operation
585 OperationInfo opInfo = (OperationInfo)operations.get(aname);
586             if (opInfo == null)
587                 throw new MBeanException (new ServiceNotFoundException (
588                         "Cannot find operation " + aname),
589                         "Cannot find operation " + aname);
590
591             // Prepare the signature required by Java reflection APIs
592 // FIXME - should we use the signature from opInfo?
593 Class types[] = new Class [signature.length];
594             for (int i = 0; i < signature.length; i++) {
595                 types[i] = BaseModelMBean.getAttributeClass(signature[i]);
596             }
597
598             // Locate the method to be invoked, either in this MBean itself
599 // or in the corresponding managed resource
600 // FIXME - Accessible methods in superinterfaces?
601 Object object = null;
602             Exception exception = null;
603             try {
604                 object = this;
605                 method = object.getClass().getMethod(aname, types);
606             } catch (NoSuchMethodException e) {
607                 exception = e;
608                 ;
609             }
610             try {
611                 if ((method == null) && (resource != null)) {
612                     object = resource;
613                     method = object.getClass().getMethod(aname, types);
614                 }
615             } catch (NoSuchMethodException e) {
616                 exception = e;
617             }
618             if (method == null) {
619                 throw new ReflectionException (exception, "Cannot find method "
620                         + aname + " with this signature");
621             }
622             // invokeAttMap.put(mkey, method);
623 }
624         return method;
625     }
626
627
628 }
629

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags