sample/java.lang.management.ManagementFactory.txt

   1 *java.lang.management.ManagementFactory* *ManagementFactory* The ManagementFacto
   2
   3 public class ManagementFactory
   4   extends    |java.lang.Object|
   5
   6 |java.lang.management.ManagementFactory_Description|
   7 |java.lang.management.ManagementFactory_Fields|
   8 |java.lang.management.ManagementFactory_Constructors|
   9 |java.lang.management.ManagementFactory_Methods|
  10
  11 ================================================================================
  12
  13 *java.lang.management.ManagementFactory_Fields*
  14 |java.lang.String_java.lang.management.ManagementFactory.CLASS_LOADING_MXBEAN_NAME|
  15 |java.lang.String_java.lang.management.ManagementFactory.COMPILATION_MXBEAN_NAME|
  16 |java.lang.String_java.lang.management.ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE|
  17 |java.lang.String_java.lang.management.ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE|
  18 |java.lang.String_java.lang.management.ManagementFactory.MEMORY_MXBEAN_NAME|
  19 |java.lang.String_java.lang.management.ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE|
  20 |java.lang.String_java.lang.management.ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME|
  21 |java.lang.String_java.lang.management.ManagementFactory.RUNTIME_MXBEAN_NAME|
  22 |java.lang.String_java.lang.management.ManagementFactory.THREAD_MXBEAN_NAME|
  23
  24 *java.lang.management.ManagementFactory_Methods*
  25 |java.lang.management.ManagementFactory.getClassLoadingMXBean()|Returns the man
  26 |java.lang.management.ManagementFactory.getCompilationMXBean()|Returns the mana
  27 |java.lang.management.ManagementFactory.getGarbageCollectorMXBeans()|Returns a
  28 |java.lang.management.ManagementFactory.getMemoryManagerMXBeans()|Returns a lis
  29 |java.lang.management.ManagementFactory.getMemoryMXBean()|Returns the managed b
  30 |java.lang.management.ManagementFactory.getMemoryPoolMXBeans()|Returns a list o
  31 |java.lang.management.ManagementFactory.getOperatingSystemMXBean()|Returns the
  32 |java.lang.management.ManagementFactory.getPlatformMBeanServer()|Returns the pl
  33 |java.lang.management.ManagementFactory.getRuntimeMXBean()|Returns the managed
  34 |java.lang.management.ManagementFactory.getThreadMXBean()|Returns the managed b
  35 |java.lang.management.ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection,String,Class)|
  36
  37 *java.lang.management.ManagementFactory_Description*
  38
  39 The ManagementFactory class is a factory class for getting managed beans for
  40 the Java platform. This class consists of static methods each of which returns
  41 one or more platform MXBean(s) representing the management interface of a
  42 component of the Java virtual machine.
  43
  44 An application can access a platform MXBean in the following ways:
  45
  46 Direct access to an MXBean interface
  47
  48 Get the MXBean instance through the static factory method and access the MXBean
  49 locally of the running virtual machine.
  50
  51 Construct an MXBean proxy instance that forwards the method calls to a given
  52 MBeanServer(|javax.management.MBeanServer|) by calling
  53 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
  54 typically constructed to remotely access an MXBean of another running virtual
  55 machine.
  56
  57 Indirect access to an MXBean interface via MBeanServer
  58
  59 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
  60 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
  61 remotely. The attributes and operations of an MXBean use only JMX open types
  62 which include basic data types,
  63 CompositeData(|javax.management.openmbean.CompositeData|) , and
  64 TabularData(|javax.management.openmbean.TabularData|) defined in
  65 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
  66 below.
  67
  68
  69
  70 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
  71 Instrumentation Specification and only uses a set of basic data types described
  72 below. A JMX management application and the platform MBeanServer can
  73 interoperate without requiring classes for MXBean specific data types. The data
  74 types being transmitted between the JMX connector server and the connector
  75 client are open types(|javax.management.openmbean.OpenType|) and this allows
  76 interoperation across versions.
  77
  78 The platform MXBean interfaces use only the following data types:
  79
  80 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
  81 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
  82 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
  83 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
  84 define a static from method with a
  85 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
  86 from an input CompositeData to an instance of that class
  87
  88 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
  89 an enum class, or a class supporting conversion from a CompositeData to its
  90 class
  91
  92 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
  93 class, an enum class, or a class supporting conversion from a CompositeData to
  94 its class
  95
  96
  97
  98 When an attribute or operation of a platform MXBean is accessed via an
  99 MBeanServer, the data types are mapped as follows:
 100
 101 A primitive type or a wrapper class is mapped to the same type.
 102
 103 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
 104 constant. A class that defines only getter methods and a static from method
 105 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
 106 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
 107
 108 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
 109 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
 110 with two items whose names are "key" and "value" and the item types are the
 111 corresponding mapped type of K and V respectively and the "key" is the index.
 112
 113 List<E> is mapped to an array with the mapped type of E as the element type.
 114
 115 An array of element type E is mapped to an array of the same dimenions with the
 116 mapped type of E as the element type.
 117
 118 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
 119 data types of the attributes and operations as primitive or open types mapped
 120 as specified above.
 121
 122 For example, the (|java.lang.management.MemoryMXBean|) interface has the
 123 following getter and setter methods:
 124
 125
 126
 127 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
 128 void setVerbose(boolean value);
 129
 130 These attributes in the MBeanInfo of the MemoryMXBean have the following names
 131 and types:
 132
 133
 134
 135 Attribute Name Type
 136
 137 HeapMemoryUsage CompositeData representing
 138 MemoryUsage(|java.lang.management.MemoryUsage|)
 139
 140 Verbose boolean
 141
 142
 143
 144 Implementation Note: The mapping specified above could be done in the
 145 implementation of each platform MXBean. One good implementation choice is to
 146 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
 147
 148 MXBean Names Each platform MXBean for a Java virtual machine has a unique
 149 ObjectName(|javax.management.ObjectName|) for registration in the platform
 150 MBeanServer. A Java virtual machine has a single instance of the following
 151 management interfaces:
 152
 153
 154
 155 Management Interface ObjectName
 156
 157 (|java.lang.management.ClassLoadingMXBean|)
 158 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
 159
 160 (|java.lang.management.MemoryMXBean|)
 161 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
 162
 163 (|java.lang.management.ThreadMXBean|)
 164 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
 165
 166 (|java.lang.management.RuntimeMXBean|)
 167 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
 168
 169 (|java.lang.management.OperatingSystemMXBean|)
 170 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
 171
 172
 173
 174
 175 A Java virtual machine has zero or a single instance of the following
 176 management interfaces.
 177
 178
 179
 180 Management Interface ObjectName
 181
 182 (|java.lang.management.CompilationMXBean|)
 183 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
 184
 185
 186
 187 A Java virtual machine may have one or more instances of the following
 188 management interfaces.
 189
 190
 191
 192 Management Interface ObjectName
 193
 194 (|java.lang.management.GarbageCollectorMXBean|)
 195 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
 196 ,name=collector's name
 197
 198 (|java.lang.management.MemoryManagerMXBean|)
 199 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
 200 ,name=manager's name
 201
 202 (|java.lang.management.MemoryPoolMXBean|)
 203 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
 204 ,name=pool's name
 205
 206
 207
 208
 209 *java.lang.String_java.lang.management.ManagementFactory.CLASS_LOADING_MXBEAN_NAME*
 210
 211 The ManagementFactory class is a factory class for getting managed beans for
 212 the Java platform. This class consists of static methods each of which returns
 213 one or more platform MXBean(s) representing the management interface of a
 214 component of the Java virtual machine.
 215
 216 An application can access a platform MXBean in the following ways:
 217
 218 Direct access to an MXBean interface
 219
 220 Get the MXBean instance through the static factory method and access the MXBean
 221 locally of the running virtual machine.
 222
 223 Construct an MXBean proxy instance that forwards the method calls to a given
 224 MBeanServer(|javax.management.MBeanServer|) by calling
 225 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
 226 typically constructed to remotely access an MXBean of another running virtual
 227 machine.
 228
 229 Indirect access to an MXBean interface via MBeanServer
 230
 231 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
 232 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
 233 remotely. The attributes and operations of an MXBean use only JMX open types
 234 which include basic data types,
 235 CompositeData(|javax.management.openmbean.CompositeData|) , and
 236 TabularData(|javax.management.openmbean.TabularData|) defined in
 237 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
 238 below.
 239
 240
 241
 242 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
 243 Instrumentation Specification and only uses a set of basic data types described
 244 below. A JMX management application and the platform MBeanServer can
 245 interoperate without requiring classes for MXBean specific data types. The data
 246 types being transmitted between the JMX connector server and the connector
 247 client are open types(|javax.management.openmbean.OpenType|) and this allows
 248 interoperation across versions.
 249
 250 The platform MXBean interfaces use only the following data types:
 251
 252 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
 253 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
 254 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
 255 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
 256 define a static from method with a
 257 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
 258 from an input CompositeData to an instance of that class
 259
 260 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
 261 an enum class, or a class supporting conversion from a CompositeData to its
 262 class
 263
 264 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
 265 class, an enum class, or a class supporting conversion from a CompositeData to
 266 its class
 267
 268
 269
 270 When an attribute or operation of a platform MXBean is accessed via an
 271 MBeanServer, the data types are mapped as follows:
 272
 273 A primitive type or a wrapper class is mapped to the same type.
 274
 275 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
 276 constant. A class that defines only getter methods and a static from method
 277 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
 278 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
 279
 280 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
 281 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
 282 with two items whose names are "key" and "value" and the item types are the
 283 corresponding mapped type of K and V respectively and the "key" is the index.
 284
 285 List<E> is mapped to an array with the mapped type of E as the element type.
 286
 287 An array of element type E is mapped to an array of the same dimenions with the
 288 mapped type of E as the element type.
 289
 290 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
 291 data types of the attributes and operations as primitive or open types mapped
 292 as specified above.
 293
 294 For example, the (|java.lang.management.MemoryMXBean|) interface has the
 295 following getter and setter methods:
 296
 297
 298
 299 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
 300 void setVerbose(boolean value);
 301
 302 These attributes in the MBeanInfo of the MemoryMXBean have the following names
 303 and types:
 304
 305
 306
 307 Attribute Name Type
 308
 309 HeapMemoryUsage CompositeData representing
 310 MemoryUsage(|java.lang.management.MemoryUsage|)
 311
 312 Verbose boolean
 313
 314
 315
 316 Implementation Note: The mapping specified above could be done in the
 317 implementation of each platform MXBean. One good implementation choice is to
 318 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
 319
 320 MXBean Names Each platform MXBean for a Java virtual machine has a unique
 321 ObjectName(|javax.management.ObjectName|) for registration in the platform
 322 MBeanServer. A Java virtual machine has a single instance of the following
 323 management interfaces:
 324
 325
 326
 327 Management Interface ObjectName
 328
 329 (|java.lang.management.ClassLoadingMXBean|)
 330 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
 331
 332 (|java.lang.management.MemoryMXBean|)
 333 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
 334
 335 (|java.lang.management.ThreadMXBean|)
 336 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
 337
 338 (|java.lang.management.RuntimeMXBean|)
 339 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
 340
 341 (|java.lang.management.OperatingSystemMXBean|)
 342 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
 343
 344
 345
 346
 347 A Java virtual machine has zero or a single instance of the following
 348 management interfaces.
 349
 350
 351
 352 Management Interface ObjectName
 353
 354 (|java.lang.management.CompilationMXBean|)
 355 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
 356
 357
 358
 359 A Java virtual machine may have one or more instances of the following
 360 management interfaces.
 361
 362
 363
 364 Management Interface ObjectName
 365
 366 (|java.lang.management.GarbageCollectorMXBean|)
 367 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
 368 ,name=collector's name
 369
 370 (|java.lang.management.MemoryManagerMXBean|)
 371 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
 372 ,name=manager's name
 373
 374 (|java.lang.management.MemoryPoolMXBean|)
 375 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
 376 ,name=pool's name
 377
 378
 379
 380
 381 *java.lang.String_java.lang.management.ManagementFactory.COMPILATION_MXBEAN_NAME*
 382
 383 The ManagementFactory class is a factory class for getting managed beans for
 384 the Java platform. This class consists of static methods each of which returns
 385 one or more platform MXBean(s) representing the management interface of a
 386 component of the Java virtual machine.
 387
 388 An application can access a platform MXBean in the following ways:
 389
 390 Direct access to an MXBean interface
 391
 392 Get the MXBean instance through the static factory method and access the MXBean
 393 locally of the running virtual machine.
 394
 395 Construct an MXBean proxy instance that forwards the method calls to a given
 396 MBeanServer(|javax.management.MBeanServer|) by calling
 397 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
 398 typically constructed to remotely access an MXBean of another running virtual
 399 machine.
 400
 401 Indirect access to an MXBean interface via MBeanServer
 402
 403 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
 404 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
 405 remotely. The attributes and operations of an MXBean use only JMX open types
 406 which include basic data types,
 407 CompositeData(|javax.management.openmbean.CompositeData|) , and
 408 TabularData(|javax.management.openmbean.TabularData|) defined in
 409 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
 410 below.
 411
 412
 413
 414 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
 415 Instrumentation Specification and only uses a set of basic data types described
 416 below. A JMX management application and the platform MBeanServer can
 417 interoperate without requiring classes for MXBean specific data types. The data
 418 types being transmitted between the JMX connector server and the connector
 419 client are open types(|javax.management.openmbean.OpenType|) and this allows
 420 interoperation across versions.
 421
 422 The platform MXBean interfaces use only the following data types:
 423
 424 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
 425 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
 426 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
 427 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
 428 define a static from method with a
 429 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
 430 from an input CompositeData to an instance of that class
 431
 432 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
 433 an enum class, or a class supporting conversion from a CompositeData to its
 434 class
 435
 436 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
 437 class, an enum class, or a class supporting conversion from a CompositeData to
 438 its class
 439
 440
 441
 442 When an attribute or operation of a platform MXBean is accessed via an
 443 MBeanServer, the data types are mapped as follows:
 444
 445 A primitive type or a wrapper class is mapped to the same type.
 446
 447 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
 448 constant. A class that defines only getter methods and a static from method
 449 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
 450 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
 451
 452 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
 453 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
 454 with two items whose names are "key" and "value" and the item types are the
 455 corresponding mapped type of K and V respectively and the "key" is the index.
 456
 457 List<E> is mapped to an array with the mapped type of E as the element type.
 458
 459 An array of element type E is mapped to an array of the same dimenions with the
 460 mapped type of E as the element type.
 461
 462 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
 463 data types of the attributes and operations as primitive or open types mapped
 464 as specified above.
 465
 466 For example, the (|java.lang.management.MemoryMXBean|) interface has the
 467 following getter and setter methods:
 468
 469
 470
 471 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
 472 void setVerbose(boolean value);
 473
 474 These attributes in the MBeanInfo of the MemoryMXBean have the following names
 475 and types:
 476
 477
 478
 479 Attribute Name Type
 480
 481 HeapMemoryUsage CompositeData representing
 482 MemoryUsage(|java.lang.management.MemoryUsage|)
 483
 484 Verbose boolean
 485
 486
 487
 488 Implementation Note: The mapping specified above could be done in the
 489 implementation of each platform MXBean. One good implementation choice is to
 490 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
 491
 492 MXBean Names Each platform MXBean for a Java virtual machine has a unique
 493 ObjectName(|javax.management.ObjectName|) for registration in the platform
 494 MBeanServer. A Java virtual machine has a single instance of the following
 495 management interfaces:
 496
 497
 498
 499 Management Interface ObjectName
 500
 501 (|java.lang.management.ClassLoadingMXBean|)
 502 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
 503
 504 (|java.lang.management.MemoryMXBean|)
 505 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
 506
 507 (|java.lang.management.ThreadMXBean|)
 508 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
 509
 510 (|java.lang.management.RuntimeMXBean|)
 511 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
 512
 513 (|java.lang.management.OperatingSystemMXBean|)
 514 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
 515
 516
 517
 518
 519 A Java virtual machine has zero or a single instance of the following
 520 management interfaces.
 521
 522
 523
 524 Management Interface ObjectName
 525
 526 (|java.lang.management.CompilationMXBean|)
 527 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
 528
 529
 530
 531 A Java virtual machine may have one or more instances of the following
 532 management interfaces.
 533
 534
 535
 536 Management Interface ObjectName
 537
 538 (|java.lang.management.GarbageCollectorMXBean|)
 539 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
 540 ,name=collector's name
 541
 542 (|java.lang.management.MemoryManagerMXBean|)
 543 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
 544 ,name=manager's name
 545
 546 (|java.lang.management.MemoryPoolMXBean|)
 547 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
 548 ,name=pool's name
 549
 550
 551
 552
 553 *java.lang.String_java.lang.management.ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE*
 554
 555 The ManagementFactory class is a factory class for getting managed beans for
 556 the Java platform. This class consists of static methods each of which returns
 557 one or more platform MXBean(s) representing the management interface of a
 558 component of the Java virtual machine.
 559
 560 An application can access a platform MXBean in the following ways:
 561
 562 Direct access to an MXBean interface
 563
 564 Get the MXBean instance through the static factory method and access the MXBean
 565 locally of the running virtual machine.
 566
 567 Construct an MXBean proxy instance that forwards the method calls to a given
 568 MBeanServer(|javax.management.MBeanServer|) by calling
 569 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
 570 typically constructed to remotely access an MXBean of another running virtual
 571 machine.
 572
 573 Indirect access to an MXBean interface via MBeanServer
 574
 575 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
 576 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
 577 remotely. The attributes and operations of an MXBean use only JMX open types
 578 which include basic data types,
 579 CompositeData(|javax.management.openmbean.CompositeData|) , and
 580 TabularData(|javax.management.openmbean.TabularData|) defined in
 581 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
 582 below.
 583
 584
 585
 586 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
 587 Instrumentation Specification and only uses a set of basic data types described
 588 below. A JMX management application and the platform MBeanServer can
 589 interoperate without requiring classes for MXBean specific data types. The data
 590 types being transmitted between the JMX connector server and the connector
 591 client are open types(|javax.management.openmbean.OpenType|) and this allows
 592 interoperation across versions.
 593
 594 The platform MXBean interfaces use only the following data types:
 595
 596 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
 597 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
 598 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
 599 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
 600 define a static from method with a
 601 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
 602 from an input CompositeData to an instance of that class
 603
 604 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
 605 an enum class, or a class supporting conversion from a CompositeData to its
 606 class
 607
 608 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
 609 class, an enum class, or a class supporting conversion from a CompositeData to
 610 its class
 611
 612
 613
 614 When an attribute or operation of a platform MXBean is accessed via an
 615 MBeanServer, the data types are mapped as follows:
 616
 617 A primitive type or a wrapper class is mapped to the same type.
 618
 619 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
 620 constant. A class that defines only getter methods and a static from method
 621 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
 622 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
 623
 624 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
 625 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
 626 with two items whose names are "key" and "value" and the item types are the
 627 corresponding mapped type of K and V respectively and the "key" is the index.
 628
 629 List<E> is mapped to an array with the mapped type of E as the element type.
 630
 631 An array of element type E is mapped to an array of the same dimenions with the
 632 mapped type of E as the element type.
 633
 634 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
 635 data types of the attributes and operations as primitive or open types mapped
 636 as specified above.
 637
 638 For example, the (|java.lang.management.MemoryMXBean|) interface has the
 639 following getter and setter methods:
 640
 641
 642
 643 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
 644 void setVerbose(boolean value);
 645
 646 These attributes in the MBeanInfo of the MemoryMXBean have the following names
 647 and types:
 648
 649
 650
 651 Attribute Name Type
 652
 653 HeapMemoryUsage CompositeData representing
 654 MemoryUsage(|java.lang.management.MemoryUsage|)
 655
 656 Verbose boolean
 657
 658
 659
 660 Implementation Note: The mapping specified above could be done in the
 661 implementation of each platform MXBean. One good implementation choice is to
 662 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
 663
 664 MXBean Names Each platform MXBean for a Java virtual machine has a unique
 665 ObjectName(|javax.management.ObjectName|) for registration in the platform
 666 MBeanServer. A Java virtual machine has a single instance of the following
 667 management interfaces:
 668
 669
 670
 671 Management Interface ObjectName
 672
 673 (|java.lang.management.ClassLoadingMXBean|)
 674 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
 675
 676 (|java.lang.management.MemoryMXBean|)
 677 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
 678
 679 (|java.lang.management.ThreadMXBean|)
 680 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
 681
 682 (|java.lang.management.RuntimeMXBean|)
 683 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
 684
 685 (|java.lang.management.OperatingSystemMXBean|)
 686 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
 687
 688
 689
 690
 691 A Java virtual machine has zero or a single instance of the following
 692 management interfaces.
 693
 694
 695
 696 Management Interface ObjectName
 697
 698 (|java.lang.management.CompilationMXBean|)
 699 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
 700
 701
 702
 703 A Java virtual machine may have one or more instances of the following
 704 management interfaces.
 705
 706
 707
 708 Management Interface ObjectName
 709
 710 (|java.lang.management.GarbageCollectorMXBean|)
 711 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
 712 ,name=collector's name
 713
 714 (|java.lang.management.MemoryManagerMXBean|)
 715 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
 716 ,name=manager's name
 717
 718 (|java.lang.management.MemoryPoolMXBean|)
 719 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
 720 ,name=pool's name
 721
 722
 723
 724
 725 *java.lang.String_java.lang.management.ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE*
 726
 727 The ManagementFactory class is a factory class for getting managed beans for
 728 the Java platform. This class consists of static methods each of which returns
 729 one or more platform MXBean(s) representing the management interface of a
 730 component of the Java virtual machine.
 731
 732 An application can access a platform MXBean in the following ways:
 733
 734 Direct access to an MXBean interface
 735
 736 Get the MXBean instance through the static factory method and access the MXBean
 737 locally of the running virtual machine.
 738
 739 Construct an MXBean proxy instance that forwards the method calls to a given
 740 MBeanServer(|javax.management.MBeanServer|) by calling
 741 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
 742 typically constructed to remotely access an MXBean of another running virtual
 743 machine.
 744
 745 Indirect access to an MXBean interface via MBeanServer
 746
 747 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
 748 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
 749 remotely. The attributes and operations of an MXBean use only JMX open types
 750 which include basic data types,
 751 CompositeData(|javax.management.openmbean.CompositeData|) , and
 752 TabularData(|javax.management.openmbean.TabularData|) defined in
 753 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
 754 below.
 755
 756
 757
 758 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
 759 Instrumentation Specification and only uses a set of basic data types described
 760 below. A JMX management application and the platform MBeanServer can
 761 interoperate without requiring classes for MXBean specific data types. The data
 762 types being transmitted between the JMX connector server and the connector
 763 client are open types(|javax.management.openmbean.OpenType|) and this allows
 764 interoperation across versions.
 765
 766 The platform MXBean interfaces use only the following data types:
 767
 768 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
 769 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
 770 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
 771 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
 772 define a static from method with a
 773 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
 774 from an input CompositeData to an instance of that class
 775
 776 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
 777 an enum class, or a class supporting conversion from a CompositeData to its
 778 class
 779
 780 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
 781 class, an enum class, or a class supporting conversion from a CompositeData to
 782 its class
 783
 784
 785
 786 When an attribute or operation of a platform MXBean is accessed via an
 787 MBeanServer, the data types are mapped as follows:
 788
 789 A primitive type or a wrapper class is mapped to the same type.
 790
 791 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
 792 constant. A class that defines only getter methods and a static from method
 793 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
 794 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
 795
 796 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
 797 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
 798 with two items whose names are "key" and "value" and the item types are the
 799 corresponding mapped type of K and V respectively and the "key" is the index.
 800
 801 List<E> is mapped to an array with the mapped type of E as the element type.
 802
 803 An array of element type E is mapped to an array of the same dimenions with the
 804 mapped type of E as the element type.
 805
 806 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
 807 data types of the attributes and operations as primitive or open types mapped
 808 as specified above.
 809
 810 For example, the (|java.lang.management.MemoryMXBean|) interface has the
 811 following getter and setter methods:
 812
 813
 814
 815 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
 816 void setVerbose(boolean value);
 817
 818 These attributes in the MBeanInfo of the MemoryMXBean have the following names
 819 and types:
 820
 821
 822
 823 Attribute Name Type
 824
 825 HeapMemoryUsage CompositeData representing
 826 MemoryUsage(|java.lang.management.MemoryUsage|)
 827
 828 Verbose boolean
 829
 830
 831
 832 Implementation Note: The mapping specified above could be done in the
 833 implementation of each platform MXBean. One good implementation choice is to
 834 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
 835
 836 MXBean Names Each platform MXBean for a Java virtual machine has a unique
 837 ObjectName(|javax.management.ObjectName|) for registration in the platform
 838 MBeanServer. A Java virtual machine has a single instance of the following
 839 management interfaces:
 840
 841
 842
 843 Management Interface ObjectName
 844
 845 (|java.lang.management.ClassLoadingMXBean|)
 846 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
 847
 848 (|java.lang.management.MemoryMXBean|)
 849 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
 850
 851 (|java.lang.management.ThreadMXBean|)
 852 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
 853
 854 (|java.lang.management.RuntimeMXBean|)
 855 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
 856
 857 (|java.lang.management.OperatingSystemMXBean|)
 858 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
 859
 860
 861
 862
 863 A Java virtual machine has zero or a single instance of the following
 864 management interfaces.
 865
 866
 867
 868 Management Interface ObjectName
 869
 870 (|java.lang.management.CompilationMXBean|)
 871 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
 872
 873
 874
 875 A Java virtual machine may have one or more instances of the following
 876 management interfaces.
 877
 878
 879
 880 Management Interface ObjectName
 881
 882 (|java.lang.management.GarbageCollectorMXBean|)
 883 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
 884 ,name=collector's name
 885
 886 (|java.lang.management.MemoryManagerMXBean|)
 887 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
 888 ,name=manager's name
 889
 890 (|java.lang.management.MemoryPoolMXBean|)
 891 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
 892 ,name=pool's name
 893
 894
 895
 896
 897 *java.lang.String_java.lang.management.ManagementFactory.MEMORY_MXBEAN_NAME*
 898
 899 The ManagementFactory class is a factory class for getting managed beans for
 900 the Java platform. This class consists of static methods each of which returns
 901 one or more platform MXBean(s) representing the management interface of a
 902 component of the Java virtual machine.
 903
 904 An application can access a platform MXBean in the following ways:
 905
 906 Direct access to an MXBean interface
 907
 908 Get the MXBean instance through the static factory method and access the MXBean
 909 locally of the running virtual machine.
 910
 911 Construct an MXBean proxy instance that forwards the method calls to a given
 912 MBeanServer(|javax.management.MBeanServer|) by calling
 913 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
 914 typically constructed to remotely access an MXBean of another running virtual
 915 machine.
 916
 917 Indirect access to an MXBean interface via MBeanServer
 918
 919 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
 920 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
 921 remotely. The attributes and operations of an MXBean use only JMX open types
 922 which include basic data types,
 923 CompositeData(|javax.management.openmbean.CompositeData|) , and
 924 TabularData(|javax.management.openmbean.TabularData|) defined in
 925 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
 926 below.
 927
 928
 929
 930 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
 931 Instrumentation Specification and only uses a set of basic data types described
 932 below. A JMX management application and the platform MBeanServer can
 933 interoperate without requiring classes for MXBean specific data types. The data
 934 types being transmitted between the JMX connector server and the connector
 935 client are open types(|javax.management.openmbean.OpenType|) and this allows
 936 interoperation across versions.
 937
 938 The platform MXBean interfaces use only the following data types:
 939
 940 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
 941 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
 942 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
 943 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
 944 define a static from method with a
 945 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
 946 from an input CompositeData to an instance of that class
 947
 948 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
 949 an enum class, or a class supporting conversion from a CompositeData to its
 950 class
 951
 952 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
 953 class, an enum class, or a class supporting conversion from a CompositeData to
 954 its class
 955
 956
 957
 958 When an attribute or operation of a platform MXBean is accessed via an
 959 MBeanServer, the data types are mapped as follows:
 960
 961 A primitive type or a wrapper class is mapped to the same type.
 962
 963 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
 964 constant. A class that defines only getter methods and a static from method
 965 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
 966 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
 967
 968 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
 969 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
 970 with two items whose names are "key" and "value" and the item types are the
 971 corresponding mapped type of K and V respectively and the "key" is the index.
 972
 973 List<E> is mapped to an array with the mapped type of E as the element type.
 974
 975 An array of element type E is mapped to an array of the same dimenions with the
 976 mapped type of E as the element type.
 977
 978 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
 979 data types of the attributes and operations as primitive or open types mapped
 980 as specified above.
 981
 982 For example, the (|java.lang.management.MemoryMXBean|) interface has the
 983 following getter and setter methods:
 984
 985
 986
 987 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
 988 void setVerbose(boolean value);
 989
 990 These attributes in the MBeanInfo of the MemoryMXBean have the following names
 991 and types:
 992
 993
 994
 995 Attribute Name Type
 996
 997 HeapMemoryUsage CompositeData representing
 998 MemoryUsage(|java.lang.management.MemoryUsage|)
 999
