Amazon web services – Java code to connect AWS Open Search(elastic Search) but getting error "The request signature we calculated does not match the signature provided

I am trying find a way to connect to AWS Open Search but I’m getting the following error:

{"message":"The request signature we calculated does not match the signature you provided.  
Check your AWS Secret Access Key and signing method. Consult the service documentation  
for details.nnThe Canonical String for this request should have beenn 
'GETn/_searchnq=testnhost:exmple.comnx-amz-date:20230609T084831Znx-amz-security-token:SecurtyToken  
host;x-amz-date;x-amz-security-tokenne3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'  
The String-to-Sign should have beenn'AWS4-HMAC-SHA256n20230609T084831Z 
20230609/us-east-1/es/aws4_requestn3dee35f26978096c8c4abe9fb6ebb8aad9fd05bd78e13b1f480595e0f3f9aab2'"}`

So can someone help me and here host: example.com(AWS OpenSeach endpoint)

What am I missing? Below is my Java code:

public class OpenSearchExampleCurl {
    private static final String ENDPOINT = "endpoint";

    public static void main(String[] args) throws InterruptedException
    {
        ProcessBuilder vProcessBuilder = null;
        Process vProcess = null;
        
        //YOUR_SIGNATURE refers to the actual signature value that you need to compute using the AWS Signature Version 4 algorithm(SigV4).
        //It is not the secret key itself.To generate the signature, you need to follow the steps outlined in the code example. The getSignatureKey method computes the signing key using your AWS Secret Key. Then, the hmacSHA256 method is used to calculate the actual signature by passing the signing key and the string to sign as parameters.
        //Replace YOUR_SIGNATURE with the computed signature value. The signature should be a hexadecimal representation of the binary signature.

        try {
             String accessKey = "youraccessKey";
             String secretKey = "secretKey";
             String sessionToken = "yoursessionToken";
             String region = "us-east-1";
             String serviceName = "es";
             String httpMethod = "POST";
             
             //String accessKey = getAccessKeyFromConfig();
             //String secretKey = getSecretKeyFromConfig();
             //String sessionToken = getSessionTokenFromConfig();
             
             //String path = "/your-bucket-name";

             //generate the AWS Signature using the AWS Signature Version 4 algorithm and pass it in the Authorization header of an . 
             // Generate timestamp and headers
             String timestamp = getTimestamp();
             String date = timestamp.substring(0, 8);
             String amzDate = getFormattedTimestamp();

             // Generate the canonical request
             String canonicalRequest = null;
             try {
                 canonicalRequest = httpMethod + "n" + "/" + "n" +"host:" + ENDPOINT.substring(8) + "n" +
                         "x-amz-date:" + amzDate + "n" + "x-amz-security-token:" + sessionToken + "n" +
                         "n" + "host;x-amz-date;x-amz-security-token" + "n" + getPayloadHash("");
             } catch (Exception e) {
                 e.printStackTrace();
             }

             // Generate the string to sign
             String stringToSign = null;
             try {
                 stringToSign = "AWS4-HMAC-SHA256n" + amzDate + "n" + date + "/" + region + "/" 
                             + serviceName + "/aws4_requestn" + getHash(canonicalRequest);
             } catch (Exception e) {
                 e.printStackTrace();
             }

             // Generate the signing key
             byte[] signingKey = null;
             try {
                 signingKey = getSignatureKey(secretKey, date, region, serviceName);
             } catch (Exception e) {
                 e.printStackTrace();
             }

             // Generate the signature
             String signature = null;
             try {
                 signature = bytesToHex(hmacSHA256(signingKey, stringToSign.getBytes(StandardCharsets.UTF_8)));
             } catch (Exception e) {
                 e.printStackTrace();
             }
             // Generate the Authorization header
             String authorizationHeader = "AWS4-HMAC-SHA256 Credential=" + accessKey +"/"+date+"/" +region + "/" +
                     serviceName + "/aws4_request, SignedHeaders=host;x-amz-date;x-amz-security-token, Signature=" + signature;
             System.out.println("authorizationHeader: " + authorizationHeader);
            
             vProcessBuilder = new ProcessBuilder(
                "curl",
                    "-X", "GET",
                    "-H", "Authorization:" + authorizationHeader,
                    "-H", "x-amz-date:" + amzDate,
                    "-H", "X-Amz-Security-Token:" + sessionToken,
                    "https://ENDPOINT/_search?q=test"//provide ENDPOINT, means OpenSearch Endpoint and test is a word to search
                );
             vProcessBuilder.redirectErrorStream(true);
             vProcess = vProcessBuilder.start();

             int exitCode1 = vProcess.exitValue();
             System.out.println("Exit Code: " + exitCode1);// if exitCode is 2 means having issue

             BufferedReader reader = new BufferedReader(new InputStreamReader(vProcess.getInputStream()));
             StringBuilder builder = new StringBuilder();
             String line = null;
             while ((line = reader.readLine()) != null)
             {
                  builder.append(line);
                  builder.append(System.getProperty("line.separator"));
             }
             String result = builder.toString();
             System.out.println(result);
             //ObjectMapper vMapper =  new ObjectMapper();
             //String vFinalResult = vMapper.writeValueAsString(result);
             //System.out.println(vFinalResult);
        } catch (IOException e) {
                e.printStackTrace();
        }
        finally
        {
            vProcess.destroy();
            vProcess = null;
        }
    }

    
    private static String getTimestamp()
    {
        // LocalDateTime class to get the current date and time.
        LocalDateTime currentDateTime = LocalDateTime.now();

        // Format the timestamp using the desired timestamp format
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        String formattedTimestamp = currentDateTime.format(formatter);

        // format the current timestamp using the format method of the LocalDateTime class and print the formatted timestamp
        System.out.println("Formatted Timestamp: " + formattedTimestamp);
        return formattedTimestamp;
    }

    private static String getPayloadHash(String payload) throws Exception
    {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(payload.getBytes(StandardCharsets.UTF_8));
        return bytesToHex(hash);
    }

    //the hmacSHA256 method is used to calculate the actual signature by passing the signing key and the string to sign as parameters.
    private static byte[] hmacSHA256(byte[] key, byte[] data) throws Exception
    {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec keySpec = new SecretKeySpec(key, "HmacSHA256");
        mac.init(keySpec);
        return mac.doFinal(data);
    }

    //The getSignatureKey method computes the signing key using your AWS Secret Key.
    private static byte[] getSignatureKey(String key, String date, String region, String service) throws Exception
    {
        byte[] kSecret = ("AWS4" + key).getBytes(StandardCharsets.UTF_8);
        byte[] kDate = hmacSHA256(kSecret, date.getBytes(StandardCharsets.UTF_8));
        byte[] kRegion = hmacSHA256(kDate, region.getBytes(StandardCharsets.UTF_8));
        byte[] kService = hmacSHA256(kRegion, service.getBytes(StandardCharsets.UTF_8));
        return hmacSHA256(kService, "aws4_request".getBytes(StandardCharsets.UTF_8));
    }

    private static String getHash(String text) throws Exception
    {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(text.getBytes(StandardCharsets.UTF_8));
        return bytesToHex(hash);
    }

    private static String bytesToHex(byte[] bytes)
    {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        return result.toString();
    }
    
    private static String getFormattedTimestamp() {
        //LocalDateTime currentDateTime = LocalDateTime.now();
       // DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'");
        //String formattedTimestamp = currentDateTime.format(formatter);
        // format the current timestamp using the format method of the LocalDateTime class and print the formatted timestamp
        ZonedDateTime utcDateTime = ZonedDateTime.now(ZoneOffset.UTC);
        String awsTimestamp = utcDateTime.format(DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'"));
        System.out.println("Formatted Timestamp: " + awsTimestamp);
        return awsTimestamp;
    }
    
    
}