Merge remote-tracking branch 'upstream/master'

core-java-modules/core-java-18/src/main/java/com/baeldung/simplewebserver/WebServer.java

@@ -0,0 +1,59 @@
+package com.baeldung.simplewebserver;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.file.Path;
+import java.util.function.Predicate;
+
+import com.sun.net.httpserver.Filter;
+import com.sun.net.httpserver.Headers;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpHandlers;
+import com.sun.net.httpserver.HttpServer;
+import com.sun.net.httpserver.Request;
+import com.sun.net.httpserver.SimpleFileServer;
+
+public class WebServer {
+
+    private final InetSocketAddress address = new InetSocketAddress(8080);
+    private final Path path = Path.of("/");
+
+    public static void main(String[] args) {
+        WebServer webServer = new WebServer();
+        HttpServer server = webServer.createWithHandler401Response();
+        server.start();
+    }
+
+    private HttpServer createBasic() {
+        return SimpleFileServer.createFileServer(address, path, SimpleFileServer.OutputLevel.VERBOSE);
+    }
+
+    private HttpServer createWithHandler() throws IOException {
+        HttpServer server = SimpleFileServer.createFileServer(address, path, SimpleFileServer.OutputLevel.VERBOSE);
+        HttpHandler handler = SimpleFileServer.createFileHandler(Path.of("/Users"));
+        server.createContext("/test", handler);
+        return server;
+    }
+
+    private HttpServer createWithHandler401Response() {
+        Predicate<Request> findAllowedPath = r -> r.getRequestURI()
+          .getPath()
+          .equals("/test/allowed");
+
+        HttpHandler allowedResponse = HttpHandlers.of(200, Headers.of("Allow", "GET"), "Welcome");
+        HttpHandler deniedResponse = HttpHandlers.of(401, Headers.of("Deny", "GET"), "Denied");
+
+        HttpHandler handler = HttpHandlers.handleOrElse(findAllowedPath, allowedResponse, deniedResponse);
+
+        HttpServer server = SimpleFileServer.createFileServer(address, path, SimpleFileServer.OutputLevel.VERBOSE);
+        server.createContext("/test", handler);
+        return server;
+    }
+
+    private HttpServer createWithFilter() throws IOException {
+        Filter filter = SimpleFileServer.createOutputFilter(System.out, SimpleFileServer.OutputLevel.INFO);
+        HttpHandler handler = SimpleFileServer.createFileHandler(Path.of("/Users"));
+        return HttpServer.create(new InetSocketAddress(8080), 10, "/test", handler, filter);
+    }
+
+}

lightrun/lightrun-tasks-service/pom.xml

@@ -48,6 +48,7 @@
         <dependency>
             <groupId>org.apache.activemq</groupId>
             <artifactId>artemis-jms-server</artifactId>
+            <version>${activemq.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -65,4 +66,8 @@
         </plugins>
     </build>
 
+    <properties>
+        <activemq.version>2.32.0</activemq.version>
+    </properties>
+
 </project>

persistence-modules/spring-boot-persistence-mongodb/src/main/java/com/baeldung/boot/connection/via/builder/SpringMongoConnectionViaBuilderApp.java

@@ -0,0 +1,25 @@
+package com.baeldung.boot.connection.via.builder;
+
+import com.mongodb.ConnectionString;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.WebApplicationType;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.mongo.MongoClientSettingsBuilderCustomizer;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication
+public class SpringMongoConnectionViaBuilderApp {
+
+    public static void main(String... args) {
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaBuilderApp.class);
+        app.web(WebApplicationType.NONE);
+        app.run(args);
+    }
+
+    @Bean
+    public MongoClientSettingsBuilderCustomizer customizer(@Value("${custom.uri}") String uri) {
+        ConnectionString connection = new ConnectionString(uri);
+        return settings -> settings.applyConnectionString(connection);
+    }
+}

persistence-modules/spring-boot-persistence-mongodb/src/main/java/com/baeldung/boot/connection/via/client/SpringMongoConnectionViaClientApp.java

@@ -0,0 +1,41 @@
+package com.baeldung.boot.connection.via.client;
+
+import com.mongodb.client.ListDatabasesIterable;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import org.bson.Document;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.WebApplicationType;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.data.mongodb.config.AbstractMongoClientConfiguration;
+
+@SpringBootApplication(exclude={EmbeddedMongoAutoConfiguration.class})
+public class SpringMongoConnectionViaClientApp extends AbstractMongoClientConfiguration {
+
+    public static void main(String... args) {
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaClientApp.class);
+        app.web(WebApplicationType.NONE);
+        app.run(args);
+    }
+
+    @Value("${spring.data.mongodb.uri}")
+    private String uri;
+
+    @Value("${spring.data.mongodb.database}")
+    private String db;
+
+    @Override
+    public MongoClient mongoClient() {
+        MongoClient client = MongoClients.create(uri);
+        ListDatabasesIterable<Document> databases = client.listDatabases();
+        databases.forEach(System.out::println);
+        return client;
+    }
+
+    @Override
+    protected String getDatabaseName() {
+        return db;
+    }
+}

persistence-modules/spring-boot-persistence-mongodb/src/main/java/com/baeldung/boot/connection/via/factory/SpringMongoConnectionViaFactoryApp.java

@@ -0,0 +1,34 @@
+package com.baeldung.boot.connection.via.factory;
+
+import com.mongodb.ConnectionString;
+import com.mongodb.client.MongoClient;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.WebApplicationType;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.data.mongodb.core.MongoClientFactoryBean;
+
+@SpringBootApplication
+public class SpringMongoConnectionViaFactoryApp {
+
+    public static void main(String... args) {
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaFactoryApp.class);
+        app.web(WebApplicationType.NONE);
+        app.run(args);
+    }
+
+    @Bean
+    public MongoClientFactoryBean mongo(@Value("${custom.uri}") String uri) throws Exception {
+        MongoClientFactoryBean mongo = new MongoClientFactoryBean();
+        ConnectionString conn = new ConnectionString(uri);
+        mongo.setConnectionString(conn);
+
+        mongo.setSingleton(false);
+
+        MongoClient client = mongo.getObject();
+        client.listDatabaseNames()
+          .forEach(System.out::println);
+        return mongo;
+    }
+}

persistence-modules/spring-boot-persistence-mongodb/src/main/java/com/baeldung/boot/connection/via/properties/SpringMongoConnectionViaPropertiesApp.java

@@ -0,0 +1,15 @@
+package com.baeldung.boot.connection.via.properties;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
+import org.springframework.context.annotation.PropertySource;
+
+@PropertySource("classpath:connection.via.properties/application.properties")
+@SpringBootApplication(exclude={EmbeddedMongoAutoConfiguration.class})
+public class SpringMongoConnectionViaPropertiesApp {
+
+    public static void main(String... args) {
+        SpringApplication.run(SpringMongoConnectionViaPropertiesApp.class, args);
+    }
+}

persistence-modules/spring-boot-persistence-mongodb/src/main/resources/connection.via.properties/application.properties

@@ -0,0 +1,5 @@
+spring.data.mongodb.host=localhost
+spring.data.mongodb.port=27017
+spring.data.mongodb.database=baeldung
+spring.data.mongodb.username=admin
+spring.data.mongodb.password=password

persistence-modules/spring-boot-persistence-mongodb/src/test/java/com/baeldung/boot/connection/via/MongoConnectionApplicationLiveTest.java

@@ -0,0 +1,99 @@
+package com.baeldung.boot.connection.via;
+
+import com.baeldung.boot.connection.via.client.SpringMongoConnectionViaClientApp;
+import com.baeldung.boot.connection.via.properties.SpringMongoConnectionViaPropertiesApp;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.boot.WebApplicationType;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.bson.Document;
+
+import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class MongoConnectionApplicationLiveTest {
+    private static final String HOST = "localhost";
+    private static final String PORT = "27017";
+    private static final String DB = "baeldung";
+    private static final String USER = "admin";
+    private static final String PASS = "password";
+
+    private void assertInsertSucceeds(ConfigurableApplicationContext context) {
+        String name = "A";
+
+        MongoTemplate mongo = context.getBean(MongoTemplate.class);
+        Document doc = Document.parse("{\"name\":\"" + name + "\"}");
+        Document inserted = mongo.insert(doc, "items");
+
+        assertNotNull(inserted.get("_id"));
+        assertEquals(inserted.get("name"), name);
+    }
+
+    @Test
+    public void whenPropertiesConfig_thenInsertSucceeds() {
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaPropertiesApp.class);
+        app.run();
+
+        assertInsertSucceeds(app.context());
+    }
+
+    @Test
+    public void givenPrecedence_whenSystemConfig_thenInsertSucceeds() {
+        System.setProperty("spring.data.mongodb.host", HOST);
+        System.setProperty("spring.data.mongodb.port", PORT);
+        System.setProperty("spring.data.mongodb.database", DB);
+        System.setProperty("spring.data.mongodb.username", USER);
+        System.setProperty("spring.data.mongodb.password", PASS);
+
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaPropertiesApp.class)
+          .properties(
+            "spring.data.mongodb.host=oldValue",
+            "spring.data.mongodb.port=oldValue",
+            "spring.data.mongodb.database=oldValue",
+            "spring.data.mongodb.username=oldValue",
+            "spring.data.mongodb.password=oldValue"
+          );
+        app.run();
+
+        assertInsertSucceeds(app.context());
+    }
+
+    @Test
+    public void givenConnectionUri_whenAlsoIncludingIndividualParameters_thenInvalidConfig() {
+        System.setProperty(
+          "spring.data.mongodb.uri",
+          "mongodb://" + USER + ":" + PASS + "@" + HOST + ":" + PORT + "/" + DB
+        );
+
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaPropertiesApp.class)
+          .properties(
+            "spring.data.mongodb.host=" + HOST,
+            "spring.data.mongodb.port=" + PORT,
+            "spring.data.mongodb.username=" + USER,
+            "spring.data.mongodb.password=" + PASS
+          );
+
+        BeanCreationException e = assertThrows(BeanCreationException.class, () -> {
+          app.run();
+        });
+
+        Throwable rootCause = e.getRootCause();
+        assertTrue(rootCause instanceof IllegalStateException);
+        assertThat(rootCause.getMessage()
+          .contains("Invalid mongo configuration, either uri or host/port/credentials/replicaSet must be specified"));
+    }
+
+    @Test
+    public void whenClientConfig_thenInsertSucceeds() {
+        SpringApplicationBuilder app = new SpringApplicationBuilder(SpringMongoConnectionViaClientApp.class);
+        app.web(WebApplicationType.NONE)
+          .run(
+            "--spring.data.mongodb.uri=mongodb://" + USER + ":" + PASS + "@" + HOST + ":" + PORT + "/" + DB,
+            "--spring.data.mongodb.database=" + DB
+        );
+
+        assertInsertSucceeds(app.context());
+    }
+}

