Add Java configuration for enricher sample

Introduce Java-based Spring Integration configuration as an
alternative to the existing XML configuration. The new
EnricherConfiguration class uses `@Configuration` and Integration
DSL to define three enricher flows demonstrating different
enrichment strategies.

The UserGateway interface uses `@MessagingGateway` to provide a
simple interface for clients to invoke enricher flows. The
application.properties file sets `java-config` as the default
profile, allowing users to run the sample with Java configuration
out of the box.

The Main class now supports profile-based configuration switching
to load either Java or XML configuration. Tests have been updated
to verify both configuration modes work correctly, with helper
methods extracted to reduce code duplication.

The XML configuration remains available by explicitly activating
the `xml-config` profile, maintaining backward compatibility.

All samples can now run using gradlew :enricher:run.  Was broken before

Author: cppwfs

basic/enricher/README.md

@@ -3,34 +3,73 @@ Spring Integration - Enricher Sample
 
 # Overview
 
-This sample demonstrates how the Enricher components can be used.
+This sample demonstrates how the Content Enricher pattern can be used in Spring Integration. The Content Enricher allows you to augment a message with additional data from an external source without requiring the original sender to know about the enrichment process.
+
+This sample supports both **XML-based** and **Java-based** Spring Integration configurations. You can select which configuration to use by setting the active Spring profile.
+
+## Configuration Options
+
+This sample supports two configuration modes:
+
+* **Java Configuration** (`java-config` profile) - Uses Java `@Configuration` classes from the `config` package. This is the **default** mode.
+* **XML Configuration** (`xml-config` profile) - Uses XML configuration files from `META-INF/spring/integration/`
+
+### Profile Selection
+
+Only one configuration profile should be active at a time. The `java-config` and `xml-config` profiles are mutually exclusive.
+
+* If no profile is explicitly provided, `java-config` is used by default (as configured in `application.properties`).
+* To use XML configuration, explicitly activate the `xml-config` profile at runtime.
 
 # Getting Started
 
-You can run the sample application by either
+## Using Java Configuration (Default)
 
-* running the "Main" class from within STS (Right-click on Main class --> Run As --> Java Application)
-* or from the command line execute:
+The sample uses Java configuration by default. You can run the sample application by either:
+
+* Running the "Main" class from within your IDE (Right-click on Main class --> Run As --> Java Application)
+* Or from the command line execute:
 
     $ gradlew :enricher:run
 
-This example illustrates the usage of the Content Enricher.           
+In this mode, the application context is defined using Spring Integration Java configuration classes instead of XML. The configuration classes are located in the `org.springframework.integration.samples.enricher.config` package.
+
+## Using XML Configuration
+
+To run the sample with XML configuration, activate the `xml-config` profile:
+
+* From your IDE, set the system property: `-Dspring.profiles.active=xml-config`
+* Or from the command line:
+    
+    $ gradlew :enricher:run -Dspring.profiles.active=xml-config
+
+This mode uses the legacy XML-based wiring from `spring-integration-context.xml`.
+
+# How It Works
+
+This example illustrates the usage of the Content Enricher pattern.           
 
-Once the application has started, please execute the various Content Enricher examples by                               
+Once the application has started, please execute the various Content Enricher examples by:                               
 
 * entering 1 + Enter
 * entering 2 + Enter
 * entering 3 + Enter
 
 3 different message flows are triggered. For use-cases 1+2 a **User** object containing only the **username** is passed in. For use-case 3 a Map with the **username** key is passed in and enriched with the **User** object using the **user** key:                          
 
-* 1: In the *Enricher*, pass the full **User** object to the **request channel**. 
-* 2: In the *Enricher*, pass only the **username** to the **request channel** by using the **request-payload-expression** attribute.   
-* 3: In the *Enricher*, pass only the username to the **request channel**, executing the same Service Activator as in **2**.
+* **1**: In the *Enricher*, pass the full **User** object to the **request channel**. 
+* **2**: In the *Enricher*, pass only the **username** to the **request channel** by using the **request-payload-expression** attribute.   
+* **3**: In the *Enricher*, pass only the username to the **request channel**, executing the same Service Activator as in **2**.
+
+## About This Pattern
+
+Spring Integration is moving toward Java configuration as the primary style for new development, while XML configuration remains available for users who prefer that style or are migrating older systems. This sample demonstrates how both approaches can coexist in the same project using Spring profiles to select the desired configuration mode at runtime.
+
+This pattern (Java first, XML as an alternative) is being applied across other samples in this repository, using `basic/barrier` as a reference model.
 
 # Resources
 
 For help please take a look at the Spring Integration documentation:
 
-https://www.springsource.org/spring-integration
+https://docs.spring.io/spring-integration/reference/
 

basic/enricher/src/main/java/org/springframework/integration/samples/enricher/Main.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2011-present 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.
@@ -22,17 +22,27 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.support.AbstractApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.core.env.StandardEnvironment;
 import org.springframework.integration.samples.enricher.domain.User;
 import org.springframework.integration.samples.enricher.service.UserService;
 
 
 /**
  * Starts the Spring Context and will initialize the Spring Integration routes.
+ * <p>
+ * This application supports both Java-based and XML-based Spring Integration
+ * configurations. The configuration mode is selected via Spring profiles:
+ * <ul>
+ *   <li>java-config (default) - Uses Java configuration classes</li>
+ *   <li>xml-config - Uses XML configuration files</li>
+ * </ul>
  *
  * @author Gunnar Hillert
  * @author Gary Russell
+ * @author Glenn Renfro
  * @version 1.0
  *
  */
@@ -62,8 +72,23 @@ public static void main(final String... args) {
 				  + EMPTY_LINE
 				  + LINE_SEPARATOR );
 
-		final AbstractApplicationContext context =
-				new ClassPathXmlApplicationContext("classpath:META-INF/spring/integration/*-context.xml");
+		// Determine which profile to use
+		String profile = System.getProperty("spring.profiles.active", "java-config");
+		
+		final AbstractApplicationContext context;
+		
+		if ("xml-config".equals(profile)) {
+			LOGGER.info("\n\n    Using XML-based configuration\n\n");
+			context = new ClassPathXmlApplicationContext("classpath:META-INF/spring/integration/*-context.xml");
+		} else {
+			LOGGER.info("\n\n    Using Java-based configuration\n\n");
+			AnnotationConfigApplicationContext annotationContext = new AnnotationConfigApplicationContext();
+			annotationContext.setEnvironment(new StandardEnvironment());
+			annotationContext.getEnvironment().setActiveProfiles("java-config");
+			annotationContext.scan("org.springframework.integration.samples.enricher.config");
+			annotationContext.refresh();
+			context = annotationContext;
+		}
 
 		context.registerShutdownHook();
 

basic/enricher/src/test/java/org/springframework/integration/samples/enricher/service/UserServiceTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2011-present 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.
@@ -18,30 +18,71 @@
 
 import org.junit.jupiter.api.Test;
 
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.springframework.integration.samples.enricher.domain.User;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Verify that the Spring Integration Application Context starts successfully.
+ * Verify that the Spring Integration Application Context starts successfully
+ * with both Java and XML configurations.
+ * 
+ * @author Glenn Renfro
  */
 public class UserServiceTest {
 
 	@Test
-	public void testStartupOfSpringIntegrationContext() throws Exception {
+	public void testStartupOfSpringIntegrationContextWithJavaConfig() throws Exception {
+		AnnotationConfigApplicationContext context = createJavaConfigContext();
+		Thread.sleep(2000);
+		context.close();
+	}
+
+	@Test
+	public void testStartupOfSpringIntegrationContextWithXmlConfig() throws Exception {
 		final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
 				"/META-INF/spring/integration/spring-integration-context.xml", UserServiceTest.class);
 		Thread.sleep(2000);
 		context.close();
 	}
 
 	@Test
-	public void testExecuteFindUser() {
+	public void testExecuteFindUserWithJavaConfig() {
+		AnnotationConfigApplicationContext context = createJavaConfigContext();
+
+		runFindUserTest(context);
+		context.close();
+	}
+
+	@Test
+	public void testExecuteFindUserWithXmlConfig() {
+		final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
+				"/META-INF/spring/integration/spring-integration-context.xml", UserServiceTest.class);
+
+		runFindUserTest(context);
+		context.close();
+	}
+
+	@Test
+	public void testExecuteFindUserByUsernameWithJavaConfig() {
+		AnnotationConfigApplicationContext context = createJavaConfigContext();
 
+		runFindUserByUsernameTest(context);
+		context.close();
+	}
+
+	@Test
+	public void testExecuteFindUserByUsernameWithXmlConfig() {
 		final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
 				"/META-INF/spring/integration/spring-integration-context.xml", UserServiceTest.class);
 
+		runFindUserByUsernameTest(context);
+		context.close();
+	}
+
+	private void runFindUserTest(ConfigurableApplicationContext context) {
 		final UserService service = context.getBean(UserService.class);
 
 		User user = new User("foo", null, null);
@@ -50,15 +91,9 @@ public void testExecuteFindUser() {
 		assertThat(fullUser.getUsername()).isEqualTo("foo");
 		assertThat(fullUser.getEmail()).isEqualTo("[email protected]");
 		assertThat(fullUser.getPassword()).isEqualTo("secret");
-		context.close();
-
 	}
 
-	@Test
-	public void testExecuteFindUserByUsername() {
-		final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
-				"/META-INF/spring/integration/spring-integration-context.xml", UserServiceTest.class);
-
+	private void runFindUserByUsernameTest(ConfigurableApplicationContext context) {
 		final UserService service = context.getBean(UserService.class);
 
 		User user = new User("foo", null, null);
@@ -67,8 +102,14 @@ public void testExecuteFindUserByUsername() {
 		assertThat(fullUser.getUsername()).isEqualTo("foo");
 		assertThat(fullUser.getEmail()).isEqualTo("[email protected]");
 		assertThat(fullUser.getPassword()).isEqualTo("secret");
-		context.close();
-
 	}
 
+
+	private AnnotationConfigApplicationContext createJavaConfigContext() {
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+		context.getEnvironment().setActiveProfiles("java-config");
+		context.scan("org.springframework.integration.samples.enricher.config");
+		context.refresh();
+		return context;
+	}
 }

build.gradle

@@ -532,6 +532,9 @@ project('enricher') {
 		api "com.h2database:h2:$h2Version"
 		api "org.apache.logging.log4j:log4j-core:$log4jVersion"
 	}
+	run {
+		standardInput = System.in
+	}
 }
 
 project('feed') {