javax.management.modelmbean.ModelMBeanInfo Java Examples

@Test
public void testAttributeHasCorrespondingOperations() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();

	ModelMBeanOperationInfo get = info.getOperation("getName");
	assertNotNull("get operation should not be null", get);
	assertEquals("get operation should have visibility of four",
			get.getDescriptor().getFieldValue("visibility"),
			new Integer(4));
	assertEquals("get operation should have role \"getter\"", "getter", get.getDescriptor().getFieldValue("role"));

	ModelMBeanOperationInfo set = info.getOperation("setName");
	assertNotNull("set operation should not be null", set);
	assertEquals("set operation should have visibility of four",
			set.getDescriptor().getFieldValue("visibility"),
			new Integer(4));
	assertEquals("set operation should have role \"setter\"", "setter", set.getDescriptor().getFieldValue("role"));
}
 

private Logger getModelMBeanLogger(String notificationType) throws MBeanException
{
   // Get a copy to avoid synchronization
   ModelMBeanInfo info = getModelMBeanInfo();

   // First look if there is a suitable notification descriptor, otherwise use MBean descriptor
   Descriptor descriptor = null;
   Logger modelMBeanLogger = null;
   if (notificationType != null)
   {
      descriptor = info.getDescriptor(notificationType, "notification");
      modelMBeanLogger = findLogger(descriptor);
   }

   if (modelMBeanLogger == null)
   {
      descriptor = info.getMBeanDescriptor();
      modelMBeanLogger = findLogger(descriptor);
      if (modelMBeanLogger != null) return modelMBeanLogger;
   }

   return null;
}
 

@Test
public void testRegistrationOnInterface() throws Exception {
	Object bean = getContext().getBean("testInterfaceBean");
	ModelMBeanInfo inf = getAssembler().getMBeanInfo(bean, "bean:name=interfaceTestBean");
	assertNotNull(inf);
	assertEquals("My Managed Bean", inf.getDescription());

	ModelMBeanOperationInfo op = inf.getOperation("foo");
	assertNotNull("foo operation not exposed", op);
	assertEquals("invoke foo", op.getDescription());

	assertNull("doNotExpose operation should not be exposed", inf.getOperation("doNotExpose"));

	ModelMBeanAttributeInfo attr = inf.getAttribute("Bar");
	assertNotNull("bar attribute not exposed", attr);
	assertEquals("Bar description", attr.getDescription());

	ModelMBeanAttributeInfo attr2 = inf.getAttribute("CacheEntries");
	assertNotNull("cacheEntries attribute not exposed", attr2);
	assertEquals("Metric Type should be COUNTER", "COUNTER",
			attr2.getDescriptor().getFieldValue("metricType"));
}
 

@Test
public void testAttributeHasCorrespondingOperations() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();

	ModelMBeanOperationInfo get = info.getOperation("getName");
	assertNotNull("get operation should not be null", get);
	assertEquals("get operation should have visibility of four",
			get.getDescriptor().getFieldValue("visibility"),
			new Integer(4));
	assertEquals("get operation should have role \"getter\"", "getter", get.getDescriptor().getFieldValue("role"));

	ModelMBeanOperationInfo set = info.getOperation("setName");
	assertNotNull("set operation should not be null", set);
	assertEquals("set operation should have visibility of four",
			set.getDescriptor().getFieldValue("visibility"),
			new Integer(4));
	assertEquals("set operation should have role \"setter\"", "setter", set.getDescriptor().getFieldValue("role"));
}
 