pom.xml

@@ -1167,7 +1167,7 @@
         <hamcrest.version>2.2</hamcrest.version>
         <hamcrest-all.version>1.3</hamcrest-all.version>
         <mockito.version>4.4.0</mockito.version>
-        <byte-buddy.version>1.14.6</byte-buddy.version>
+        <byte-buddy.version>1.14.11</byte-buddy.version>
 
         <!-- logging -->
         <!-- overwriting in the slf4j and logback in the hibernate-jpa, spring-data-eclipselink. When updated to the latest version remove the version from that module-->

spring-aop-2/src/main/java/com/baeldung/logging/GreetingServiceWithoutAOP.java

@@ -10,9 +10,9 @@ public class GreetingServiceWithoutAOP {
     private static final Logger logger = LoggerFactory.getLogger(GreetingServiceWithoutAOP.class);
 
     public String greet(String name) {
-        logger.info(">> greet() - {}", name);
+        logger.debug(">> greet() - {}", name);
         String result = String.format("Hello %s", name);
-        logger.info("<< greet() - {}", result);
+        logger.debug("<< greet() - {}", result);
         return result;
     }
 }

spring-aop-2/src/main/java/com/baeldung/logging/LoggingAspect.java

@@ -28,13 +28,13 @@ private void publicMethodsFromLoggingPackage() {
     public void logBefore(JoinPoint joinPoint) {
         Object[] args = joinPoint.getArgs();
         String methodName = joinPoint.getSignature().getName();
-        logger.info(">> {}() - {}", methodName, Arrays.toString(args));
+        logger.debug(">> {}() - {}", methodName, Arrays.toString(args));
     }
 
     @AfterReturning(value = "publicMethodsFromLoggingPackage()", returning = "result")
     public void logAfter(JoinPoint joinPoint, Object result) {
         String methodName = joinPoint.getSignature().getName();
-        logger.info("<< {}() - {}", methodName, result);
+        logger.debug("<< {}() - {}", methodName, result);
     }
 
     @AfterThrowing(pointcut = "publicMethodsFromLoggingPackage()", throwing = "exception")
@@ -47,9 +47,9 @@ public void logException(JoinPoint joinPoint, Throwable exception) {
     public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
         Object[] args = joinPoint.getArgs();
         String methodName = joinPoint.getSignature().getName();
-        logger.info(">> {}() - {}", methodName, Arrays.toString(args));
+        logger.debug(">> {}() - {}", methodName, Arrays.toString(args));
         Object result = joinPoint.proceed();
-        logger.info("<< {}() - {}", methodName, result);
+        logger.debug("<< {}() - {}", methodName, result);
         return result;
     }
 }

spring-ejb-modules/spring-ejb-client/pom.xml

@@ -50,6 +50,18 @@
             <groupId>io.undertow</groupId>
             <artifactId>undertow-servlet</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.wildfly</groupId>
+            <artifactId>wildfly-naming-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.jboss</groupId>
+            <artifactId>jboss-ejb-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.wildfly.common</groupId>
+            <artifactId>wildfly-common</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

spring-ejb-modules/spring-ejb-client/src/main/java/com/baeldung/springejbclient/SpringEjbClientApplication.java

@@ -21,7 +21,7 @@ public Context context() throws NamingException {
         Properties jndiProps = new Properties();
         jndiProps.put("java.naming.factory.initial", "org.jboss.naming.remote.client.InitialContextFactory");
         jndiProps.put("jboss.naming.client.ejb.context", true);
-        jndiProps.put("java.naming.provider.url", "http-remoting://localhost:8080");
+        jndiProps.put("java.naming.provider.url", "remote+http://localhost:8080");
         return new InitialContext(jndiProps);
     }
 
@@ -37,7 +37,7 @@ public HelloStatefulWorld helloStatefulWorld(Context context) throws NamingExcep
 
     @SuppressWarnings("rawtypes")
     private String getFullName(Class classType) {
-        String moduleName = "spring-ejb-remote/";
+        String moduleName = "ejb:/spring-ejb-remote/";
         String beanName = classType.getSimpleName();
         String viewClassName = classType.getName();