1000 Verbose boolean
1001
1002
1003
1004 Implementation Note: The mapping specified above could be done in the
1005 implementation of each platform MXBean. One good implementation choice is to
1006 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
1007
1008 MXBean Names Each platform MXBean for a Java virtual machine has a unique
1009 ObjectName(|javax.management.ObjectName|) for registration in the platform
1010 MBeanServer. A Java virtual machine has a single instance of the following
1011 management interfaces:
1012
1013
1014
1015 Management Interface ObjectName
1016
1017 (|java.lang.management.ClassLoadingMXBean|)
1018 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
1019
1020 (|java.lang.management.MemoryMXBean|)
1021 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
1022
1023 (|java.lang.management.ThreadMXBean|)
1024 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
1025
1026 (|java.lang.management.RuntimeMXBean|)
1027 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
1028
1029 (|java.lang.management.OperatingSystemMXBean|)
1030 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
1031
1032
1033
1034
1035 A Java virtual machine has zero or a single instance of the following
1036 management interfaces.
1037
1038
1039
1040 Management Interface ObjectName
1041
1042 (|java.lang.management.CompilationMXBean|)
1043 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
1044
1045
1046
1047 A Java virtual machine may have one or more instances of the following
1048 management interfaces.
1049
1050
1051
1052 Management Interface ObjectName
1053
1054 (|java.lang.management.GarbageCollectorMXBean|)
1055 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
1056 ,name=collector's name
1057
1058 (|java.lang.management.MemoryManagerMXBean|)
1059 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
1060 ,name=manager's name
1061
1062 (|java.lang.management.MemoryPoolMXBean|)
1063 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
1064 ,name=pool's name
1065
1066
1067
1068
1069 *java.lang.String_java.lang.management.ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE*
1070
1071 The ManagementFactory class is a factory class for getting managed beans for
1072 the Java platform. This class consists of static methods each of which returns
1073 one or more platform MXBean(s) representing the management interface of a
1074 component of the Java virtual machine.
1075
1076 An application can access a platform MXBean in the following ways:
1077
1078 Direct access to an MXBean interface
1079
1080 Get the MXBean instance through the static factory method and access the MXBean
1081 locally of the running virtual machine.
1082
1083 Construct an MXBean proxy instance that forwards the method calls to a given
1084 MBeanServer(|javax.management.MBeanServer|) by calling
1085 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
1086 typically constructed to remotely access an MXBean of another running virtual
1087 machine.
1088
1089 Indirect access to an MXBean interface via MBeanServer
1090
1091 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
1092 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
1093 remotely. The attributes and operations of an MXBean use only JMX open types
1094 which include basic data types,
1095 CompositeData(|javax.management.openmbean.CompositeData|) , and
1096 TabularData(|javax.management.openmbean.TabularData|) defined in
1097 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
1098 below.
1099
1100
1101
1102 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
1103 Instrumentation Specification and only uses a set of basic data types described
1104 below. A JMX management application and the platform MBeanServer can
1105 interoperate without requiring classes for MXBean specific data types. The data
1106 types being transmitted between the JMX connector server and the connector
1107 client are open types(|javax.management.openmbean.OpenType|) and this allows
1108 interoperation across versions.
1109
1110 The platform MXBean interfaces use only the following data types:
1111
1112 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
1113 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
1114 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
1115 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
1116 define a static from method with a
1117 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
1118 from an input CompositeData to an instance of that class
1119
1120 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
1121 an enum class, or a class supporting conversion from a CompositeData to its
1122 class
1123
1124 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
1125 class, an enum class, or a class supporting conversion from a CompositeData to
1126 its class
1127
1128
1129
1130 When an attribute or operation of a platform MXBean is accessed via an
1131 MBeanServer, the data types are mapped as follows:
1132
1133 A primitive type or a wrapper class is mapped to the same type.
1134
1135 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
1136 constant. A class that defines only getter methods and a static from method
1137 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
1138 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
1139
1140 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
1141 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
1142 with two items whose names are "key" and "value" and the item types are the
1143 corresponding mapped type of K and V respectively and the "key" is the index.
1144
1145 List<E> is mapped to an array with the mapped type of E as the element type.
1146
1147 An array of element type E is mapped to an array of the same dimenions with the
1148 mapped type of E as the element type.
1149
1150 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
1151 data types of the attributes and operations as primitive or open types mapped
1152 as specified above.
1153
1154 For example, the (|java.lang.management.MemoryMXBean|) interface has the
1155 following getter and setter methods:
1156
1157
1158
1159 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
1160 void setVerbose(boolean value);
1161
1162 These attributes in the MBeanInfo of the MemoryMXBean have the following names
1163 and types:
1164
1165
1166
1167 Attribute Name Type
1168
1169 HeapMemoryUsage CompositeData representing
1170 MemoryUsage(|java.lang.management.MemoryUsage|)
1171
1172 Verbose boolean
1173
1174
1175
1176 Implementation Note: The mapping specified above could be done in the
1177 implementation of each platform MXBean. One good implementation choice is to
1178 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
1179
1180 MXBean Names Each platform MXBean for a Java virtual machine has a unique
1181 ObjectName(|javax.management.ObjectName|) for registration in the platform
1182 MBeanServer. A Java virtual machine has a single instance of the following
1183 management interfaces:
1184
1185
1186
1187 Management Interface ObjectName
1188
1189 (|java.lang.management.ClassLoadingMXBean|)
1190 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
1191
1192 (|java.lang.management.MemoryMXBean|)
1193 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
1194
1195 (|java.lang.management.ThreadMXBean|)
1196 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
1197
1198 (|java.lang.management.RuntimeMXBean|)
1199 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
1200
1201 (|java.lang.management.OperatingSystemMXBean|)
1202 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
1203
1204
1205
1206
1207 A Java virtual machine has zero or a single instance of the following
1208 management interfaces.
1209
1210
1211
1212 Management Interface ObjectName
1213
1214 (|java.lang.management.CompilationMXBean|)
1215 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
1216
1217
1218
1219 A Java virtual machine may have one or more instances of the following
1220 management interfaces.
1221
1222
1223
1224 Management Interface ObjectName
1225
1226 (|java.lang.management.GarbageCollectorMXBean|)
1227 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
1228 ,name=collector's name
1229
1230 (|java.lang.management.MemoryManagerMXBean|)
1231 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
1232 ,name=manager's name
1233
1234 (|java.lang.management.MemoryPoolMXBean|)
1235 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
1236 ,name=pool's name
1237
1238
1239
1240
1241 *java.lang.String_java.lang.management.ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME*
1242
1243 The ManagementFactory class is a factory class for getting managed beans for
1244 the Java platform. This class consists of static methods each of which returns
1245 one or more platform MXBean(s) representing the management interface of a
1246 component of the Java virtual machine.
1247
1248 An application can access a platform MXBean in the following ways:
1249
1250 Direct access to an MXBean interface
1251
1252 Get the MXBean instance through the static factory method and access the MXBean
1253 locally of the running virtual machine.
1254
1255 Construct an MXBean proxy instance that forwards the method calls to a given
1256 MBeanServer(|javax.management.MBeanServer|) by calling
1257 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
1258 typically constructed to remotely access an MXBean of another running virtual
1259 machine.
1260
1261 Indirect access to an MXBean interface via MBeanServer
1262
1263 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
1264 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
1265 remotely. The attributes and operations of an MXBean use only JMX open types
1266 which include basic data types,
1267 CompositeData(|javax.management.openmbean.CompositeData|) , and
1268 TabularData(|javax.management.openmbean.TabularData|) defined in
1269 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
1270 below.
1271
1272
1273
1274 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
1275 Instrumentation Specification and only uses a set of basic data types described
1276 below. A JMX management application and the platform MBeanServer can
1277 interoperate without requiring classes for MXBean specific data types. The data
1278 types being transmitted between the JMX connector server and the connector
1279 client are open types(|javax.management.openmbean.OpenType|) and this allows
1280 interoperation across versions.
1281
1282 The platform MXBean interfaces use only the following data types:
1283
1284 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
1285 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
1286 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
1287 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
1288 define a static from method with a
1289 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
1290 from an input CompositeData to an instance of that class
1291
1292 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
1293 an enum class, or a class supporting conversion from a CompositeData to its
1294 class
1295
1296 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
1297 class, an enum class, or a class supporting conversion from a CompositeData to
1298 its class
1299
1300
1301
1302 When an attribute or operation of a platform MXBean is accessed via an
1303 MBeanServer, the data types are mapped as follows:
1304
1305 A primitive type or a wrapper class is mapped to the same type.
1306
1307 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
1308 constant. A class that defines only getter methods and a static from method
1309 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
1310 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
1311
1312 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
1313 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
1314 with two items whose names are "key" and "value" and the item types are the
1315 corresponding mapped type of K and V respectively and the "key" is the index.
1316
1317 List<E> is mapped to an array with the mapped type of E as the element type.
1318
1319 An array of element type E is mapped to an array of the same dimenions with the
1320 mapped type of E as the element type.
1321
1322 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
1323 data types of the attributes and operations as primitive or open types mapped
1324 as specified above.
1325
1326 For example, the (|java.lang.management.MemoryMXBean|) interface has the
1327 following getter and setter methods:
1328
1329
1330
1331 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
1332 void setVerbose(boolean value);
1333
1334 These attributes in the MBeanInfo of the MemoryMXBean have the following names
1335 and types:
1336
1337
1338
1339 Attribute Name Type
1340
1341 HeapMemoryUsage CompositeData representing
1342 MemoryUsage(|java.lang.management.MemoryUsage|)
1343
1344 Verbose boolean
1345
1346
1347
1348 Implementation Note: The mapping specified above could be done in the
1349 implementation of each platform MXBean. One good implementation choice is to
1350 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
1351
1352 MXBean Names Each platform MXBean for a Java virtual machine has a unique
1353 ObjectName(|javax.management.ObjectName|) for registration in the platform
1354 MBeanServer. A Java virtual machine has a single instance of the following
1355 management interfaces:
1356
1357
1358
1359 Management Interface ObjectName
1360
1361 (|java.lang.management.ClassLoadingMXBean|)
1362 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
1363
1364 (|java.lang.management.MemoryMXBean|)
1365 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
1366
1367 (|java.lang.management.ThreadMXBean|)
1368 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
1369
1370 (|java.lang.management.RuntimeMXBean|)
1371 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
1372
1373 (|java.lang.management.OperatingSystemMXBean|)
1374 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
1375
1376
1377
1378
1379 A Java virtual machine has zero or a single instance of the following
1380 management interfaces.
1381
1382
1383
1384 Management Interface ObjectName
1385
1386 (|java.lang.management.CompilationMXBean|)
1387 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
1388
1389
1390
1391 A Java virtual machine may have one or more instances of the following
1392 management interfaces.
1393
1394
1395
1396 Management Interface ObjectName
1397
1398 (|java.lang.management.GarbageCollectorMXBean|)
1399 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
1400 ,name=collector's name
1401
1402 (|java.lang.management.MemoryManagerMXBean|)
1403 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
1404 ,name=manager's name
1405
1406 (|java.lang.management.MemoryPoolMXBean|)
1407 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
1408 ,name=pool's name
1409
1410
1411
1412
1413 *java.lang.String_java.lang.management.ManagementFactory.RUNTIME_MXBEAN_NAME*
1414
1415 The ManagementFactory class is a factory class for getting managed beans for
1416 the Java platform. This class consists of static methods each of which returns
1417 one or more platform MXBean(s) representing the management interface of a
1418 component of the Java virtual machine.
1419
1420 An application can access a platform MXBean in the following ways:
1421
1422 Direct access to an MXBean interface
1423
1424 Get the MXBean instance through the static factory method and access the MXBean
1425 locally of the running virtual machine.
1426
1427 Construct an MXBean proxy instance that forwards the method calls to a given
1428 MBeanServer(|javax.management.MBeanServer|) by calling
1429 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
1430 typically constructed to remotely access an MXBean of another running virtual
1431 machine.
1432
1433 Indirect access to an MXBean interface via MBeanServer
1434
1435 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
1436 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
1437 remotely. The attributes and operations of an MXBean use only JMX open types
1438 which include basic data types,
1439 CompositeData(|javax.management.openmbean.CompositeData|) , and
1440 TabularData(|javax.management.openmbean.TabularData|) defined in
1441 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
1442 below.
1443
1444
1445
1446 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
1447 Instrumentation Specification and only uses a set of basic data types described
1448 below. A JMX management application and the platform MBeanServer can
1449 interoperate without requiring classes for MXBean specific data types. The data
1450 types being transmitted between the JMX connector server and the connector
1451 client are open types(|javax.management.openmbean.OpenType|) and this allows
1452 interoperation across versions.
1453
1454 The platform MXBean interfaces use only the following data types:
1455
1456 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
1457 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
1458 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
1459 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
1460 define a static from method with a
1461 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
1462 from an input CompositeData to an instance of that class
1463
1464 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
1465 an enum class, or a class supporting conversion from a CompositeData to its
1466 class
1467
1468 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
1469 class, an enum class, or a class supporting conversion from a CompositeData to
1470 its class
1471
1472
1473
1474 When an attribute or operation of a platform MXBean is accessed via an
1475 MBeanServer, the data types are mapped as follows:
1476
1477 A primitive type or a wrapper class is mapped to the same type.
1478
1479 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
1480 constant. A class that defines only getter methods and a static from method
1481 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
1482 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
1483
1484 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
1485 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
1486 with two items whose names are "key" and "value" and the item types are the
1487 corresponding mapped type of K and V respectively and the "key" is the index.
1488
1489 List<E> is mapped to an array with the mapped type of E as the element type.
1490
1491 An array of element type E is mapped to an array of the same dimenions with the
1492 mapped type of E as the element type.
1493
1494 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
1495 data types of the attributes and operations as primitive or open types mapped
1496 as specified above.
1497
1498 For example, the (|java.lang.management.MemoryMXBean|) interface has the
1499 following getter and setter methods:
1500
1501
1502
1503 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
1504 void setVerbose(boolean value);
1505
1506 These attributes in the MBeanInfo of the MemoryMXBean have the following names
1507 and types:
1508
1509
1510
1511 Attribute Name Type
1512
1513 HeapMemoryUsage CompositeData representing
1514 MemoryUsage(|java.lang.management.MemoryUsage|)
1515
1516 Verbose boolean
1517
1518
1519
1520 Implementation Note: The mapping specified above could be done in the
1521 implementation of each platform MXBean. One good implementation choice is to
1522 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
1523
1524 MXBean Names Each platform MXBean for a Java virtual machine has a unique
1525 ObjectName(|javax.management.ObjectName|) for registration in the platform
1526 MBeanServer. A Java virtual machine has a single instance of the following
1527 management interfaces:
1528
1529
1530
1531 Management Interface ObjectName
1532
1533 (|java.lang.management.ClassLoadingMXBean|)
1534 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
1535
1536 (|java.lang.management.MemoryMXBean|)
1537 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
1538
1539 (|java.lang.management.ThreadMXBean|)
1540 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
1541
1542 (|java.lang.management.RuntimeMXBean|)
1543 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
1544
1545 (|java.lang.management.OperatingSystemMXBean|)
1546 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
1547
1548
1549
1550
1551 A Java virtual machine has zero or a single instance of the following
1552 management interfaces.
1553
1554
1555
1556 Management Interface ObjectName
1557
1558 (|java.lang.management.CompilationMXBean|)
1559 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
1560
1561
1562
1563 A Java virtual machine may have one or more instances of the following
1564 management interfaces.
1565
1566
1567
1568 Management Interface ObjectName
1569
1570 (|java.lang.management.GarbageCollectorMXBean|)
1571 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
1572 ,name=collector's name
1573
1574 (|java.lang.management.MemoryManagerMXBean|)
1575 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
1576 ,name=manager's name
1577
1578 (|java.lang.management.MemoryPoolMXBean|)
1579 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
1580 ,name=pool's name
1581
1582
1583
1584
1585 *java.lang.String_java.lang.management.ManagementFactory.THREAD_MXBEAN_NAME*
1586
1587 The ManagementFactory class is a factory class for getting managed beans for
1588 the Java platform. This class consists of static methods each of which returns
1589 one or more platform MXBean(s) representing the management interface of a
1590 component of the Java virtual machine.
1591
1592 An application can access a platform MXBean in the following ways:
1593
1594 Direct access to an MXBean interface
1595
1596 Get the MXBean instance through the static factory method and access the MXBean
1597 locally of the running virtual machine.
1598
1599 Construct an MXBean proxy instance that forwards the method calls to a given
1600 MBeanServer(|javax.management.MBeanServer|) by calling
1601 newPlatfromMXBeanProxy(|java.lang.management.ManagementFactory|) . A proxy is
1602 typically constructed to remotely access an MXBean of another running virtual
1603 machine.
1604
1605 Indirect access to an MXBean interface via MBeanServer
1606
1607 Go through the platform MBeanServer(|java.lang.management.ManagementFactory|)
1608 to access MXBeans locally or a specific MBeanServerConnection to access MXBeans
1609 remotely. The attributes and operations of an MXBean use only JMX open types
1610 which include basic data types,
1611 CompositeData(|javax.management.openmbean.CompositeData|) , and
1612 TabularData(|javax.management.openmbean.TabularData|) defined in
1613 OpenType(|javax.management.openmbean.OpenType|) . The mapping is specified
1614 below.
1615
1616
1617
1618 Platform MXBeans A platform MXBean is a managed bean that conforms to the JMX
1619 Instrumentation Specification and only uses a set of basic data types described
1620 below. A JMX management application and the platform MBeanServer can
1621 interoperate without requiring classes for MXBean specific data types. The data
1622 types being transmitted between the JMX connector server and the connector
1623 client are open types(|javax.management.openmbean.OpenType|) and this allows
1624 interoperation across versions.
1625
1626 The platform MXBean interfaces use only the following data types:
1627
1628 Primitive types such as int, long, boolean, etc Wrapper classes for primitive
1629 types such as Integer(|java.lang.Integer|) , Long(|java.lang.Long|) ,
1630 Boolean(|java.lang.Boolean|) , etc and String(|java.lang.String|)
1631 Enum(|java.lang.Enum|) classes Classes that define only getter methods and
1632 define a static from method with a
1633 CompositeData(|javax.management.openmbean.CompositeData|) argument to convert
1634 from an input CompositeData to an instance of that class
1635
1636 List&lt;E&gt;(|java.util.List|) where E is a primitive type, a wrapper class,
1637 an enum class, or a class supporting conversion from a CompositeData to its
1638 class
1639
1640 Map&lt;K,V&gt;(|java.util.Map|) where K and V are a primitive type, a wrapper
1641 class, an enum class, or a class supporting conversion from a CompositeData to
1642 its class
1643
1644
1645
1646 When an attribute or operation of a platform MXBean is accessed via an
1647 MBeanServer, the data types are mapped as follows:
1648
1649 A primitive type or a wrapper class is mapped to the same type.
1650
1651 An (|java.lang.Enum|) is mapped to String whose value is the name of the enum
1652 constant. A class that defines only getter methods and a static from method
1653 with a CompositeData(|javax.management.openmbean.CompositeData|) argument is
1654 mapped to CompositeData(|javax.management.openmbean.CompositeData|) .
1655
1656 Map<K,V> is mapped to TabularData(|javax.management.openmbean.TabularData|)
1657 whose row type is a CompositeType(|javax.management.openmbean.CompositeType|)
1658 with two items whose names are "key" and "value" and the item types are the
1659 corresponding mapped type of K and V respectively and the "key" is the index.
1660
1661 List<E> is mapped to an array with the mapped type of E as the element type.
1662
1663 An array of element type E is mapped to an array of the same dimenions with the
1664 mapped type of E as the element type.
1665
1666 The MBeanInfo(|javax.management.MBeanInfo|) for a platform MXBean describes the
1667 data types of the attributes and operations as primitive or open types mapped
1668 as specified above.
1669
1670 For example, the (|java.lang.management.MemoryMXBean|) interface has the
1671 following getter and setter methods:
1672
1673
1674
1675 public MemoryUsage getHeapMemoryUsage(); public boolean isVerbose(); public
1676 void setVerbose(boolean value);
1677
1678 These attributes in the MBeanInfo of the MemoryMXBean have the following names
1679 and types:
1680
1681
1682
1683 Attribute Name Type
1684
1685 HeapMemoryUsage CompositeData representing
1686 MemoryUsage(|java.lang.management.MemoryUsage|)
1687
1688 Verbose boolean
1689
1690
1691
1692 Implementation Note: The mapping specified above could be done in the
1693 implementation of each platform MXBean. One good implementation choice is to
1694 implement a MXBean as a dynamic MBean(|javax.management.DynamicMBean|) .
1695
1696 MXBean Names Each platform MXBean for a Java virtual machine has a unique
1697 ObjectName(|javax.management.ObjectName|) for registration in the platform
1698 MBeanServer. A Java virtual machine has a single instance of the following
1699 management interfaces:
1700
1701
1702
1703 Management Interface ObjectName
1704
1705 (|java.lang.management.ClassLoadingMXBean|)
1706 <tt>java.lang:type=ClassLoading</tt>(|java.lang.management.ManagementFactory|)
1707
1708 (|java.lang.management.MemoryMXBean|)
1709 <tt>java.lang:type=Memory</tt>(|java.lang.management.ManagementFactory|)
1710
1711 (|java.lang.management.ThreadMXBean|)
1712 <tt>java.lang:type=Threading</tt>(|java.lang.management.ManagementFactory|)
1713
1714 (|java.lang.management.RuntimeMXBean|)
1715 <tt>java.lang:type=Runtime</tt>(|java.lang.management.ManagementFactory|)
1716
1717 (|java.lang.management.OperatingSystemMXBean|)
1718 <tt>java.lang:type=OperatingSystem</tt>(|java.lang.management.ManagementFactory|)
1719
1720
1721
1722
1723 A Java virtual machine has zero or a single instance of the following
1724 management interfaces.
1725
1726
1727
1728 Management Interface ObjectName
1729
1730 (|java.lang.management.CompilationMXBean|)
1731 <tt>java.lang:type=Compilation</tt>(|java.lang.management.ManagementFactory|)
1732
1733
1734
1735 A Java virtual machine may have one or more instances of the following
1736 management interfaces.
1737
1738
1739
1740 Management Interface ObjectName
1741
1742 (|java.lang.management.GarbageCollectorMXBean|)
1743 <tt>java.lang:type=GarbageCollector</tt>(|java.lang.management.ManagementFactory|)
1744 ,name=collector's name
1745
1746 (|java.lang.management.MemoryManagerMXBean|)
1747 <tt>java.lang:type=MemoryManager</tt>(|java.lang.management.ManagementFactory|)
1748 ,name=manager's name
1749
1750 (|java.lang.management.MemoryPoolMXBean|)
1751 <tt>java.lang:type=MemoryPool</tt>(|java.lang.management.ManagementFactory|)
1752 ,name=pool's name
1753
1754
1755
1756
1757
1758 *java.lang.management.ManagementFactory.getClassLoadingMXBean()*
1759
1760 public static |java.lang.management.ClassLoadingMXBean| getClassLoadingMXBean()
1761
1762 Returns the managed bean for the class loading system of the Java virtual
1763 machine.
1764
1765
1766     Returns: a {@link ClassLoadingMXBean} object for the Java virtual machine.
1767 *java.lang.management.ManagementFactory.getCompilationMXBean()*
1768
1769 public static |java.lang.management.CompilationMXBean| getCompilationMXBean()
1770
1771 Returns the managed bean for the compilation system of the Java virtual
1772 machine. This method returns null if the Java virtual machine has no
1773 compilation system.
1774
1775
1776     Returns: a {@link CompilationMXBean} object for the Java virtual machine or null if the
1777              Java virtual machine has no compilation system.
1778 *java.lang.management.ManagementFactory.getGarbageCollectorMXBeans()*
1779
1780 public static |java.util.List| getGarbageCollectorMXBeans()
1781
1782 Returns a list of (|java.lang.management.GarbageCollectorMXBean|) objects in
1783 the Java virtual machine. The Java virtual machine may have one or more
1784 GarbageCollectorMXBean objects. It may add or remove GarbageCollectorMXBean
1785 during execution.
1786
1787
1788     Returns: a list of GarbageCollectorMXBean objects.
1789 *java.lang.management.ManagementFactory.getMemoryManagerMXBeans()*
1790
1791 public static |java.util.List| getMemoryManagerMXBeans()
1792
1793 Returns a list of (|java.lang.management.MemoryManagerMXBean|) objects in the
1794 Java virtual machine. The Java virtual machine can have one or more memory
1795 managers. It may add or remove memory managers during execution.
1796
1797
1798     Returns: a list of MemoryManagerMXBean objects.
1799 *java.lang.management.ManagementFactory.getMemoryMXBean()*
1800
1801 public static |java.lang.management.MemoryMXBean| getMemoryMXBean()
1802
1803 Returns the managed bean for the memory system of the Java virtual machine.
1804
1805
1806     Returns: a {@link MemoryMXBean} object for the Java virtual machine.
1807 *java.lang.management.ManagementFactory.getMemoryPoolMXBeans()*
1808
1809 public static |java.util.List| getMemoryPoolMXBeans()
1810
1811 Returns a list of (|java.lang.management.MemoryPoolMXBean|) objects in the Java
1812 virtual machine. The Java virtual machine can have one or more memory pools. It
1813 may add or remove memory pools during execution.
1814
1815
1816     Returns: a list of MemoryPoolMXBean objects.
1817 *java.lang.management.ManagementFactory.getOperatingSystemMXBean()*
1818
1819 public static |java.lang.management.OperatingSystemMXBean| getOperatingSystemMXBean()
1820
1821 Returns the managed bean for the operating system on which the Java virtual
1822 machine is running.
1823
1824
1825     Returns: an {@link OperatingSystemMXBean} object for the Java virtual machine.
1826 *java.lang.management.ManagementFactory.getPlatformMBeanServer()*
1827
1828 public static synchronized |javax.management.MBeanServer| getPlatformMBeanServer()
1829
1830 Returns the platform MBeanServer(|javax.management.MBeanServer|) . On the first
1831 call to this method, it first creates the platform MBeanServer by calling the
1832 (|javax.management.MBeanServerFactory|) method and registers the platform
1833 MXBeans in this platform MBeanServer using the MXBean names defined in the
1834 class description. This method, in subsequent calls, will simply return the
1835 initially created platform MBeanServer.
1836
1837 MXBeans that get created and destroyed dynamically, for example, memory
1838 pools(|java.lang.management.MemoryPoolMXBean|) and
1839 managers(|java.lang.management.MemoryManagerMXBean|) , will automatically be
1840 registered and deregistered into the platform MBeanServer.
1841
1842 If the system property javax.management.builder.initial is set, the platform
1843 MBeanServer creation will be done by the specified
1844 (|javax.management.MBeanServerBuilder|) .
1845
1846 It is recommended that this platform MBeanServer also be used to register other
1847 application managed beans besides the platform MXBeans. This will allow all
1848 MBeans to be published through the same MBeanServer and hence allow for easier
1849 network publishing and discovery. Name conflicts with the platform MXBeans
1850 should be avoided.
1851
1852
1853     Returns: the platform MBeanServer; the platform MXBeans are registered into the platform
1854              MBeanServer at the first time this method is called.
1855 *java.lang.management.ManagementFactory.getRuntimeMXBean()*
1856
1857 public static |java.lang.management.RuntimeMXBean| getRuntimeMXBean()
1858
1859 Returns the managed bean for the runtime system of the Java virtual machine.
1860
1861
1862     Returns: a {@link RuntimeMXBean} object for the Java virtual machine.
1863 *java.lang.management.ManagementFactory.getThreadMXBean()*
1864
1865 public static |java.lang.management.ThreadMXBean| getThreadMXBean()
1866
1867 Returns the managed bean for the thread system of the Java virtual machine.
1868
1869
1870     Returns: a {@link ThreadMXBean} object for the Java virtual machine.
1871 *java.lang.management.ManagementFactory.newPlatformMXBeanProxy(MBeanServerConnection,String,Class)*
1872
1873 public static |java.lang.Object| newPlatformMXBeanProxy(
1874   javax.management.MBeanServerConnection connection,
1875   java.lang.String mxbeanName,
1876   java.lang.Class mxbeanInterface)
1877   throws |java.io.IOException|
1878
1879 Returns a proxy for a platform MXBean interface of a given MXBean name that
1880 forwards its method calls through the given MBeanServerConnection.
1881
1882 This method is equivalent to: Proxy.newProxyInstance(|java.lang.reflect.Proxy|)
1883 (mxbeanInterface.getClassLoader(), new Class[] { mxbeanInterface }, handler)
1884
1885 where handler is an InvocationHandler(|java.lang.reflect.InvocationHandler|) to
1886 which method invocations to the MXBean interface are dispatched. This handler
1887 converts an input parameter from an MXBean data type to its mapped open type
1888 before forwarding to the MBeanServer and converts a return value from an MXBean
1889 method call through the MBeanServer from an open type to the corresponding
1890 return type declared in the MXBean interface.
1891
1892 If the MXBean is a notification emitter (i.e., it implements
1893 NotificationEmitter(|javax.management.NotificationEmitter|) ), both the
1894 mxbeanInterface and NotificationEmitter will be implemented by this proxy.
1895
1896 Notes:
1897
1898 Using an MXBean proxy is a convenience remote access to a platform MXBean of a
1899 running virtual machine. All method calls to the MXBean proxy are forwarded to
1900 an MBeanServerConnection where IOException(|java.io.IOException|) may be thrown
1901 when the communication problem occurs with the connector server. An application
1902 remotely accesses the platform MXBeans using proxy should prepare to catch
1903 IOException as if accessing with the MBeanServerConnector interface.
1904
1905 When a client application is designed to remotely access MXBeans for a running
1906 virtual machine whose version is different than the version on which the
1907 application is running, it should prepare to catch
1908 InvalidObjectException(|java.io.InvalidObjectException|) which is thrown when
1909 an MXBean proxy receives a name of an enum constant which is missing in the
1910 enum class loaded in the client application.
1911
1912 MBeanServerInvocationHandler(|javax.management.MBeanServerInvocationHandler|)
1913 or its newProxyInstance(|javax.management.MBeanServerInvocationHandler|) method
1914 cannot be used to create a proxy for a platform MXBean. The proxy object
1915 created by MBeanServerInvocationHandler does not handle the properties of the
1916 platform MXBeans described in the class specification.
1917
1918
1919
1920     connection - the MBeanServerConnection to forward to.
1921     mxbeanName - the name of a platform MXBean within connection to forward to. mxbeanName must
1922        be in the format of {@link ObjectName ObjectName}.
1923     mxbeanInterface - the MXBean interface to be implemented by the proxy.
1924
1925