SimpleDynamic


1   package org.webjmx.example;
2   
3   
4   // Java imports
5   //
6   import java.lang.reflect.Constructor  ;
7   import java.util.Iterator  ;
8   
9   import javax.management.*;
10  
11  /**
12   * Simple definition of a dynamic MBean, named "SimpleDynamic".
13   *
14   * The "SimpleDynamic" dynamic MBean shows how to expose for management
15   * attributes and operations, at runtime,  by implementing the  
16   * "javax.management.DynamicMBean" interface.
17   *
18   * This MBean exposes for management two attributes and one operation:
19   *      - the read/write "State" attribute,
20   *      - the read only "NbChanges" attribute,
21   *  - the "reset()" operation.
22   * It does so by putting this information in an MBeanInfo object that
23   * is returned by the getMBeanInfo() method of the DynamicMBean interface.
24   *
25   * It implements the access to its attributes through the getAttribute(),
26   * getAttributes(), setAttribute(), and setAttributes() methods of the
27   * DynamicMBean interface.
28   *
29   * It implements the invocation of its reset() operation through the
30   * invoke() method of the DynamicMBean interface.
31   * 
32   * Note that as "SimpleDynamic" explicitly defines one constructor,
33   * this constructor must be public and exposed for management through
34   * the MBeanInfo object.
35   */
36  
37  public class SimpleDynamic implements DynamicMBean 
38  {
39      public SimpleDynamic() 
40      {
41      // build the management information to be exposed by the dynamic MBean
42      //
43      buildDynamicMBeanInfo();
44      }
45  
46      /*
47       * -----------------------------------------------------
48       * IMPLEMENTATION OF THE DynamicMBean INTERFACE
49       * -----------------------------------------------------
50       */
51  
52      /**
53       * Allows the value of the specified attribute of the Dynamic MBean to be obtained.
54       */
55      public Object   getAttribute(String   attribute_name) 
56      throws AttributeNotFoundException, MBeanException, ReflectionException 
57      {
58  
59      // Check attribute_name is not null to avoid NullPointerException later on
60      if (attribute_name == null) 
61          throw new RuntimeOperationsException(new IllegalArgumentException  ("Attribute name cannot be null"), 
62                           "Cannot invoke a getter of " + dClassName + " with null attribute name");
63      
64      // Check for a recognized attribute_name and call the corresponding getter
65      if (attribute_name.equals("State")) 
66          return getState();
67      
68      if (attribute_name.equals("NbChanges")) 
69          return getNbChanges();
70      
71      // If attribute_name has not been recognized throw an AttributeNotFoundException
72      throw(new AttributeNotFoundException("Cannot find " + attribute_name + " attribute in " + dClassName));
73      }
74  
75      /**
76       * Sets the value of the specified attribute of the Dynamic MBean.
77       */
78      public void setAttribute(Attribute attribute) 
79      throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException,  ReflectionException 
80      {
81  
82      // Check attribute is not null to avoid NullPointerException later on
83      if (attribute == null) {
84          throw new RuntimeOperationsException(new IllegalArgumentException  ("Attribute cannot be null"), 
85                           "Cannot invoke a setter of " + dClassName + " with null attribute");
86      }
87      String   name = attribute.getName();
88      Object   value = attribute.getValue();
89  
90      if (name == null) {
91          throw new RuntimeOperationsException(new IllegalArgumentException  ("Attribute name cannot be null"), 
92                           "Cannot invoke the setter of " + dClassName + " with null attribute name");
93      }
94      // Check for a recognized attribute name and call the corresponding setter
95      //
96      if (name.equals("State")) {
97          // if null value, try and see if the setter returns any exception
98          if (value == null) {
99          try {
100             setState( null );
101         } catch (Exception   e) {
102             throw(new InvalidAttributeValueException("Cannot set attribute "+ name +" to null")); 
103         }
104         }
105         // if non null value, make sure it is assignable to the attribute
106         else {
107         try {
108             if ((Class.forName("java.lang.String")).isAssignableFrom(value.getClass())) {
109             setState((String  ) value);
110             }
111             else {
112             throw(new InvalidAttributeValueException("Cannot set attribute "+ name +" to a " + 
113                                  value.getClass().getName() + " object, String expected"));
114             }
115         } catch (ClassNotFoundException   e) {
116             e.printStackTrace();
117         }
118         }
119     }
120     // recognize an attempt to set "NbChanges" attribute (read-only):
121     else if (name.equals("NbChanges")) {
122         throw(new AttributeNotFoundException("Cannot set attribute "+ name +" because it is read-only"));
123     }
124     // unrecognized attribute name:
125     else {
126         throw(new AttributeNotFoundException("Attribute " + name +
127                          " not found in " + this.getClass().getName()));
128     }
129     }
130 
131     /**
132      * Enables the to get the values of several attributes of the Dynamic MBean.
133      */
134     public AttributeList getAttributes(String  [] attributeNames) {
135 
136     // Check attributeNames is not null to avoid NullPointerException later on
137     if (attributeNames == null) {
138         throw new RuntimeOperationsException(new IllegalArgumentException  ("attributeNames[] cannot be null"),
139                          "Cannot invoke a getter of " + dClassName);
140     }
141     AttributeList resultList = new AttributeList();
142 
143     // if attributeNames is empty, return an empty result list
144     if (attributeNames.length == 0)
145         return resultList;
146         
147     // build the result attribute list
148     for (int i=0 ; i<attributeNames.length ; i++){
149         try {        
150         Object   value = getAttribute((String  ) attributeNames[i]);     
151         resultList.add(new Attribute(attributeNames[i],value));
152         } catch (Exception   e) {
153         e.printStackTrace();
154         }
155     }
156     return(resultList);
157     }
158 
159     /**
160      * Sets the values of several attributes of the Dynamic MBean, and returns the
161      * list of attributes that have been set.
162      */
163     public AttributeList setAttributes(AttributeList attributes) {
164 
165     // Check attributes is not null to avoid NullPointerException later on
166     if (attributes == null) {
167         throw new RuntimeOperationsException(new IllegalArgumentException  ("AttributeList attributes cannot be null"),
168                          "Cannot invoke a setter of " + dClassName);
169     }
170     AttributeList resultList = new AttributeList();
171 
172     // if attributeNames is empty, nothing more to do
173     if (attributes.isEmpty())
174         return resultList;
175 
176     // for each attribute, try to set it and add to the result list if successfull
177     for (Iterator   i = attributes.iterator(); i.hasNext();) {
178         Attribute attr = (Attribute) i.next();
179         try {
180         setAttribute(attr);
181         String   name = attr.getName();
182         Object   value = getAttribute(name); 
183         resultList.add(new Attribute(name,value));
184         } catch(Exception   e) {
185         e.printStackTrace();
186         }
187     }
188     return(resultList);
189     }
190 
191     /**
192      * Allows an operation to be invoked on the Dynamic MBean.
193      */
194     public Object   invoke(String   operationName, Object   params[], String   signature[])
195     throws MBeanException,
196            ReflectionException {
197 
198     // Check operationName is not null to avoid NullPointerException later on
199     if (operationName == null) {
200         throw new RuntimeOperationsException(new IllegalArgumentException  ("Operation name cannot be null"), 
201                          "Cannot invoke a null operation in " + dClassName);
202     }
203     // Check for a recognized operation name and call the corresponding operation
204     if (operationName.equals("reset")){
205         reset();
206         return null;
207     } else { 
208         // unrecognized operation name:
209         throw new ReflectionException(new NoSuchMethodException  (operationName), 
210                       "Cannot find the operation " + operationName + " in " + dClassName);
211     }
212     }
213 
214     /**
215      * This method provides the exposed attributes and operations of the Dynamic MBean.
216      * It provides this information using an MBeanInfo object.
217      */
218     public MBeanInfo getMBeanInfo() {
219 
220     // return the information we want to expose for management:
221     // the dMBeanInfo private field has been built at instanciation time,
222     return(dMBeanInfo);
223     }
224 
225 
226     /*
227      * -----------------------------------------------------
228      * OTHER PUBLIC METHODS
229      * -----------------------------------------------------
230      */
231 
232     /**
233      * Getter: get the "State" attribute of the "SimpleDynamic" dynamic MBean.
234      */
235     public String   getState() {
236     return state;
237     }
238 
239     /** 
240      * Setter: set the "State" attribute of the "SimpleDynamic" dynamic MBean.
241      */
242     public void setState(String   s) {
243     state = s;
244     nbChanges++;
245     }
246 
247     /**
248      * Getter: get the "NbChanges" attribute of the "SimpleDynamic" dynamic MBean.
249      */
250     public Integer   getNbChanges() {
251     return new Integer  (nbChanges);
252     }
253 
254     /**
255      * Operation: reset to their initial values the "State" and "NbChanges" 
256      * attributes of the "SimpleDynamic" dynamic MBean. 
257      */
258     public void reset() {
259     state = "initial state";
260     nbChanges = 0;
261     nbResets++;
262     }
263 
264     /**
265      * Return the "NbResets" property. 
266      * This method is not a Getter in the JMX sense because 
267      * it is not returned by the getMBeanInfo() method.
268      */
269     public Integer   getNbResets() {
270     return new Integer  (nbResets);
271     }
272 
273     /*
274      * -----------------------------------------------------
275      * PRIVATE METHODS
276      * -----------------------------------------------------
277      */
278   
279     /**
280      * Build the private dMBeanInfo field,
281      * which represents the management interface exposed by the MBean;
282      * that is, the set of attributes, constructors, operations and notifications
283      * which are available for management. 
284      *
285      * A reference to the dMBeanInfo object is returned by the getMBeanInfo() method
286      * of the DynamicMBean interface. Note that, once constructed, an MBeanInfo object is immutable.
287      */
288     private void buildDynamicMBeanInfo() {
289 
290     dAttributes[0] = new MBeanAttributeInfo("State",
291                         "java.lang.String",
292                         "State: state string.",
293                         true,
294                         true,
295                         false);
296     dAttributes[1] = new MBeanAttributeInfo("NbChanges",
297                         "java.lang.Integer",
298                         "NbChanges: number of times the State string has been changed.",
299                         true,
300                         false,
301                         false);
302         
303     Constructor  [] constructors = this.getClass().getConstructors();
304     dConstructors[0] = new MBeanConstructorInfo("SimpleDynamic(): Constructs a SimpleDynamic object",
305                             constructors[0]);
306         
307     MBeanParameterInfo[] params = null;        
308     dOperations[0] = new MBeanOperationInfo("reset",
309                         "reset(): reset State and NbChanges attributes to their initial values",
310                         params , 
311                         "void", 
312                         MBeanOperationInfo.ACTION);
313         
314     dMBeanInfo = new MBeanInfo(dClassName,
315                    dDescription,
316                    dAttributes,
317                    dConstructors,
318                    dOperations,
319                    new MBeanNotificationInfo[0]);
320     }
321 
322     /*
323      * -----------------------------------------------------
324      * PRIVATE VARIABLES
325      * -----------------------------------------------------
326      */
327 
328     private String    state = "initial state";
329     private int     nbChanges = 0;
330     private int     nbResets = 0;
331 
332 
333     private String   dClassName = this.getClass().getName();
334     private String   dDescription = "Simple implementation of a dynamic MBean.";
335 
336     private MBeanAttributeInfo[] dAttributes = new MBeanAttributeInfo[2];
337     private MBeanConstructorInfo[] dConstructors = new MBeanConstructorInfo[1];
338     private MBeanOperationInfo[] dOperations = new MBeanOperationInfo[1];
339     private MBeanInfo dMBeanInfo = null;
340   
341 }
342
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags