Merge branch 'master' into feature/BAEL-7419-how-to-mock-aws-s3-for-integration-test

.gitignore

@@ -64,13 +64,13 @@ core-java-io/hard_link.txt
 core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
-jmeter/src/main/resources/*-JMeter.csv
-jmeter/src/main/resources/*-Basic*.csv
-jmeter/src/main/resources/*-JMeter*.csv
-jmeter/src/main/resources/*ReportsDashboard*.csv
-jmeter/src/main/resources/dashboard/*ReportsDashboard*.csv
-jmeter/src/main/resources/*FileExtractionExample.csv
-jmeter/src/main/resources/*_Summary-Report.csv
+testing-modules/jmeter/src/main/resources/*-JMeter.csv
+testing-modules/jmeter/src/main/resources/*-Basic*.csv
+testing-modules/jmeter/src/main/resources/*-JMeter*.csv
+testing-modules/jmeter/src/main/resources/*ReportsDashboard*.csv
+testing-modules/jmeter/src/main/resources/dashboard/*ReportsDashboard*.csv
+testing-modules/jmeter/src/main/resources/*FileExtractionExample.csv
+testing-modules/jmeter/src/main/resources/*_Summary-Report.csv
 
 ninja/devDb.mv.db
 
@@ -128,3 +128,6 @@ persistence-modules/neo4j/data/**
 /deep-shallow-copy/.mvn/wrapper
 /deep-shallow-copy/mvnw
 /deep-shallow-copy/mvnw.cmd
+
+#spring-5-webflux-2
+**/testdb.mv.db

algorithms-modules/algorithms-miscellaneous-2/pom.xml

@@ -14,16 +14,6 @@
     </parent>
 
     <dependencies>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-math3</artifactId>
-            <version>${commons-math3.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>commons-codec</groupId>
-            <artifactId>commons-codec</artifactId>
-            <version>${commons-codec.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/DijkstraAlgorithmLongRunningUnitTest.java

@@ -1,7 +1,5 @@
 package com.baeldung.algorithms;
 
-
-
 import com.baeldung.algorithms.ga.dijkstra.Dijkstra;
 import com.baeldung.algorithms.ga.dijkstra.Graph;
 import com.baeldung.algorithms.ga.dijkstra.Node;

algorithms-modules/algorithms-miscellaneous-7/README.md

@@ -6,4 +6,6 @@
 - [Calculate Distance Between Two Coordinates in Java](https://www.baeldung.com/java-find-distance-between-points)
 - [Rotate Arrays in Java](https://www.baeldung.com/java-rotate-arrays)
 - [Find Missing Number From a Given Array in Java](https://www.baeldung.com/java-array-find-missing-number)
+- [Calculate Weighted Mean in Java](https://www.baeldung.com/java-compute-weighted-average)
+- [Check if Two Strings Are Rotations of Each Other](https://www.baeldung.com/java-string-check-strings-rotations)
 - More articles: [[<-- prev]](/algorithms-miscellaneous-6)

algorithms-modules/algorithms-miscellaneous-7/src/main/java/com/baeldung/algorithms/primeundernumber/LargestPrimeFinder.java

@@ -0,0 +1,43 @@
+package com.baeldung.algorithms.primeundernumber;
+
+import java.util.Arrays;
+
+public class LargestPrimeFinder {
+
+    public static int findByBruteForce(int n) {
+        for (int i = n - 1; i >= 2; i--) {
+            if (isPrime(i)) {
+                return i;
+            }
+        }
+        return -1; // Return -1 if no prime number is found
+    }
+
+    public static boolean isPrime(int number) {
+        for (int i = 2; i <= Math.sqrt(number); i++) {
+            if (number % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static int findBySieveOfEratosthenes(int n) {
+        boolean[] isPrime = new boolean[n];
+        Arrays.fill(isPrime, true);
+        for (int p = 2; p*p < n; p++) {
+            if (isPrime[p]) {
+                for (int i = p * p; i < n; i += p) {
+                    isPrime[i] = false;
+                }
+            }
+        }
+
+        for (int i = n - 1; i >= 2; i--) {
+            if (isPrime[i]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/main/java/com/baeldung/algorithms/stringrotation/StringRotation.java

@@ -0,0 +1,123 @@
+package com.baeldung.algorithms.stringrotation;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class StringRotation {
+
+    public static boolean doubledOriginContainsRotation(String origin, String rotation) {
+        if (origin.length() == rotation.length()) {
+            return origin.concat(origin)
+              .contains(rotation);
+        }
+
+        return false;
+    }
+
+    public static boolean isRotationUsingCommonStartWithOrigin(String origin, String rotation) {
+
+        if (origin.length() == rotation.length()) {
+
+            List<Integer> indexes = IntStream.range(0, origin.length())
+              .filter(i -> rotation.charAt(i) == origin.charAt(0))
+              .boxed()
+              .collect(Collectors.toList());
+
+            for (int startingAt : indexes) {
+                if (isRotation(startingAt, rotation, origin)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    static boolean isRotation(int startingAt, String rotation, String origin) {
+
+        for (int i = 0; i < origin.length(); i++) {
+            if (rotation.charAt((startingAt + i) % origin.length()) != origin.charAt(i)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static boolean isRotationUsingQueue(String origin, String rotation) {
+
+        if (origin.length() == rotation.length()) {
+            return checkWithQueue(origin, rotation);
+        }
+
+        return false;
+    }
+
+    static boolean checkWithQueue(String origin, String rotation) {
+
+        if (origin.length() == rotation.length()) {
+
+            Queue<Character> originQueue = getCharactersQueue(origin);
+
+            Queue<Character> rotationQueue = getCharactersQueue(rotation);
+
+            int k = rotation.length();
+            while (k > 0 && null != rotationQueue.peek()) {
+                k--;
+                char ch = rotationQueue.peek();
+                rotationQueue.remove();
+                rotationQueue.add(ch);
+                if (rotationQueue.equals(originQueue)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    static Queue<Character> getCharactersQueue(String origin) {
+        return origin.chars()
+          .mapToObj(c -> (char) c)
+          .collect(Collectors.toCollection(LinkedList::new));
+    }
+
+    public static boolean isRotationUsingSuffixAndPrefix(String origin, String rotation) {
+
+        if (origin.length() == rotation.length()) {
+            return checkPrefixAndSuffix(origin, rotation);
+        }
+
+        return false;
+    }
+
+    static boolean checkPrefixAndSuffix(String origin, String rotation) {
+        if (origin.length() == rotation.length()) {
+
+            for (int i = 0; i < origin.length(); i++) {
+                if (origin.charAt(i) == rotation.charAt(0)) {
+                    if (checkRotationPrefixWithOriginSuffix(origin, rotation, i)) {
+                        if (checkOriginPrefixWithRotationSuffix(origin, rotation, i))
+                            return true;
+                    }
+                }
+            }
+
+        }
+
+        return false;
+    }
+
+    private static boolean checkRotationPrefixWithOriginSuffix(String origin, String rotation, int i) {
+        return origin.substring(i)
+          .equals(rotation.substring(0, origin.length() - i));
+    }
+
+    private static boolean checkOriginPrefixWithRotationSuffix(String origin, String rotation, int i) {
+        return origin.substring(0, i)
+          .equals(rotation.substring(origin.length() - i));
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/primeundernumber/LargestPrimeFinderUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.algorithms.primeundernumber;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class LargestPrimeFinderUnitTest {
+
+    @Test
+    public void givenNormalCases_whenFindPrime_ThenFoundResult() {
+        assertEquals(7, LargestPrimeFinder.findByBruteForce(10));
+        assertEquals(97, LargestPrimeFinder.findByBruteForce(100));
+        assertEquals(7, LargestPrimeFinder.findBySieveOfEratosthenes(10));
+        assertEquals(97, LargestPrimeFinder.findBySieveOfEratosthenes(100));
+    }
+
+    @Test
+    public void givenEdgeCases_whenFindPrime_ThenNotFoundResult() {
+        assertEquals(-1, LargestPrimeFinder.findByBruteForce(0));
+        assertEquals(-1, LargestPrimeFinder.findByBruteForce(1));
+        assertEquals(-1, LargestPrimeFinder.findByBruteForce(2));
+        assertEquals(-1, LargestPrimeFinder.findBySieveOfEratosthenes(0));
+        assertEquals(-1, LargestPrimeFinder.findBySieveOfEratosthenes(1));
+        assertEquals(-1, LargestPrimeFinder.findBySieveOfEratosthenes(2));
+    }
+
+    @Test
+    public void givenLargeInput_whenFindPrime_ThenFoundResult() {
+        assertEquals(99991, LargestPrimeFinder.findByBruteForce(100000));
+        assertEquals(99991, LargestPrimeFinder.findBySieveOfEratosthenes(100000));
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/stringrotation/StringRotationUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.stringrotation;
+
+import static com.baeldung.algorithms.stringrotation.StringRotation.doubledOriginContainsRotation;
+import static com.baeldung.algorithms.stringrotation.StringRotation.isRotationUsingCommonStartWithOrigin;
+import static com.baeldung.algorithms.stringrotation.StringRotation.isRotationUsingQueue;
+import static com.baeldung.algorithms.stringrotation.StringRotation.isRotationUsingSuffixAndPrefix;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class StringRotationUnitTest {
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckIfOriginContainsRotation_thenIsRotation() {
+        assertTrue(doubledOriginContainsRotation("abcd", "cdab"));
+        assertTrue(doubledOriginContainsRotation("abcd", "abcd"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckIfOriginContainsRotation_thenNoRotation() {
+        assertFalse(doubledOriginContainsRotation("abcd", "bbbb"));
+        assertFalse(doubledOriginContainsRotation("abcd", "abcde"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckingCommonStartWithOrigin_thenIsRotation() {
+        assertTrue(isRotationUsingCommonStartWithOrigin("abcd", "cdab"));
+        assertTrue(isRotationUsingCommonStartWithOrigin("abcd", "abcd"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckingCommonStartWithOrigin_thenNoRotation() {
+        assertFalse(isRotationUsingCommonStartWithOrigin("abcd", "bbbb"));
+        assertFalse(isRotationUsingCommonStartWithOrigin("abcd", "abcde"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckingUsingQueues_thenIsRotation() {
+        assertTrue(isRotationUsingQueue("abcd", "cdab"));
+        assertTrue(isRotationUsingQueue("abcd", "abcd"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckingUsingQueues_thenNoRotation() {
+        assertFalse(isRotationUsingQueue("abcd", "bbbb"));
+        assertFalse(isRotationUsingQueue("abcd", "abcde"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckingUsingSuffixAndPrefix_thenIsRotation() {
+        assertTrue(isRotationUsingSuffixAndPrefix("abcd", "cdab"));
+        assertTrue(isRotationUsingSuffixAndPrefix("abcd", "abcd"));
+    }
+
+    @Test
+    void givenOriginAndRotationInput_whenCheckingUsingSuffixAndPrefix_thenNoRotation() {
+        assertFalse(isRotationUsingSuffixAndPrefix("abcd", "bbbb"));
+        assertFalse(isRotationUsingSuffixAndPrefix("abcd", "abcde"));
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/weightedaverage/WeightedAverageUnitTest.java

@@ -0,0 +1,153 @@
+package com.baeldung.algorithms.weightedaverage;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class WeightedAverageUnitTest {
+
+    private List<Values> values = Arrays.asList(
+            new Values(1, 10),
+            new Values(3, 20),
+            new Values(5, 30),
+            new Values(7, 50),
+            new Values(9, 40)
+    );
+
+    private Double expected = 6.2;
+
+    @Test
+    void twoPass() {
+        double top = values.stream()
+                .mapToDouble(v -> v.value * v.weight)
+                .sum();
+        double bottom = values.stream()
+                .mapToDouble(v -> v.weight)
+                .sum();
+
+        double result = top / bottom;
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void onePass() {
+        double top = 0;
+        double bottom = 0;
+
+        for (Values v : values) {
+            top += (v.value * v.weight);
+            bottom += v.weight;
+        }
+
+        double result = top / bottom;
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void expanding() {
+        double result = values.stream()
+                .flatMap(v -> Collections.nCopies(v.weight, v.value).stream())
+                .mapToInt(v -> v)
+                .average()
+                .getAsDouble();
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void reduce() {
+        class WeightedAverage {
+            final double top;
+            final double bottom;
+
+            public WeightedAverage(double top, double bottom) {
+                this.top = top;
+                this.bottom = bottom;
+            }
+
+            double average() {
+                return top / bottom;
+            }
+        }
+
+        double result = values.stream()
+                .reduce(new WeightedAverage(0, 0),
+                        (acc, next) -> new WeightedAverage(
+                                acc.top + (next.value * next.weight),
+                                acc.bottom + next.weight),
+                        (left, right) -> new WeightedAverage(
+                                left.top + right.top,
+                                left.bottom + right.bottom))
+                .average();
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void customCollector() {
+        class WeightedAverage implements Collector<Values, WeightedAverage.RunningTotals, Double> {
+            class RunningTotals {
+                double top;
+                double bottom;
+
+                public RunningTotals() {
+                    this.top = 0;
+                    this.bottom = 0;
+                }
+            }
+
+            @Override
+            public Supplier<RunningTotals> supplier() {
+                return RunningTotals::new;
+            }
+
+            @Override
+            public BiConsumer<RunningTotals, Values> accumulator() {
+                return (current, next) -> {
+                    current.top += (next.value * next.weight);
+                    current.bottom += next.weight;
+                };
+            }
+
+            @Override
+            public BinaryOperator<RunningTotals> combiner() {
+                return (left, right) -> {
+                    left.top += right.top;
+                    left.bottom += right.bottom;
+
+                    return left;
+                };
+            }
+
+            @Override
+            public Function<RunningTotals, Double> finisher() {
+                return rt -> rt.top / rt.bottom;
+            }
+
+            @Override
+            public Set<Characteristics> characteristics() {
+                return Collections.singleton(Characteristics.UNORDERED);
+            }
+        }
+
+        double result = values.stream()
+                .collect(new WeightedAverage());
+        assertEquals(expected, result);
+    }
+
+    private static class Values {
+        int value;
+        int weight;
+
+        public Values(int value, int weight) {
+            this.value = value;
+            this.weight = weight;
+        }
+    }
+}

algorithms-modules/algorithms-searching/README.md

@@ -13,3 +13,4 @@ This module contains articles about searching algorithms.
 - [Range Search Algorithm in Java](https://www.baeldung.com/java-range-search)
 - [Fast Pattern Matching of Strings Using Suffix Tree in Java](https://www.baeldung.com/java-pattern-matching-suffix-tree)
 - [Find the Kth Smallest Element in Two Sorted Arrays in Java](https://www.baeldung.com/java-kth-smallest-element-in-sorted-arrays)
+- [Find the First Non-repeating Element of a List](https://www.baeldung.com/java-list-find-first-non-repeating-element)

algorithms-modules/algorithms-searching/src/main/java/com/baeldung/algorithms/firstnonrepeating/FirstNonRepeatingElement.java

@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.firstnonrepeating;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FirstNonRepeatingElement {
+    public static Integer findFirstNonRepeatingUsingForLoop(List<Integer> list) {
+        for (int i = 0; i < list.size(); i++) {
+            int current = list.get(i);
+            boolean isRepeating = false;
+            for (int j = 0; j < list.size(); j++) {
+                if (i != j && current == list.get(j)) {
+                    isRepeating = true;
+                    break;
+                }
+            }
+            if (!isRepeating) {
+                return current;
+            }
+        }
+        return null;
+    }
+
+    public static Integer findFirstNonRepeatedElementUsingIndex(List<Integer> list) {
+        for (int i = 0; i < list.size(); i++) {
+            if (list.indexOf(list.get(i)) == list.lastIndexOf(list.get(i))) {
+                return list.get(i);
+            }
+        }
+        return null;
+    }
+
+    public static Integer findFirstNonRepeatingUsingHashMap(List<Integer> list) {
+        Map<Integer, Integer> counts = new HashMap<>();
+        for (int num : list) {
+            counts.put(num, counts.getOrDefault(num, 0) + 1);
+        }
+        for (int num : list) {
+            if (counts.get(num) == 1) {
+                return num;
+            }
+        }
+        return null;
+    }
+
+    public static Integer findFirstNonRepeatingUsingArray(List<Integer> list) {
+        int maxElement = Collections.max(list);
+        int[] frequency = new int[maxElement + 1];
+        for (int num : list) {
+            frequency[num]++;
+        }
+        for (int num : list) {
+            if (frequency[num] == 1) {
+                return num;
+            }
+        }
+        return null;
+    }
+}

algorithms-modules/algorithms-searching/src/test/java/com/baeldung/algorithms/firstnonrepeating/FirstNonRepeatingElementUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.algorithms.firstnonrepeating;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class FirstNonRepeatingElementUnitTest {
+
+    private List<Integer> list;
+
+    @BeforeEach
+    void setUp() {
+        list = Arrays.asList(1, 2, 3, 2, 1, 4, 5, 4);
+    }
+
+    @Test
+    void whenUsingForLoop_thenReturnFirstNonRepeatingElement() {
+        int result = FirstNonRepeatingElement.findFirstNonRepeatingUsingForLoop(list);
+        assertEquals(3, result);
+    }
+
+    @Test
+    void whenUsingIndexOf_thenReturnFirstNonRepeatingElement() {
+        int result = FirstNonRepeatingElement.findFirstNonRepeatedElementUsingIndex(list);
+        assertEquals(3, result);
+    }
+
+    @Test
+    void whenUsingHashMap_thenReturnFirstNonRepeatingElement() {
+        int result = FirstNonRepeatingElement.findFirstNonRepeatingUsingHashMap(list);
+        assertEquals(3, result);
+    }
+
+    @Test
+    void whenUsingArray_thenReturnFirstNonRepeatingElement() {
+        int result = FirstNonRepeatingElement.findFirstNonRepeatingUsingArray(list);
+        assertEquals(3, result);
+    }
+}

apache-cxf-modules/cxf-aegis/pom.xml

@@ -20,8 +20,4 @@
         </dependency>
     </dependencies>
 
-    <properties>
-        <cxf.version>4.0.0</cxf.version>
-    </properties>
-
 </project>

apache-cxf-modules/cxf-introduction/pom.xml

@@ -48,7 +48,6 @@
     </build>
 
     <properties>
-        <cxf.version>4.0.0</cxf.version>
         <jakarta-xml.version>4.0.0</jakarta-xml.version>
         <jakarta.jws.version>3.0.0</jakarta.jws.version>
     </properties>

apache-cxf-modules/cxf-jaxrs-implementation/pom.xml

@@ -16,12 +16,12 @@
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-frontend-jaxrs</artifactId>
-            <version>4.0.0</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-transports-http-jetty</artifactId>
-            <version>4.0.0</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>jakarta.xml.ws</groupId>

apache-cxf-modules/cxf-spring/pom.xml

@@ -115,6 +115,7 @@
     </profiles>
 
     <properties>
+        <cxf.version>3.1.8</cxf.version>
         <spring.version>5.3.25</spring.version>
         <cargo-maven2-plugin.version>1.6.1</cargo-maven2-plugin.version>
         <jstl.version>1.2</jstl.version>

apache-cxf-modules/pom.xml

@@ -35,7 +35,7 @@
     </build>
 
     <properties>
-        <cxf.version>3.1.8</cxf.version>
+        <cxf.version>4.0.0</cxf.version>
     </properties>
 
 </project>

apache-cxf-modules/sse-jaxrs/sse-jaxrs-client/pom.xml

@@ -16,12 +16,12 @@
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-rs-client</artifactId>
-            <version>${cxf-version}</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-rs-sse</artifactId>
-            <version>${cxf-version}</version>
+            <version>${cxf.version}</version>
         </dependency>
         <dependency>
             <groupId>jakarta.ws.rs</groupId>
@@ -60,7 +60,6 @@
     </build>
 
     <properties>
-        <cxf-version>4.0.0</cxf-version>
         <jakarta-ws.version>3.1.0</jakarta-ws.version>
     </properties>
 

apache-libraries-2/README.md

@@ -1,2 +1,3 @@
 ## Relevant Articles
 - [Understanding XSLT Processing in Java](https://www.baeldung.com/java-extensible-stylesheet-language-transformations)
+- [Add Camel Route at Runtime in Java](https://www.baeldung.com/java-camel-dynamic-route)

apache-libraries-2/pom.xml

@@ -19,10 +19,29 @@
             <artifactId>validation-api</artifactId>
             <version>${javax.validation.validation-api.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-core</artifactId>
+            <version>${camel.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-test-junit5</artifactId>
+            <version>${camel.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-main</artifactId>
+            <version>${camel.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
         <javax.validation.validation-api.version>2.0.1.Final</javax.validation.validation-api.version>
+        <camel.version>4.3.0</camel.version>
     </properties>
 
 </project>

apache-libraries-2/src/main/java/com/baeldung/dynamicrouter/DynamicRouterBean.java

@@ -0,0 +1,29 @@
+package com.baeldung.dynamicrouter;
+
+import org.apache.camel.ExchangeProperties;
+
+import java.util.Map;
+
+public class DynamicRouterBean {
+    public String route(String body, @ExchangeProperties Map<String, Object> properties) {
+        int invoked = (int) properties.getOrDefault("invoked", 0) + 1;
+
+        properties.put("invoked", invoked);
+
+        if (invoked == 1) {
+            switch (body.toLowerCase()) {
+                case "mock":
+                    return "mock:dynamicRouter";
+                case "direct":
+                    return "mock:directDynamicRouter";
+                case "seda":
+                    return "mock:sedaDynamicRouter";
+                case "file":
+                    return "mock:fileDynamicRouter";
+                default:
+                    break;
+            }
+        }
+        return null;
+    }
+}

apache-libraries-2/src/main/java/com/baeldung/dynamicrouter/DynamicRouterRoute.java

@@ -0,0 +1,13 @@
+package com.baeldung.dynamicrouter;
+
+import org.apache.camel.builder.RouteBuilder;
+
+public class DynamicRouterRoute extends RouteBuilder {
+
+    @Override
+    public void configure() {
+
+        from("direct:dynamicRouter").dynamicRouter(method(DynamicRouterBean.class, "route"));
+
+    }
+}

apache-libraries-2/src/main/resources/logback.xml

@@ -10,4 +10,6 @@
     <root level="INFO">
         <appender-ref ref="STDOUT" />
     </root>
+
+    <logger name="org.apache.camel.impl.engine" level="WARN"/>
 </configuration>

apache-libraries-2/src/test/java/dynamicrouter/DynamicRouterRouteUnitTest.java

@@ -0,0 +1,61 @@
+package dynamicrouter;
+
+import com.baeldung.dynamicrouter.DynamicRouterRoute;
+import org.apache.camel.RoutesBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.test.junit5.CamelTestSupport;
+import org.junit.jupiter.api.Test;
+
+public class DynamicRouterRouteUnitTest extends CamelTestSupport {
+
+    @Override
+    protected RoutesBuilder createRouteBuilder() {
+        return new DynamicRouterRoute();
+    }
+
+    @Test
+    void givenDynamicRouter_whenMockEndpointExpectedMessageCountOneAndMockAsMessageBody_thenMessageSentToDynamicRouter() throws InterruptedException {
+
+        MockEndpoint mockDynamicEndpoint = getMockEndpoint("mock:dynamicRouter");
+        mockDynamicEndpoint.expectedMessageCount(1);
+
+        template.send("direct:dynamicRouter", exchange -> exchange.getIn()
+            .setBody("mock"));
+        MockEndpoint.assertIsSatisfied(context);
+    }
+
+    @Test
+    void givenDynamicRouter_whenMockEndpointExpectedMessageCountOneAndDirectAsMessageBody_thenMessageSentToDynamicRouter() throws InterruptedException {
+
+        MockEndpoint mockDynamicEndpoint = context.getEndpoint("mock:directDynamicRouter", MockEndpoint.class);
+        mockDynamicEndpoint.expectedMessageCount(1);
+
+        template.send("direct:dynamicRouter", exchange -> exchange.getIn()
+            .setBody("direct"));
+
+        MockEndpoint.assertIsSatisfied(context);
+    }
+
+    @Test
+    void givenDynamicRouter_whenMockEndpointExpectedMessageCountOneAndSedaAsMessageBody_thenMessageSentToDynamicRouter() throws InterruptedException {
+
+        MockEndpoint mockDynamicEndpoint = context.getEndpoint("mock:sedaDynamicRouter", MockEndpoint.class);
+        mockDynamicEndpoint.expectedMessageCount(1);
+
+        template.send("direct:dynamicRouter", exchange -> exchange.getIn()
+            .setBody("seda"));
+        MockEndpoint.assertIsSatisfied(context);
+    }
+
+    @Test
+    void givenDynamicRouter_whenMockEndpointExpectedMessageCountOneAndBookAsMessageBody_thenMessageSentToDynamicRouter() throws InterruptedException {
+
+        MockEndpoint mockDynamicEndpoint = getMockEndpoint("mock:fileDynamicRouter");
+        mockDynamicEndpoint.expectedMessageCount(1);
+
+        template.send("direct:dynamicRouter", exchange -> exchange.getIn()
+            .setBody("file"));
+        MockEndpoint.assertIsSatisfied(context);
+    }
+
+}

apache-libraries-2/src/test/resources/logback-test.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+    <logger name="ch.qos.logback.classic.joran.action" level="WARN"/>
+</configuration>

apache-libraries/pom.xml

@@ -191,7 +191,7 @@
         <bval.version>2.0.6</bval.version>
         <javax.validation.validation-api.version>2.0.1.Final</javax.validation.validation-api.version>
         <meecrowave-junit.version>1.2.15</meecrowave-junit.version>
-        <okhttp.version>4.12.0</okhttp.version>
+        <okhttp.version>5.0.0-alpha.12</okhttp.version>
         <meecrowave-jpa.version>1.2.15</meecrowave-jpa.version>
         <meecrowave-core.version>1.2.15</meecrowave-core.version>
         <meecrowave-maven-plugin.version>1.2.15</meecrowave-maven-plugin.version>

apache-poi-2/README.md

@@ -14,4 +14,4 @@ This module contains articles about Apache POI.
 - [Set the Date Format Using Apache POI](https://www.baeldung.com/java-apache-poi-date-format)
 - [Replacing Variables in a Document Template with Java](https://www.baeldung.com/java-replace-pattern-word-document-doc-docx)
 - [Lock Header Rows With Apache POI](https://www.baeldung.com/java-apache-poi-lock-header-rows)
-- More articles: [[<-- prev]](../apache-poi)
+- More articles: [[<-- prev]](../apache-poi)[[next -->]](../apache-poi-3)

apache-poi-2/pom.xml

@@ -27,7 +27,7 @@
     </dependencies>
 
     <properties>
-        <poi.version>5.2.3</poi.version>
+        <poi.version>5.2.5</poi.version>
     </properties>
 
 </project>

apache-poi-3/README.md

@@ -1,3 +1,10 @@
-## Relevant Articles
+## Apache POI
+
+This module contains articles about Apache POI.
+
+### Relevant Articles:
+
 - [How To Convert Excel Data Into List Of Java Objects](https://www.baeldung.com/java-convert-excel-data-into-list)
 - [Expand Columns with Apache POI](https://www.baeldung.com/java-apache-poi-expand-columns)
+- [Apply Bold Text Style for an Entire Row Using Apache POI](https://www.baeldung.com/appache-poi-apply-bold-text-style-entire-row)
+- More articles: [[<-- prev]](../apache-poi-2)

apache-poi-3/pom.xml

@@ -24,50 +24,41 @@
             <artifactId>poi-scratchpad</artifactId>
             <version>${poi.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/com.github.ozlerhakan/poiji -->
         <dependency>
             <groupId>com.github.ozlerhakan</groupId>
             <artifactId>poiji</artifactId>
             <version>${poiji.version}</version>
         </dependency>
-
-        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi/5.2.3 -->
         <dependency>
             <groupId>org.apache.poi</groupId>
             <artifactId>poi</artifactId>
             <version>${poi.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml-schemas/4.1.2 -->
         <dependency>
             <groupId>org.apache.poi</groupId>
             <artifactId>poi-ooxml-schemas</artifactId>
-            <version>4.1.2</version>
+            <version>${poi-ooxml-schemas.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/org.apache.xmlbeans/xmlbeans/5.1.1 -->
         <dependency>
             <groupId>org.apache.xmlbeans</groupId>
             <artifactId>xmlbeans</artifactId>
-            <version>5.1.1</version>
+            <version>${xmlbeans.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-collections4</artifactId>
-            <version>4.4</version>
+            <version>${commons-collections4.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/org.dhatim/fastexcel/0.15.7 -->
         <dependency>
             <groupId>org.dhatim</groupId>
             <artifactId>fastexcel</artifactId>
             <version>${fastexcel.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/org.dhatim/fastexcel-reader/0.15.7 -->
         <dependency>
             <groupId>org.dhatim</groupId>
             <artifactId>fastexcel-reader</artifactId>
             <version>${fastexcel.version}</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/net.sourceforge.jexcelapi/jxl/2.6.12 -->
         <dependency>
             <groupId>net.sourceforge.jexcelapi</groupId>
             <artifactId>jxl</artifactId>
@@ -77,8 +68,11 @@
 
     <properties>
         <poi.version>5.2.5</poi.version>
-        <poiji.version>4.1.1</poiji.version>
-        <fastexcel.version>0.15.7</fastexcel.version>
+        <poi-ooxml-schemas.version>4.1.2</poi-ooxml-schemas.version>
+        <poiji.version>4.2.0</poiji.version>
+        <xmlbeans.version>5.2.0</xmlbeans.version>
+        <commons-collections4.version>4.4</commons-collections4.version>
+        <fastexcel.version>0.17.0</fastexcel.version>
         <jxl.version>2.6.12</jxl.version>
     </properties>