Code review comment: We need to close the FileInputStream once we done use it.

Code under review:
private static SSLContext getSSLContext(MapValue secureSocket) {
        final String CERT_PASS = "password";
        final String CERT_PATH = "path";
        try {
            MapValue cryptoKeyStore = secureSocket.getMapValue(RabbitMQConstants.RABBITMQ_CONNECTION_KEYSTORE);
            MapValue cryptoTrustStore = secureSocket.getMapValue(RabbitMQConstants.RABBITMQ_CONNECTION_TRUSTORE);

            char[] keyPassphrase = cryptoKeyStore.getStringValue(CERT_PASS).toCharArray();
            String keyFilePath = cryptoKeyStore.getStringValue(CERT_PATH);

            char[] trustPassphrase = cryptoTrustStore.getStringValue(CERT_PASS).toCharArray();
            String trustFilePath = cryptoTrustStore.getStringValue(CERT_PATH);

            String tlsVersion = secureSocket.getStringValue(RabbitMQConstants.RABBITMQ_CONNECTION_TLS_VERSION);
            if (tlsVersion == null) {
                tlsVersion = "TLS";
            }

            KeyStore keyStore = KeyStore.getInstance(RabbitMQConstants.KEY_STORE_TYPE);
            if (keyFilePath != null) {
                keyStore.load(new FileInputStream(keyFilePath), keyPassphrase);
            } else {
                throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                        "Path for the keystore is not found.");
            }
            KeyManagerFactory keyManagerFactory =
                    KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, keyPassphrase);

            KeyStore trustStore = KeyStore.getInstance(RabbitMQConstants.KEY_STORE_TYPE);
            if (trustFilePath != null) {
                trustStore.load(new FileInputStream(trustFilePath), trustPassphrase);
            } else {
                throw new RabbitMQConnectorException("Path for the truststore is not found.");
            }
            TrustManagerFactory trustManagerFactory =
                    TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(trustStore);

            SSLContext sslContext = SSLContext.getInstance(tlsVersion);
            sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
            return sslContext;
        } catch (FileNotFoundException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    exception.getLocalizedMessage());
        } catch (IOException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "I/O error occurred. " +
                    exception.getLocalizedMessage());
        } catch (CertificateException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "Certification error occurred. " +
                    exception.getLocalizedMessage());
        } catch (UnrecoverableKeyException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "A key in the keystore cannot be recovered. " +
                    exception.getLocalizedMessage());
        } catch (NoSuchAlgorithmException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "The particular cryptographic algorithm requested is not available in the environment." +
                    exception.getLocalizedMessage());
        } catch (KeyStoreException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "No provider supports a KeyStoreSpi implementation for this keystore type." +
                    exception.getLocalizedMessage());
        } catch (KeyManagementException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "Error occurred in an operation with key management." +
                    exception.getLocalizedMessage());
        }
    }

Line commented on: keyStore.load(new FileInputStream(keyFilePath), keyPassphrase);

Revised code:
private static SSLContext getSSLContext(MapValue secureSocket) {
        try {
            MapValue cryptoKeyStore = secureSocket.getMapValue(RabbitMQConstants.RABBITMQ_CONNECTION_KEYSTORE);
            MapValue cryptoTrustStore = secureSocket.getMapValue(RabbitMQConstants.RABBITMQ_CONNECTION_TRUSTORE);
            char[] keyPassphrase = cryptoKeyStore.getStringValue(RabbitMQConstants.KEY_STORE_PASS).toCharArray();
            String keyFilePath = cryptoKeyStore.getStringValue(RabbitMQConstants.KEY_STORE_PATH);
            char[] trustPassphrase = cryptoTrustStore.getStringValue(RabbitMQConstants.KEY_STORE_PASS).toCharArray();
            String trustFilePath = cryptoTrustStore.getStringValue(RabbitMQConstants.KEY_STORE_PATH);
            String tlsVersion = secureSocket.getStringValue(RabbitMQConstants.RABBITMQ_CONNECTION_TLS_VERSION);

            KeyStore keyStore = KeyStore.getInstance(RabbitMQConstants.KEY_STORE_TYPE);
            if (keyFilePath != null) {
                try (FileInputStream keyFileInputStream = new FileInputStream(keyFilePath)) {
                    keyStore.load(keyFileInputStream, keyPassphrase);
                }
            } else {
                throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                        "Path for the keystore is not found.");
            }
            KeyManagerFactory keyManagerFactory =
                    KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, keyPassphrase);

            KeyStore trustStore = KeyStore.getInstance(RabbitMQConstants.KEY_STORE_TYPE);
            if (trustFilePath != null) {
                try (FileInputStream trustFileInputStream = new FileInputStream(trustFilePath)) {
                    trustStore.load(trustFileInputStream, trustPassphrase);
                }
            } else {
                throw new RabbitMQConnectorException("Path for the truststore is not found.");
            }
            TrustManagerFactory trustManagerFactory =
                    TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(trustStore);

            SSLContext sslContext = SSLContext.getInstance(tlsVersion);
            sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
            return sslContext;
        } catch (FileNotFoundException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    exception.getLocalizedMessage());
        } catch (IOException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "I/O error occurred.");
        } catch (CertificateException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "Certification error occurred.");
        } catch (UnrecoverableKeyException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "A key in the keystore cannot be recovered.");
        } catch (NoSuchAlgorithmException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "The particular cryptographic algorithm requested is not available in the environment.");
        } catch (KeyStoreException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "No provider supports a KeyStoreSpi implementation for this keystore type." +
                    exception.getLocalizedMessage());
        } catch (KeyManagementException exception) {
            throw new RabbitMQConnectorException(RabbitMQConstants.CREATE_SECURE_CONNECTION_ERROR +
                    "Error occurred in an operation with key management." +
                    exception.getLocalizedMessage());
        }
    }