Introduce IntegrationPattern abstraction

* Add `IntegrationPattern` contract to implement on the target components
which represent particular EIP
* Add `IntegrationPatternType` with an internal `IntegrationPatternCategory`
to return from the component implementing `IntegrationPattern`
* Parse `IntegrationPatternType` in the `IntegrationNode` for potential
use on the UI for drawing a particular icon

* More pattern representations

* Clean up Checkstyle
* Fix JavaDocs
* Add `integrationPatternCategory` assertion into the `IntegrationGraphServerTests`

* Add more IntegrationPattern implementations
* Provide some delegation and overriding logic whenever we have
components wrapping

* Fix unused imports

* Add `inbound_gateway` pattern indicator
* Add conditional on `expectReply` to indicate a component as an
`IntegrationPatternType.outbound_channel_adapter` or
`IntegrationPatternType.outbound_gateway`
* Make some code clean up in affected classes

* Add a `gateway` type for `@MessagingGateway`

* Comment the reason for `outbound_gateway` type in the `AbstractReplyProducingMessageHandler`
* Bump `IntegrationGraphServer.GRAPH_VERSION`
* Add new attributes into graph sample in the `graph.adoc`
* Document an `IntegrationPattern`

* Apply changes for version 5.3

* Rebased into `5.3-WIP`
* Add a `whats-new.adoc` note about an `IntegrationPattern`

Author: artembilan

spring-integration-amqp/src/main/java/org/springframework/integration/amqp/outbound/AmqpOutboundEndpoint.java

@@ -30,6 +30,7 @@
 import org.springframework.amqp.rabbit.core.RabbitTemplate.ReturnCallback;
 import org.springframework.amqp.support.converter.MessageConverter;
 import org.springframework.context.Lifecycle;
+import org.springframework.integration.IntegrationPatternType;
 import org.springframework.integration.MessageTimeoutException;
 import org.springframework.integration.amqp.support.MappingUtils;
 import org.springframework.integration.support.AbstractIntegrationMessageBuilder;
@@ -96,6 +97,10 @@ public String getComponentType() {
 		return this.expectReply ? "amqp:outbound-gateway" : "amqp:outbound-channel-adapter";
 	}
 
