Java client library to use the Watson APIs.
Table of Contents
All the services:
<dependency>
<groupId>com.ibm.watson.developer_cloud</groupId>
<artifactId>java-sdk</artifactId>
<version>5.4.0</version>
</dependency>Only Discovery:
<dependency>
<groupId>com.ibm.watson.developer_cloud</groupId>
<artifactId>discovery</artifactId>
<version>5.4.0</version>
</dependency>All the services:
'com.ibm.watson.developer_cloud:java-sdk:5.4.0'Only Assistant:
'com.ibm.watson.developer_cloud:assistant:5.4.0'Snapshots of the development version are available in Sonatype's snapshots repository.
Add repository to your project Gradle file
allprojects {
repositories {
maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
}
}And then reference the snapshot version on your app module gradle Only Speech to Text:
'com.ibm.watson.developer_cloud:speech-to-text:5.4.1-SNAPSHOT'Download the jar with dependencies here.
Now, you are ready to see some examples.
The examples within each service assume that you already have service credentials. If not, you will have to create a service in IBM Cloud.
If you are running your application in IBM Cloud (or other platforms based on Cloud Foundry), you don't need to specify the
credentials; the library will get them for you by looking at the VCAP_SERVICES environment variable.
When running in IBM Cloud (or other platforms based on Cloud Foundry), the library will automatically get the credentials from VCAP_SERVICES.
If you have more than one plan, you can use CredentialUtils to get the service credentials for an specific plan.
There are three ways to authenticate with IBM Cloud through the SDK: using a username and password, using an api_key, and with IAM.
Getting the credentials necessary for authentication is the same process for all methods. To get them, follow these steps:
- Log in to IBM Cloud
- In the IBM Cloud Catalog, select the service you want to use.
- Click Create.
- On the left side of the page, click Service Credentials, and then View credentials to view your service credentials.
- Copy the necessary credentials (
url,username,password,api_key,apikey, etc.).
In your code, you can use these values in the service constructor or with a method call after instantiating your service. Here are some examples:
// in the constructor
Discovery service = new Discovery("2017-11-07", "<username>", "<password>");// after instantiation
Discovery service = new Discovery("2017-11-07");
service.setUsernameAndPassword("<username>", "<password>");Note: This version of instantiation only works with Visual Recognition, as it's the only service that uses an API key rather than a username and password.
// in the constructor
VisualRecognition service = new VisualRecognition("2016-05-20", "<api_key>");// after instantiation
VisualRecognition service = new VisualRecognition("2016-05-20");
service.setApiKey("<api_key>");When authenticating with IAM, you have the option of passing in:
- the IAM API key and, optionally, the IAM service URL
- an IAM access token
Be aware that passing in an access token means that you're assuming responsibility for maintaining that token's lifecycle. If you instead pass in an IAM API key, the SDK will manage it for you.
// in the constructor, letting the SDK manage the IAM token
IamOptions options = new IamOptions.Builder()
.apiKey("<iam_api_key>")
.url("<iam_url>") // optional - the default value is https://iam.ng.bluemix.net/identity/token
.build();
Discovery service = new Discovery("2017-11-07", options);// after instantiation, letting the SDK manage the IAM token
Discovery service = new Discovery("2017-11-07");
IamOptions options = new IamOptions.Builder()
.apiKey("<iam_api_key>")
.build();
service.setIamCredentials(options);// in the constructor, assuming control of managing IAM token
IamOptions options = new IamOptions.Builder()
.accessToken("<access_token>")
.build();
Discovery service = new Discovery("2017-11-07", options);// after instantiation, assuming control of managing IAM token
Discovery service = new Discovery("2017-11-07");
IamOptions options = new IamOptions.Builder()
.accessToken("<access_token>")
.build();
service.setIamCredentials(options);If at any time you would like to let the SDK take over managing your IAM token, simply override your stored IAM credentials with an IAM API key by calling the setIamCredentials() method again.
The Android SDK utilizes the Java SDK while making some Android-specific additions. This repository can be found here. It depends on OkHttp and gson.
Override the configureHttpClient() method and add the proxy using the OkHttpClient.Builder object.
For example:
Assistant service = new Assistant("2018-02-16") {
@Override
protected OkHttpClient configureHttpClient() {
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxyHost", 8080));
return super.configureHttpClient().newBuilder().proxy(proxy).build();
}
};
service.setUsernameAndPassword("<username>", "<password>");
WorkspaceCollection workspaces = service.listWorkspaces().execute();
System.out.println(workspaces);For more information see: OkHTTPClient Proxy authentication how to?
PersonalityInsights service = new PersonalityInsights("2016-10-19");
String apiKey = CredentialUtils.getAPIKey(service.getName(), CredentialUtils.PLAN_STANDARD);
service.setApiKey(apiKey);Custom headers can be passed with any request. To do so, add the header to the ServiceCall object before executing the request. For example, this is what it looks like to send the header Custom-Header along with a call to the Watson Assistant service:
WorkspaceCollection workspaces = service.listWorkspaces()
.addHeader("Custom-Header", "custom_value")
.execute();The basic execute(), enqueue(), and rx() methods make HTTP requests to your Watson service and return models based on the requested endpoint. If you would like access to some HTTP response information along with the response model, you can use the more detailed versions of those three methods: executeWithDetails(), enqueueWithDetails(), and rxWithDetails(). To capture the responses, use the new Response<T> class, with T being the expected response model.
Here is an example of calling the Watson Assistant listWorkspaces() method and parsing its response model as well as the response headers:
Response<WorkspaceCollection> response = service.listWorkspaces().executeWithDetails();
// getting result equivalent to execute()
WorkspaceCollection workspaces = response.getResult();
// getting returned HTTP headers
Headers responseHeaders = response.getHeaders();Note that when using enqueueWithDetails(), you must also implement the new ServiceCallbackWithDetails interface. For example:
service.listWorkspaces().enqueueWithDetails(new ServiceCallbackWithDetails<WorkspaceCollection>() {
@Override
public void onResponse(Response<WorkspaceCollection> response) {
WorkspaceCollection workspaces = response.getResult();
Headers responseHeaders = response.getHeaders();
}
@Override
public void onFailure(Exception e) { }
});Default headers can be specified at any time by using the setDefaultHeaders(Map<String, String> headers) method.
The example below sends the X-Watson-Learning-Opt-Out header in every request preventing Watson from using the payload to improve the service.
PersonalityInsights service = new PersonalityInsights("2016-10-19");
Map<String, String> headers = new HashMap<String, String>();
headers.put(HttpHeaders.X_WATSON_LEARNING_OPT_OUT, 1);
service.setDefaultHeaders(headers);
// All the api calls from now on will send the default headersYou can set the correct API Endpoint for your service calling setEndPoint().
For example, if you have the Discovery service in Germany, the Endpoint may be https://gateway-fra.watsonplatform.net/discovery/api.
You will need to call
Discovery service = new Discovery("2017-11-07");
service.sentEndPoint("https://gateway-fra.watsonplatform.net/discovery/api")Make sure you are using the service credentials and not your IBM Cloud account/password.
Check the API Endpoint, you may need to update the default using setEndPoint().
Version 4.0 focuses on the move to programmatically-generated code for many of the services. See the changelog for the details. This version also includes many breaking changes as a result of standardizing behavior across the new generated services. Full details on migration from previous versions can be found here.
HTTP requests can be logged by adding a logging.properties file to your classpath.
handlers=java.util.logging.ConsoleHandler
java.util.logging.ConsoleHandler.level=FINE
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s %4$s: %5$s%n
.level=SEVERE
# HTTP Logging - Basic
com.ibm.watson.developer_cloud.util.HttpLogging.level=INFO
The configuration above will log only the URL and query parameters for each request.
For example:
Mar 30, 2017 7:31:22 PM okhttp3.internal.platform.Platform log
INFO: --> POST https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=false http/1.1 (923-byte body)
Mar 30, 2017 7:31:22 PM okhttp3.internal.platform.Platform log
INFO: <-- 200 OK https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=false (104ms, unknown-length body)
Mar 30, 2017 7:31:23 PM okhttp3.internal.platform.Platform log
INFO: --> POST https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=true http/1.1 (12398-byte body)
Mar 30, 2017 7:31:35 PM okhttp3.internal.platform.Platform log
INFO: <-- 200 OK https://gateway.watsonplatform.net/tradeoff-analytics/api/v1/dilemmas?generate_visualization=true (12311ms, unknown-length body)
Warning: The logs generated by this logger when using the level FINE or ALL has the potential to leak sensitive information such as "Authorization" or "Cookie" headers and the contents of request and response bodies. This data should only be logged in a controlled way or in a non-production environment.
To build and test the project you can use Gradle (version 1.x).
Gradle:
cd java-sdk
gradle jar # build jar file (build/libs/watson-developer-cloud-5.4.0.jar)
gradle test # run tests
gradle check # performs quality checks on source files and generates reports
gradle testReport # run tests and generate the aggregated test report (build/reports/allTests)
gradle codeCoverageReport # run tests and generate the code coverage report (build/reports/jacoco)If you want to work on the code in an IDE instead of a text editor you can easily create project files with gradle:
gradle idea # Intellij IDEA
gradle eclipse # EclipseFind more open source projects on the IBM Github Page
This library is licensed under Apache 2.0. Full license text is available in LICENSE.
See CONTRIBUTING.md.
See CODE_OF_CONDUCT.md.
If you are having difficulties using the APIs or you have a question about the IBM Watson Services, please ask a question on dW Answers or Stack Overflow.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent