javax.management

Annotation Type MXBean

@Documented
 @Retention(value=RUNTIME)
 @Target(value=TYPE)
public @interface MXBean

用于将界面明确标记为MXBean接口或不作为MXBean接口的注释。 默认情况下，界面是MXBean接口，如果它是公共的，其名称以MXBean ，如SomethingMXBean 。 以下接口是MXBean接口：

  public interface WhatsitMXBean {}

    @MXBean
    public interface Whatsit1Interface {}

    @MXBean(true)
    public interface Whatsit2Interface {} 

以下接口不是MXBean接口：

  interface NonPublicInterfaceNotMXBean{}

    public interface Whatsit3Interface{}

    @MXBean(false)
    public interface MisleadingMXBean {} 

MXBean规范

MXBean概念提供了一种简单的方法来编写一个仅引用预定义类型的MBean，由javax.management.openmbean定义。 这样，您可以确保您的MBean可以由任何客户端（包括远程客户端）使用，无需客户端访问代表您的MBean类型的模型特定类 。

与标准MBean概念相比，这些概念更容易理解。 以下是管理对象如何表示为标准MBean以及MXBean：

Standard MBean MXBean

public interface MemoryPoolMBean {
    String getName();
    MemoryUsage getUsage();
    // ...
}
          

public interface MemoryPoolMXBean {
    String getName();
    MemoryUsage getUsage();
    // ...
}
          

你可以看到，这些定义非常相似。 唯一的区别是，命名接口的惯例是使用SomethingMXBean作为MXBeans，而不是SomethingMBean用于标准MBean。

在此管理对象中，有一个名为Usage的属性类型为MemoryUsage 。 像这样的属性的点是它给出了一组数据项的一致的快照。 例如，它可能包括内存池中当前使用的内存量以及内存池的当前最大值。 如果这些是单独的项目，通过单独的getAttribute调用获得，那么我们可以得到在不同时间看不一致的值。 我们可能会得到一个used值比更大max值。

所以我们可以这样定义MemoryUsage ：

Standard MBean MXBean

public class MemoryUsage implements Serializable {
    // standard JavaBean conventions with getters

    public MemoryUsage(long init, long used,
                       long committed, long max) {...}
    long getInit() {...}
    long getUsed() {...}
    long getCommitted() {...}
    long getMax() {...}
}
          

public class MemoryUsage {
    // standard JavaBean conventions with getters
    @ConstructorProperties({"init", "used", "committed", "max"})
    public MemoryUsage(long init, long used,
                       long committed, long max) {...}
    long getInit() {...}
    long getUsed() {...}
    long getCommitted() {...}
    long getMax() {...}
}
          

在两种情况下，定义是相同的，除了使用MXBean， MemoryUsage不再需要标记Serializable （尽管可以）。 另一方面，我们添加了一个@ConstructorProperties注释来将构造函数参数链接到相应的getter。 我们将在下面看到更多。

MemoryUsage是一个模特儿类 。 使用标准MBean，如果MBean服务器的客户端不知道Usage类，则无法访问Usage MemoryUsage 。 假设客户端是基于JMX技术的通用控制台。 那么控制台必须配置它可能连接到的每个应用程序的特定于模型的类。 对于不是以Java语言编写的客户端，问题更加严重。 那么可能没有办法告诉客户MemoryUsage是什么样的。

这是MXBeans与标准MBeans不同的地方。 虽然我们以几乎完全相同的方式定义了管理界面，但MXBean框架将特定于类的类转换为Java平台中的标准类。 使用数组和标准javax.management.openmbean包中的CompositeData和TabularData类，可以使用标准类构建任意复杂的数据结构。

如果我们比较两个模型的客户端可能是什么样子，这将变得更加清晰

Standard MBean MXBean

String name = (String)
    mbeanServer.getAttribute(objectName, "Name");
MemoryUsage usage = (MemoryUsage)
    mbeanServer.getAttribute(objectName, "Usage");
long used = usage.getUsed();
          

String name = (String)
    mbeanServer.getAttribute(objectName, "Name");
CompositeData usage = (CompositeData)
    mbeanServer.getAttribute(objectName, "Usage");
long used = (Long) usage.get("used");
          