+	@Override
+	public IntegrationPatternType getIntegrationPatternType() {
+		return this.expectReply ? super.getIntegrationPatternType() : IntegrationPatternType.outbound_channel_adapter;
+	}
 
 	@Override
 	public RabbitTemplate getRabbitTemplate() {
@@ -168,6 +173,7 @@ private void waitForConfirm(Message<?> requestMessage, CorrelationData correlati
 
 	private void send(String exchangeName, String routingKey,
 			final Message<?> requestMessage, CorrelationData correlationData) {
+
 		if (this.rabbitTemplate != null) {
 			MessageConverter converter = this.rabbitTemplate.getMessageConverter();
 			org.springframework.amqp.core.Message amqpMessage = MappingUtils.mapMessage(requestMessage, converter,

spring-integration-core/src/main/java/org/springframework/integration/IntegrationPattern.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2019 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
+ *
+ *      https://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.integration;
+
+/**
+ * Indicates that a component implements some Enterprise Integration Pattern.
+ *
+ * @author Artem Bilan
+ *
+ * @since 5.3
+ *
+ * @see IntegrationPatternType
+ * @see <a href="https://www.enterpriseintegrationpatterns.com/patterns/messaging">EIP official site</a>
+ */
+public interface IntegrationPattern {
+
+	/**
+	 * Return a pattern type this component implements.
+	 * @return the {@link IntegrationPatternType} this component implements.
+	 */
+	IntegrationPatternType getIntegrationPatternType();
+
+}

spring-integration-core/src/main/java/org/springframework/integration/IntegrationPatternType.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2019 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
+ *
+ *      https://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.integration;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * The Enterprise Integration Pattern types.
+ * Used to indicate which pattern a target component implements.
+ *
+ * @author Artem Bilan
+ *
+ * @since 5.3
+ */
+public enum IntegrationPatternType {
+
+	message_channel(IntegrationPatternCategory.messaging_channel),
+
+	publish_subscribe_channel(IntegrationPatternCategory.messaging_channel),
+
+	executor_channel(IntegrationPatternCategory.messaging_channel),
+
+	pollable_channel(IntegrationPatternCategory.messaging_channel),
+
+	reactive_channel(IntegrationPatternCategory.messaging_channel),
+
+	null_channel(IntegrationPatternCategory.messaging_channel),
+
+	bridge(IntegrationPatternCategory.messaging_endpoint),
+
+	service_activator(IntegrationPatternCategory.messaging_endpoint),
+
+	outbound_channel_adapter(IntegrationPatternCategory.messaging_endpoint),
+
+	inbound_channel_adapter(IntegrationPatternCategory.messaging_endpoint),
+
+	outbound_gateway(IntegrationPatternCategory.messaging_endpoint),
+
+	inbound_gateway(IntegrationPatternCategory.messaging_endpoint),
+
+	gateway(IntegrationPatternCategory.messaging_endpoint),
+
+	splitter(IntegrationPatternCategory.message_routing),
+
+	transformer(IntegrationPatternCategory.message_transformation),
+
+	header_enricher(IntegrationPatternCategory.message_transformation),
+
+	filter(IntegrationPatternCategory.message_routing),
+
+	content_enricher(IntegrationPatternCategory.message_transformation),
+
+	header_filter(IntegrationPatternCategory.message_transformation),
+
+	claim_check_in(IntegrationPatternCategory.message_transformation),
+
+	claim_check_out(IntegrationPatternCategory.message_transformation),
+
+	aggregator(IntegrationPatternCategory.message_routing),
+
+	resequencer(IntegrationPatternCategory.message_routing),
+
+	barrier(IntegrationPatternCategory.message_routing),
+
+	chain(IntegrationPatternCategory.message_routing),
+
+	scatter_gather(IntegrationPatternCategory.message_routing),
+
+	delayer(IntegrationPatternCategory.message_routing),
+
+	control_bus(IntegrationPatternCategory.system_management),
+
+	router(IntegrationPatternCategory.message_routing),
+
+	recipient_list_router(IntegrationPatternCategory.message_routing);
+
+
+	private final IntegrationPatternCategory patternCategory;
+
+	IntegrationPatternType(IntegrationPatternCategory patternCategory) {
+		this.patternCategory = patternCategory;
+	}
+
+	public IntegrationPatternCategory getPatternCategory() {
+		return this.patternCategory;
+	}
+
+	/**
+	 * The Enterprise Integration Pattern categories.
+	 * Used to indicate which pattern category a target component belongs.
+	 */
+	public enum IntegrationPatternCategory {
+
+		messaging_channel(
+				message_channel,
+				publish_subscribe_channel,
+				executor_channel,
+				pollable_channel,
+				reactive_channel,
+				null_channel),
+
+		messaging_endpoint(
+				service_activator,
+				outbound_channel_adapter,
+				inbound_channel_adapter,
+				outbound_gateway,
+				inbound_gateway,
+				gateway,
+				bridge),
+
+		message_routing(
+				splitter,
+				filter,
+				aggregator,
+				resequencer,
+				barrier,
+				chain,
+				scatter_gather,
+				delayer,
+				router,
+				recipient_list_router),
+
+		message_transformation(
+				transformer,
+				header_enricher,
+				content_enricher,
+				header_filter,
+				claim_check_in,
+				claim_check_out),
+
+		system_management(control_bus);
+
+		private final IntegrationPatternType[] patternTypes;
+
+		IntegrationPatternCategory(IntegrationPatternType... patternTypes) {
+			this.patternTypes = patternTypes;
+		}
+
+		public Set<IntegrationPatternType> getPatternTypes() {
+			return Arrays.stream(this.patternTypes).collect(Collectors.toSet());
+		}
+
+	}
+
+}

spring-integration-core/src/main/java/org/springframework/integration/aggregator/AggregatingMessageHandler.java

@@ -18,6 +18,7 @@
 
 import java.util.Collection;
 
+import org.springframework.integration.IntegrationPatternType;
 import org.springframework.integration.store.MessageGroup;
 import org.springframework.integration.store.MessageGroupStore;
 import org.springframework.integration.store.SimpleMessageStore;
@@ -40,6 +41,7 @@ public class AggregatingMessageHandler extends AbstractCorrelatingMessageHandler
 
 	public AggregatingMessageHandler(MessageGroupProcessor processor, MessageGroupStore store,
 			CorrelationStrategy correlationStrategy, ReleaseStrategy releaseStrategy) {
+
 		super(processor, store, correlationStrategy, releaseStrategy);
 	}
 
@@ -53,15 +55,18 @@ public AggregatingMessageHandler(MessageGroupProcessor processor) {
 
 	/**
 	 * Will set the 'expireGroupsUponCompletion' flag.
-	 *
 	 * @param expireGroupsUponCompletion true when groups should be expired on completion.
-	 *
 	 * @see #afterRelease
 	 */
 	public void setExpireGroupsUponCompletion(boolean expireGroupsUponCompletion) {
 		this.expireGroupsUponCompletion = expireGroupsUponCompletion;
 	}
 
+	@Override
+	public IntegrationPatternType getIntegrationPatternType() {
+		return IntegrationPatternType.aggregator;
+	}
+
 	@Override
 	protected boolean isExpireGroupsUponCompletion() {
 		return this.expireGroupsUponCompletion;

spring-integration-core/src/main/java/org/springframework/integration/aggregator/BarrierMessageHandler.java

@@ -22,6 +22,7 @@
 import java.util.concurrent.TimeUnit;
 
 import org.springframework.integration.IntegrationMessageHeaderAccessor;
+import org.springframework.integration.IntegrationPatternType;
 import org.springframework.integration.handler.AbstractReplyProducingMessageHandler;
 import org.springframework.integration.handler.DiscardingMessageHandler;
 import org.springframework.integration.handler.MessageTriggerAction;
@@ -149,6 +150,11 @@ public String getComponentType() {
 		return "barrier";
 	}
 
+	@Override
+	public IntegrationPatternType getIntegrationPatternType() {
+		return IntegrationPatternType.barrier;
+	}
+
 	@Override
 	protected Object handleRequestMessage(Message<?> requestMessage) {
 		Object key = this.correlationStrategy.getCorrelationKey(requestMessage);

spring-integration-core/src/main/java/org/springframework/integration/aggregator/FluxAggregatorMessageHandler.java

@@ -23,6 +23,7 @@
 
 import org.springframework.context.Lifecycle;
 import org.springframework.integration.IntegrationMessageHeaderAccessor;
+import org.springframework.integration.IntegrationPatternType;
 import org.springframework.integration.channel.ReactiveStreamsSubscribableChannel;
 import org.springframework.integration.handler.AbstractMessageProducingHandler;
 import org.springframework.messaging.Message;
@@ -216,6 +217,16 @@ public void setWindowConfigurer(Function<Flux<Message<?>>, Flux<Flux<Message<?>>
 		this.windowConfigurer = windowConfigurer;
 	}
 
+	@Override
+	public String getComponentType() {
+		return "flux-aggregator";
+	}
+
+	@Override
+	public IntegrationPatternType getIntegrationPatternType() {
+		return IntegrationPatternType.aggregator;
+	}
+
 	@Override
 	public void start() {
 		if (this.subscribed.compareAndSet(false, true)) {

spring-integration-core/src/main/java/org/springframework/integration/aggregator/ResequencingMessageHandler.java

@@ -18,6 +18,7 @@
 
 import java.util.Collection;
 
+import org.springframework.integration.IntegrationPatternType;
 import org.springframework.integration.store.MessageGroup;
 import org.springframework.integration.store.MessageGroupStore;
 import org.springframework.integration.store.SimpleMessageStore;
@@ -35,16 +36,15 @@
  */
 public class ResequencingMessageHandler extends AbstractCorrelatingMessageHandler {
 
-	public ResequencingMessageHandler(MessageGroupProcessor processor,
-			MessageGroupStore store, CorrelationStrategy correlationStrategy,
-			ReleaseStrategy releaseStrategy) {
+	public ResequencingMessageHandler(MessageGroupProcessor processor, MessageGroupStore store,
+			CorrelationStrategy correlationStrategy, ReleaseStrategy releaseStrategy) {
+
 		super(processor, store, correlationStrategy, releaseStrategy);
 		this.setExpireGroupsUponTimeout(false);
 	}
 
 
-	public ResequencingMessageHandler(MessageGroupProcessor processor,
-			MessageGroupStore store) {
+	public ResequencingMessageHandler(MessageGroupProcessor processor, MessageGroupStore store) {
 		super(processor, store);
 		this.setExpireGroupsUponTimeout(false);
 	}
@@ -56,10 +56,8 @@ public ResequencingMessageHandler(MessageGroupProcessor processor) {
 	}
 
 	/**
-	 * {@inheritDoc}
-	 *
-	 * (overridden to false for a resequencer so late messages are immediately discarded rather
-	 * than waiting for the next timeout)
+	 * Overridden to false for a resequencer so late messages are immediately discarded rather
+	 * than waiting for the next timeout
 	 */
 	@Override
 	public final void setExpireGroupsUponTimeout(boolean expireGroupsUponTimeout) {
@@ -71,6 +69,11 @@ public String getComponentType() {
 		return "resequencer";
 	}
 
+	@Override
+	public IntegrationPatternType getIntegrationPatternType() {
+		return IntegrationPatternType.resequencer;
+	}
+
 	@Override
 	protected boolean shouldCopyRequestHeaders() {
 		return false;

spring-integration-core/src/main/java/org/springframework/integration/channel/AbstractExecutorChannel.java

@@ -22,6 +22,7 @@
 import java.util.List;
 import java.util.concurrent.Executor;
 
+import org.springframework.integration.IntegrationPatternType;
 import org.springframework.integration.dispatcher.AbstractDispatcher;
 import org.springframework.integration.support.MessagingExceptionWrapper;
 import org.springframework.lang.Nullable;
@@ -128,6 +129,11 @@ public boolean hasExecutorInterceptors() {
 		return this.executorInterceptorsSize > 0;
 	}
 
+	@Override
+	public IntegrationPatternType getIntegrationPatternType() {
+		return IntegrationPatternType.executor_channel;
+	}
+
 	protected class MessageHandlingTask implements Runnable {
 
 		private final MessageHandlingRunnable delegate;