Sample Program to Invoke GET REST API

The following example sends an HTTP GET request to the /workspace/{workspaceId} endpoint to retrieve information about a workspace with a given workspace ID.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
  
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
  
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
  
public class SampleProgram {
  
    private static String userName = "<username>";
    private static String password = "<password>";
    private static String hostName = "<hostName>";
    private static String workspaceId = "<workspaceId>";
    private static String version = "3";
    private static String tokenGenerationUrl = "https://" + hostName + "/primediscovery/apitoken/request?scope=" + "http://" + hostName + "/api";
    private static String getWorkspaceUrl = "https://" + hostName + "/api/restapi/workspace/" + workspaceId;
  
    public static void main(String s[]) throws Exception {
        String workspaceJson = callRestURL();
        System.out.println("Workspace:- " + workspaceJson);
    }
  
    private static JsonNode getAuthTokenDetails() {
        HttpURLConnection conn = null;
        try {
            // Generating the OAuth Token
            URL tokenUrl = new URL(tokenGenerationUrl);
            conn = (HttpURLConnection) tokenUrl.openConnection();
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Accept", "application/json");
            conn.setRequestProperty("Content-Type", "application/json");
            String userCredentials = userName + ":" + password;
            String base64Credentials = jakarta.xml.bind.DatatypeConverter.printBase64Binary(userCredentials.getBytes());
            String basicAuth = "Basic " + base64Credentials;
            conn.setRequestProperty("Authorization", basicAuth);
            if (conn.getResponseCode() != 200) {
                throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode() + "Error: " + readStreamData(conn.getErrorStream()));
            }
            JsonNode authTokenJson = new ObjectMapper().readValue(conn.getInputStream(), JsonNode.class);
            conn.disconnect();
            return authTokenJson;
        } catch (Exception e) {
            conn.disconnect();
            throw new RuntimeException("Failed to generate OAuth Token");
        }
  
    }
  
    private static String callRestURL() throws Exception {
        HttpURLConnection conn = null;
        try {
            trustAllCert();
            JsonNode authTokenResponse = getAuthTokenDetails();
            conn = null;
            URL apiUrl = new URL(getWorkspaceUrl);
            conn = (HttpURLConnection) apiUrl.openConnection();
            conn.setRequestProperty("Version", version);
            System.out.println("Token Generated : " + authTokenResponse.get("accessToken").asText());
            conn.setRequestProperty("Authorization", "Bearer " + authTokenResponse.get("accessToken").asText());
            conn.setRequestProperty("x-prime-tenant-code", authTokenResponse.get("primeTenantCode").asText());
            Iterator<Entry<String, JsonNode>> requestHeadersIterator = authTokenResponse.get("requestHeaders").fields();
            while(requestHeadersIterator.hasNext()) {
                Entry<String, JsonNode> header = requestHeadersIterator.next();
                conn.setRequestProperty(header.getKey(), header.getValue().asText());
            }
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setRequestMethod("GET");
            if (conn.getResponseCode() != 200) {
                throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode() + "Error: " + readStreamData(conn.getErrorStream()));
            }
            return readStreamData(conn.getInputStream());
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }
  
    private static String readStreamData(InputStream is) throws IOException {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
            String output;
            StringBuilder buff = new StringBuilder();
            while ((output = br.readLine()) != null) {
                buff.append(output);
            }
            return buff.toString();
        }
    }
  
    private static void trustAllCert() throws NoSuchAlgorithmException, KeyManagementException {
        // Create a trust manager that does not validate certificate chains
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
  
            @Override
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
  
            @Override
            public void checkClientTrusted(X509Certificate[] certs, String authType) {
            }
  
            @Override
            public void checkServerTrusted(X509Certificate[] certs, String authType) {
            }
        } };
        // Install the all-trusting trust manager
        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        // Create all-trusting host name verifier
        HostnameVerifier allHostsValid = new HostnameVerifier() {
  
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };
        // Install the all-trusting host verifier
        HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
    }
}