对于类似于String的简单类型的String ，代码是一样的。 但是对于具有复杂类型的属性，标准MBean代码要求客户端了解特定于型号的类别MemoryUsage ，而MXBean代码不需要非标准类。

这里显示的客户端代码对于MXBean客户端来说稍微复杂一些。 但是，如果客户端实际上知道该模型，这里的接口是MemoryPoolMXBean和MemoryUsage类，那么它可以构造一个代理 。 当您事先知道模型时，无论您使用的是标准MBean还是MXBean，这是建议与受管对象进行交互的方式：

Standard MBean MXBean

MemoryPoolMBean proxy =
    JMX.newMBeanProxy(
        mbeanServer,
        objectName,
        MemoryPoolMBean.class);
String name = proxy.getName();
MemoryUsage usage = proxy.getUsage();
long used = usage.getUsed();
          

MemoryPoolMXBean proxy =
    JMX.newMXBeanProxy(
        mbeanServer,
        objectName,
        MemoryPoolMXBean.class);
String name = proxy.getName();
MemoryUsage usage = proxy.getUsage();
long used = usage.getUsed();
          

实现MemoryPool对象与标准MBean和MXBean类似。

Standard MBean MXBean

public class MemoryPool
        implements MemoryPoolMBean {
    public String getName() {...}
    public MemoryUsage getUsage() {...}
    // ...
}
          

public class MemoryPool
        implements MemoryPoolMXBean {
    public String getName() {...}
    public MemoryUsage getUsage() {...}
    // ...
}
          

在这两种情况下，在MBean服务器中注册MBean的工作原理都是相同的：

Standard MBean MXBean

{
    MemoryPoolMBean pool = new MemoryPool();
    mbeanServer.registerMBean(pool, objectName);
}
          

{
    MemoryPoolMXBean pool = new MemoryPool();
    mbeanServer.registerMBean(pool, objectName);
}
          

MXBean的定义

MXBean是一种MBean。 MXBean对象可以直接注册到MBean服务器中，也可以用作StandardMBean的参数，MBean服务器中注册的MBean。

当一个对象在MBean服务器使用注册registerMBean或createMBean的方法MBeanServer接口，该对象的类的检查，以确定是什么类型的MBean：

• 如果类实现接口DynamicMBean，则MBean是动态MBean。 请注意， StandardMBean类StandardMBean了此接口，因此本例适用于使用StandardMBean类创建的标准MBean或MXBean。
• 否则，如果类与标准MBean命名约定匹配，则MBean是标准MBean。
• 否则，它可能是一个MXBean。 检查由对象实现的一组接口，用于以下接口：
  • 有一个类名SMXBean其中S是任何非空字符串，并没有注释@MXBean(false) ; 和/或
  • 有一个注释@MXBean(true)或只是@MXBean 。
  如果只有一个这样的接口，或者如果有一个这样的接口是所有其他接口的子接口，则对象是MXBean。 该界面是MXBean界面 。 在上面的示例中，MXBean接口为MemoryPoolMXBean 。
• 如果这些条件都不满足，则MBean无效，并且尝试注册它将生成NotCompliantMBeanException 。

显示为在MXBean接口的参数或返回类型的方法的每一个Java类型必须使用下面的规则是可兑换 。 另外，参数必须如下所述重构 。

尝试构造不符合上述规则的MXBean将产生异常。

命名约定

相同的命名约定应用于MXBean中的方法，如标准MBean中所示：

1. 方法T getN() ，其中T是Java类型（不是void ），而N是非空字符串，指定有一个可读属性叫做N 。 属性的Java类型和Open类型由下面的映射规则确定。 从Object的方法final Class getClass()在查找getter时被忽略。
2. 方法boolean isN()指定有一个名为N的可读N ，Java类型为boolean ，打开类型为SimpleType.Boolean 。
3. 方法void setN(T x)指定有一个可写属性叫做N 。 属性的Java类型和Open类型由下面的映射规则确定。 （当然，名称x参数是无关的。）
4. 每个其他方法都指定有一个与该方法名称相同的操作。 返回值和每个参数的Java类型和Open类型由以下映射规则确定。

getN和isN的规则共同定义了吸气剂的概念。 setN的规则定义了设置者的概念。

这是一个错误，有两个同名的getter，或两个同名的setter。 如果有同一个名字的getter和setter，那么两者中的类型T必须相同。 在这种情况下，属性是读/写。 如果只有一个getter或只有一个setter，那么该属性是分别只读或只写的。

键入映射规则

MXBean是一种开放MBean，由javax.management.openmbean包定义。 这意味着属性，操作参数和操作返回值的类型必须全部使用Open Types进行描述 ，即OpenType的四个标准子类 。 MXBeans通过将Java类型映射到“打开类型”来实现此目的。

对于每个Java类型J ，MXBean映射由以下信息描述：

• 相应的Open Type， opentype（J） 。 这是OpenType的子类的一个实例。
• 映射的 Java类型， opendata（J） ，对于任何给定的opentype（J）来说都是相同的。 这是一个Java类。
• 如何将值从类型J转换为类型opendata（J） 。
• 如何将值从类型opendata（J）转换为类型J （如果可以）。

例如，对于Java类型List<String> ：

• 开放型，OpenType字体（ List<String> ），是ArrayType (1, SimpleType.STRING )表示的1维阵列String秒。
• 映射的Java类型， opendata（ List<String> ）是String[] 。
• A List<String>可以转换为String[]使用List.toArray(new String[0]) 。
• 甲String[]可以被转换为一个List<String>使用Arrays.asList 。

如果没有映射规则从J导出opentype（J） ，则J不能是MXBean接口中的方法参数或返回值的类型。

如果有一种方法将opendata（J）转换回J，那么我们说J是可重构的 。 MXBean接口中的所有方法参数必须可重构，因为当MXBean框架正在调用方法时，将需要将这些参数从opendata（J）转换为J。 在由JMX.newMXBeanProxy生成的代理中，MXBean接口中方法的返回值必须可重构。

所有Java类型和开放类型都允许空值，除了不可能的原始Java类型。 当从类型J转换为类型opendata（J）或从类型opendata（J）转换为类型J时，空值映射到空值。

下表总结了类型映射规则。

Java type J opentype(J) opendata(J) int, boolean, etc
(the 8 primitive Java types) SimpleType.INTEGER,
SimpleType.BOOLEAN, etc Integer, Boolean, etc
(the corresponding boxed types) Integer, ObjectName, etc
(the types covered by SimpleType) the corresponding SimpleType J, the same type int[] etc
(a one-dimensional array with
primitive element type) ArrayType.getPrimitiveArrayType(int[].class) etc J, the same type E[]
(an array with non-primitive element type E; this includes int[][], where E is int[]) ArrayType.getArrayType(opentype(E)) opendata(E)[] List<E>
Set<E>
SortedSet<E> (see below) same as for E[] same as for E[] An enumeration E
(declared in Java as 枚举E {...}) SimpleType.STRING String Map<K,V>
SortedMap<K,V> TabularType
(see below) TabularData
(see below) An MXBean interface SimpleType.OBJECTNAME
(see below) ObjectName
(see below) Any other type CompositeType, if possible
(see below) CompositeData

以下部分将详细介绍这些规则。

原始类型的映射

8种基本Java类型（ boolean ， byte ， short ， int ， long ， float ， double ， char ）被映射到相应的盒装类型从java.lang ，即Boolean ， Byte等开放式是相应的SimpleType 。 因此， opentype（ long ）是SimpleType.LONG ，而opendata（ long ）是java.lang.Long 。

原始类型的数组，如long[]可以直接表示为打开类型。 因此， openType（ long[] ）是ArrayType.getPrimitiveArrayType(long[].class) ，而opendata（ long[] ）是long[] 。

实际上，平原int和Integer等之间的int并不显示，因为JMX API中的操作始终在Java对象而不是基元上。 然而，差异确实出现在数组中。

收藏图（ List< E >等）

甲List< ë >或Set< Ë > ，如List<String>或Set<ObjectName> ，被映射在相同的方式，相同的元素类型的阵列，如String[]或ObjectName[] 。

A SortedSet< E >也以与E []相同的方式进行映射，但如果E是实现Comparable的类或接口，则只能转换 。 因此， SortedSet<String>或SortedSet<Integer>是可转换的，但SortedSet<int[]>或SortedSet<List<String>>不是。 SortedSet实例的转换将失败， IllegalArgumentException如果它具有非空值comparator() 。

A List< E >被重建为java.util.ArrayList< E > ; a Set< E > as a java.util.HashSet< E > ; a SortedSet< E > as a java.util.TreeSet< E > 。

地图绘图（ Map< K ， V >等）

A Map< K ， V >或SortedMap< K ， V > ，例如Map<String,ObjectName> ，具有开放类型TabularType并被映射到TabularData 。 TabularType有两个项目叫做key和value 。 key的开放类型为opentype（K） ， value的开放类型为opentype（V） 。 TabularType的索引是单项key 。

例如， TabularType为Map<String,ObjectName>可能与这样的代码来构建：

  String typeName =
    "java.util.Map<java.lang.String, javax.management.ObjectName>";
String[] keyValue =
    new String[] {"key", "value"};
OpenType[] openTypes =
    new OpenType[] {SimpleType.STRING, SimpleType.OBJECTNAME};
CompositeType rowType =
    new CompositeType(typeName, typeName, keyValue, keyValue, openTypes);
TabularType tabularType =
    new TabularType(typeName, typeName, rowType, new String[] {"key"}); 

typeName这里是由下面详细描述的type name rules决定的。

A SortedMap< K ， V >以相同的方式映射，但如果K是实现Comparable的类或接口，则只能转换 。 因此， SortedMap<String,int[]>是可转换的，但SortedMap<int[],String>不是。 SortedMap实例的转换将失败，如果IllegalArgumentException具有非空值comparator()，则失败 。

A Map< K ， V >被重建为java.util.HashMap< K ， V > ; a SortedMap< K ， V > as a java.util.TreeMap< K ， V > 。

TabularData是一个接口。 用于表示Map< K ， V >作为开放数据的具体类是TabularDataSupport ，或另一个实现TabularData的TabularData ，序列化为TabularDataSupport 。

用于MXBean接口的映射

MXBean接口或MXBean接口中引用的类型可以引用另一个MXBean接口J。 那么opentype（J）是SimpleType.OBJECTNAME ，而opendata（J）是ObjectName 。

例如，假设您有两个MXBean接口，如下所示：

  public interface ProductMXBean {
    public ModuleMXBean[] getModules();
}

public interface ModuleMXBean {
    public ProductMXBean getProduct();
} 

实现该目的ModuleMXBean从其界面返回getProduct方法实现该目的ProductMXBean接口。 ModuleMXBean对象和返回的ProductMXBean对象都必须在同一MBean服务器中注册为MXBean。

方法ModuleMXBean.getProduct()定义了一个名为Product 。 此属性的“打开类型”为SimpleType.OBJECTNAME ，相应的ObjectName值将是MBean Server中引用的ProductMXBean ProductMXBean的名称。

如果您为ModuleMXBean创建MXBean代理并调用其getProduct()方法，则代理将通过创建另一个MXBean代理将ObjectName回ProductMXBean 。 更正式地，当代理人用JMX.newMXBeanProxy(mbeanServerConnection, objectNameX, interfaceX)进行映射时，需要将objectNameY映射到interfaceY ，另一个MXBean接口，它与JMX.newMXBeanProxy(mbeanServerConnection, objectNameY, interfaceY) 。 实现可以返回一个以前通过调用创建一个代理JMX.newMXBeanProxy具有相同的参数，也可以创建一个新的代理。

反向映射是由下列变化于图示ModuleMXBean接口：

  public interface ModuleMXBean {
    public ProductMXBean getProduct();
    public void setProduct(ProductMXBean c);
} 

setProduct方法的存在现在意味着Product属性是读/写。 如前所述，此属性的值为ObjectName 。 当属性设置时， ObjectName必须转换为setProduct方法期望的ProductMXBean对象。 该对象将是同一MBean服务器中给定的ObjectName的MXBean代理。

如果您为ModuleMXBean创建MXBean代理，并调用其setProduct方法，则代理将将其ProductMXBean参数映射回ObjectName 。 这只有在参数实际上是另一个代理ProductMXBean ，对于同一个ProductMXBean中的MBeanServerConnection 。 代理可以被从另一个代理返回（如ModuleMXBean.getProduct() ，它返回一个代理用于ProductMXBean ）; 或者它可以由JMX.newMXBeanProxy创建; 或者它可以使用已经创建Proxy与调用处理程序是MBeanServerInvocationHandler或子类。

如果相同的MXBean在两个不同的注册ObjectName S，从另一个那么对哪个MXBean进行引用将是不明确的。 因此，如果MXBean对象已在MBean服务器中注册，并尝试以另一个名称将其注册到同一个MBean服务器中，则结果为InstanceAlreadyExistsException 。 不鼓励在多个名称下注册相同的MBean对象，特别是因为它对于NotificationBroadcaster的MBean不能正常工作。

其他类型的映射

给定一个与上表中其他规则不匹配的Java类或接口J ，MXBean框架将尝试将其映射到CompositeType ，如下所示。 此CompositeType的类型名称由下面的type name rules决定 。

使用约定above检查吸烟者的课程 。 （Getters必须是公共实例方法。）如果没有getter，或者如果任何getter的类型不可转换，则J不可转换。

如果至少有一个吸气剂和每个吸气剂都有可转换型，那么opentype（J）是一个CompositeType ，每个吸气剂都有一个项目。 如果吸气剂是

T getName()

那么CompositeType中的项目被称为name ，并且具有类型opentype（T） 。 例如，如果项目是

String getOwner()

那么该项目被称为owner ，并且具有打开类型SimpleType.STRING 。 如果吸气剂是

boolean isName()

那么CompositeType中的项目被称为name ，并且具有类型SimpleType.BOOLEAN 。

请注意，第一个字符（或代码点）转换为小写。 这遵循Java Beans约定，由于历史原因与标准MBean约定不同。 在标准MBean或MXBean接口中，方法getOwner定义了一个称为Owner ，而在Java Bean或映射的CompositeType ，方法getOwner定义了一个名为owner的属性或项。

如果两种方法产生相同的项目名称（例如， getOwner和isOwner或getOwner和getowner ），则该类型不可转换。

当Open Type为CompositeType时，对应的映射Java类型（ opendata（J） ）为CompositeData 。 从J的实例所涉及的映射CompositeData对应于CompositeType刚刚描述的如下完成。 首先，如果J实现接口CompositeDataView ，那么该接口的toCompositeData方法被调用来进行转换。 否则， CompositeData是通过调用每个项目的getter并将其转换为相应的Open Data类型来构造的。 因此，吸气剂如

List<String> getNames()

将被映射到名称为“ names ”的项目，并打开类型ArrayType(1, SimpleType.STRING) 。 转换为CompositeData将致电getNames() ，并将结果List<String>转换为String[]的项目“ names ”。

CompositeData是一个接口。 用于表示打开数据类型的具体类别为CompositeDataSupport ，或另一个实现CompositeData的CompositeData ，序列化为CompositeDataSupport 。

从CompositeData Java类型J的CompositeData

如果对于Java类型J ， opendata（J）为CompositeData ，则可以从CompositeData J的一个实例，或者J不可重构。 如果CompositeData中的任何项目不可重构，则J也不可重构。

对于任何给定的J ，参考以下规则来确定如何从CompositeData重建J的CompositeData 。 列表中的第一个适用规则是将被使用的规则。

1. 如果J有一个方法
   public static J from(CompositeData cd)
   那么该方法被调用来重建J的一个实例。

2. 否则，如果J具有至少一个具有ConstructorProperties注释的公共构造函数，则将调用其中一个构造函数（不一定总是相同的）来重构J的实例。 每个这样的注释必须列出与构造函数具有参数一样多的字符串; 每个字符串必须命名一个对应于J的getter的属性; 并且该getter的类型必须与相应的构造函数参数相同。 在ConstructorProperties注释中没有提到的getter不是错误（这些可能对应于不需要重建对象的信息）。

   通过从CompositeData调用具有适当重建项目的CompositeData函数来重建J的一个实例。 被调用的构造函数将根据CompositeData中实际存在的项目在运行时CompositeData ，因为CompositeData可能来自较早版本的J ，其中并不是所有的项目都存在。 如果所有在其指定的属性的构造方法是适用 ConstructorProperties注释是存在于该项目CompositeData 。 如果不适用构造函数，则重建J的尝试失败。

   对于任何可能的属性组合，必须是（a）没有适用的构造函数，或（b）只有一个适用的构造函数，或（c）其中一个适用的构造函数命名属性的正确超集由其他适用的构造函数命名。 （换句话说，对于哪个构造函数来说绝对不应该有歧义）。如果这个条件不是真的，那么J不可重构。

