diff --git a/pom.xml b/pom.xml index a8ab1ef..90a61bd 100644 --- a/pom.xml +++ b/pom.xml @@ -40,12 +40,6 @@ test - - io.airlift - parameternames - 1.5 - - com.google.inject guice diff --git a/src/main/java/org/weakref/jmx/AnnotationUtils.java b/src/main/java/org/weakref/jmx/AnnotationUtils.java index c26a3d2..7d50a6e 100644 --- a/src/main/java/org/weakref/jmx/AnnotationUtils.java +++ b/src/main/java/org/weakref/jmx/AnnotationUtils.java @@ -121,11 +121,11 @@ private static void processAnnotation(Annotation annotation, Map // Convert Class and Enum value or array value to String or String array // see DescriptorKey javadocs for more info - if (value instanceof Class) { - value = ((Class) value).getName(); + if (value instanceof Class clazz) { + value = clazz.getName(); } - else if (value instanceof Enum) { - value = ((Enum) value).name(); + else if (value instanceof Enum enumValue) { + value = enumValue.name(); } else if (value.getClass().isArray()) { Class componentType = value.getClass().getComponentType(); @@ -175,8 +175,8 @@ public static String getDescription(Descriptor descriptor, Method... annotatedMe // If that didn't work, look for one in the descriptor object Object descriptionValue = descriptor.getFieldValue("description"); - if (descriptionValue instanceof String) { - return (String) descriptionValue; + if (descriptionValue instanceof String stringValue) { + return stringValue; } return null; } @@ -191,8 +191,8 @@ public static String getDescription(Descriptor descriptor, Annotation... annotat // If that didn't work, look for one in the descriptor object Object descriptionValue = descriptor.getFieldValue("description"); - if (descriptionValue instanceof String) { - return (String) descriptionValue; + if (descriptionValue instanceof String stringValue) { + return stringValue; } return null; } @@ -212,7 +212,7 @@ public static String getDescription(Annotation... annotations) .stream() ) .findFirst() - .orElse(""); + .orElse(null); } public static String getName(Method annotatedMethod) @@ -231,7 +231,7 @@ public static String getName(Annotation... annotations) .stream() ) .findFirst() - .orElse(""); + .orElse(null); } /** diff --git a/src/main/java/org/weakref/jmx/MBean.java b/src/main/java/org/weakref/jmx/MBean.java index 227176d..7812afc 100644 --- a/src/main/java/org/weakref/jmx/MBean.java +++ b/src/main/java/org/weakref/jmx/MBean.java @@ -37,6 +37,8 @@ import java.util.Collections; import java.util.HashMap; +import static java.util.Objects.requireNonNull; + class MBean implements DynamicMBean { private static final Object[] NO_PARAMS = new Object[0]; @@ -92,7 +94,7 @@ public Collection getOperations() public Object invoke(String actionName, Object[] params, String[] argTypes) throws MBeanException, ReflectionException { - assertNotNull("actionName", actionName); + requireNonNull(actionName, "actionName is null"); // params argTypes are allowed to be null and mean no-arg method if (params == null) { @@ -103,7 +105,7 @@ public Object invoke(String actionName, Object[] params, String[] argTypes) } for (int i = 0; i < argTypes.length; i++) { - assertNotNull("argTypes[" + i + "]", argTypes[i]); + requireNonNull(argTypes[i], "argTypes[" + i + "] is null"); } Signature signature = new Signature(actionName, argTypes); @@ -121,7 +123,7 @@ public Object invoke(String actionName, Object[] params, String[] argTypes) public Object getAttribute(String name) throws AttributeNotFoundException, MBeanException, ReflectionException { - assertNotNull("attribute", name); + requireNonNull(name, "name is null"); MBeanAttribute mbeanAttribute = attributes.get(name); if (mbeanAttribute == null) { throw new AttributeNotFoundException(name); @@ -134,9 +136,9 @@ public Object getAttribute(String name) public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException { - assertNotNull("attribute", attribute); + requireNonNull(attribute, "attribute is null"); String name = attribute.getName(); - assertNotNull("attribute.name", name); + requireNonNull(name, "attribute.name is null"); Object value = attribute.getValue(); MBeanAttribute mbeanAttribute = attributes.get(name); @@ -185,11 +187,4 @@ public AttributeList setAttributes(AttributeList attributes) } return response; } - - private static void assertNotNull(String name, Object value) - { - if (value == null) { - throw new RuntimeOperationsException(new NullPointerException(name + " is null")); - } - } } diff --git a/src/main/java/org/weakref/jmx/MBeanAttributeBuilder.java b/src/main/java/org/weakref/jmx/MBeanAttributeBuilder.java index b5f772d..8894ecc 100644 --- a/src/main/java/org/weakref/jmx/MBeanAttributeBuilder.java +++ b/src/main/java/org/weakref/jmx/MBeanAttributeBuilder.java @@ -26,6 +26,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; +import static java.util.Objects.requireNonNull; import static org.weakref.jmx.ReflectionUtils.isValidGetter; import static org.weakref.jmx.ReflectionUtils.isValidSetter; @@ -43,27 +44,19 @@ public class MBeanAttributeBuilder public MBeanAttributeBuilder onInstance(Object target) { - if (target == null) { - throw new NullPointerException("target is null"); - } - this.target = target; + this.target = requireNonNull(target, "target is null"); return this; } public MBeanAttributeBuilder named(String name) { - if (name == null) { - throw new NullPointerException("name is null"); - } - this.name = name; + this.name = requireNonNull(name, "name is null"); return this; } public MBeanAttributeBuilder withConcreteGetter(Method concreteGetter) { - if (concreteGetter == null) { - throw new NullPointerException("concreteGetter is null"); - } + requireNonNull(concreteGetter, "concreteGetter is null"); if (!isValidGetter(concreteGetter)) { throw new IllegalArgumentException("Method is not a valid getter: " + concreteGetter); } @@ -73,9 +66,7 @@ public MBeanAttributeBuilder withConcreteGetter(Method concreteGetter) public MBeanAttributeBuilder withAnnotatedGetter(Method annotatedGetter) { - if (annotatedGetter == null) { - throw new NullPointerException("annotatedGetter is null"); - } + requireNonNull(annotatedGetter, "annotatedGetter is null"); if (!isValidGetter(annotatedGetter)) { throw new IllegalArgumentException("Method is not a valid getter: " + annotatedGetter); } @@ -85,9 +76,7 @@ public MBeanAttributeBuilder withAnnotatedGetter(Method annotatedGetter) public MBeanAttributeBuilder withConcreteSetter(Method concreteSetter) { - if (concreteSetter == null) { - throw new NullPointerException("concreteSetter is null"); - } + requireNonNull(concreteSetter, "concreteSetter is null"); if (!isValidSetter(concreteSetter)) { throw new IllegalArgumentException("Method is not a valid setter: " + concreteSetter); } @@ -97,9 +86,7 @@ public MBeanAttributeBuilder withConcreteSetter(Method concreteSetter) public MBeanAttributeBuilder withAnnotatedSetter(Method annotatedSetter) { - if (annotatedSetter == null) { - throw new NullPointerException("annotatedSetter is null"); - } + requireNonNull(annotatedSetter, "annotatedSetter is null"); if (!isValidSetter(annotatedSetter)) { throw new IllegalArgumentException("Method is not a valid setter: " + annotatedSetter); } @@ -181,51 +168,50 @@ else if (nested || AnnotationUtils.isNested(annotatedGetter)) { } return Collections.unmodifiableCollection(features); } + + // We must have a getter or a setter + if (concreteGetter == null && concreteSetter == null) { + throw new IllegalArgumentException("JmxAttribute must have a concrete getter or setter method"); + } + + // Type + Class attributeType; + if (concreteGetter != null) { + attributeType = concreteGetter.getReturnType(); + } else { - // We must have a getter or a setter - if (concreteGetter == null && concreteSetter == null) { - throw new IllegalArgumentException("JmxAttribute must have a concrete getter or setter method"); - } + attributeType = concreteSetter.getParameterTypes()[0]; + } - // Type - Class attributeType; - if (concreteGetter != null) { - attributeType = concreteGetter.getReturnType(); + // Descriptor + Descriptor descriptor = null; + if (annotatedGetter != null) { + descriptor = AnnotationUtils.buildDescriptor(annotatedGetter); + } + if (annotatedSetter != null) { + Descriptor setterDescriptor = AnnotationUtils.buildDescriptor(annotatedSetter); + if (descriptor == null) { + descriptor = setterDescriptor; } else { - attributeType = concreteSetter.getParameterTypes()[0]; - } - - // Descriptor - Descriptor descriptor = null; - if (annotatedGetter != null) { - descriptor = AnnotationUtils.buildDescriptor(annotatedGetter); - } - if (annotatedSetter != null) { - Descriptor setterDescriptor = AnnotationUtils.buildDescriptor(annotatedSetter); - if (descriptor == null) { - descriptor = setterDescriptor; - } - else { - descriptor = ImmutableDescriptor.union(descriptor, setterDescriptor); - } + descriptor = ImmutableDescriptor.union(descriptor, setterDescriptor); } + } - // Description - String description = AnnotationUtils.getDescription(descriptor, annotatedGetter, annotatedSetter); + // Description + String description = AnnotationUtils.getDescription(descriptor, annotatedGetter, annotatedSetter); - MBeanAttributeInfo mbeanAttributeInfo = new MBeanAttributeInfo( - attributeName, - attributeType.getName(), - description, - concreteGetter != null, - concreteSetter != null, - concreteGetter != null && concreteGetter.getName().startsWith("is"), - descriptor); + MBeanAttributeInfo mbeanAttributeInfo = new MBeanAttributeInfo( + attributeName, + attributeType.getName(), + description, + concreteGetter != null, + concreteSetter != null, + concreteGetter != null && concreteGetter.getName().startsWith("is"), + descriptor); - return Collections.singleton(new ReflectionMBeanAttribute(mbeanAttributeInfo, target, concreteGetter, concreteSetter)); - } + return Collections.singleton(new ReflectionMBeanAttribute(mbeanAttributeInfo, target, concreteGetter, concreteSetter)); } private static String getAttributeName(Method... methods) diff --git a/src/main/java/org/weakref/jmx/MBeanBuilder.java b/src/main/java/org/weakref/jmx/MBeanBuilder.java index 45f5040..4ec90cb 100644 --- a/src/main/java/org/weakref/jmx/MBeanBuilder.java +++ b/src/main/java/org/weakref/jmx/MBeanBuilder.java @@ -21,6 +21,7 @@ import java.util.Map; import java.util.TreeMap; +import static java.util.Objects.requireNonNull; import static org.weakref.jmx.ReflectionUtils.getAttributeName; import static org.weakref.jmx.ReflectionUtils.isGetter; import static org.weakref.jmx.ReflectionUtils.isSetter; @@ -49,9 +50,7 @@ public static MBeanBuilder from(Object object) public MBeanBuilder(Object target) { - if (target == null) { - throw new NullPointerException("target is null"); - } + requireNonNull(target, "target is null"); Map attributeBuilders = new TreeMap<>(); @@ -121,11 +120,11 @@ public MBean build() List operations = new ArrayList<>(); for (MBeanAttributeBuilder attributeBuilder : attributeBuilders) { for (MBeanFeature feature : attributeBuilder.build()) { - if (feature instanceof MBeanAttribute) { - attributes.add((MBeanAttribute) feature); + if (feature instanceof MBeanAttribute attribute) { + attributes.add(attribute); } - if (feature instanceof MBeanOperation) { - operations.add((MBeanOperation) feature); + if (feature instanceof MBeanOperation operation) { + operations.add(operation); } } } diff --git a/src/main/java/org/weakref/jmx/MBeanExporter.java b/src/main/java/org/weakref/jmx/MBeanExporter.java index 2a9f91d..7ef0aad 100644 --- a/src/main/java/org/weakref/jmx/MBeanExporter.java +++ b/src/main/java/org/weakref/jmx/MBeanExporter.java @@ -219,7 +219,6 @@ public Map unexportAllAndReportMissing() toRemove.add(objectName); } catch (MBeanRegistrationException e) { - //noinspection ThrowableResultOfMethodCallIgnored errors.put(objectName.toString(), e); } } diff --git a/src/main/java/org/weakref/jmx/MBeanOperationBuilder.java b/src/main/java/org/weakref/jmx/MBeanOperationBuilder.java index 9db4a8b..94ef688 100644 --- a/src/main/java/org/weakref/jmx/MBeanOperationBuilder.java +++ b/src/main/java/org/weakref/jmx/MBeanOperationBuilder.java @@ -21,9 +21,13 @@ import java.lang.annotation.Annotation; import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.util.Arrays; import java.util.List; -import static io.airlift.parameternames.ParameterNames.getParameterNames; +import static com.google.common.base.Preconditions.checkArgument; +import static java.util.Objects.requireNonNull; +import static java.util.stream.Collectors.toUnmodifiableList; public class MBeanOperationBuilder { @@ -34,50 +38,33 @@ public class MBeanOperationBuilder public MBeanOperationBuilder onInstance(Object target) { - if (target == null) { - throw new NullPointerException("target is null"); - } - this.target = target; + this.target = requireNonNull(target, "target is null"); return this; } public MBeanOperationBuilder named(String name) { - if (name == null) { - throw new NullPointerException("name is null"); - } - this.name = name; + this.name = requireNonNull(name, "name is null"); return this; } public MBeanOperationBuilder withConcreteMethod(Method concreteMethod) { - if (concreteMethod == null) { - throw new NullPointerException("concreteMethod is null"); - } - this.concreteMethod = concreteMethod; + this.concreteMethod = requireNonNull(concreteMethod, "concreteMethod is null"); return this; } public MBeanOperationBuilder withAnnotatedMethod(Method annotatedMethod) { - if (annotatedMethod == null) { - throw new NullPointerException("annotatedMethod is null"); - } - this.annotatedMethod = annotatedMethod; + this.annotatedMethod = requireNonNull(annotatedMethod, "annotatedMethod is null"); return this; } public MBeanOperation build() { - if (target == null) { - throw new IllegalArgumentException("JmxOperation must have a target object"); - } - + requireNonNull(target, "JmxOperation must have a target object"); // We must have a method to invoke - if (concreteMethod == null) { - throw new IllegalArgumentException("JmxOperation must have a concrete method"); - } + requireNonNull(concreteMethod, "JmxOperation must have a concrete method"); String operationName = name; if (operationName == null) { @@ -86,7 +73,10 @@ public MBeanOperation build() // // Build Parameter Infos - List parameterNames = getParameterNames(concreteMethod); + List parameterNames = Arrays.stream(concreteMethod.getParameters()) + .map(Parameter::getName) + .collect(toUnmodifiableList()); + Class[] types = concreteMethod.getParameterTypes(); // Parameter annotations used form descriptor come from the annotated method, not the public method diff --git a/src/main/java/org/weakref/jmx/ManagedAttribute.java b/src/main/java/org/weakref/jmx/ManagedAttribute.java index 4fcc128..065d36a 100644 --- a/src/main/java/org/weakref/jmx/ManagedAttribute.java +++ b/src/main/java/org/weakref/jmx/ManagedAttribute.java @@ -17,38 +17,11 @@ import java.lang.reflect.Method; -public class ManagedAttribute +public record ManagedAttribute(Method method, String name, String description, boolean flatten) { - private final Method method; - private final String name; - private final String description; - private final boolean flatten; - - public ManagedAttribute(Method method, String name, String description, boolean flatten) - { - this.method = Preconditions.checkNotNull(method, "method is null"); - this.name = Preconditions.checkNotNull(name, "name is null"); - this.description = description; - this.flatten = flatten; - } - - public Method getMethod() - { - return method; - } - - public String getName() - { - return name; - } - - public String getDescription() - { - return description; - } - - public boolean isFlatten() + public ManagedAttribute { - return flatten; + Preconditions.checkNotNull(method, "method is null"); + Preconditions.checkNotNull(name, "name is null"); } } diff --git a/src/main/java/org/weakref/jmx/ManagedClass.java b/src/main/java/org/weakref/jmx/ManagedClass.java index 8e3e327..0dd2ca5 100644 --- a/src/main/java/org/weakref/jmx/ManagedClass.java +++ b/src/main/java/org/weakref/jmx/ManagedClass.java @@ -13,7 +13,6 @@ */ package org.weakref.jmx; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -54,7 +53,7 @@ public static ManagedClass fromExportedObject(Object target) String attributeName = AnnotationUtils.getName(annotatedMethod); String description = AnnotationUtils.getDescription(annotatedMethod); - if (attributeName == null || attributeName.equals("")) { + if (attributeName == null || attributeName.isEmpty()) { attributeName = getAttributeName(concreteMethod); } @@ -76,7 +75,7 @@ public static ManagedClass fromExportedObject(Object target) return new ManagedClass(target, children.build(), attributes.build()); } - public Class getTargetClass() + public Class getTargetClass() { return getTarget().getClass(); } @@ -109,17 +108,17 @@ public Set getAttributeNames() public Object invokeAttribute(String attributeName) throws InvocationTargetException, IllegalAccessException { - return getManagedAttribute(attributeName).getMethod().invoke(getTarget()); + return getManagedAttribute(attributeName).method().invoke(getTarget()); } public String getAttributeDescription(String attributeName) { - return getManagedAttribute(attributeName).getDescription(); + return getManagedAttribute(attributeName).description(); } public boolean isAttributeFlatten(String attributeName) { - return getManagedAttribute(attributeName).isFlatten(); + return getManagedAttribute(attributeName).flatten(); } private ManagedAttribute getManagedAttribute(String attributeName) diff --git a/src/main/java/org/weakref/jmx/ReflectionMBeanAttribute.java b/src/main/java/org/weakref/jmx/ReflectionMBeanAttribute.java index fc3156c..246cc21 100644 --- a/src/main/java/org/weakref/jmx/ReflectionMBeanAttribute.java +++ b/src/main/java/org/weakref/jmx/ReflectionMBeanAttribute.java @@ -15,6 +15,7 @@ */ package org.weakref.jmx; +import static java.util.Objects.requireNonNull; import static org.weakref.jmx.ReflectionUtils.invoke; import javax.management.AttributeNotFoundException; @@ -34,14 +35,8 @@ class ReflectionMBeanAttribute implements MBeanAttribute public ReflectionMBeanAttribute(MBeanAttributeInfo info, Object target, Method getter, Method setter) { - if (info == null) { - throw new NullPointerException("info is null"); - } - if (target == null) { - throw new NullPointerException("target is null"); - } - this.info = info; - this.target = target; + this.info = requireNonNull(info, "info is null"); + this.target = requireNonNull(target, "target is null"); this.name = info.getName(); this.getter = getter; this.setter = setter; diff --git a/src/main/java/org/weakref/jmx/ReflectionMBeanOperation.java b/src/main/java/org/weakref/jmx/ReflectionMBeanOperation.java index 88857b6..442427d 100644 --- a/src/main/java/org/weakref/jmx/ReflectionMBeanOperation.java +++ b/src/main/java/org/weakref/jmx/ReflectionMBeanOperation.java @@ -20,6 +20,8 @@ import javax.management.ReflectionException; import java.lang.reflect.Method; +import static java.util.Objects.requireNonNull; + class ReflectionMBeanOperation implements MBeanOperation { private final MBeanOperationInfo info; @@ -29,9 +31,9 @@ class ReflectionMBeanOperation implements MBeanOperation public ReflectionMBeanOperation(MBeanOperationInfo info, Object target, Method method) { - this.info = info; - this.target = target; - this.method = method; + this.info = requireNonNull(info, "info is null"); + this.target = requireNonNull(target, "target is null"); + this.method = requireNonNull(method, "method is null"); this.signature = new Signature(method); } diff --git a/src/main/java/org/weakref/jmx/ReflectionUtils.java b/src/main/java/org/weakref/jmx/ReflectionUtils.java index 76b7259..2274a32 100644 --- a/src/main/java/org/weakref/jmx/ReflectionUtils.java +++ b/src/main/java/org/weakref/jmx/ReflectionUtils.java @@ -21,19 +21,18 @@ import javax.management.RuntimeOperationsException; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.util.regex.Matcher; -import java.util.regex.Pattern; import java.util.Map; import java.util.LinkedHashMap; import java.util.Collections; +import static java.util.Objects.requireNonNull; + final class ReflectionUtils { private ReflectionUtils() { } - private static final Pattern getterOrSetterPattern = Pattern.compile("(get|set|is)(.+)"); private static final Map, Class> primitiveToWrapper; static { @@ -52,38 +51,37 @@ private ReflectionUtils() public static Object invoke(Object target, Method method, Object... params) throws MBeanException, ReflectionException { - assertNotNull(target, "target"); - assertNotNull(target, "method"); - assertNotNull(target, "params"); + requireNonNull(target, "target is null"); + requireNonNull(method, "method is ull"); + requireNonNull(params, "params is null"); try { - Object result = method.invoke(target, params); - return result; + return method.invoke(target, params); } catch (InvocationTargetException e) { // unwrap exception Throwable targetException = e.getTargetException(); - if (targetException instanceof RuntimeException) { + if (targetException instanceof RuntimeException runtimeException) { throw new MBeanException( - (RuntimeException) targetException, + runtimeException, "RuntimeException occurred while invoking " + toSimpleName(method)); } - else if (targetException instanceof ReflectionException) { + else if (targetException instanceof ReflectionException exception) { // allow ReflectionException to passthrough - throw (ReflectionException) targetException; + throw exception; } - else if (targetException instanceof MBeanException) { + else if (targetException instanceof MBeanException exception) { // allow MBeanException to passthrough - throw (MBeanException) targetException; + throw exception; } - else if (targetException instanceof Exception) { + else if (targetException instanceof Exception exception) { throw new MBeanException( - (Exception) targetException, + exception, "Exception occurred while invoking " + toSimpleName(method)); } - else if (targetException instanceof Error) { + else if (targetException instanceof Error error) { throw new RuntimeErrorException( - (Error) targetException, + error, "Error occurred while invoking " + toSimpleName(method)); } else { @@ -124,36 +122,29 @@ public static boolean isSetter(Method method) public static String getAttributeName(Method method) { - Matcher matcher = getterOrSetterPattern.matcher(method.getName()); - if (!matcher.matches()) { - throw new IllegalArgumentException("method does not represent a getter or setter"); + String name = method.getName(); + + if (name.startsWith("is")) { + return name.substring(2); + } + + if (name.startsWith("get") || name.startsWith("set")) { + return name.substring(3); } - return matcher.group(2); + + throw new IllegalArgumentException("method does not represent a getter or setter"); } public static boolean isValidGetter(Method getter) { - if (getter == null) { - throw new NullPointerException("getter is null"); - } - if (getter.getParameterTypes().length != 0) { - return false; - } - if (getter.getReturnType().equals(Void.TYPE)) { - return false; - } - return true; + requireNonNull(getter, "getter is null"); + return getter.getParameterCount() == 0 && !getter.getReturnType().equals(Void.TYPE); } public static boolean isValidSetter(Method setter) { - if (setter == null) { - throw new NullPointerException("setter is null"); - } - if (setter.getParameterTypes().length != 1) { - return false; - } - return true; + requireNonNull(setter, "setter is null"); + return setter.getParameterCount() == 1; } public static boolean isAssignable(Object value, Class type) @@ -161,15 +152,7 @@ public static boolean isAssignable(Object value, Class type) if (type.isPrimitive()) { return primitiveToWrapper.get(type).isInstance(value); } - else { - return value == null || type.isInstance(value); - } - } - private static void assertNotNull(Object param, String name) - { - if (param == null) { - throw new RuntimeOperationsException(new NullPointerException(name + " is null")); - } + return value == null || type.isInstance(value); } } diff --git a/src/main/java/org/weakref/jmx/Signature.java b/src/main/java/org/weakref/jmx/Signature.java index 85d8a53..665595a 100644 --- a/src/main/java/org/weakref/jmx/Signature.java +++ b/src/main/java/org/weakref/jmx/Signature.java @@ -19,27 +19,26 @@ import javax.management.MBeanParameterInfo; import java.lang.reflect.Method; -import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Objects; import static java.util.Collections.unmodifiableList; +import static java.util.stream.Collectors.toUnmodifiableList; -final class Signature +final record Signature(String actionName, List parameterTypes) { - private final String actionName; - private final List parameterTypes; + public Signature + { + actionName = actionName; + parameterTypes = unmodifiableList(parameterTypes); + } public Signature(Method method) { - this.actionName = method.getName(); - - List builder = new ArrayList<>(); - for (Class type : method.getParameterTypes()) { - builder.add(type.getName()); - } - parameterTypes = unmodifiableList(builder); + this(method.getName(), Arrays.stream(method.getParameterTypes()) + .map(Class::getName) + .collect(toUnmodifiableList())); } public Signature(String actionName, String... parameterTypes) @@ -47,56 +46,17 @@ public Signature(String actionName, String... parameterTypes) this(actionName, Arrays.asList(parameterTypes)); } - public Signature(String actionName, List parameterTypes) - { - this.actionName = actionName; - this.parameterTypes = unmodifiableList(parameterTypes); - } - - public Signature(MBeanOperationInfo info) { - this.actionName = info.getName(); - - List parameterTypes = new ArrayList<>(info.getSignature().length); - for (MBeanParameterInfo parameterInfo : info.getSignature()) { - parameterTypes.add(parameterInfo.getType()); - } - this.parameterTypes = unmodifiableList(parameterTypes); - } - - public String getActionName() - { - return actionName; - } - - public List getParameterTypes() - { - return parameterTypes; - } - - @Override - public boolean equals(Object o) - { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - Signature signature = (Signature) o; - return Objects.equals(actionName, signature.actionName) && - Objects.equals(parameterTypes, signature.parameterTypes); - } - - @Override - public int hashCode() + public Signature(MBeanOperationInfo info) { - return Objects.hash(actionName, parameterTypes); + this(info.getName(), Arrays.stream(info.getSignature()) + .map(MBeanParameterInfo::getType) + .collect(toUnmodifiableList())); } @Override public String toString() { - final StringBuilder sb = new StringBuilder(); + StringBuilder sb = new StringBuilder(); sb.append(actionName).append('('); boolean first = true; for (String type : parameterTypes) { diff --git a/src/main/java/org/weakref/jmx/guice/ExportBinder.java b/src/main/java/org/weakref/jmx/guice/ExportBinder.java index 1c58c00..2dea6c6 100644 --- a/src/main/java/org/weakref/jmx/guice/ExportBinder.java +++ b/src/main/java/org/weakref/jmx/guice/ExportBinder.java @@ -25,8 +25,8 @@ public class ExportBinder public static ExportBinder newExporter(Binder binder) { - Multibinder> collectionBinder = newSetBinder(binder, new TypeLiteral>() {}); - Multibinder> mapBinder = newSetBinder(binder, new TypeLiteral>() {}); + Multibinder> collectionBinder = newSetBinder(binder, new TypeLiteral<>() {}); + Multibinder> mapBinder = newSetBinder(binder, new TypeLiteral<>() {}); return new ExportBinder(newSetBinder(binder, Mapping.class), collectionBinder, mapBinder); } diff --git a/src/main/java/org/weakref/jmx/guice/NamedBindingBuilder.java b/src/main/java/org/weakref/jmx/guice/NamedBindingBuilder.java index 2a64b87..1eed531 100644 --- a/src/main/java/org/weakref/jmx/guice/NamedBindingBuilder.java +++ b/src/main/java/org/weakref/jmx/guice/NamedBindingBuilder.java @@ -40,8 +40,8 @@ public class NamedBindingBuilder public void withGeneratedName() { if (key.getAnnotation() != null) { - if (key.getAnnotation() instanceof Named) { - as(factory -> factory.generatedNameOf(key.getTypeLiteral().getRawType(), ((Named) key.getAnnotation()).value())); + if (key.getAnnotation() instanceof Named annotation) { + as(factory -> factory.generatedNameOf(key.getTypeLiteral().getRawType(), annotation.value())); } else { as(factory -> factory.generatedNameOf(key.getTypeLiteral().getRawType(), key.getAnnotation().annotationType().getSimpleName())); diff --git a/src/main/java/org/weakref/jmx/guice/NamedExportBinder.java b/src/main/java/org/weakref/jmx/guice/NamedExportBinder.java index f72d184..be15e61 100644 --- a/src/main/java/org/weakref/jmx/guice/NamedExportBinder.java +++ b/src/main/java/org/weakref/jmx/guice/NamedExportBinder.java @@ -39,8 +39,8 @@ public class NamedExportBinder public void withGeneratedName() { if (key.getAnnotation() != null) { - if (key.getAnnotation() instanceof Named) { - as(factory -> factory.generatedNameOf(key.getTypeLiteral().getRawType(), ((Named) key.getAnnotation()).value())); + if (key.getAnnotation() instanceof Named annotation) { + as(factory -> factory.generatedNameOf(key.getTypeLiteral().getRawType(), annotation.value())); } else { as(factory -> factory.generatedNameOf(key.getTypeLiteral().getRawType(), key.getAnnotation().annotationType().getSimpleName())); diff --git a/src/main/java/org/weakref/jmx/testing/TestingMBeanServer.java b/src/main/java/org/weakref/jmx/testing/TestingMBeanServer.java index 9e3df7f..54f197a 100644 --- a/src/main/java/org/weakref/jmx/testing/TestingMBeanServer.java +++ b/src/main/java/org/weakref/jmx/testing/TestingMBeanServer.java @@ -38,12 +38,10 @@ public ObjectInstance registerMBean(Object object, ObjectName name) throw new UnsupportedOperationException("Only explicit name supported at this time"); } - if (!(object instanceof DynamicMBean)) { + if (!(object instanceof DynamicMBean mbean)) { throw new UnsupportedOperationException("Only DynamicMBeans supported at this time"); } - DynamicMBean mbean = (DynamicMBean) object; - if (mbeans.containsKey(name)) { throw new InstanceAlreadyExistsException(format("MBean already registered: %s", name)); }