1 /*
2 * Copyright 1999-2006 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26 package javax.management;
27
28 import com.sun.jmx.mbeanserver.Introspector;
29 import java.lang.annotation.Annotation;
30 import java.lang.reflect.Method;
31 import java.util.Arrays;
32
33 /**
34 * Describes a management operation exposed by an MBean. Instances of
35 * this class are immutable. Subclasses may be mutable but this is
36 * not recommended.
37 *
38 * @since 1.5
39 */
40 public class MBeanOperationInfo extends MBeanFeatureInfo implements Cloneable {
41
42 /* Serial version */
43 static final long serialVersionUID = -6178860474881375330L;
44
45 static final MBeanOperationInfo[] NO_OPERATIONS =
46 new MBeanOperationInfo[0];
47
48 /**
49 * Indicates that the operation is read-like,
50 * it basically returns information.
51 */
52 public static final int INFO = 0;
53
54 /**
55 * Indicates that the operation is a write-like,
56 * and would modify the MBean in some way, typically by writing some value
57 * or changing a configuration.
58 */
59 public static final int ACTION = 1;
60
61 /**
62 * Indicates that the operation is both read-like and write-like.
63 */
64 public static final int ACTION_INFO = 2;
65
66 /**
67 * Indicates that the operation has an "unknown" nature.
68 */
69 public static final int UNKNOWN = 3;
70
71 /**
72 * @serial The method's return value.
73 */
74 private final String type;
75
76 /**
77 * @serial The signature of the method, that is, the class names
78 * of the arguments.
79 */
80 private final MBeanParameterInfo[] signature;
81
82 /**
83 * @serial The impact of the method, one of
84 * <CODE>INFO</CODE>,
85 * <CODE>ACTION</CODE>,
86 * <CODE>ACTION_INFO</CODE>,
87 * <CODE>UNKNOWN</CODE>
88 */
89 private final int impact;
90
91 /** @see MBeanInfo#arrayGettersSafe */
92 private final transient boolean arrayGettersSafe;
93
94
95 /**
96 * Constructs an <CODE>MBeanOperationInfo</CODE> object. The
97 * {@link Descriptor} of the constructed object will include
98 * fields contributed by any annotations on the {@code Method}
99 * object that contain the {@link DescriptorKey} meta-annotation.
100 *
101 * @param method The <CODE>java.lang.reflect.Method</CODE> object
102 * describing the MBean operation.
103 * @param description A human readable description of the operation.
104 */
105 public MBeanOperationInfo(String description, Method method) {
106 this(method.getName(),
107 description,
108 methodSignature(method),
109 method.getReturnType().getName(),
110 UNKNOWN,
111 Introspector.descriptorForElement(method));
112 }
113
114 /**
115 * Constructs an <CODE>MBeanOperationInfo</CODE> object.
116 *
117 * @param name The name of the method.
118 * @param description A human readable description of the operation.
119 * @param signature <CODE>MBeanParameterInfo</CODE> objects
120 * describing the parameters(arguments) of the method. This may be
121 * null with the same effect as a zero-length array.
122 * @param type The type of the method's return value.
123 * @param impact The impact of the method, one of <CODE>INFO,
124 * ACTION, ACTION_INFO, UNKNOWN</CODE>.
125 */
126 public MBeanOperationInfo(String name,
127 String description,
128 MBeanParameterInfo[] signature,
129 String type,
130 int impact) {
131 this(name, description, signature, type, impact, (Descriptor) null);
132 }
133
134 /**
135 * Constructs an <CODE>MBeanOperationInfo</CODE> object.
136 *
137 * @param name The name of the method.
138 * @param description A human readable description of the operation.
139 * @param signature <CODE>MBeanParameterInfo</CODE> objects
140 * describing the parameters(arguments) of the method. This may be
141 * null with the same effect as a zero-length array.
142 * @param type The type of the method's return value.
143 * @param impact The impact of the method, one of <CODE>INFO,
144 * ACTION, ACTION_INFO, UNKNOWN</CODE>.
145 * @param descriptor The descriptor for the operation. This may be null
146 * which is equivalent to an empty descriptor.
147 *
148 * @since 1.6
149 */
150 public MBeanOperationInfo(String name,
151 String description,
152 MBeanParameterInfo[] signature,
153 String type,
154 int impact,
155 Descriptor descriptor) {
156
157 super(name, description, descriptor);
158
159 if (signature == null || signature.length == 0)
160 signature = MBeanParameterInfo.NO_PARAMS;
161 else
162 signature = signature.clone();
163 this.signature = signature;
164 this.type = type;
165 this.impact = impact;
166 this.arrayGettersSafe =
167 MBeanInfo.arrayGettersSafe(this.getClass(),
168 MBeanOperationInfo.class);
169 }
170
171 /**
172 * <p>Returns a shallow clone of this instance.
173 * The clone is obtained by simply calling <tt>super.clone()</tt>,
174 * thus calling the default native shallow cloning mechanism
175 * implemented by <tt>Object.clone()</tt>.
176 * No deeper cloning of any internal field is made.</p>
177 *
178 * <p>Since this class is immutable, cloning is chiefly of interest
179 * to subclasses.</p>
180 */
181 public Object clone () {
182 try {
183 return super.clone() ;
184 } catch (CloneNotSupportedException e) {
185 // should not happen as this class is cloneable
186 return null;
187 }
188 }
189
190 /**
191 * Returns the type of the method's return value.
192 *
193 * @return the return type.
194 */
195 public String getReturnType() {
196 return type;
197 }
198
199 /**
200 * <p>Returns the list of parameters for this operation. Each
201 * parameter is described by an <CODE>MBeanParameterInfo</CODE>
202 * object.</p>
203 *
204 * <p>The returned array is a shallow copy of the internal array,
205 * which means that it is a copy of the internal array of
206 * references to the <CODE>MBeanParameterInfo</CODE> objects but
207 * that each referenced <CODE>MBeanParameterInfo</CODE> object is
208 * not copied.</p>
209 *
210 * @return An array of <CODE>MBeanParameterInfo</CODE> objects.
211 */
212 public MBeanParameterInfo[] getSignature() {
213 // If MBeanOperationInfo was created in our implementation,
214 // signature cannot be null - because our constructors replace
215 // null with MBeanParameterInfo.NO_PARAMS;
216 //
217 // However, signature could be null if an MBeanOperationInfo is
218 // deserialized from a byte array produced by another implementation.
219 // This is not very likely but possible, since the serial form says
220 // nothing against it. (see 6373150)
221 //
222 if (signature == null)
223 // if signature is null simply return an empty array .
224 //
225 return MBeanParameterInfo.NO_PARAMS;
226 else if (signature.length == 0)
227 return signature;
228 else
229 return signature.clone();
230 }
231
232 private MBeanParameterInfo[] fastGetSignature() {
233 if (arrayGettersSafe) {
234 // if signature is null simply return an empty array .
235 // see getSignature() above.
236 //
237 if (signature == null)
238 return MBeanParameterInfo.NO_PARAMS;
239 else return signature;
240 } else return getSignature();
241 }
242
243 /**
244 * Returns the impact of the method, one of
245 * <CODE>INFO</CODE>, <CODE>ACTION</CODE>, <CODE>ACTION_INFO</CODE>, <CODE>UNKNOWN</CODE>.
246 *
247 * @return the impact code.
248 */
249 public int getImpact() {
250 return impact;
251 }
252
253 public String toString() {
254 String impactString;
255 switch (getImpact()) {
256 case ACTION: impactString = "action"; break;
257 case ACTION_INFO: impactString = "action/info"; break;
258 case INFO: impactString = "info"; break;
259 case UNKNOWN: impactString = "unknown"; break;
260 default: impactString = "(" + getImpact() + ")";
261 }
262 return getClass().getName() + "[" +
263 "description=" + getDescription() + ", " +
264 "name=" + getName() + ", " +
265 "returnType=" + getReturnType() + ", " +
266 "signature=" + Arrays.asList(fastGetSignature()) + ", " +
267 "impact=" + impactString + ", " +
268 "descriptor=" + getDescriptor() +
269 "]";
270 }
271
272 /**
273 * Compare this MBeanOperationInfo to another.
274 *
275 * @param o the object to compare to.
276 *
277 * @return true if and only if <code>o</code> is an MBeanOperationInfo such
278 * that its {@link #getName()}, {@link #getReturnType()}, {@link
279 * #getDescription()}, {@link #getImpact()}, {@link #getDescriptor()}
280 * and {@link #getSignature()} values are equal (not necessarily identical)
281 * to those of this MBeanConstructorInfo. Two signature arrays
282 * are equal if their elements are pairwise equal.
283 */
284 public boolean equals(Object o) {
285 if (o == this)
286 return true;
287 if (!(o instanceof MBeanOperationInfo))
288 return false;
289 MBeanOperationInfo p = (MBeanOperationInfo) o;
290 return (p.getName().equals(getName()) &&
291 p.getReturnType().equals(getReturnType()) &&
292 p.getDescription().equals(getDescription()) &&
293 p.getImpact() == getImpact() &&
294 Arrays.equals(p.fastGetSignature(), fastGetSignature()) &&
295 p.getDescriptor().equals(getDescriptor()));
296 }
297
298 /* We do not include everything in the hashcode. We assume that
299 if two operations are different they'll probably have different
300 names or types. The penalty we pay when this assumption is
301 wrong should be less than the penalty we would pay if it were
302 right and we needlessly hashed in the description and the
303 parameter array. */
304 public int hashCode() {
305 return getName().hashCode() ^ getReturnType().hashCode();
306 }
307
308 private static MBeanParameterInfo[] methodSignature(Method method) {
309 final Class[] classes = method.getParameterTypes();
310 final Annotation[][] annots = method.getParameterAnnotations();
311 return parameters(classes, annots);
312 }
313
314 static MBeanParameterInfo[] parameters(Class[] classes,
315 Annotation[][] annots) {
316 final MBeanParameterInfo[] params =
317 new MBeanParameterInfo[classes.length];
318 assert(classes.length == annots.length);
319
320 for (int i = 0; i < classes.length; i++) {
321 Descriptor d = Introspector.descriptorForAnnotations(annots[i]);
322 final String pn = "p" + (i + 1);
323 params[i] =
324 new MBeanParameterInfo(pn, classes[i].getName(), "", d);
325 }
326
327 return params;
328 }
329 }
Save This Page