3. 否则，如果J有一个public no-arg构造函数，并且对于类型为T和N的 J中的每个getter，都有一个具有相同名称和类型的相应setter，那么J的一个实例使用no-arg构造函数构造，从CompositeData调用重建的项目来恢复值。 例如，如果有一个方法
   public List<String> getNames()
   那么还必须有一种方法
   public void setNames(List<String> names)
   这个规则适用。

   如果CompositeData来自较早版本的J ，某些项目可能不存在。 在这种情况下，不会调用相应的设置器。

4. 否则，如果J是具有不大于吸气剂的其它方法的接口，J的一个实例是使用构造Proxy与CompositeDataInvocationHandler由备份CompositeData被转换。

5. 否则， J不可重构。

规则2不适用于Java SE的不包括java.beans包的java.beans文件。 当定位不包括java.beans包的运行时，并且编译时和运行时间环境之间存在不匹配，其中J使用公共构造函数和ConstructorProperties批注编译时，除非另有规则适用，否则J不可重构。

以下是一些示例，显示了由int和String组成的类型NamedNumber的String 。 在每种情况下， CompositeType如下所示：

CompositeType(
    "NamedNumber",                      // typeName
    "NamedNumber",                      // description
    new String[] {"number", "name"},    // itemNames
    new String[] {"number", "name"},    // itemDescriptions
    new OpenType[] {SimpleType.INTEGER,
                    SimpleType.STRING}  // itemTypes
);
      

1. 静态from方法：

   public class NamedNumber {
       public int getNumber() {return number;}
       public String getName() {return name;}
       private NamedNumber(int number, String name) {
           this.number = number;
           this.name = name;
       }
       public static NamedNumber from(CompositeData cd) {
           return new NamedNumber((Integer) cd.get("number"),
                                  (String) cd.get("name"));
       }
       private final int number;
       private final String name;
   }
             

2. 具有@ConstructorProperties注释的公共@ConstructorProperties函数：

   public class NamedNumber {
       public int getNumber() {return number;}
       public String getName() {return name;}
       @ConstructorProperties({"number", "name"})
       public NamedNumber(int number, String name) {
           this.number = number;
           this.name = name;
       }
       private final int number;
       private final String name;
   }
             

3. 每个吸气剂的设定者：

   public class NamedNumber {
       public int getNumber() {return number;}
       public void setNumber(int number) {this.number = number;}
       public String getName() {return name;}
       public void setName(String name) {this.name = name;}
       public NamedNumber() {}
       private int number;
       private String name;
   }
             

4. 仅与吸气口接口：

   public interface NamedNumber {
       public int getNumber();
       public String getName();
   }
             

它通常是用于简单地表示数据的集合是不可变的类。 一个不可变类的实例在构造完成后不能被改变。 请注意， CompositeData本身是不可变的。 不可变性有很多优点，特别是在线程安全和安全方面。 因此，如果可能，通常应避免使用设置器的方法。

递归类型

递归（自引用）类型不能在MXBean接口中使用。 这是CompositeType的不变性的结果 。 例如，以下类型不能是属性的类型，因为它引用自身：

  public interface Node {
    public String getName();
    public int getPriority();
    public Node getNext();
} 

总是可以重写这样的递归类型，所以它们不再是递归的。 这样做可能需要引入新的类型。 例如：

  public interface NodeList {
    public List<Node> getNodes();
}

public interface Node {
    public String getName();
    public int getPriority();
} 

MXBean的MBeanInfo内容

MXBean是一种Open MBean。 但是，出于兼容性原因，它的MBeanInfo不是OpenMBeanInfo 。 特别地，当属性，参数或操作返回值的类型是诸如int或void （对于返回类型）的基本类型时，属性，参数或操作将分别由MBeanAttributeInfo表示 ， MBeanParameterInfo或MBeanOperationInfo ，其getType()或getReturnType()返回原始名称（“ int ”等）。 即使上面的映射规则指定opendata映射是包装类型（ Integer等） Integer 。

由MBean Server直接注册的MXBean返回的MBeanInfo.getConstructors()的公共构造函数数组将包含该MXBean的所有公共构造函数。 如果MXBean的类不是公开的，那么它的构造函数也不被认为是公开的。 为使用StandardMBean类构造的MXBean返回的列表的派生方式与标准MBeans相同。 不管MXBean如何构造，其构造函数参数不受MXBean映射规则的约束，并且没有相应的OpenType 。

通过返回的通知类型的数组MBeanInfo.getNotifications()于MXBean是在MBean服务器中注册，直接会是空的，如果的MXBean没有实现NotificationBroadcaster接口。 否则，将在MXBean 注册时调用NotificationBroadcaster.getNotificationInfo()的结果。 即使这种方法的结果MBeanInfo.getNotifications()改变，MBeanInfo.getNotifications()的结果也不会。 使用StandardMBean或StandardEmitterMBean类构造的MXBean返回的列表与标准MBean的方法相同。

该Descriptor对于所有的MBeanAttributeInfo ， MBeanParameterInfo和MBeanOperationInfo中包含的对象MBeanInfo将有一个字段openType ，其值是OpenType由上述映射规则指定。 所以即使getType()是“ int ”， getDescriptor().getField("openType")将是SimpleType.INTEGER 。

每个这些对象的Descriptor也将有一个字段originalType ，它是一个字符串，表示MXBean界面中出现的Java类型。 此字符串的格式，以便在部分中描述Type Names下方。

Descriptor的MBeanInfo将有一个字段mxbean ，其值是字符串“ true ”。

键入名称

有时，MXBean中的方法参数或返回值的未映射类型T必须用字符串表示。 如果T是非泛型类型，则此字符串是由Class.getName()返回的值。 否则它是通用字符串（T）的值，定义如下：

• 如果T是非泛型非数组类型， 则通用字符串（T）是由Class.getName()返回的值，例如"int"或"java.lang.String" 。
• 如果T是数组E [] ， 通用字符串（T）是通用字符串（E），后跟"[]" 。 例如， 通用字符串（ int[] ）是"int[]" ， 通用字符串（ List<String>[][] ）是"java.util.List<java.lang.String>[][]" 。
• 否则， T是一个参数化类型，如List<String> ， genericstring（T）由以下组成：Class.getName()返回的Class.getName()化类型的全限定名; 左角括号（ "<" ）; 通用字符串（A）其中A是第一个类型的参数; 如果有第二个类型参数B，那么", " （逗号和一个空格），后跟通用字符串（B） ; 一个直角括号（ ">" ）。

请注意，如果方法返回int[] ， "[I"返回的字符串"[I" Class.getName() ，但如果方法返回List<int[]> ，则将以字符串"java.util.List<int[]>" 。

例外

使用OpenDataException发送从 Java类型映射到 Open类型的问题 。 当分析MXBean接口时，可能会发生这种情况，例如，如果它引用了一个没有getter的类型，就像java.util.Random 。 或者当实例被转换时（MXBean代理中的MXBean方法中的返回值或参数转换为MXBean代理中的方法），例如从SortedSet<String>为String[]如果SortedSet具有非空值Comparator ），则SortedSet会Comparator 。

使用InvalidObjectException发送从打开类型映射到 Java类型的问题 。 当分析MXBean接口时，例如，如果在需要可重构类型的上下文中引用了根据上述规则不可重构的类型，则可能会发生这种情况。 或者当实例被转换时（MXBean中的方法的参数或MXBean代理中的方法的返回值），例如，如果不存在具有该名称的枚举常量，则可以从字符串到枚举。

根据上下文， OpenDataException或InvalidObjectException可能会被包装在另一个例外中，如RuntimeMBeanException或UndeclaredThrowableException 。 对于每一个被抛出的异常，条件C将为真：“e是OpenDataException或InvalidObjectException （根据需要），或C是E的真。 getCause() ”。

从以下版本开始：

1.6

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
boolean	value 如果注释的界面是MXBean接口，则为true。

Element Detail

value

public abstract boolean value

如果注释的界面是MXBean接口，则为true。

结果

如果注释的界面是MXBean接口，则为true。

Default:

真正