Real-Time Forex, CFD and Crypto WebSocket with Java
Tags: java, websocket, marketdata, forexdata
Published: 2022-12-12 10:27:16

The tutorial takes you through the Java WebSocket client used to access real-time Forex, cryptocurrency, and CFD (indices, stocks, and commodities) data through our Forex Java API.

Although notepad and the command line compiler will be used in this tutorial, you can substitute your preferred development environment.

By enabling bi-directional, real-time, full-duplex client-server connections, the Websocket offers a workable substitute for client-server communication's drawbacks. 

With minimal latency and low-level communication giving low overheads on each message, the TCP connection allows the client to transmit data to the server and the server to send data to the client at any time.

It's time to code.
A few assistance libraries must be imported. We need the java.net.URI for the WebSocket address; java.net.http.HttpClient to work with the java.net.http.WebSocket library to establish a connection to the server. Processing of the messages takes place at the Java.util.concurrent.CompletionStage.

```
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.util.concurrent.CompletionStage;
```
The program's fundamental structure may then be established. We employ a continuous loop to keep the program running and watch for new messages. Furthermore, we start a new WebSocket instance and feed the URL into it. You must create an account by registering for a WebSocket key. Try out our Java Websocket API for free for the first two weeks!
 

```
public class ClientCaller {

    public static void main(String[] args) throws Exception {
        WebSocket ws = HttpClient
                .newHttpClient()
                .newWebSocketBuilder()
                .buildAsync(URI.create("wss://marketdata.tradermade.com/feedadv"), new WebSocketClient(latch))
                .join();
        while(true){};
    }

    private static class WebSocketClient implements WebSocket.Listener {
        //Insert Body here 
     }
  }
```
After creating the three functions listed in the class WebSocket.Listener- which are 

- onOpen (used to establish a connection), 
- onText (called when a new message is received), and 
- onError (called when an error occurs), 
We can now fill in the details of our program.

### The onOpen command
We add our WebSocket listener class to the WebSocket in the onOpen function, and then, using our userKey, we send a message to the server (you can get it from your user dashboard by logging in). Additionally, we set the necessary symbols as a list separated by commas (strictly no spaces).
 

```
public void onOpen(WebSocket webSocket) {
    System.out.println("onOpen using subprotocol " + webSocket.getSubprotocol());
    WebSocket.Listener.super.onOpen(webSocket);
    webSocket.sendText("{"userKey":"INSERT_API_KEY", "symbol":"GBPUSD,EURUSD"}", true);
}

```

### The onText command
We obtain our forex data from the onText function as stated above; the processing of this data will be covered later in the tutorial. We utilise the WebSocket.Listener.super.onTest function to construct and return the class CompletionStage return function that the WebSocket interface expects.

```
public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
    System.out.println("onText received " + data);
    return WebSocket.Listener.super.onText(webSocket, data, last);
}
```

### The method onError
We can handle errors in the onError function, but we must also feed the call back to the underlying WebSocket.

```
public void onError(WebSocket webSocket, Throwable error) {
    System.out.println("Bad day! " + webSocket.toString());
    WebSocket.Listener.super.onError(webSocket, error);
}
```
Our program's foundational code is complete, so let's compile it and give it a shot. Navigate to the folder containing your client code in a command window after opening one. Run the following command to build your program and produce a . class file that you can use to launch it.
 

```
javac ClientCaller.java
```
Run the program now.

```
java ClientCaller
```
The real-time market data should now be streaming in the terminal, as illustrated below.
 

```
{"symbol":"GBPUSD","ts":"1645790870117","bid":1.33881,"ask":1.33882,"mid":1.338815}
{"symbol":"GBPUSD","ts":"1645790870246","bid":1.33881,"ask":1.33881,"mid":1.33881}
{"symbol":"GBPUSD","ts":"1645790870295","bid":1.33879,"ask":1.33881,"mid":1.3388}
{"symbol":"GBPUSD","ts":"1645790870369","bid":1.33878,"ask":1.33881,"mid":1.338795}
{"symbol":"GBPUSD","ts":"1645790870441","bid":1.33878,"ask":1.3388,"mid":1.3387899}
{"symbol":"GBPUSD","ts":"1645790872080","bid":1.33877,"ask":1.3388,"mid":1.3387849}
```

### Data Distillation
Since the currency data is in JSON format, we must first parse it. To parse JSON, we require an additional library. To do this, copy the JSON parser library to the same directory where you created the class file after downloading it.
After importing the library, we will add the code to parse the incoming data.
 

```
import org.json.*;
```
Although parsing is straightforward, we must first examine the message. We must respond to the "Connected" notification WebSocket sends first. If the notification has data, we will build a new JSON Object and add the message's data. When the data is a JSON object, we can use the "get" command to extract the information we need.
 

```
String dataS = data.toString();
if ( !dataS.equals("Connected")) {
    JSONObject obj = new JSONObject(dataS);
    System.out.println(obj.getString("symbol") + " " + obj.getLong("ts") + " " + obj.getDouble("bid") + " " + obj.getDouble("ask") + " " + obj.getDouble("mid"));
}
```
The code that parses the data can now be compiled and run.
 

```
javac -cp ./;./json-20211205.jar ClientCaller.java
```
A class path element must be added to include the JSON parser.jar.
 

```
java -cp ./;./json-20211205.jar ClientCaller
```
You ought to now see the program's output in raw data format. The information can be modified and changed as you see fit.
 

```
GBPUSD 1646215857362 1.33131 1.33137 1.3313401
GBPUSD 1646215857447 1.33131 1.33136 1.3313351
EURUSD 1646215857472 1.10833 1.10834 1.108335
GBPUSD 1646215857506 1.3313 1.33136 1.3313301
EURUSD 1646215858341 1.10833 1.10833 1.10833
EURUSD 1646215858561 1.10832 1.10833 1.108325
```

TraderMade provides reliable and accurate Forex data via [Forex API](https://tradermade.com/forex). You can sign up for a free API key and start exploring real-time and historical data at your fingertips.

Please go through the originally published tutorial on the TraderMade Website: [Real-Time Forex, CFD, and Crypto WebSocket with Java](https://tradermade.com/tutorials/real-time-forex-cfd-and-crypto-websocket-with-java)

Along with that, you can refer to some other Java-based tutorials to enhance your coding and data retrieval skills:
1. [Forex, Crypto, and CFD WebSocket with Java](https://tradermade.com/tutorials/forex-crypto-and-cfd-rest-json-with-java)
2. [First JavaScript REST Client](https://tradermade.com/tutorials/how-to-write-your-first-javascript-rest-client-server-side)

Here are technical tutorials in a few other popular programming languages to fetch real-time forex and CFD data:
1. [Python WebSocket Client](https://tradermade.com/tutorials/python-websocket-client)
2. [Golang WebSocket Client](https://tradermade.com/tutorials/golang-websocket-client)
3. [WebSocket with C#](https://tradermade.com/tutorials/forex-websocket-with-c)
4. [PHP WebSocket Client](https://tradermade.com/tutorials/your-first-php-websocket)