Merge remote-tracking branch 'upstream/master'

algorithms-modules/algorithms-miscellaneous-7/src/main/java/com/baeldung/algorithms/latlondistance/EquirectangularApproximation.java

@@ -0,0 +1,19 @@
+package com.baeldung.algorithms.latlondistance;
+
+public class EquirectangularApproximation {
+
+    private static final int EARTH_RADIUS = 6371; // Approx Earth radius in KM
+
+    public static double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
+        double lat1Rad = Math.toRadians(lat1);
+        double lat2Rad = Math.toRadians(lat2);
+        double lon1Rad = Math.toRadians(lon1);
+        double lon2Rad = Math.toRadians(lon2);
+
+        double x = (lon2Rad - lon1Rad) * Math.cos((lat1Rad + lat2Rad) / 2);
+        double y = (lat2Rad - lat1Rad);
+        double distance = Math.sqrt(x * x + y * y) * EARTH_RADIUS;
+
+        return distance;
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/main/java/com/baeldung/algorithms/latlondistance/HaversineDistance.java

@@ -0,0 +1,24 @@
+package com.baeldung.algorithms.latlondistance;
+
+public class HaversineDistance {
+    private static final int EARTH_RADIUS = 6371; // Approx Earth radius in KM
+
+    public static double calculateDistance(double startLat, double startLong,
+                                           double endLat, double endLong) {
+
+        double dLat = Math.toRadians((endLat - startLat));
+        double dLong = Math.toRadians((endLong - startLong));
+
+        startLat = Math.toRadians(startLat);
+        endLat = Math.toRadians(endLat);
+
+        double a = haversine(dLat) + Math.cos(startLat) * Math.cos(endLat) * haversine(dLong);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        return EARTH_RADIUS * c;
+    }
+
+    public static double haversine(double val) {
+        return Math.pow(Math.sin(val / 2), 2);
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/main/java/com/baeldung/algorithms/latlondistance/VincentyDistance.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.latlondistance;
+
+public class VincentyDistance {
+
+    // Constants for WGS84 ellipsoid model of Earth
+    private static final double SEMI_MAJOR_AXIS_MT = 6378137;
+    private static final double SEMI_MINOR_AXIS_MT = 6356752.314245;
+    private static final double FLATTENING = 1 / 298.257223563;
+    private static final double ERROR_TOLERANCE = 1e-12;
+
+    public static double calculateDistance(double latitude1, double longitude1, double latitude2, double longitude2) {
+        double U1 = Math.atan((1 - FLATTENING) * Math.tan(Math.toRadians(latitude1)));
+        double U2 = Math.atan((1 - FLATTENING) * Math.tan(Math.toRadians(latitude2)));
+
+        double sinU1 = Math.sin(U1);
+        double cosU1 = Math.cos(U1);
+        double sinU2 = Math.sin(U2);
+        double cosU2 = Math.cos(U2);
+
+        double longitudeDifference = Math.toRadians(longitude2 - longitude1);
+        double previousLongitudeDifference;
+
+        double sinSigma, cosSigma, sigma, sinAlpha, cosSqAlpha, cos2SigmaM;
+
+        do {
+            sinSigma = Math.sqrt(Math.pow(cosU2 * Math.sin(longitudeDifference), 2) +
+                    Math.pow(cosU1 * sinU2 - sinU1 * cosU2 * Math.cos(longitudeDifference), 2));
+            cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * Math.cos(longitudeDifference);
+            sigma = Math.atan2(sinSigma, cosSigma);
+            sinAlpha = cosU1 * cosU2 * Math.sin(longitudeDifference) / sinSigma;
+            cosSqAlpha = 1 - Math.pow(sinAlpha, 2);
+            cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha;
+            if (Double.isNaN(cos2SigmaM)) {
+                cos2SigmaM = 0;
+            }
+            previousLongitudeDifference = longitudeDifference;
+            double C = FLATTENING / 16 * cosSqAlpha * (4 + FLATTENING * (4 - 3 * cosSqAlpha));
+            longitudeDifference = Math.toRadians(longitude2 - longitude1) + (1 - C) * FLATTENING * sinAlpha *
+                    (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * Math.pow(cos2SigmaM, 2))));
+        } while (Math.abs(longitudeDifference - previousLongitudeDifference) > ERROR_TOLERANCE);
+
+        double uSq = cosSqAlpha * (Math.pow(SEMI_MAJOR_AXIS_MT, 2) - Math.pow(SEMI_MINOR_AXIS_MT, 2)) / Math.pow(SEMI_MINOR_AXIS_MT, 2);
+
+        double A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+        double B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+
+        double deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * Math.pow(cos2SigmaM, 2)) -
+                B / 6 * cos2SigmaM * (-3 + 4 * Math.pow(sinSigma, 2)) * (-3 + 4 * Math.pow(cos2SigmaM, 2))));
+
+        double distanceMt = SEMI_MINOR_AXIS_MT * A * (sigma - deltaSigma);
+        return distanceMt / 1000;
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/latlondistance/GeoDistanceUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.latlondistance;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GeoDistanceUnitTest {
+    @Test
+    public void testCalculateDistance() {
+        double lat1 = 40.714268; // New York
+        double lon1 = -74.005974;
+        double lat2 = 34.0522; // Los Angeles
+        double lon2 = -118.2437;
+
+        double equirectangularDistance = EquirectangularApproximation.calculateDistance(lat1, lon1, lat2, lon2);
+        double haversineDistance = HaversineDistance.calculateDistance(lat1, lon1, lat2, lon2);
+        double vincentyDistance = VincentyDistance.calculateDistance(lat1, lon1, lat2, lon2);
+
+        double expectedDistance = 3944;
+        assertTrue(Math.abs(equirectangularDistance - expectedDistance) < 100);
+        assertTrue(Math.abs(haversineDistance - expectedDistance) < 10);
+        assertTrue(Math.abs(vincentyDistance - expectedDistance) < 0.5);
+
+    }
+
+}

apache-httpclient-2/src/main/java/com/baeldung/tlsversion/ClientTlsVersionExamples.java

@@ -1,36 +1,43 @@
 package com.baeldung.tlsversion;
 
-import javax.net.ssl.SSLSocket;
-
-import org.apache.http.HttpEntity;
-import org.apache.http.client.methods.CloseableHttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.ssl.SSLContexts;
-import org.apache.http.util.EntityUtils;
-
 import java.io.IOException;
 
+import javax.net.ssl.SSLSocket;
+
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.config.TlsConfig;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
+import org.apache.hc.client5.http.io.HttpClientConnectionManager;
+import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
+import org.apache.hc.core5.http.HttpEntity;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.core5.http.ssl.TLS;
+import org.apache.hc.core5.ssl.SSLContexts;
+import org.apache.hc.core5.util.Timeout;
+
 public class ClientTlsVersionExamples {
-
     public static CloseableHttpClient setViaSocketFactory() {
-        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
-          SSLContexts.createDefault(),
-          new String[] { "TLSv1.2", "TLSv1.3" },
-          null,
-          SSLConnectionSocketFactory.getDefaultHostnameVerifier());
+        final HttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create()
+            .setDefaultTlsConfig(TlsConfig.custom()
+                .setHandshakeTimeout(Timeout.ofSeconds(30))
+                .setSupportedProtocols(TLS.V_1_2, TLS.V_1_3)
+                .build())
+            .build();
 
-        return HttpClients.custom().setSSLSocketFactory(sslsf).build();
+        return HttpClients.custom()
+            .setConnectionManager(cm)
+            .build();
     }
 
     public static CloseableHttpClient setTlsVersionPerConnection() {
         SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(SSLContexts.createDefault()) {
-
             @Override
             protected void prepareSocket(SSLSocket socket) {
-                String hostname = socket.getInetAddress().getHostName();
+                String hostname = socket.getInetAddress()
+                    .getHostName();
                 if (hostname.endsWith("internal.system.com")) {
                     socket.setEnabledProtocols(new String[] { "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3" });
                 } else {
@@ -39,7 +46,14 @@ public class ClientTlsVersionExamples {
             }
         };
 
-        return HttpClients.custom().setSSLSocketFactory(sslsf).build();
+        HttpClientConnectionManager connManager = PoolingHttpClientConnectionManagerBuilder.create()
+            .setSSLSocketFactory(sslsf)
+            .build();
+
+        return HttpClients.custom()
+            .setConnectionManager(connManager)
+            .build();
+
     }
 
     // To configure the TLS versions for the client, set the https.protocols system property during runtime.
@@ -47,15 +61,11 @@ public class ClientTlsVersionExamples {
     public static CloseableHttpClient setViaSystemProperties() {
         return HttpClients.createSystem();
         // Alternatively:
-        // return HttpClients.custom().useSystemProperties().build();
+        //return HttpClients.custom().useSystemProperties().build();
     }
 
     public static void main(String[] args) throws IOException {
-        // Alternatively:
-        // CloseableHttpClient httpClient = setTlsVersionPerConnection();
-        // CloseableHttpClient httpClient = setViaSystemProperties();
-        try (CloseableHttpClient httpClient = setViaSocketFactory();
-           CloseableHttpResponse response = httpClient.execute(new HttpGet("https://httpbin.org/"))) {
+        try (CloseableHttpClient httpClient = setViaSocketFactory(); CloseableHttpResponse response = httpClient.execute(new HttpGet("https://httpbin.org/"))) {
 
             HttpEntity entity = response.getEntity();
             EntityUtils.consume(entity);

apache-httpclient/src/test/java/com/baeldung/httpclient/conn/MultiHttpClientConnThread.java

@@ -2,12 +2,12 @@ package com.baeldung.httpclient.conn;
 
 import java.io.IOException;
 
-import org.apache.http.HttpResponse;
-import org.apache.http.client.ClientProtocolException;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
-import org.apache.http.util.EntityUtils;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
+import org.apache.hc.core5.http.HttpEntity;
+import org.apache.hc.core5.http.HttpResponse;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -45,22 +45,21 @@ public class MultiHttpClientConnThread extends Thread {
         try {
             logger.debug("Thread Running: " + getName());
 
-            logger.debug("Thread Running: " + getName());
 
             if (connManager != null) {
                 logger.info("Before - Leased Connections = " + connManager.getTotalStats().getLeased());
                 logger.info("Before - Available Connections = " + connManager.getTotalStats().getAvailable());
             }
 
-            final HttpResponse response = client.execute(get);
+            HttpEntity entity = client.execute(get).getEntity();
 
             if (connManager != null) {
                 leasedConn = connManager.getTotalStats().getLeased();
                 logger.info("After - Leased Connections = " + connManager.getTotalStats().getLeased());
                 logger.info("After - Available Connections = " + connManager.getTotalStats().getAvailable());
             }
+            EntityUtils.consume(entity);
 
-            EntityUtils.consume(response.getEntity());
         } catch (final IOException ex) {
             logger.error("", ex);
         }

apache-httpclient/src/test/java/com/baeldung/httpclient/conn/TesterVersion_MultiHttpClientConnThread.java

@@ -2,10 +2,9 @@ package com.baeldung.httpclient.conn;
 
 import java.io.IOException;
 
-import org.apache.http.client.ClientProtocolException;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

apache-httpclient4/src/main/java/com/baeldung/tlsversion/ClientTlsVersionExamples.java

@@ -0,0 +1,64 @@
+package com.baeldung.tlsversion;
+
+import javax.net.ssl.SSLSocket;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.ssl.SSLContexts;
+import org.apache.http.util.EntityUtils;
+
+import java.io.IOException;
+
+public class ClientTlsVersionExamples {
+
+    public static CloseableHttpClient setViaSocketFactory() {
+        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
+          SSLContexts.createDefault(),
+          new String[] { "TLSv1.2", "TLSv1.3" },
+          null,
+          SSLConnectionSocketFactory.getDefaultHostnameVerifier());
+
+        return HttpClients.custom().setSSLSocketFactory(sslsf).build();
+    }
+
+    public static CloseableHttpClient setTlsVersionPerConnection() {
+        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(SSLContexts.createDefault()) {
+
+            @Override
+            protected void prepareSocket(SSLSocket socket) {
+                String hostname = socket.getInetAddress().getHostName();
+                if (hostname.endsWith("internal.system.com")) {
+                    socket.setEnabledProtocols(new String[] { "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3" });
+                } else {
+                    socket.setEnabledProtocols(new String[] { "TLSv1.3" });
+                }
+            }
+        };
+
+        return HttpClients.custom().setSSLSocketFactory(sslsf).build();
+    }
+
+    // To configure the TLS versions for the client, set the https.protocols system property during runtime.
+    // For example: java -Dhttps.protocols=TLSv1.1,TLSv1.2,TLSv1.3 -jar webClient.jar
+    public static CloseableHttpClient setViaSystemProperties() {
+        return HttpClients.createSystem();
+        // Alternatively:
+        // return HttpClients.custom().useSystemProperties().build();
+    }
+
+    public static void main(String[] args) throws IOException {
+        // Alternatively:
+        // CloseableHttpClient httpClient = setTlsVersionPerConnection();
+        // CloseableHttpClient httpClient = setViaSystemProperties();
+        try (CloseableHttpClient httpClient = setViaSocketFactory();
+           CloseableHttpResponse response = httpClient.execute(new HttpGet("https://httpbin.org/"))) {
+
+            HttpEntity entity = response.getEntity();
+            EntityUtils.consume(entity);
+        }
+    }
+}

apache-httpclient4/src/test/java/com/baeldung/httpclient/httpclient/conn/IdleConnectionMonitorThread.java

@@ -0,0 +1,41 @@
+package com.baeldung.httpclient.httpclient.conn;
+
+import java.util.concurrent.TimeUnit;
+
+import org.apache.http.conn.HttpClientConnectionManager;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+
+public class IdleConnectionMonitorThread extends Thread {
+    private final HttpClientConnectionManager connMgr;
+    private volatile boolean shutdown;
+
+    IdleConnectionMonitorThread(final PoolingHttpClientConnectionManager connMgr) {
+        super();
+        this.connMgr = connMgr;
+    }
+
+    // API
+
+    @Override
+    public final void run() {
+        try {
+            while (!shutdown) {
+                synchronized (this) {
+                    wait(1000);
+                    connMgr.closeExpiredConnections();
+                    connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
+                }
+            }
+        } catch (final InterruptedException ex) {
+            shutdown();
+        }
+    }
+
+    private void shutdown() {
+        shutdown = true;
+        synchronized (this) {
+            notifyAll();
+        }
+    }
+
+}

apache-httpclient4/src/test/java/com/baeldung/httpclient/httpclient/conn/MultiHttpClientConnThread.java

@@ -0,0 +1,69 @@
+package com.baeldung.httpclient.httpclient.conn;
+
+import java.io.IOException;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MultiHttpClientConnThread extends Thread {
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final CloseableHttpClient client;
+    private final HttpGet get;
+
+    private PoolingHttpClientConnectionManager connManager;
+    private int leasedConn;
+
+    MultiHttpClientConnThread(final CloseableHttpClient client, final HttpGet get, final PoolingHttpClientConnectionManager connManager) {
+        this.client = client;
+        this.get = get;
+        this.connManager = connManager;
+        leasedConn = 0;
+    }
+
+    MultiHttpClientConnThread(final CloseableHttpClient client, final HttpGet get) {
+        this.client = client;
+        this.get = get;
+    }
+
+    // API
+
+    final int getLeasedConn() {
+        return leasedConn;
+    }
+
+    //
+
+    @Override
+    public final void run() {
+        try {
+            logger.debug("Thread Running: " + getName());
+
+            logger.debug("Thread Running: " + getName());
+
+            if (connManager != null) {
+                logger.info("Before - Leased Connections = " + connManager.getTotalStats().getLeased());
+                logger.info("Before - Available Connections = " + connManager.getTotalStats().getAvailable());
+            }
+
+            final HttpResponse response = client.execute(get);
+
+            if (connManager != null) {
+                leasedConn = connManager.getTotalStats().getLeased();
+                logger.info("After - Leased Connections = " + connManager.getTotalStats().getLeased());
+                logger.info("After - Available Connections = " + connManager.getTotalStats().getAvailable());
+            }
+
+            EntityUtils.consume(response.getEntity());
+        } catch (final IOException ex) {
+            logger.error("", ex);
+        }
+    }
+
+}

apache-httpclient4/src/test/java/com/baeldung/httpclient/httpclient/conn/TesterVersion_MultiHttpClientConnThread.java

@@ -0,0 +1,46 @@
+package com.baeldung.httpclient.httpclient.conn;
+
+import java.io.IOException;
+
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+
+public class TesterVersion_MultiHttpClientConnThread extends Thread {
+    private final Logger logger = LoggerFactory.getLogger(getClass());
+
+    private final CloseableHttpClient client;
+    private final HttpGet get;
+    private PoolingHttpClientConnectionManager connManager;
+
+    TesterVersion_MultiHttpClientConnThread(final CloseableHttpClient client, final HttpGet get, final PoolingHttpClientConnectionManager connManager) {
+        this.client = client;
+        this.get = get;
+        this.connManager = Preconditions.checkNotNull(connManager);
+    }
+
+    //
+
+    @Override
+    public final void run() {
+        try {
+            logger.debug("Thread Running: " + getName());
+
+            logger.info("Before - Leased Connections = " + connManager.getTotalStats().getLeased());
+            logger.info("Before - Available Connections = " + connManager.getTotalStats().getAvailable());
+
+            client.execute(get);
+
+            logger.info("After - Leased Connections = " + connManager.getTotalStats().getLeased());
+            logger.info("After - Available Connections = " + connManager.getTotalStats().getAvailable());
+        } catch (final IOException ex) {
+            logger.error("", ex);
+        }
+    }
+
+}

apache-kafka-2/README.md

@@ -12,3 +12,4 @@ You can build the project from the command line using: *mvn clean install*, or i
 - [Is a Key Required as Part of Sending Messages to Kafka?](https://www.baeldung.com/java-kafka-message-key)
 - [Read Data From the Beginning Using Kafka Consumer API](https://www.baeldung.com/java-kafka-consumer-api-read)
 - [Get Partition Count for a Topic in Kafka](https://www.baeldung.com/java-kafka-partition-count-topic)
+- [bootstrap-server in Kafka Configuration](https://www.baeldung.com/java-kafka-bootstrap-server)

apache-poi-2/README.md

@@ -13,4 +13,5 @@ This module contains articles about Apache POI.
 - [Setting Formulas in Excel with Apache POI](https://www.baeldung.com/java-apache-poi-set-formulas)
 - [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)

aws-modules/aws-s3-update-object/pom.xml

@@ -2,26 +2,21 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.1.2</version>
-        <relativePath/> <!-- lookup parent from repository -->
-    </parent>
-    <groupId>com.baeldung</groupId>
     <artifactId>aws-s3-update-object</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <name>aws-s3-update-object</name>
     <description>Project demonstrating overwriting of S3 objects</description>
-    <properties>
-        <java.version>17</java.version>
-    </properties>
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-boot-2</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-boot-2</relativePath>
+    </parent>
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
-
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
@@ -30,10 +25,9 @@
         <dependency>
             <groupId>com.amazonaws</groupId>
             <artifactId>aws-java-sdk</artifactId>
-            <version>1.12.523</version>
+            <version>${aws-java-sdk-version}</version>
         </dependency>
     </dependencies>
-
     <build>
         <plugins>
             <plugin>
@@ -42,5 +36,7 @@
             </plugin>
         </plugins>
     </build>
-
+    <properties>
+        <aws-java-sdk-version>1.12.523</aws-java-sdk-version>
+    </properties>
 </project>

aws-modules/aws-s3-update-object/src/main/java/com/baeldung/awss3updateobject/service/FileService.java

@@ -7,13 +7,13 @@ import com.amazonaws.regions.Regions;
 import com.amazonaws.services.s3.AmazonS3;
 import com.amazonaws.services.s3.AmazonS3ClientBuilder;
 import com.amazonaws.services.s3.model.*;
-import jakarta.annotation.PostConstruct;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
+import javax.annotation.PostConstruct;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;

aws-modules/aws-s3-update-object/src/test/java/com/baeldung/awss3updateobject/controller/FileControllerUnitTest.java

@@ -11,6 +11,7 @@ import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 import org.springframework.web.multipart.MultipartFile;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.*;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@@ -34,28 +35,28 @@ public class FileControllerUnitTest {
 
     @Test
     public void givenValidMultipartFile_whenUploadedViaEndpoint_thenCorrectPathIsReturned() throws Exception {
-        MockMultipartFile multipartFile = new MockMultipartFile("multipartFile", "test.txt",
-                "text/plain", "test data".getBytes());
+        MockMultipartFile multipartFile = new MockMultipartFile("file", "test.txt", "text/plain", "sample file content".getBytes());
+        String expectedResult = "File Uploaded Successfully";
 
-        when(fileService.uploadFile(any(MultipartFile.class))).thenReturn("/documents/test.txt");
+        when(fileService.uploadFile(multipartFile)).thenReturn(expectedResult);
 
-        mockMvc.perform(multipart("/file/upload").file(multipartFile))
+        mockMvc.perform(multipart("/api/v1/file/upload").file(multipartFile))
                 .andExpect(status().isOk())
-                .andExpect(content().string("/documents/test.txt"));
+                .andExpect(content().string(expectedResult));
     }
 
     @Test
     public void givenValidMultipartFileAndExistingPath_whenUpdatedViaEndpoint_thenSamePathIsReturned() throws Exception {
-        MockMultipartFile multipartFile = new MockMultipartFile("multipartFile", "test.txt",
-                "text/plain", "test update data".getBytes());
-        String existingFilePath = "/documents/existingFile.txt";
+        MockMultipartFile multipartFile = new MockMultipartFile("file", "test.txt", "text/plain", "updated file content".getBytes());
+        String filePath = "some/path/to/file";
+        String expectedResult = "File Updated Successfully";
 
-        when(fileService.updateFile(any(MultipartFile.class), eq(existingFilePath))).thenReturn(existingFilePath);
+        when(fileService.updateFile(multipartFile, filePath)).thenReturn(expectedResult);
 
-        mockMvc.perform(multipart("/file/update")
+        mockMvc.perform(multipart("/api/v1/file/update")
                         .file(multipartFile)
-                        .param("exitingFilePath", existingFilePath))
+                        .param("filePath", filePath))
                 .andExpect(status().isOk())
-                .andExpect(content().string(existingFilePath));
+                .andExpect(content().string(expectedResult));
     }
 }

aws-modules/aws-s3-update-object/src/test/java/com/baeldung/awss3updateobject/service/FileServiceUnitTest.java

@@ -41,6 +41,7 @@ public class FileServiceUnitTest {
     @Test
     public void givenValidFile_whenUploaded_thenKeyMatchesDocumentPath() throws Exception {
         when(multipartFile.getName()).thenReturn("testFile");
+        when(multipartFile.getOriginalFilename()).thenReturn("testFile");
         when(multipartFile.getContentType()).thenReturn("application/pdf");
         when(multipartFile.getSize()).thenReturn(1024L);
         when(multipartFile.getInputStream()).thenReturn(mock(InputStream.class));
@@ -57,6 +58,7 @@ public class FileServiceUnitTest {
     @Test
     public void givenValidFile_whenUploadFailsDueToNoBucket_thenExceptionIsThrown() throws Exception {
         when(multipartFile.getName()).thenReturn("testFile");
+        when(multipartFile.getOriginalFilename()).thenReturn("testFile");
         when(multipartFile.getContentType()).thenReturn("application/pdf");
         when(multipartFile.getSize()).thenReturn(1024L);
         when(multipartFile.getInputStream()).thenReturn(mock(InputStream.class));

aws-modules/pom.xml

@@ -19,6 +19,7 @@
         <module>aws-miscellaneous</module>
         <module>aws-reactive</module>
         <module>aws-s3</module>
+        <module>aws-s3-update-object</module>
     </modules>
 
     <properties>

core-java-modules/core-java-arrays-convert/README.md

@@ -9,3 +9,4 @@ This module contains articles about arrays conversion in Java
 - [Converting a String Array Into an int Array in Java](https://www.baeldung.com/java-convert-string-array-to-int-array)
 - [Convert Java Array to Iterable](https://www.baeldung.com/java-array-convert-to-iterable)
 - [Converting an int[] to HashSet in Java](https://www.baeldung.com/java-converting-int-array-to-hashset)
+- [Convert an ArrayList of String to a String Array in Java](https://www.baeldung.com/java-convert-string-arraylist-array)

core-java-modules/core-java-collections-conversions-2/README.md

@@ -12,4 +12,5 @@ This module contains articles about conversions among Collection types and array
 - [Convert a List of Integers to a List of Strings](https://www.baeldung.com/java-convert-list-integers-to-list-strings)
 - [Combining Two Lists Into a Map in Java](https://www.baeldung.com/java-combine-two-lists-into-map)
 - [Convert a List of Strings to a List of Integers](https://www.baeldung.com/java-convert-list-strings-to-integers)
+- [Convert List to Long[] Array in Java](https://www.baeldung.com/java-convert-list-object-to-long-array)
 - More articles: [[<-- prev]](../core-java-collections-conversions)

core-java-modules/core-java-collections-maps-6/README.md

@@ -8,3 +8,4 @@
 - [How to Modify a Key in a HashMap?](https://www.baeldung.com/java-hashmap-modify-key)
 - [Converting String or String Array to Map in Java](https://www.baeldung.com/java-convert-string-to-map)
 - [Remove Duplicate Values From HashMap in Java](https://www.baeldung.com/java-hashmap-delete-duplicates)
+- [Sorting Java Map in Descending Order](https://www.baeldung.com/java-sort-map-descending)

core-java-modules/core-java-conditionals/README.md

@@ -3,3 +3,4 @@
 This module contains articles about Java Conditionals.
 
 ### Relevant articles:
+- [Guide to the yield Keyword in Java](https://www.baeldung.com/java-yield-switch)

core-java-modules/core-java-datetime-conversion/README.md

@@ -8,3 +8,4 @@ This module contains articles about converting between Java date and time object
 - [Convert Date to LocalDate or LocalDateTime and Back](http://www.baeldung.com/java-date-to-localdate-and-localdatetime)
 - [Convert Between java.time.Instant and java.sql.Timestamp](https://www.baeldung.com/java-time-instant-to-java-sql-timestamp)
 - [Convert Between LocalDateTime and ZonedDateTime](https://www.baeldung.com/java-localdatetime-zoneddatetime)
+- [Conversion From 12-Hour Time to 24-Hour Time in Java](https://www.baeldung.com/java-convert-time-format)

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/socketexception/SslServer.java

@@ -0,0 +1,32 @@
+package com.baeldung.socketexception;
+
+import java.io.IOException;
+
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+
+public class SslServer {
+
+    public static void createSSLSocketWithEnabledProtocols(SSLServerSocketFactory socketFactory, int port, String[] enabledProtocols) {
+        SSLServerSocket serverSocket = null;
+
+        try {
+            serverSocket = (SSLServerSocket) socketFactory.createServerSocket(port);
+            // Set the enabled protocols
+            serverSocket.setEnabledProtocols(enabledProtocols);
+            System.out.println("Server is running on port " + port);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (serverSocket != null) {
+                try {
+                    serverSocket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+}

core-java-modules/core-java-exceptions-2/src/test/java/com/baeldung/socketexception/SocketExceptionHandlingUnitTest.java

@@ -1,25 +1,33 @@
 package com.baeldung.socketexception;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 import java.io.IOException;
 import java.net.SocketException;
 import java.util.concurrent.Executors;
 
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 public class SocketExceptionHandlingUnitTest {
+    private static final int PORT = 6699;
 
     @BeforeClass
     public static void runServer() throws IOException, InterruptedException {
         Executors.newSingleThreadExecutor()
-            .submit(() -> new SocketServer().start(6699));
+          .submit(() -> new SocketServer().start(PORT));
         Thread.sleep(100);
     }
 
     @Test
     public void givenRunningServer_whenConnectToClosedSocket_thenHandleException() throws IOException {
         SocketClient client = new SocketClient();
-        client.startConnection("127.0.0.1", 6699);
+        client.startConnection("127.0.0.1", PORT);
         try {
             client.sendMessage("hi");
             client.sendMessage("hi again");
@@ -28,4 +36,22 @@ public class SocketExceptionHandlingUnitTest {
         }
     }
 
+    @Test
+    public void givenRunningServer_whenConnectToSocket_thenHandleConnectionResetException() throws IOException {
+        // Enable multiple SSL/TLS protocols
+        String[] enabledProtocols = { "TLSv1.2", "TLSv1.3", "TLSv1.1", "TLSv1", "SSLv3", "SSLv3" };
+        SSLServerSocketFactory mockFactory = mock(SSLServerSocketFactory.class);
+        SSLServerSocket mockServerSocket = mock(SSLServerSocket.class);
+
+        // Set up the mock factory to return the mock server socket
+        when(mockFactory.createServerSocket(PORT)).thenReturn(mockServerSocket);
+
+        // Call the method being tested
+        SslServer.createSSLSocketWithEnabledProtocols(mockFactory, PORT, enabledProtocols);
+
+        // Verify that setEnabledProtocols and close were called
+        verify(mockServerSocket).setEnabledProtocols(enabledProtocols);
+        verify(mockServerSocket).close();
+    }
+
 }

core-java-modules/core-java-lang-6/src/main/java/com/baeldung/randominset/RandomInSetUtil.java

@@ -0,0 +1,50 @@
+package com.baeldung.randominset;
+
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class RandomInSetUtil {
+
+    public static <T> T getByRandomClass(Set<T> set) {
+        if (set == null || set.isEmpty()) {
+            throw new IllegalArgumentException("The Set cannot be empty.");
+        }
+        int randomIndex = new Random().nextInt(set.size());
+        int i = 0;
+        for (T element : set) {
+            if (i == randomIndex) {
+                return element;
+            }
+            i++;
+        }
+        throw new IllegalStateException("Something went wrong while picking a random element.");
+    }
+
+    public static <T> T getByThreadLocalRandom(Set<T> set) {
+        if (set == null || set.isEmpty()) {
+            throw new IllegalArgumentException("The Set cannot be empty.");
+        }
+        int randomIndex = ThreadLocalRandom.current().nextInt(set.size());
+        int i = 0;
+        for (T element : set) {
+            if (i == randomIndex) {
+                return element;
+            }
+            i++;
+        }
+        throw new IllegalStateException("Something went wrong while picking a random element.");
+    }
+
+    public static void main(String[] args) {
+        Set<String> animals = new HashSet<>();
+        animals.add("Lion");
+        animals.add("Elephant");
+        animals.add("Giraffe");
+
+        String randomAnimal = getByThreadLocalRandom(animals);
+        System.out.println("Randomly picked animal: " + randomAnimal);
+    }
+
+}

core-java-modules/core-java-lang-math-3/src/test/java/com/baeldung/magicsquare/README.md

@@ -0,0 +1,2 @@
+## Relevant Articles
+- [Creating a Magic Square in Java](https://www.baeldung.com/java-magic-square)

core-java-modules/core-java-lang-oop-generics/README.md

@@ -9,3 +9,4 @@ This module contains articles about generics in Java
 - [Super Type Tokens in Java Generics](https://www.baeldung.com/java-super-type-tokens)
 - [Java Warning “unchecked conversion”](https://www.baeldung.com/java-unchecked-conversion)
 - [Java Warning “Unchecked Cast”](https://www.baeldung.com/java-warning-unchecked-cast)
+- [What Does the Holder<T> Class Do in Java?](https://www.baeldung.com/java-holder-class)