下面列出了怎么用javax.management.openmbean.SimpleType的API类实例代码及写法,或者点击链接到github查看源代码。
@Test
public void testSimpleTypeObjectExpressions() throws Exception {
ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG);
description.get(EXPRESSIONS_ALLOWED).set(true);
TypeConverter converter = getConverter(description);
assertMapType(assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG);
ModelNode node = new ModelNode();
node.get("one").set(new ValueExpression("${this.should.not.exist.!!!!!:1}"));
node.get("two").set(new ValueExpression("${this.should.not.exist.!!!!!:2}"));
TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
Assert.assertEquals(2, tabularData.size());
Assert.assertEquals((long) 1, tabularData.get(new Object[] {"one"}).get("value"));
Assert.assertEquals((long) 2, tabularData.get(new Object[] {"two"}).get("value"));
}
@Test
public void testCompositeDataToMap() throws Exception {
CompositeType compositeType = new CompositeType(
"MyCompositeType",
"my composite descr",
new String[] {"key1", "key2"},
new String[] {"key1 descr", "key2 descr"},
new OpenType[] {SimpleType.STRING, SimpleType.STRING});
Map<String, ?> items = ImmutableMap.of(
"key1", "val1",
"key2", "val2");
CompositeData data = new CompositeDataSupport(compositeType, items);
Map<String,?> result = JmxValueFunctions.compositeDataToMap(data);
assertEquals(result, items);
Map<?,?> result2 = JmxValueFunctions.compositeDataToMap().apply(data);
assertEquals(result2, items);
}
public TestClass(String str, URL url)
{
this.str = str;
this.url = url;
list.add("a");
list.add("b");
list.add("c");
map.put("1", "a");
map.put("2", "b");
map.put("3", "c");
try
{
CompositeType type = new CompositeType("My type",
"My type",
new String[]{"item1", "item2"},
new String[]{"item1", "item2"},
new OpenType[]{SimpleType.STRING, SimpleType.STRING});
compositeData = new CompositeDataSupport(type, new String[]{"item1", "item2"}, new Object[]{"item value 1", "item value 2"});
}
catch (OpenDataException e)
{
e.printStackTrace();
}
}
@Test
public void testByteArrayObject() throws Exception {
ModelNode description = createDescription(ModelType.OBJECT, ModelType.BYTES);
TypeConverter converter = getConverter(description);
assertMapType(assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, ArrayType.getPrimitiveArrayType(byte[].class));
ModelNode node = new ModelNode();
node.get("one").set(new byte[] {1,2});
node.get("two").set(new byte[] {3,4});
TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
Assert.assertEquals(2, tabularData.size());
Assert.assertTrue(Arrays.equals(new byte[] {1,2}, (byte[])tabularData.get(new Object[] {"one"}).get("value")));
Assert.assertTrue(Arrays.equals(new byte[] {3,4}, (byte[])tabularData.get(new Object[] {"two"}).get("value")));
//Allow plain map as well? Yeah why not!
Map<String, byte[]> map = new HashMap<String, byte[]>();
map.put("one", new byte[] {1,2});
map.put("two", new byte[] {3,4});
Assert.assertEquals(node, converter.toModelNode(map));
}
@Test
public void testSimpleTypeObjectEmpty() throws Exception {
ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG);
TypeConverter converter = getConverter(description);
assertMapType(assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG);
ModelNode node = new ModelNode();
node.get("one").set("");
node.get("two").set("");
TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node));
Assert.assertEquals(2, tabularData.size());
Assert.assertNull(tabularData.get(new Object[] {"one"}).get("value"));
Assert.assertNull(tabularData.get(new Object[] {"two"}).get("value"));
ModelNode expected = new ModelNode();
expected.get("one");
expected.get("two");
Assert.assertEquals(expected, converter.toModelNode(tabularData));
}
static synchronized OpenType[] getBaseGcInfoItemTypes() {
if (baseGcInfoItemTypes == null) {
OpenType<?> memoryUsageOpenType = memoryUsageMapType.getOpenType();
baseGcInfoItemTypes = new OpenType<?>[] {
SimpleType.LONG,
SimpleType.LONG,
SimpleType.LONG,
SimpleType.LONG,
memoryUsageOpenType,
memoryUsageOpenType,
};
}
return baseGcInfoItemTypes;
}
@Test
public void testBooleanConverter() {
ModelNode description = createDescription(ModelType.BOOLEAN);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.BOOLEAN, converter.getOpenType());
Assert.assertEquals(Boolean.FALSE, assertCast(Boolean.class, converter.fromModelNode(ModelNode.FALSE)));
Assert.assertEquals(true, converter.toModelNode(Boolean.TRUE).asBoolean());
assertToArray(converter, Boolean.TRUE, Boolean.FALSE);
}
@Test
public void testPropertyTypeConverter() {
ModelNode description = createDescription(ModelType.PROPERTY);
TypeConverter converter = getConverter(description);
ModelNode node = new ModelNode();
node.set("name", "value");
node.protect();
Assert.assertEquals(SimpleType.STRING, converter.getOpenType());
String dmr = assertCast(String.class, converter.fromModelNode(node));
Assert.assertEquals(node, ModelNode.fromString(dmr));
Assert.assertEquals(dmr, assertCast(String.class, converter.fromModelNode(node)));
assertToArray(converter, dmr);
}
@Test
public void testStringEmptyConverter() {
ModelNode description = createDescription(ModelType.STRING);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.STRING, converter.getOpenType());
Assert.assertNull(converter.fromModelNode(new ModelNode().set("")));
}
@Test
public void testTypeEmptyConverter() {
ModelNode description = createDescription(ModelType.TYPE);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.STRING, converter.getOpenType());
Assert.assertNull(converter.fromModelNode(new ModelNode().set("")));
}
@Override
public Object[] toArray(List<Object> list) {
if (getOpenType() == SimpleType.STRING) {
return list.toArray(new String[list.size()]);
}
return list.toArray(new Object[list.size()]);
}
static ArrayType make(SimpleType baseType, boolean primitiveArray) {
try {
return new ArrayType(baseType, primitiveArray);
} catch (OpenDataException e) {
throw new Error(e);
}
}
static ArrayType make(SimpleType baseType, boolean primitiveArray) {
try {
return new ArrayType(baseType, primitiveArray);
} catch (OpenDataException e) {
throw new Error(e);
}
}
private static void testMXBean(MBeanServer mbs, ObjectName on)
throws Exception {
MBeanInfo mbi = mbs.getMBeanInfo(on);
MBeanAttributeInfo[] attrs = mbi.getAttributes();
int nattrs = attrs.length;
if (mbi.getAttributes().length != 1)
failure("wrong number of attributes: " + attrs);
else {
MBeanAttributeInfo mbai = attrs[0];
if (mbai.getName().equals("Ints")
&& mbai.isReadable() && !mbai.isWritable()
&& mbai.getDescriptor().getFieldValue("openType")
.equals(new ArrayType<int[]>(SimpleType.INTEGER, true))
&& attrs[0].getType().equals("[I"))
success("MBeanAttributeInfo");
else
failure("MBeanAttributeInfo: " + mbai);
}
int[] ints = (int[]) mbs.getAttribute(on, "Ints");
if (equal(ints, new int[] {1, 2, 3}, null))
success("getAttribute");
else
failure("getAttribute: " + Arrays.toString(ints));
ExplicitMXBean proxy =
JMX.newMXBeanProxy(mbs, on, ExplicitMXBean.class);
int[] pints = proxy.getInts();
if (equal(pints, new int[] {1, 2, 3}, null))
success("getAttribute through proxy");
else
failure("getAttribute through proxy: " + Arrays.toString(pints));
}
private CompositeType makeSessionsTypePre2_1() throws OpenDataException {
String typeName = "org.apache.cassandra.streaming.SessionInfo";
String description = "SessionInfo";
String[] itemNames = {
"connecting",
"peer",
"planId",
"receivingFiles",
"receivingSummaries",
"sendingFiles",
"sendingSummaries",
"state"
};
String[] itemDescriptions = {
"connecting",
"peer",
"planId",
"receivingFiles",
"receivingSummaries",
"sendingFiles",
"sendingSummaries",
"state"
};
OpenType[] itemTypes = {
SimpleType.STRING,
SimpleType.STRING,
SimpleType.STRING,
ArrayType.getArrayType(makeFilesType_2_0_17()),
ArrayType.getArrayType(makeSummariesType_pre_4_0()),
ArrayType.getArrayType(makeFilesType_2_0_17()),
ArrayType.getArrayType(makeSummariesType_pre_4_0()),
SimpleType.STRING,
};
return new CompositeType(typeName, description, itemNames, itemDescriptions, itemTypes);
}
@Test
public void testIntConverter() {
ModelNode description = createDescription(ModelType.INT);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.INTEGER, converter.getOpenType());
Assert.assertEquals(Integer.valueOf(1), assertCast(Integer.class, converter.fromModelNode(new ModelNode().set(1))));
Assert.assertEquals(2, converter.toModelNode(2).asInt());
assertToArray(converter, 1, 2);
}
static ArrayType make(SimpleType baseType, boolean primitiveArray) {
try {
return new ArrayType(baseType, primitiveArray);
} catch (OpenDataException e) {
throw new Error(e);
}
}
private static void testMXBean(MBeanServer mbs, ObjectName on)
throws Exception {
MBeanInfo mbi = mbs.getMBeanInfo(on);
MBeanAttributeInfo[] attrs = mbi.getAttributes();
int nattrs = attrs.length;
if (mbi.getAttributes().length != 1)
failure("wrong number of attributes: " + attrs);
else {
MBeanAttributeInfo mbai = attrs[0];
if (mbai.getName().equals("Ints")
&& mbai.isReadable() && !mbai.isWritable()
&& mbai.getDescriptor().getFieldValue("openType")
.equals(new ArrayType<int[]>(SimpleType.INTEGER, true))
&& attrs[0].getType().equals("[I"))
success("MBeanAttributeInfo");
else
failure("MBeanAttributeInfo: " + mbai);
}
int[] ints = (int[]) mbs.getAttribute(on, "Ints");
if (equal(ints, new int[] {1, 2, 3}, null))
success("getAttribute");
else
failure("getAttribute: " + Arrays.toString(ints));
ExplicitMXBean proxy =
JMX.newMXBeanProxy(mbs, on, ExplicitMXBean.class);
int[] pints = proxy.getInts();
if (equal(pints, new int[] {1, 2, 3}, null))
success("getAttribute through proxy");
else
failure("getAttribute through proxy: " + Arrays.toString(pints));
}
@Test
public void testDoubleEmptyConverter() {
ModelNode description = createDescription(ModelType.DOUBLE);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.STRING, converter.getOpenType());
Assert.assertNull(converter.fromModelNode(new ModelNode().set("")));
}
static ArrayType make(SimpleType baseType, boolean primitiveArray) {
try {
return new ArrayType(baseType, primitiveArray);
} catch (OpenDataException e) {
throw new Error(e);
}
}
static synchronized OpenType[] getBaseGcInfoItemTypes() {
if (baseGcInfoItemTypes == null) {
OpenType<?> memoryUsageOpenType = memoryUsageMapType.getOpenType();
baseGcInfoItemTypes = new OpenType<?>[] {
SimpleType.LONG,
SimpleType.LONG,
SimpleType.LONG,
SimpleType.LONG,
memoryUsageOpenType,
memoryUsageOpenType,
};
}
return baseGcInfoItemTypes;
}
private CompositeType streamStateType_4_0_0() throws OpenDataException {
String typeName = "org.apache.cassandra.streaming.StreamState";
String description = "StreamState";
String[] itemNames = {
"currentRxBytes",
"currentTxBytes",
"description",
"planId",
"rxPercentage",
"sessions",
"totalRxBytes",
"totalTxBytes",
"txPercentage"
};
String[] itemDescriptions = {
"currentRxBytes",
"currentTxBytes",
"description",
"planId",
"rxPercentage",
"sessions",
"totalRxBytes",
"totalTxBytes",
"txPercentage"
};
OpenType[] itemTypes = {
SimpleType.LONG,
SimpleType.LONG,
SimpleType.STRING,
SimpleType.STRING,
SimpleType.DOUBLE,
ArrayType.getArrayType(makeSessionsType4_0()),
SimpleType.LONG,
SimpleType.LONG,
SimpleType.DOUBLE
};
return new CompositeType(typeName, description, itemNames, itemDescriptions, itemTypes);
}
@Test
public void testLongEmptyConverter() {
ModelNode description = createDescription(ModelType.LONG);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.STRING, converter.getOpenType());
Assert.assertNull(converter.fromModelNode(new ModelNode().set("")));
}
@Test
public void testSimpleTypeList() throws Exception {
ModelNode description = createDescription(ModelType.LIST, ModelType.INT);
TypeConverter converter = getConverter(description);
Assert.assertEquals(ArrayType.getArrayType(SimpleType.STRING), converter.getOpenType());
ModelNode node = new ModelNode();
node.add(1);
node.add(2);
Assert.assertTrue(Arrays.equals(new String[] {"1", "2"} ,assertCast(String[].class, converter.fromModelNode(node))));
Assert.assertEquals(node, converter.toModelNode(new String[] {"1", "2"}));
}
private static void testMXBean(MBeanServer mbs, ObjectName on)
throws Exception {
MBeanInfo mbi = mbs.getMBeanInfo(on);
MBeanAttributeInfo[] attrs = mbi.getAttributes();
int nattrs = attrs.length;
if (mbi.getAttributes().length != 1)
failure("wrong number of attributes: " + attrs);
else {
MBeanAttributeInfo mbai = attrs[0];
if (mbai.getName().equals("Ints")
&& mbai.isReadable() && !mbai.isWritable()
&& mbai.getDescriptor().getFieldValue("openType")
.equals(new ArrayType<int[]>(SimpleType.INTEGER, true))
&& attrs[0].getType().equals("[I"))
success("MBeanAttributeInfo");
else
failure("MBeanAttributeInfo: " + mbai);
}
int[] ints = (int[]) mbs.getAttribute(on, "Ints");
if (equal(ints, new int[] {1, 2, 3}, null))
success("getAttribute");
else
failure("getAttribute: " + Arrays.toString(ints));
ExplicitMXBean proxy =
JMX.newMXBeanProxy(mbs, on, ExplicitMXBean.class);
int[] pints = proxy.getInts();
if (equal(pints, new int[] {1, 2, 3}, null))
success("getAttribute through proxy");
else
failure("getAttribute through proxy: " + Arrays.toString(pints));
}
@Test
public void testLongEmptyConverter() {
ModelNode description = createDescription(ModelType.LONG);
TypeConverter converter = getConverter(description);
Assert.assertEquals(SimpleType.LONG, converter.getOpenType());
Assert.assertNull(converter.fromModelNode(new ModelNode().set("")));
}
public static OpenType<?> getOpenType(Object o)
{
if(o instanceof Long)
{
return SimpleType.LONG;
}
else if(o instanceof String)
{
return SimpleType.STRING;
}
else if(o instanceof Date)
{
return SimpleType.DATE;
}
else if(o instanceof Integer)
{
return SimpleType.INTEGER;
}
else if(o instanceof Boolean)
{
return SimpleType.BOOLEAN;
}
else if(o instanceof Double)
{
return SimpleType.DOUBLE;
}
else if(o instanceof Float)
{
return SimpleType.FLOAT;
}
else
{
throw new IllegalArgumentException();
}
}
static synchronized OpenType[] getBaseGcInfoItemTypes() {
if (baseGcInfoItemTypes == null) {
OpenType<?> memoryUsageOpenType = memoryUsageMapType.getOpenType();
baseGcInfoItemTypes = new OpenType<?>[] {
SimpleType.LONG,
SimpleType.LONG,
SimpleType.LONG,
SimpleType.LONG,
memoryUsageOpenType,
memoryUsageOpenType,
};
}
return baseGcInfoItemTypes;
}
@ManagedAttribute
public TabularData getActiveRoutes() {
if (routes.length == 0) {
return null;
}
final OpenType<?>[] types = new OpenType<?>[routes.length];
final String[] keys = new String[types.length];
final String[] values = new String[types.length];
for (int i = 0; i < types.length; i++) {
types[i] = SimpleType.STRING;
keys[i] = routes[i].getOrigin().substring(prefix.length());
values[i] = routes[i].getRawDestination().substring(prefix.length());
}
try {
final CompositeType ct = new CompositeType("routes", "routes", keys, keys, types);
final TabularType type = new TabularType("router", "routes", ct, keys);
final TabularDataSupport data = new TabularDataSupport(type);
final CompositeData line = new CompositeDataSupport(ct, keys, values);
data.put(line);
return data;
} catch (final OpenDataException e) {
return null;
}
}
private static void testMXBean(MBeanServer mbs, ObjectName on)
throws Exception {
MBeanInfo mbi = mbs.getMBeanInfo(on);
MBeanAttributeInfo[] attrs = mbi.getAttributes();
int nattrs = attrs.length;
if (mbi.getAttributes().length != 1)
failure("wrong number of attributes: " + attrs);
else {
MBeanAttributeInfo mbai = attrs[0];
if (mbai.getName().equals("Ints")
&& mbai.isReadable() && !mbai.isWritable()
&& mbai.getDescriptor().getFieldValue("openType")
.equals(new ArrayType<int[]>(SimpleType.INTEGER, true))
&& attrs[0].getType().equals("[I"))
success("MBeanAttributeInfo");
else
failure("MBeanAttributeInfo: " + mbai);
}
int[] ints = (int[]) mbs.getAttribute(on, "Ints");
if (equal(ints, new int[] {1, 2, 3}, null))
success("getAttribute");
else
failure("getAttribute: " + Arrays.toString(ints));
ExplicitMXBean proxy =
JMX.newMXBeanProxy(mbs, on, ExplicitMXBean.class);
int[] pints = proxy.getInts();
if (equal(pints, new int[] {1, 2, 3}, null))
success("getAttribute through proxy");
else
failure("getAttribute through proxy: " + Arrays.toString(pints));
}