J-Framework Service Client

Service client is a project that aims to simplify Microservices and REST-API client development.

It consists of two clients clients:

  • Simple Client that communicates with traditional microservices.

  • Mature Service Client that communicates with Mature Microservices.

Mature Microservice is a microservice that uses HTTP protocol methods instead of API-specific URLs as a common protocol between servers and clients.


Most likely, you will NOT need to add the direct dependency of this project, since it’s already included in the parent projects or the other framework projects. However, if you need to, the dependency is added as follows.

<!-- https://mvnrepository.com/artifact/com.jalalkiswani/j-framework-core -->

Basic Usage

  1. Create a Maven Project with J-App-Data as the Parent.

  2. Create and use the following clients per your needs.

Traditional Service Client

To use it, declare the ServiceClient instance with the API URL base and the common Model as parameters, then use that instance to call the method of your need. for example:

String url = "http://localhost:8080/app/example";
JKServiceClient<Person> client = new JKServiceClient<>(url, Person.class);

String response = client.callJsonAsString("/hello");

String response2 = client.callJsonAsString("/hello/Jalal");

Person p = new Person();

String response3 = client.callJsonWithPost("/hello", p);

The recommended approach is to:

  1. Create a service client with the name of your microservice.

  2. It should extend the ServiceClient.

  3. Override the getBase() method, and load the URL from the configuration.

  4. Provide a business wrapper method to all the endpoints in the Microservice.

Here is a full example:

package com.app;

import com.jk.core.config.JKConfig;
import com.jk.services.client.JKServiceClient;

public class DemoSeviceClient extends JKServiceClient<Person> {

	public String getBase() {
		return JKConfig.get().getProperty("example.service.url", "http://localhost:8080/app/example");

	public String hello() {
		return callJsonAsString("/hello");

	public String hellowithParam(String name) {
		return callJsonAsString("/hello/" + name);

	public String helloWithModel(Person p) {
		return callJsonWithPost("/hello", p);


and you use it with something like this:

DemoSeviceClient client=new DemoSeviceClient();

The service client and the needed models should be created by the Microservice developers themselves and placed in a commons-lib that is accessible by all projects, in this approach, any new update to the client will be immediately available to all apps.

If you need to cast the response (which normally is a JSON object), you can use one of the following utility methods:

  • JKObjectUtil.jsonToObject(Json, Class)

  • JKObjectUtil.jsonToObjectList(Json,Class

Mature Service Client

Mature Service clients are clients that are designed to communicate with Mature Microservice. As explained, mature microservices use the standard HTTP methods as the standard application protocol between an API and its client.

To use this client, you need to:

  • Class a client of your service that extends JKMatureServiceClient

  • Provide your model as a Generic parameter.

  • Override getBase method.


package com.app.person;

import com.jk.core.config.JKConfig;
import com.jk.services.client.JKMatureServiceClient;

public class ExampleServiceClient extends JKMatureServiceClient<Model> {

	public String getBase() {
		return JKConfig.get().getProperty("example.service.url", "http://localhost:8080/app/example");


This client provides the following methods out of the box:

  • getAll() which calls GET method

  • find(id) which calls GET method with query param.

  • insert(model) which is called the POST method.

  • update(model) which calls the PUT method.

  • delete(id) which is called the DELETE method. -