@Test
public void testRegistrationOnInterface() throws Exception {
	Object bean = getContext().getBean("testInterfaceBean");
	ModelMBeanInfo inf = getAssembler().getMBeanInfo(bean, "bean:name=interfaceTestBean");
	assertNotNull(inf);
	assertEquals("My Managed Bean", inf.getDescription());

	ModelMBeanOperationInfo op = inf.getOperation("foo");
	assertNotNull("foo operation not exposed", op);
	assertEquals("invoke foo", op.getDescription());

	assertNull("doNotExpose operation should not be exposed", inf.getOperation("doNotExpose"));

	ModelMBeanAttributeInfo attr = inf.getAttribute("Bar");
	assertNotNull("bar attribute not exposed", attr);
	assertEquals("Bar description", attr.getDescription());

	ModelMBeanAttributeInfo attr2 = inf.getAttribute("CacheEntries");
	assertNotNull("cacheEntries attribute not exposed", attr2);
	assertEquals("Metric Type should be COUNTER", "COUNTER",
			attr2.getDescriptor().getFieldValue("metricType"));
}
 

@Test
public void testAttributeHasCorrespondingOperations() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();

	ModelMBeanOperationInfo get = info.getOperation("getName");
	assertNotNull("get operation should not be null", get);
	assertEquals("get operation should have visibility of four",
			get.getDescriptor().getFieldValue("visibility"),
			new Integer(4));
	assertEquals("get operation should have role \"getter\"", "getter", get.getDescriptor().getFieldValue("role"));

	ModelMBeanOperationInfo set = info.getOperation("setName");
	assertNotNull("set operation should not be null", set);
	assertEquals("set operation should have visibility of four",
			set.getDescriptor().getFieldValue("visibility"),
			new Integer(4));
	assertEquals("set operation should have role \"setter\"", "setter", set.getDescriptor().getFieldValue("role"));
}
 

@Test
public void testOperationParameterMetadata() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanOperationInfo oper = info.getOperation("add");
	MBeanParameterInfo[] params = oper.getSignature();

	assertEquals("Invalid number of params", 2, params.length);
	assertEquals("Incorrect name for x param", "x", params[0].getName());
	assertEquals("Incorrect type for x param", int.class.getName(), params[0].getType());

	assertEquals("Incorrect name for y param", "y", params[1].getName());
	assertEquals("Incorrect type for y param", int.class.getName(), params[1].getType());
}
 

@Test
public void testGetAgeIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);

	assertTrue(attr.isReadable());
	assertFalse(attr.isWritable());
}
 

@Test
public void testOperationDescriptor() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	Descriptor desc = info.getOperation("myOperation").getDescriptor();

	assertEquals("Currency Time Limit should be 30", "30", desc.getFieldValue("currencyTimeLimit"));
	assertEquals("Role should be \"operation\"", "operation", desc.getFieldValue("role"));
}
 

@Test
public void testMetricDescriptor() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	Descriptor desc = info.getAttribute(QUEUE_SIZE_METRIC).getDescriptor();
	assertEquals("Currency Time Limit should be 20", "20", desc.getFieldValue("currencyTimeLimit"));
	assertEquals("Persist Policy should be OnUpdate", "OnUpdate", desc.getFieldValue("persistPolicy"));
	assertEquals("Persist Period should be 300", "300", desc.getFieldValue("persistPeriod"));
	assertEquals("Unit should be messages", "messages",desc.getFieldValue("units"));
	assertEquals("Display Name should be Queue Size", "Queue Size",desc.getFieldValue("displayName"));
	assertEquals("Metric Type should be COUNTER", "COUNTER",desc.getFieldValue("metricType"));
	assertEquals("Metric Category should be utilization", "utilization",desc.getFieldValue("metricCategory"));
}
 

@Test
public void testGetAgeIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);

	assertTrue(attr.isReadable());
	assertFalse(attr.isWritable());
}
 

@Test
public void testAttributeHasCorrespondingOperations() throws Exception {
    ModelMBeanInfo info = getMBeanInfoFromAssembler();

    ModelMBeanOperationInfo myOperation = info.getOperation("myOperation");
    assertNotNull("get operation should not be null", myOperation);
    assertEquals("Incorrect myOperation return type", "long", myOperation.getReturnType());

    ModelMBeanOperationInfo add = info.getOperation("add");
    assertNotNull("set operation should not be null", add);
    assertEquals("Incorrect add method description", "Add Two Numbers Together", add.getDescription());

}
 

@Test
public void testGetAgeIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);
	assertTrue("Age is not readable", attr.isReadable());
	assertFalse("Age is not writable", attr.isWritable());
}
 

public ModelMBean assemble(Object obj, ObjectName name) throws JMException {
  ModelMBeanInfo mbi = null;

  // use the default provided mbean which has been annotated with JMX
  // annotations
  LOG.trace("Assembling MBeanInfo for: {} from @ManagedResource object: {}", name, obj);
  mbi = assembler.getMBeanInfo(obj, null, name.toString());

  if (mbi == null) {
    return null;
  }

  RequiredModelMBean mbean = new RequiredModelMBean(mbi);

  try {
    mbean.setManagedResource(obj, "ObjectReference");
  } catch (InvalidTargetObjectTypeException e) {
    throw new JMException(e.getMessage());
  }

  // Allows the managed object to send notifications
  if (obj instanceof NotificationSenderAware) {
    ((NotificationSenderAware) obj).setNotificationSender(new NotificationSenderAdapter(mbean));
  }

  return mbean;
}
 

/**
 * Gets the {@code ModelMBeanInfo} for the bean with the supplied key
 * and of the supplied type.
 */
private ModelMBeanInfo getMBeanInfo(Object managedBean, String beanKey) throws JMException {
	ModelMBeanInfo info = this.assembler.getMBeanInfo(managedBean, beanKey);
	if (logger.isWarnEnabled() && ObjectUtils.isEmpty(info.getAttributes()) &&
			ObjectUtils.isEmpty(info.getOperations())) {
		logger.warn("Bean with key '" + beanKey +
				"' has been registered as an MBean but has no exposed attributes or operations");
	}
	return info;
}
 

@Test
public void testAttributeFromInterface() throws Exception {
	ModelMBeanInfo inf = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = inf.getAttribute("Colour");
	assertTrue("The name attribute should be writable", attr.isWritable());
	assertTrue("The name attribute should be readable", attr.isReadable());
}
 

@Test
public void testWithFallThrough() throws Exception {
	InterfaceBasedMBeanInfoAssembler assembler =
			getWithMapping("foobar", "org.springframework.jmx.export.assembler.ICustomJmxBean");
	assembler.setManagedInterfaces(new Class<?>[] {IAdditionalTestMethods.class});

	ModelMBeanInfo inf = assembler.getMBeanInfo(getBean(), getObjectName());
	MBeanAttributeInfo attr = inf.getAttribute("NickName");

	assertNickName(attr);
}
 

@Test
public void testNickNameIsExposed() throws Exception {
	ModelMBeanInfo inf = (ModelMBeanInfo) getMBeanInfo();
	MBeanAttributeInfo attr = inf.getAttribute("NickName");
	assertNotNull("Nick Name should not be null", attr);
	assertTrue("Nick Name should be writable", attr.isWritable());
	assertTrue("Nick Name should be readable", attr.isReadable());
}
 

@Test
public void testManagedResourceDescriptor() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	Descriptor desc = info.getMBeanDescriptor();

	assertEquals("Logging should be set to true", "true", desc.getFieldValue("log"));
	assertEquals("Log file should be jmx.log", "jmx.log", desc.getFieldValue("logFile"));
	assertEquals("Currency Time Limit should be 15", "15", desc.getFieldValue("currencyTimeLimit"));
	assertEquals("Persist Policy should be OnUpdate", "OnUpdate", desc.getFieldValue("persistPolicy"));
	assertEquals("Persist Period should be 200", "200", desc.getFieldValue("persistPeriod"));
	assertEquals("Persist Location should be foo", "./foo", desc.getFieldValue("persistLocation"));
	assertEquals("Persist Name should be bar", "bar.jmx", desc.getFieldValue("persistName"));
}
 

/**
 * Gets the {@code ModelMBeanInfo} for the bean with the supplied key
 * and of the supplied type.
 */
private ModelMBeanInfo getMBeanInfo(Object managedBean, String beanKey) throws JMException {
	ModelMBeanInfo info = this.assembler.getMBeanInfo(managedBean, beanKey);
	if (logger.isInfoEnabled() && ObjectUtils.isEmpty(info.getAttributes()) &&
			ObjectUtils.isEmpty(info.getOperations())) {
		logger.info("Bean with key '" + beanKey +
				"' has been registered as an MBean but has no exposed attributes or operations");
	}
	return info;
}
 

@Test
public void testNotificationMetadata() throws Exception {
	ModelMBeanInfo info = (ModelMBeanInfo) getMBeanInfo();
	MBeanNotificationInfo[] notifications = info.getNotifications();
	assertEquals("Incorrect number of notifications", 1, notifications.length);
	assertEquals("Incorrect notification name", "My Notification", notifications[0].getName());

	String[] notifTypes = notifications[0].getNotifTypes();

	assertEquals("Incorrect number of notification types", 2, notifTypes.length);
	assertEquals("Notification type.foo not found", "type.foo", notifTypes[0]);
	assertEquals("Notification type.bar not found", "type.bar", notifTypes[1]);
}
 

@Test
public void testGetAgeIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);

	assertTrue("Age is not readable", attr.isReadable());
	assertFalse("Age is not writable", attr.isWritable());
}
 

@Test
public void testGetAgeIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);

	assertTrue(attr.isReadable());
	assertFalse(attr.isWritable());
}
 

@Test
public void testNickNameIsExposed() throws Exception {
	ModelMBeanInfo inf = (ModelMBeanInfo) getMBeanInfo();
	MBeanAttributeInfo attr = inf.getAttribute("NickName");
	assertNotNull("Nick Name should not be null", attr);
	assertTrue("Nick Name should be writable", attr.isWritable());
	assertTrue("Nick Name should be readable", attr.isReadable());
}
 

@Test
public void testGetAgeIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute(AGE_ATTRIBUTE);
	assertTrue("Age is not readable", attr.isReadable());
	assertFalse("Age is not writable", attr.isWritable());
}
 

@Test
public void testSupermanIsReadOnly() throws Exception {
	ModelMBeanInfo info = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = info.getAttribute("Superman");

	assertTrue(attr.isReadable());
	assertFalse(attr.isWritable());
}
 

@Test
public void testNickNameIsExposed() throws Exception {
	ModelMBeanInfo inf = (ModelMBeanInfo) getMBeanInfo();
	MBeanAttributeInfo attr = inf.getAttribute("NickName");
	assertNotNull("Nick Name should not be null", attr);
	assertTrue("Nick Name should be writable", attr.isWritable());
	assertTrue("Nick Name should be readable", attr.isReadable());
}
 

@Test
public void testNickNameIsExposed() throws Exception {
	ModelMBeanInfo inf = (ModelMBeanInfo) getMBeanInfo();
	MBeanAttributeInfo attr = inf.getAttribute("NickName");

	assertNickName(attr);
}
 

@Test
public void testNickNameIsExposed() throws Exception {
	ModelMBeanInfo inf = (ModelMBeanInfo) getMBeanInfo();
	MBeanAttributeInfo attr = inf.getAttribute("NickName");

	assertNickName(attr);
}
 

@Test
public void testAttributeFromInterface() throws Exception {
	ModelMBeanInfo inf = getMBeanInfoFromAssembler();
	ModelMBeanAttributeInfo attr = inf.getAttribute("Colour");
	assertTrue("The name attribute should be writable", attr.isWritable());
	assertTrue("The name attribute should be readable", attr.isReadable());
}