Тип аннотации 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 будет пригоден для любого клиента, включая удалённых клиентов, без необходимости, чтобы клиент имел доступ к модель-специфичным классам, представляющим типы ваших MBeans.

Концепции легче понять при сравнении с концепцией Standard MBean. Вот как управляемый объект может быть представлен как Standard MBean и как MXBean:

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

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

Как видите, определения очень похожи. Единственное отличие заключается в том, что соглашение об именовании интерфейса для MXBean использует SomethingMXBean вместо SomethingMBean для Standard MBean.

В этом управляемом объекте есть атрибут, называемый Usage типа MemoryUsage. Цель такого атрибута заключается в предоставлении согласованной «моментальной фотографии» набора элементов данных. Например, он может включать текущий объём используемой памяти в пуле памяти и текущий максимум пула памяти. Если бы эти значения были отдельными элементами, полученными с помощью отдельных вызовов getAttribute, то мы могли бы получить значения, полученные в разное время, которые не были бы согласованными. Мы могли бы получить значение used, которое было бы больше, чем значение max.

Итак, мы можем определить MemoryUsage следующим образом:

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
    @ConstructorParameters({"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 (хотя это возможно). С другой стороны, мы добавили аннотацию @ConstructorParameters для связывания параметров конструктора с соответствующими методами-геттерами. Подробнее об этом ниже.

MemoryUsage является модель-специфичным классом. В случае Standard MBeans клиент MBean Server не может получить доступ к атрибуту Usage, если не знает класс MemoryUsage. Предположим, клиент представляет собой обобщенную консоль на основе технологии JMX. Тогда консоль должна быть настроена с модель-специфичными классами каждого приложения, к которому она может подключиться. Проблема ещё больше усугубляется для клиентов, написанных не на языке Java. В таком случае может не быть способа сообщить клиенту, как выглядит MemoryUsage.

В этом случае MXBeans отличаются от Standard MBeans. Хотя мы определяем интерфейс управления практически точно так же, как и раньше, фреймворк MXBean преобразует модель-специфичные классы в стандартные классы платформы Java. Используя массивы и классы CompositeData и TabularData из стандартного пакета javax.management.openmbean, можно создать структуры данных произвольной сложности, используя только стандартные классы.

Это становится более ясным, если сравнить, как могут выглядеть клиенты обеих моделей:

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, код идентичен. Но для атрибутов со сложными типами код Standard MBean требует, чтобы клиент знал модель-специфичный класс MemoryUsage, в то время как код MXBean не требует использования нестандартных классов.

Код клиента для MXBean немного сложнее. Однако, если клиент на самом деле знает модель, здесь интерфейс MemoryPoolMXBean и класс MemoryUsage, то он может построить прокси. Это рекомендуемый способ взаимодействия с управляемыми объектами, когда модель известна заранее, независимо от того, используете ли вы Standard MBeans или MXBeans:

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 аналогична как для Standard MBeans, так и для MXBeans.

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

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

Регистрация MBean в MBean Server происходит одинаково в обоих случаях:

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

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

Определение MXBean

MXBean — это разновидность MBean. Объект MXBean может быть зарегистрирован непосредственно в MBean Server или использоваться в качестве аргумента для StandardMBean, а полученный MBean зарегистрирован в MBean Server.

Когда объект регистрируется в MBean Server с помощью методов registerMBean или createMBean интерфейса MBeanServer, проверяется класс объекта, чтобы определить его тип MBean:

• Если класс реализует интерфейс DynamicMBean, то MBean является Dynamic MBean. Обратите внимание, что класс StandardMBean реализует этот интерфейс, поэтому этот случай применим к Standard MBean или MXBean, созданному с помощью класса StandardMBean.
• В противном случае, если класс соответствует соглашениям об именовании Standard MBean, то MBean является Standard MBean.
• В противном случае, это может быть MXBean. Проверяется набор реализованных объектом интерфейсов на предмет интерфейсов, которые:
  • имеют имя класса SMXBean (где S — любая непустая строка) и не имеют аннотации @MXBean(false); и/или
  • имеют аннотацию @MXBean(true) или просто @MXBean.
  Если существует ровно один такой интерфейс или если существует один такой интерфейс, являющийся подынтерфейсом всех остальных, то объект является MXBean. Интерфейс в вопросе — это MXBean-интерфейс. В примере выше MXBean-интерфейсом является MemoryPoolMXBean.
• Если ни одно из этих условий не выполняется, MBean является недействительным, и попытка его регистрации вызовет NotCompliantMBeanException.

Каждый тип Java, который появляется в качестве параметра или возвращаемого значения метода в интерфейсе MXBean, должен быть преобразуем в соответствии с правилами ниже. Кроме того, параметры должны быть восстановимы, как определено ниже.

Попытка создать MXBean, не соответствующий вышеуказанным правилам, вызовет исключение.

Соглашения об именовании

К методам MXBean применяются те же соглашения об именовании, что и к методам Standard MBean:

1. Метод T getN(), где T — тип Java (не void) и N — непустая строка, указывает на то, что существует читаемый атрибут, называемый N. Тип Java и открытый тип атрибута определяются правилами сопоставления ниже. Метод final Class getClass() унаследованный от Object игнорируется при поиске геттеров.
2. Метод boolean isN() указывает на то, что существует читаемый атрибут, называемый N с типом Java boolean и открытым типом SimpleType.Boolean.
3. Метод void setN(T x) указывает на то, что существует записываемый атрибут, называемый N. Тип Java и открытый тип атрибута определяются правилами сопоставления ниже. (Конечно, имя x параметра не имеет значения.)
4. Все остальные методы указывают на то, что существует операция с тем же именем, что и метод. Тип Java и открытый тип возвращаемого значения и каждого параметра определяются правилами сопоставления ниже.

Правила для getN и isN вместе определяют понятие геттера. Правило для setN определяет понятие сеттера.

Ошибка — это наличие двух геттеров с одинаковым именем или двух сеттеров с одинаковым именем. Если есть геттер и сеттер для одного имени, то тип T в обоих случаях должен быть одинаковым. В этом случае атрибут является читаемым/записываемым. Если есть только геттер или только сеттер, атрибут является только для чтения или только для записи соответственно.

Правила сопоставления типов

MXBean — это разновидность Open MBean, как определено в пакете javax.management.openmbean. Это означает, что типы атрибутов, параметров операций и возвращаемых значений операций должны описываться с помощью открытых типов, то есть четырёх стандартных подклассов OpenType. MXBeans достигают этого, сопоставляя типы Java с открытыми типами.

Для каждого типа Java J сопоставление MXBean описывается следующей информацией:

• Соответствующий открытый тип, opentype(J). Это экземпляр подкласса OpenType.
• Преобразованный тип Java, opendata(J), который всегда одинаков для любого данного opentype(J). Это класс Java.
• Как значение преобразуется из типа J в тип opendata(J).
• Как значение преобразуется из типа opendata(J) в тип J, если это возможно.

Например, для типа Java List<String>: