Add support for making endpoints accessible via JMX

This commit adds support to the new endpoint infrastructure for
exposing endpoint operations via JMX. It also introduces support for
JMX-specific extensions to a general-purpose endpoint. Such an
extension is identified by the `@JmxEndpointExtension` annotation.

See gh-9946

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/EndpointMBean.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import javax.management.Attribute;
+import javax.management.AttributeList;
+import javax.management.AttributeNotFoundException;
+import javax.management.DynamicMBean;
+import javax.management.InvalidAttributeValueException;
+import javax.management.MBeanException;
+import javax.management.MBeanInfo;
+import javax.management.ReflectionException;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.boot.endpoint.EndpointInfo;
+import org.springframework.util.ClassUtils;
+
+/**
+ * A {@link DynamicMBean} that invokes operations on an {@link EndpointInfo endpoint}.
+ *
+ * @author Stephane Nicoll
+ * @author Andy Wilkinson
+ * @since 2.0.0
+ * @see EndpointMBeanInfoAssembler
+ */
+public class EndpointMBean implements DynamicMBean {
+
+	private static final boolean REACTOR_PRESENT = ClassUtils.isPresent(
+			"reactor.core.publisher.Mono", EndpointMBean.class.getClassLoader());
+
+	private final Function<Object, Object> operationResponseConverter;
+
+	private final EndpointMBeanInfo endpointInfo;
+
+	EndpointMBean(Function<Object, Object> operationResponseConverter,
+			EndpointMBeanInfo endpointInfo) {
+		this.operationResponseConverter = operationResponseConverter;
+		this.endpointInfo = endpointInfo;
+	}
+
+	/**
+	 * Return the id of the related endpoint.
+	 * @return the endpoint id
+	 */
+	public String getEndpointId() {
+		return this.endpointInfo.getEndpointId();
+	}
+
+	@Override
+	public MBeanInfo getMBeanInfo() {
+		return this.endpointInfo.getMbeanInfo();
+	}
+
+	@Override
+	public Object invoke(String actionName, Object[] params, String[] signature)
+			throws MBeanException, ReflectionException {
+		JmxEndpointOperation operationInfo = this.endpointInfo.getOperations()
+				.get(actionName);
+		if (operationInfo != null) {
+			Map<String, Object> arguments = new HashMap<>();
+			List<JmxEndpointOperationParameterInfo> parameters = operationInfo
+					.getParameters();
+			for (int i = 0; i < params.length; i++) {
+				arguments.put(parameters.get(i).getName(), params[i]);
+			}
+			Object result = operationInfo.getOperationInvoker().invoke(arguments);
+			if (REACTOR_PRESENT) {
+				result = ReactiveHandler.handle(result);
+			}
+			return this.operationResponseConverter.apply(result);
+		}
+		throw new ReflectionException(new IllegalArgumentException(
+				String.format("Endpoint with id '%s' has no operation named %s",
+						this.endpointInfo.getEndpointId(), actionName)));
+	}
+
+	@Override
+	public Object getAttribute(String attribute)
+			throws AttributeNotFoundException, MBeanException, ReflectionException {
+		throw new AttributeNotFoundException();
+	}
+
+	@Override
+	public void setAttribute(Attribute attribute) throws AttributeNotFoundException,
+			InvalidAttributeValueException, MBeanException, ReflectionException {
+		throw new AttributeNotFoundException();
+	}
+
+	@Override
+	public AttributeList getAttributes(String[] attributes) {
+		return new AttributeList();
+	}
+
+	@Override
+	public AttributeList setAttributes(AttributeList attributes) {
+		return new AttributeList();
+	}
+
+	private static class ReactiveHandler {
+
+		public static Object handle(Object result) {
+			if (result instanceof Mono) {
+				return ((Mono<?>) result).block();
+			}
+			return result;
+		}
+
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/EndpointMBeanInfo.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.util.Map;
+
+import javax.management.MBeanInfo;
+
+import org.springframework.boot.endpoint.EndpointInfo;
+import org.springframework.boot.endpoint.EndpointOperation;
+
+/**
+ * The {@link MBeanInfo} for a particular {@link EndpointInfo endpoint}. Maps operation
+ * names to an {@link EndpointOperation}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.0.0
+ */
+public final class EndpointMBeanInfo {
+
+	private final String endpointId;
+
+	private final MBeanInfo mBeanInfo;
+
+	private final Map<String, JmxEndpointOperation> operations;
+
+	public EndpointMBeanInfo(String endpointId, MBeanInfo mBeanInfo,
+			Map<String, JmxEndpointOperation> operations) {
+		this.endpointId = endpointId;
+		this.mBeanInfo = mBeanInfo;
+		this.operations = operations;
+	}
+
+	public String getEndpointId() {
+		return this.endpointId;
+	}
+
+	public MBeanInfo getMbeanInfo() {
+		return this.mBeanInfo;
+	}
+
+	public Map<String, JmxEndpointOperation> getOperations() {
+		return this.operations;
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/EndpointMBeanInfoAssembler.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import javax.management.MBeanInfo;
+import javax.management.MBeanOperationInfo;
+import javax.management.MBeanParameterInfo;
+import javax.management.modelmbean.ModelMBeanAttributeInfo;
+import javax.management.modelmbean.ModelMBeanConstructorInfo;
+import javax.management.modelmbean.ModelMBeanInfoSupport;
+import javax.management.modelmbean.ModelMBeanNotificationInfo;
+import javax.management.modelmbean.ModelMBeanOperationInfo;
+
+import org.springframework.boot.endpoint.EndpointInfo;
+import org.springframework.boot.endpoint.EndpointOperationType;
+
+/**
+ * Gathers the management operations of a particular {@link EndpointInfo endpoint}.
+ *
+ * @author Stephane Nicoll
+ * @author Andy Wilkinson
+ */
+class EndpointMBeanInfoAssembler {
+
+	private final JmxOperationResponseMapper responseMapper;
+
+	EndpointMBeanInfoAssembler(JmxOperationResponseMapper responseMapper) {
+		this.responseMapper = responseMapper;
+	}
+
+	/**
+	 * Creates the {@link EndpointMBeanInfo} for the specified {@link EndpointInfo
+	 * endpoint}.
+	 * @param endpointInfo the endpoint to handle
+	 * @return the mbean info for the endpoint
+	 */
+	EndpointMBeanInfo createEndpointMBeanInfo(
+			EndpointInfo<JmxEndpointOperation> endpointInfo) {
+		Map<String, OperationInfos> operationsMapping = getOperationInfo(endpointInfo);
+		ModelMBeanOperationInfo[] operationsMBeanInfo = operationsMapping.values()
+				.stream().map((t) -> t.mBeanOperationInfo).collect(Collectors.toList())
+				.toArray(new ModelMBeanOperationInfo[] {});
+		Map<String, JmxEndpointOperation> operationsInfo = new LinkedHashMap<>();
+		operationsMapping.forEach((name, t) -> operationsInfo.put(name, t.operation));
+
+		MBeanInfo info = new ModelMBeanInfoSupport(EndpointMBean.class.getName(),
+				getDescription(endpointInfo), new ModelMBeanAttributeInfo[0],
+				new ModelMBeanConstructorInfo[0], operationsMBeanInfo,
+				new ModelMBeanNotificationInfo[0]);
+		return new EndpointMBeanInfo(endpointInfo.getId(), info, operationsInfo);
+	}
+
+	private String getDescription(EndpointInfo<?> endpointInfo) {
+		return "MBean operations for endpoint " + endpointInfo.getId();
+	}
+
+	private Map<String, OperationInfos> getOperationInfo(
+			EndpointInfo<JmxEndpointOperation> endpointInfo) {
+		Map<String, OperationInfos> operationInfos = new HashMap<>();
+		endpointInfo.getOperations().forEach((operationInfo) -> {
+			String name = operationInfo.getOperationName();
+			ModelMBeanOperationInfo mBeanOperationInfo = new ModelMBeanOperationInfo(
+					operationInfo.getOperationName(), operationInfo.getDescription(),
+					getMBeanParameterInfos(operationInfo), this.responseMapper
+							.mapResponseType(operationInfo.getOutputType()).getName(),
+					mapOperationType(operationInfo.getType()));
+			operationInfos.put(name,
+					new OperationInfos(mBeanOperationInfo, operationInfo));
+		});
+		return operationInfos;
+	}
+
+	private MBeanParameterInfo[] getMBeanParameterInfos(JmxEndpointOperation operation) {
+		return operation.getParameters().stream()
+				.map((operationParameter) -> new MBeanParameterInfo(
+						operationParameter.getName(),
+						operationParameter.getType().getName(),
+						operationParameter.getDescription()))
+				.collect(Collectors.collectingAndThen(Collectors.toList(),
+						(parameterInfos) -> parameterInfos
+								.toArray(new MBeanParameterInfo[parameterInfos.size()])));
+	}
+
+	private int mapOperationType(EndpointOperationType type) {
+		if (type == EndpointOperationType.READ) {
+			return MBeanOperationInfo.INFO;
+		}
+		if (type == EndpointOperationType.WRITE) {
+			return MBeanOperationInfo.ACTION;
+		}
+		return MBeanOperationInfo.UNKNOWN;
+	}
+
+	private static class OperationInfos {
+
+		private final ModelMBeanOperationInfo mBeanOperationInfo;
+
+		private final JmxEndpointOperation operation;
+
+		OperationInfos(ModelMBeanOperationInfo mBeanOperationInfo,
+				JmxEndpointOperation operation) {
+			this.mBeanOperationInfo = mBeanOperationInfo;
+			this.operation = operation;
+		}
+
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/EndpointMBeanRegistrar.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import javax.management.InstanceNotFoundException;
+import javax.management.MBeanRegistrationException;
+import javax.management.MBeanServer;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.jmx.JmxException;
+import org.springframework.jmx.export.MBeanExportException;
+import org.springframework.jmx.export.MBeanExporter;
+import org.springframework.util.Assert;
+
+/**
+ * JMX Registrar for {@link EndpointMBean}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.0.0
+ * @see EndpointObjectNameFactory
+ */
+public class EndpointMBeanRegistrar {
+
+	private static final Log logger = LogFactory.getLog(EndpointMBeanRegistrar.class);
+
+	private final MBeanServer mBeanServer;
+
+	private final EndpointObjectNameFactory objectNameFactory;
+
+	/**
+	 * Create a new instance with the {@link MBeanExporter} and
+	 * {@link EndpointObjectNameFactory} to use.
+	 * @param mBeanServer the mbean exporter
+	 * @param objectNameFactory the {@link ObjectName} factory
+	 */
+	public EndpointMBeanRegistrar(MBeanServer mBeanServer,
+			EndpointObjectNameFactory objectNameFactory) {
+		Assert.notNull(mBeanServer, "MBeanServer must not be null");
+		Assert.notNull(objectNameFactory, "ObjectNameFactory must not be null");
+		this.mBeanServer = mBeanServer;
+		this.objectNameFactory = objectNameFactory;
+	}
+
+	/**
+	 * Register the specified {@link EndpointMBean} and return its {@link ObjectName}.
+	 * @param endpoint the endpoint to register
+	 * @return the {@link ObjectName} used to register the {@code endpoint}
+	 */
+	public ObjectName registerEndpointMBean(EndpointMBean endpoint) {
+		Assert.notNull(endpoint, "Endpoint must not be null");
+		try {
+			if (logger.isDebugEnabled()) {
+				logger.debug(String.format(
+						"Registering endpoint with id '%s' to " + "the JMX domain",
+						endpoint.getEndpointId()));
+			}
+			ObjectName objectName = this.objectNameFactory.generate(endpoint);
+			this.mBeanServer.registerMBean(endpoint, objectName);
+			return objectName;
+		}
+		catch (MalformedObjectNameException ex) {
+			throw new IllegalStateException(
+					String.format("Invalid ObjectName for " + "endpoint with id '%s'",
+							endpoint.getEndpointId()),
+					ex);
+		}
+		catch (Exception ex) {
+			throw new MBeanExportException(
+					String.format("Failed to register MBean for endpoint with id '%s'",
+							endpoint.getEndpointId()),
+					ex);
+		}
+	}
+
+	/**
+	 * Unregister the specified {@link ObjectName} if necessary.
+	 * @param objectName the {@link ObjectName} of the endpoint to unregister
+	 * @return {@code true} if the endpoint was unregistered, {@code false} if no such
+	 * endpoint was found
+	 */
+	public boolean unregisterEndpointMbean(ObjectName objectName) {
+		try {
+			if (logger.isDebugEnabled()) {
+				logger.debug(String.format("Unregister endpoint with ObjectName '%s' "
+						+ "from the JMX domain", objectName));
+			}
+			this.mBeanServer.unregisterMBean(objectName);
+			return true;
+		}
+		catch (InstanceNotFoundException ex) {
+			return false;
+		}
+		catch (MBeanRegistrationException ex) {
+			throw new JmxException(
+					String.format("Failed to unregister MBean with" + "ObjectName '%s'",
+							objectName),
+					ex);
+		}
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/EndpointObjectNameFactory.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+
+/**
+ * A factory to create an {@link ObjectName} for an {@link EndpointMBean}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.0.0
+ */
+@FunctionalInterface
+public interface EndpointObjectNameFactory {
+
+	/**
+	 * Generate an {@link ObjectName} for the specified {@link EndpointMBean endpoint}.
+	 * @param mBean the endpoint to handle
+	 * @return the {@link ObjectName} to use for the endpoint
+	 * @throws MalformedObjectNameException if the object name is invalid
+	 */
+	ObjectName generate(EndpointMBean mBean) throws MalformedObjectNameException;
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/JmxAnnotationEndpointDiscoverer.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import org.springframework.boot.endpoint.AnnotationEndpointDiscoverer;
+import org.springframework.boot.endpoint.CachingConfiguration;
+import org.springframework.boot.endpoint.CachingOperationInvoker;
+import org.springframework.boot.endpoint.Endpoint;
+import org.springframework.boot.endpoint.EndpointInfo;
+import org.springframework.boot.endpoint.EndpointOperationType;
+import org.springframework.boot.endpoint.EndpointType;
+import org.springframework.boot.endpoint.OperationInvoker;
+import org.springframework.boot.endpoint.OperationParameterMapper;
+import org.springframework.boot.endpoint.ReflectiveOperationInvoker;
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource;
+import org.springframework.jmx.export.metadata.ManagedOperation;
+import org.springframework.jmx.export.metadata.ManagedOperationParameter;
+import org.springframework.util.StringUtils;
+
+/**
+ * Discovers the {@link Endpoint endpoints} in an {@link ApplicationContext} with
+ * {@link JmxEndpointExtension JMX extensions} applied to them.
+ *
+ * @author Stephane Nicoll
+ * @author Andy Wilkinson
+ * @since 2.0.0
+ */
+public class JmxAnnotationEndpointDiscoverer
+		extends AnnotationEndpointDiscoverer<JmxEndpointOperation, String> {
+
+	private static final AnnotationJmxAttributeSource jmxAttributeSource = new AnnotationJmxAttributeSource();
+
+	/**
+	 * Creates a new {@link JmxAnnotationEndpointDiscoverer} that will discover
+	 * {@link Endpoint endpoints} and {@link JmxEndpointExtension jmx extensions} using
+	 * the given {@link ApplicationContext}.
+	 *
+	 * @param applicationContext the application context
+	 * @param parameterMapper the {@link OperationParameterMapper} used to convert
+	 * arguments when an operation is invoked
+	 * @param cachingConfigurationFactory the {@link CachingConfiguration} factory to use
+	 */
+	public JmxAnnotationEndpointDiscoverer(ApplicationContext applicationContext,
+			OperationParameterMapper parameterMapper,
+			Function<String, CachingConfiguration> cachingConfigurationFactory) {
+		super(applicationContext, new JmxEndpointOperationFactory(parameterMapper),
+				JmxEndpointOperation::getOperationName, cachingConfigurationFactory);
+	}
+
+	@Override
+	public Collection<EndpointInfo<JmxEndpointOperation>> discoverEndpoints() {
+		Collection<EndpointInfoDescriptor<JmxEndpointOperation, String>> endpointDescriptors = discoverEndpointsWithExtension(
+				JmxEndpointExtension.class, EndpointType.JMX);
+		verifyThatOperationsHaveDistinctName(endpointDescriptors);
+		return endpointDescriptors.stream().map(EndpointInfoDescriptor::getEndpointInfo)
+				.collect(Collectors.toList());
+	}
+
+	private void verifyThatOperationsHaveDistinctName(
+			Collection<EndpointInfoDescriptor<JmxEndpointOperation, String>> endpointDescriptors) {
+		List<List<JmxEndpointOperation>> clashes = new ArrayList<>();
+		endpointDescriptors.forEach((descriptor) -> clashes
+				.addAll(descriptor.findDuplicateOperations().values()));
+		if (!clashes.isEmpty()) {
+			StringBuilder message = new StringBuilder();
+			message.append(
+					String.format("Found multiple JMX operations with the same name:%n"));
+			clashes.forEach((clash) -> {
+				message.append("    ").append(clash.get(0).getOperationName())
+						.append(String.format(":%n"));
+				clash.forEach((operation) -> message.append("        ")
+						.append(String.format("%s%n", operation)));
+			});
+			throw new IllegalStateException(message.toString());
+		}
+	}
+
+	private static class JmxEndpointOperationFactory
+			implements EndpointOperationFactory<JmxEndpointOperation> {
+
+		private final OperationParameterMapper parameterMapper;
+
+		JmxEndpointOperationFactory(OperationParameterMapper parameterMapper) {
+			this.parameterMapper = parameterMapper;
+		}
+
+		@Override
+		public JmxEndpointOperation createOperation(String endpointId,
+				AnnotationAttributes operationAttributes, Object target, Method method,
+				EndpointOperationType type, long timeToLive) {
+			String operationName = method.getName();
+			Class<?> outputType = mapParameterType(method.getReturnType());
+			String description = getDescription(method,
+					() -> "Invoke " + operationName + " for endpoint " + endpointId);
+			List<JmxEndpointOperationParameterInfo> parameters = getParameters(method);
+			OperationInvoker invoker = new ReflectiveOperationInvoker(
+					this.parameterMapper, target, method);
+			if (timeToLive > 0) {
+				invoker = new CachingOperationInvoker(invoker, timeToLive);
+			}
+			return new JmxEndpointOperation(type, invoker, operationName, outputType,
+					description, parameters);
+		}
+
+		private String getDescription(Method method, Supplier<String> fallback) {
+			ManagedOperation managedOperation = jmxAttributeSource
+					.getManagedOperation(method);
+			if (managedOperation != null
+					&& StringUtils.hasText(managedOperation.getDescription())) {
+				return managedOperation.getDescription();
+			}
+			return fallback.get();
+		}
+
+		private List<JmxEndpointOperationParameterInfo> getParameters(Method method) {
+			List<JmxEndpointOperationParameterInfo> parameters = new ArrayList<>();
+			Parameter[] methodParameters = method.getParameters();
+			if (methodParameters.length == 0) {
+				return parameters;
+			}
+			ManagedOperationParameter[] managedOperationParameters = jmxAttributeSource
+					.getManagedOperationParameters(method);
+			if (managedOperationParameters.length > 0) {
+				for (int i = 0; i < managedOperationParameters.length; i++) {
+					ManagedOperationParameter mBeanParameter = managedOperationParameters[i];
+					Parameter methodParameter = methodParameters[i];
+					parameters.add(new JmxEndpointOperationParameterInfo(
+							mBeanParameter.getName(),
+							mapParameterType(methodParameter.getType()),
+							mBeanParameter.getDescription()));
+				}
+			}
+			else {
+				for (Parameter parameter : methodParameters) {
+					parameters.add(
+							new JmxEndpointOperationParameterInfo(parameter.getName(),
+									mapParameterType(parameter.getType()), null));
+				}
+			}
+			return parameters;
+		}
+
+		private Class<?> mapParameterType(Class<?> parameter) {
+			if (parameter.isEnum()) {
+				return String.class;
+			}
+			if (Date.class.isAssignableFrom(parameter)) {
+				return String.class;
+			}
+			if (parameter.getName().startsWith("java.")) {
+				return parameter;
+			}
+			if (parameter.equals(Void.TYPE)) {
+				return parameter;
+			}
+			return Object.class;
+		}
+
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/JmxEndpointExtension.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.boot.endpoint.Endpoint;
+
+/**
+ * Identifies a type as being a JMX-specific extension of an {@link Endpoint}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.0.0
+ * @see Endpoint
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface JmxEndpointExtension {
+
+	/**
+	 * The {@link Endpoint endpoint} class to which this JMX extension relates.
+	 * @return the endpoint class
+	 */
+	Class<?> endpoint();
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/JmxEndpointMBeanFactory.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+import org.springframework.boot.endpoint.EndpointInfo;
+
+/**
+ * A factory for creating JMX MBeans for endpoint operations.
+ *
+ * @author Stephane Nicoll
+ * @author Andy Wilkinson
+ * @since 2.0.0
+ */
+public class JmxEndpointMBeanFactory {
+
+	private final EndpointMBeanInfoAssembler assembler;
+
+	private final JmxOperationResponseMapper resultMapper;
+
+	/**
+	 * Create a new {@link JmxEndpointMBeanFactory} instance that will use the given
+	 * {@code responseMapper} to convert an operation's response to a JMX-friendly form.
+	 * @param responseMapper the response mapper
+	 */
+	public JmxEndpointMBeanFactory(JmxOperationResponseMapper responseMapper) {
+		this.assembler = new EndpointMBeanInfoAssembler(responseMapper);
+		this.resultMapper = responseMapper;
+	}
+
+	/**
+	 * Creates MBeans for the given {@code endpoints}.
+	 * @param endpoints the endpoints
+	 * @return the MBeans
+	 */
+	public Collection<EndpointMBean> createMBeans(
+			Collection<EndpointInfo<JmxEndpointOperation>> endpoints) {
+		return endpoints.stream().map((endpointInfo) -> {
+			EndpointMBeanInfo endpointMBeanInfo = this.assembler
+					.createEndpointMBeanInfo(endpointInfo);
+			return new EndpointMBean(this.resultMapper::mapResponse, endpointMBeanInfo);
+		}).collect(Collectors.toList());
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/JmxEndpointOperation.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.boot.endpoint.EndpointOperation;
+import org.springframework.boot.endpoint.EndpointOperationType;
+import org.springframework.boot.endpoint.OperationInvoker;
+
+/**
+ * An operation on a JMX endpoint.
+ *
+ * @author Stephane Nicoll
+ * @author Andy Wilkinson
+ * @since 2.0.0
+ */
+public class JmxEndpointOperation extends EndpointOperation {
+
+	private final String operationName;
+
+	private final Class<?> outputType;
+
+	private final String description;
+
+	private final List<JmxEndpointOperationParameterInfo> parameters;
+
+	/**
+	 * Creates a new {@code JmxEndpointOperation} for an operation of the given
+	 * {@code type}. The operation can be performed using the given {@code invoker}.
+	 * @param type the type of the operation
+	 * @param invoker used to perform the operation
+	 * @param operationName the name of the operation
+	 * @param outputType the type of the output of the operation
+	 * @param description the description of the operation
+	 * @param parameters the parameters of the operation
+	 */
+	public JmxEndpointOperation(EndpointOperationType type, OperationInvoker invoker,
+			String operationName, Class<?> outputType, String description,
+			List<JmxEndpointOperationParameterInfo> parameters) {
+		super(type, invoker, true);
+		this.operationName = operationName;
+		this.outputType = outputType;
+		this.description = description;
+		this.parameters = parameters;
+	}
+
+	/**
+	 * Returns the name of the operation.
+	 * @return the operation name
+	 */
+	public String getOperationName() {
+		return this.operationName;
+	}
+
+	/**
+	 * Returns the type of the output of the operation.
+	 * @return the output type
+	 */
+	public Class<?> getOutputType() {
+		return this.outputType;
+	}
+
+	/**
+	 * Returns the description of the operation.
+	 * @return the operation description
+	 */
+	public String getDescription() {
+		return this.description;
+	}
+
+	/**
+	 * Returns the parameters of the operation.
+	 * @return the operation parameters
+	 */
+	public List<JmxEndpointOperationParameterInfo> getParameters() {
+		return Collections.unmodifiableList(this.parameters);
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/JmxEndpointOperationParameterInfo.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+/**
+ * Describes the parameters of an operation on a JMX endpoint.
+ *
+ * @author Stephane Nicoll
+ * @since 2.0.0
+ */
+public class JmxEndpointOperationParameterInfo {
+
+	private final String name;
+
+	private final Class<?> type;
+
+	private final String description;
+
+	public JmxEndpointOperationParameterInfo(String name, Class<?> type,
+			String description) {
+		this.name = name;
+		this.type = type;
+		this.description = description;
+	}
+
+	public String getName() {
+		return this.name;
+	}
+
+	public Class<?> getType() {
+		return this.type;
+	}
+
+	/**
+	 * Return the description of the parameter or {@code null} if none is available.
+	 * @return the description or {@code null}
+	 */
+	public String getDescription() {
+		return this.description;
+	}
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/JmxOperationResponseMapper.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+/**
+ * A {@code JmxOperationResponseMapper} maps an operation's response to a JMX-friendly
+ * form.
+ *
+ * @author Stephane Nicoll
+ * @since 2.0.0
+ */
+public interface JmxOperationResponseMapper {
+
+	/**
+	 * Map the operation's response so that it can be consumed by a JMX compliant client.
+	 * @param response the operation's response
+	 * @return the {@code response}, in a JMX compliant format
+	 */
+	Object mapResponse(Object response);
+
+	/**
+	 * Map the response type to its JMX compliant counterpart.
+	 * @param responseType the operation's response type
+	 * @return the JMX compliant type
+	 */
+	Class<?> mapResponseType(Class<?> responseType);
+
+}

spring-boot/src/main/java/org/springframework/boot/endpoint/jmx/package-info.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * JMX endpoint support.
+ */
+package org.springframework.boot.endpoint.jmx;

spring-boot/src/test/java/org/springframework/boot/endpoint/jmx/EndpointMBeanInfoAssemblerTests.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import java.util.Collections;
+import java.util.Map;
+
+import javax.management.MBeanInfo;
+import javax.management.MBeanOperationInfo;
+import javax.management.MBeanParameterInfo;
+
+import org.junit.Test;
+
+import org.springframework.boot.endpoint.EndpointInfo;
+import org.springframework.boot.endpoint.EndpointOperationType;
+import org.springframework.boot.endpoint.OperationInvoker;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.entry;
+
+/**
+ * Tests for {@link EndpointMBeanInfoAssembler}.
+ *
+ * @author Stephane Nicoll
+ */
+public class EndpointMBeanInfoAssemblerTests {
+
+	private final EndpointMBeanInfoAssembler mBeanInfoAssembler = new EndpointMBeanInfoAssembler(
+			new DummyOperationResponseMapper());
+
+	@Test
+	public void exposeSimpleReadOperation() {
+		JmxEndpointOperation operation = new JmxEndpointOperation(
+				EndpointOperationType.READ, new DummyOperationInvoker(), "getAll",
+				Object.class, "Test operation", Collections.emptyList());
+		EndpointInfo<JmxEndpointOperation> endpoint = new EndpointInfo<>("test", true,
+				Collections.singletonList(operation));
+		EndpointMBeanInfo endpointMBeanInfo = this.mBeanInfoAssembler
+				.createEndpointMBeanInfo(endpoint);
+		assertThat(endpointMBeanInfo).isNotNull();
+		assertThat(endpointMBeanInfo.getEndpointId()).isEqualTo("test");
+		assertThat(endpointMBeanInfo.getOperations())
+				.containsOnly(entry("getAll", operation));
+		MBeanInfo mbeanInfo = endpointMBeanInfo.getMbeanInfo();
+		assertThat(mbeanInfo).isNotNull();
+		assertThat(mbeanInfo.getClassName()).isEqualTo(EndpointMBean.class.getName());
+		assertThat(mbeanInfo.getDescription())
+				.isEqualTo("MBean operations for endpoint test");
+		assertThat(mbeanInfo.getAttributes()).isEmpty();
+		assertThat(mbeanInfo.getNotifications()).isEmpty();
+		assertThat(mbeanInfo.getConstructors()).isEmpty();
+		assertThat(mbeanInfo.getOperations()).hasSize(1);
+		MBeanOperationInfo mBeanOperationInfo = mbeanInfo.getOperations()[0];
+		assertThat(mBeanOperationInfo.getName()).isEqualTo("getAll");
+		assertThat(mBeanOperationInfo.getReturnType()).isEqualTo(Object.class.getName());
+		assertThat(mBeanOperationInfo.getImpact()).isEqualTo(MBeanOperationInfo.INFO);
+		assertThat(mBeanOperationInfo.getSignature()).hasSize(0);
+	}
+
+	@Test
+	public void exposeSimpleWriteOperation() {
+		JmxEndpointOperation operation = new JmxEndpointOperation(
+				EndpointOperationType.WRITE, new DummyOperationInvoker(), "update",
+				Object.class, "Update operation",
+				Collections.singletonList(new JmxEndpointOperationParameterInfo("test",
+						String.class, "Test argument")));
+		EndpointInfo<JmxEndpointOperation> endpoint = new EndpointInfo<>("another", true,
+				Collections.singletonList(operation));
+		EndpointMBeanInfo endpointMBeanInfo = this.mBeanInfoAssembler
+				.createEndpointMBeanInfo(endpoint);
+		assertThat(endpointMBeanInfo).isNotNull();
+		assertThat(endpointMBeanInfo.getEndpointId()).isEqualTo("another");
+		assertThat(endpointMBeanInfo.getOperations())
+				.containsOnly(entry("update", operation));
+		MBeanInfo mbeanInfo = endpointMBeanInfo.getMbeanInfo();
+		assertThat(mbeanInfo).isNotNull();
+		assertThat(mbeanInfo.getClassName()).isEqualTo(EndpointMBean.class.getName());
+		assertThat(mbeanInfo.getDescription())
+				.isEqualTo("MBean operations for endpoint another");
+		assertThat(mbeanInfo.getAttributes()).isEmpty();
+		assertThat(mbeanInfo.getNotifications()).isEmpty();
+		assertThat(mbeanInfo.getConstructors()).isEmpty();
+		assertThat(mbeanInfo.getOperations()).hasSize(1);
+		MBeanOperationInfo mBeanOperationInfo = mbeanInfo.getOperations()[0];
+		assertThat(mBeanOperationInfo.getName()).isEqualTo("update");
+		assertThat(mBeanOperationInfo.getReturnType()).isEqualTo(Object.class.getName());
+		assertThat(mBeanOperationInfo.getImpact()).isEqualTo(MBeanOperationInfo.ACTION);
+		assertThat(mBeanOperationInfo.getSignature()).hasSize(1);
+		MBeanParameterInfo mBeanParameterInfo = mBeanOperationInfo.getSignature()[0];
+		assertThat(mBeanParameterInfo.getName()).isEqualTo("test");
+		assertThat(mBeanParameterInfo.getType()).isEqualTo(String.class.getName());
+		assertThat(mBeanParameterInfo.getDescription()).isEqualTo("Test argument");
+	}
+
+	private static class DummyOperationInvoker implements OperationInvoker {
+
+		@Override
+		public Object invoke(Map<String, Object> arguments) {
+			return null;
+		}
+
+	}
+
+	private static class DummyOperationResponseMapper
+			implements JmxOperationResponseMapper {
+
+		@Override
+		public Object mapResponse(Object response) {
+			return response;
+		}
+
+		@Override
+		public Class<?> mapResponseType(Class<?> responseType) {
+			return responseType;
+		}
+	}
+
+}

spring-boot/src/test/java/org/springframework/boot/endpoint/jmx/EndpointMBeanRegistrarTests.java

+/*
+ * Copyright 2012-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.endpoint.jmx;
+
+import javax.management.InstanceNotFoundException;
+import javax.management.MBeanRegistrationException;
+import javax.management.MBeanServer;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import org.springframework.jmx.JmxException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Tests for {@link EndpointMBeanRegistrar}.
+ *
+ * @author Stephane Nicoll
+ */
+public class EndpointMBeanRegistrarTests {
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	private MBeanServer mBeanServer = mock(MBeanServer.class);
+
+	@Test
+	public void mBeanServerMustNotBeNull() {
+		this.thrown.expect(IllegalArgumentException.class);
+		new EndpointMBeanRegistrar(null, (e) -> new ObjectName("foo"));
+	}
+
+	@Test
+	public void objectNameFactoryMustNotBeNull() {
+		this.thrown.expect(IllegalArgumentException.class);
+		new EndpointMBeanRegistrar(this.mBeanServer, null);
+	}
+
+	@Test
+	public void endpointMustNotBeNull() {
+		EndpointMBeanRegistrar registrar = new EndpointMBeanRegistrar(this.mBeanServer,
+				(e) -> new ObjectName("foo"));
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage("Endpoint must not be null");
+		registrar.registerEndpointMBean(null);
+	}
+
+	@Test
+	public void registerEndpointInvokesObjectNameFactory()
+			throws MalformedObjectNameException {
+		EndpointObjectNameFactory factory = mock(EndpointObjectNameFactory.class);
+		EndpointMBean endpointMBean = mock(EndpointMBean.class);
+		ObjectName objectName = mock(ObjectName.class);
+		given(factory.generate(endpointMBean)).willReturn(objectName);
+		EndpointMBeanRegistrar registrar = new EndpointMBeanRegistrar(this.mBeanServer,
+				factory);
+		ObjectName actualObjectName = registrar.registerEndpointMBean(endpointMBean);
+		assertThat(actualObjectName).isSameAs(objectName);
+		verify(factory).generate(endpointMBean);
+	}
+
+	@Test
+	public void registerEndpointInvalidObjectName() throws MalformedObjectNameException {
+		EndpointMBean endpointMBean = mock(EndpointMBean.class);
+		given(endpointMBean.getEndpointId()).willReturn("test");
+		EndpointObjectNameFactory factory = mock(EndpointObjectNameFactory.class);
+		given(factory.generate(endpointMBean))
+				.willThrow(new MalformedObjectNameException());
+		EndpointMBeanRegistrar registrar = new EndpointMBeanRegistrar(this.mBeanServer,
+				factory);
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Invalid ObjectName for endpoint with id 'test'");
+		registrar.registerEndpointMBean(endpointMBean);
+	}
+
+	@Test
+	public void registerEndpointFailure() throws Exception {
+		EndpointMBean endpointMBean = mock(EndpointMBean.class);
+		given(endpointMBean.getEndpointId()).willReturn("test");
+		EndpointObjectNameFactory factory = mock(EndpointObjectNameFactory.class);
+		ObjectName objectName = mock(ObjectName.class);
+		given(factory.generate(endpointMBean)).willReturn(objectName);
+		given(this.mBeanServer.registerMBean(endpointMBean, objectName))
+				.willThrow(MBeanRegistrationException.class);
+		EndpointMBeanRegistrar registrar = new EndpointMBeanRegistrar(this.mBeanServer,
+				factory);
+		this.thrown.expect(JmxException.class);
+		this.thrown.expectMessage("Failed to register MBean for endpoint with id 'test'");
+		registrar.registerEndpointMBean(endpointMBean);
+	}
+
+	@Test
+	public void unregisterEndpoint() throws Exception {
+		ObjectName objectName = mock(ObjectName.class);
+		EndpointMBeanRegistrar registrar = new EndpointMBeanRegistrar(this.mBeanServer,
+				mock(EndpointObjectNameFactory.class));
+		assertThat(registrar.unregisterEndpointMbean(objectName)).isTrue();
+		verify(this.mBeanServer).unregisterMBean(objectName);
+	}
+
+	@Test
+	public void unregisterUnknownEndpoint() throws Exception {
+		ObjectName objectName = mock(ObjectName.class);
+		willThrow(InstanceNotFoundException.class).given(this.mBeanServer)
+				.unregisterMBean(objectName);
+		EndpointMBeanRegistrar registrar = new EndpointMBeanRegistrar(this.mBeanServer,
+				mock(EndpointObjectNameFactory.class));
+		assertThat(registrar.unregisterEndpointMbean(objectName)).isFalse();
+		verify(this.mBeanServer).unregisterMBean(objectName);
+	}
+
+}