Restful client example

Restful client example DEFAULT

4 Developing RESTful Web Service Clients

How to Configure the Request Entity

Configure the request entity and type using the method on the Web resource. Alternatively, you can configure the request entity type only using the method on the Web resource.

Example 4-13 provides an example of how to configure a request entity and type.

Example 4-13 Configuring the Request Entity

import com.sun.jersey.api.client.WebResource; ... public static void main(String[] args) { ... WebResource resource = c.resource(""); String response = resource.entity(request, MediaType.TEXT_PLAIN_TYPE).get(String.class); ...

Example 4-14 provides an example of how to configure the request entity media type only.

Example 4-14 Configuring the Request Entity Media Type Only

import com.sun.jersey.api.client.WebResource; ... public static void main(String[] args) { ... WebResource resource = c.resource(""); String response = resource.type(MediaType.TEXT_PLAIN_TYPE).get(String.class); ...

REST Client -- simple DSL for accessing HTTP and REST resources

Gem DownloadsBuild StatusCode ClimateInline docsJoin the chat at

A simple HTTP and REST client for Ruby, inspired by the Sinatra's microframework style of specifying actions: get, put, post, delete.

New mailing list

We have a new email list for announcements, hosted by

The old Librelist mailing list is defunct, as Librelist appears to be broken and not accepting new mail. The old archives are still up, but have been imported into the new list archives as well.


MRI Ruby 2.0 and newer are supported. Alternative interpreters compatible with 2.0+ should work as well.

Earlier Ruby versions such as 1.8.7, 1.9.2, and 1.9.3 are no longer supported. These versions no longer have any official support, and do not receive security updates.

The rest-client gem depends on these other gems for usage at runtime:

There are also several development dependencies. It's recommended to use bundler to manage these dependencies for hacking on rest-client.

Upgrading to rest-client 2.0 from 1.x

Users are encouraged to upgrade to rest-client 2.0, which cleans up a number of API warts and wrinkles, making rest-client generally more useful. Usage is largely compatible, so many applications will be able to upgrade with no changes.

Overview of significant changes:

  • requires Ruby >= 2.0
  • objects are a subclass of rather than a Frankenstein monster. And or return a true object.
  • cleanup of exception classes, including new
  • improvements to handling of redirects: responses and history are properly exposed
  • major changes to cookie support: cookie jars are used for browser-like behavior throughout
  • encoding: Content-Type charset response headers are used to automatically set the encoding of the response string
  • HTTP params: handling of GET/POST params is more consistent and sophisticated for deeply nested hash objects, and can be used to pass ordered params
  • improved proxy support with per-request proxy configuration, plus the ability to disable proxies set by environment variables
  • default request headers: rest-client sets and

See for a more complete description of changes.

Usage: Raw URL

Basic usage:


In the high level helpers, only POST, PATCH, and PUT take a payload argument. To pass a payload with other HTTP verbs or to pass more advanced options, use instead.

More detailed examples:

require'rest-client'RestClient.get''RestClient.get'',{params: {id: 50,'foo'=>'bar'}}RestClient.get'https://user:[email protected]/private/resource',{accept: :json}'',{param1: 'one',nested: {param2: 'two'}}"",{'x'=>1}.to_json,{content_type: :json,accept: :json}RestClient.delete'' >> response=RestClient.get''=> <RestClient::Response200"<!doctype h..."> >> response.code=>200 >> response.cookies=>{"Foo"=>"BAR","QUUX"=>"QUUUUX"} >> response.headers=>{:content_type=>"text/html; charset=utf-8",:cache_control=>"private" ... } >> response.body=>"<!doctype html>\n<html>\n<head>\n <title>Example Domain</title>\n\n ...",{:transfer=>{:path=>'/foo/bar',:owner=>'that_guy',:group=>'those_guys'},:upload=>{:file=>,'rb')}})

Passing advanced options

The top level helper methods like RestClient.get accept a headers hash as their last argument and don't allow passing more complex options. But these helpers are just thin wrappers around .

RestClient::Request.execute(method: :get,url: '',timeout: 10)RestClient::Request.execute(method: :get,url: '',ssl_ca_file: 'myca.pem',ssl_ciphers: 'AESGCM:!aNULL')

You can also use this to pass a payload for HTTP verbs like DELETE, where the helper doesn't accept a payload.

RestClient::Request.execute(method: :delete,url: '',payload: 'foo',headers: {myheader: 'bar'})

Due to unfortunate choices in the original API, the params used to populate the query string are actually taken out of the headers hash. So if you want to pass both the params hash and more complex options, use the special key in the headers hash. This design may change in a future major release.

RestClient::Request.execute(method: :get,url: '',timeout: 10,headers: {params: {foo: 'bar'}})➔GET


Yeah, that's right! This does multipart sends for you!'/data',:myfile=>"/path/to/image.jpg",'rb')

This does two things for you:

  • Auto-detects that you have a File value sends it as multipart
  • Auto-detects the mime of the file and sets it in the HEAD of the payload for each entry

If you are sending params that do not contain a File object but the payload needs to be multipart then:'/data',{:foo=>'bar',:multipart=>true}

Usage: ActiveResource-Style'''','user','pass''pic.jpg'),:content_type=>'image/jpg'

See RestClient::Resource module docs for details.

Usage: Resource Nesting'')site['posts/1/comments'].post'Good article.',:content_type=>'text/plain'

See docs for details.

Exceptions (see

  • for result codes between and , a will be returned
  • for result codes , or , the redirection will be followed if the request is a or a
  • for result code , the redirection will be followed and the request transformed into a
  • for other cases, a holding the Response will be raised; a specific exception class will be thrown for known error codes
  • call on the exception to get the server's response
>> RestClient.get''Exception: RestClient::NotFound: 404NotFound >> beginRestClient.get''rescueRestClient::ExceptionWithResponse=>ee.responseend=> <RestClient::Response404"<!doctype h...">

Other exceptions

While most exceptions have been collected under aka , there are a few quirky exceptions that have been kept for backwards compatibility.

RestClient will propagate up exceptions like socket errors without modification:

>> RestClient.get'http://localhost:12345'Exception: Errno::ECONNREFUSED: Connectionrefused - connect(2)for"localhost"port12345

RestClient handles a few specific error cases separately in order to give better error messages. These will hopefully be cleaned up in a future major release.

is translated from to give a better error message.

is raised when HTTPS validation fails. Other errors are raised as is.


By default, rest-client will follow HTTP 30x redirection requests.

New in 2.0: exposes a method that returns a list of each response received in a redirection chain.

>> r=RestClient.get('')=> <RestClient::Response200"{\n\"args\":..."> # see each response in the redirect chain >> r.history=>[<RestClient::Response302"<!DOCTYPE H...">, <RestClient::Response302 "">]# see each requested URL>> r.request.url=> "">> {|x| x.request.url}=> ["",""]

Manually following redirection

To disable automatic redirection, set .

New in 2.0: Prior versions of rest-client would raise , with no easy way to access the server's response. In 2.0, rest-client raises the normal as it would with any other non-HTTP-20x response.

>> RestClient::Request.execute(method: :get,url: '')=>RestClient::Response200"{\n "args":..." >> RestClient::Request.execute(method: :get,url: '',max_redirects: 0)RestClient::Found: 302Found

To manually follow redirection, you can call . Or you could of course inspect the result and choose custom behavior.

>> RestClient::Request.execute(method: :get,url: '',max_redirects: 0)RestClient::Found: 302Found >> beginRestClient::Request.execute(method: :get,url: '',max_redirects: 0)rescueRestClient::ExceptionWithResponse=>errend >> err=>#<RestClient::Found: 302 Found> >> err.response=>RestClient::Response302 "<!DOCTYPEH...">> err.response.headers[:location]=> "/get">> err.response.follow_redirection=> RestClient::Response 200 "{\n "args":..."

Result handling

The result of a is a object.

New in 2.0: objects are now a subclass of . Previously, they were a real String object with response functionality mixed in, which was very confusing to work with.

Response objects have several useful methods. (See the class rdoc for more details.)

  • : The HTTP response code
  • : The response body as a string. (AKA .to_s)
  • : A hash of HTTP response headers
  • : A hash of HTTP response headers as unprocessed arrays
  • : A hash of HTTP cookies set by the server
  • : New in 1.8 An HTTP::CookieJar of cookies
  • : The RestClient::Request object used to make the request
  • : New in 2.0 If redirection was followed, a list of prior Response objects
RestClient.get('')➔ <RestClient::Response200"<!doctype h..."> beginRestClient.get('')rescueRestClient::ExceptionWithResponse=>errerr.responseend➔ <RestClient::Response404"<!doctype h...">

Response callbacks, error handling

A block can be passed to the RestClient method. This block will then be called with the Response. Response.return! can be called to invoke the default response's behavior.

# Don't raise exceptions but return the response >> RestClient.get(''){|response,request,result| response}=> <RestClient::Response404"<!doctype h...">
# Manage a specific error codeRestClient.get(''){ |response,request,result, &block| caseresponse.codewhen200p"It worked !"responsewhen423raiseSomeCustomExceptionIfYouWantelseresponse.return!(&block)end}

But note that it may be more straightforward to use exceptions to handle different HTTP error response cases:

beginresp=RestClient.get('')rescueRestClient::Unauthorized,RestClient::Forbidden=>errputs'Access denied'returnerr.responserescueRestClient::ImATeapot=>errputs'The server is a teapot! # RFC 2324'returnerr.responseelseputs'It worked!'returnrespend

For GET and HEAD requests, rest-client automatically follows redirection. For other HTTP verbs, call on the response object (works both in block form and in exception form).

# Follow redirections for all request types and not only for get and head# RFC : "If the 301, 302 or 307 status code is received in response to a request other than GET or HEAD,# the user agent MUST NOT automatically redirect the request unless it can be confirmed by the user,# since this might change the conditions under which the request was issued."# block'','body'){ |response,request,result| caseresponse.codewhen301,302,307response.follow_redirectionelseresponse.return!end}# exception style by explicit'','body')rescueRestClient::MovedPermanently,RestClient::Found,RestClient::TemporaryRedirect=>errerr.response.follow_redirectionend# exception style by response'','body')rescueRestClient::ExceptionWithResponse=>errcaseerr.http_codewhen301,302,307err.response.follow_redirectionelseraiseendend

Non-normalized URIs

If you need to normalize URIs, e.g. to work with International Resource Identifiers (IRIs), use the Addressable gem ( in your code:


Lower-level access

For cases not covered by the general API, you can use the class, which provides a lower-level API.

You can:

  • specify ssl parameters
  • override cookies
  • manually handle the response (e.g. to operate on it as a stream rather than reading it all into memory)

See 's documentation for more information.

Streaming request payload

RestClient will try to stream any file-like payload rather than reading it into memory. This happens through , which is automatically called internally by

  1. Camila cabello havana instrumental
  2. Arsenal wallpaper iphone 6
  3. Mike holt live
7 Simple REST Client Examples

You’ve launched your DreamFactory instance and connected to your database, and executed a few test API calls in the API Docs interface. So what’s next? Fortunately DreamFactory has already taken care of auto-generating your API endpoints so you can skip right past that and proceed to creating a client that will talk to the DreamFactory-managed API. In this article we will demonstrate seven simple REST client examples involving sending a GET request to an HTTP-based API using an API key for authentication. We will present examples demonstrating NodeJS, Python, Ruby, PHP, and Perl. We’ll also show you how to use the great Insomnia and Postman API testing tools to test your new API calls.

Even if you’re not a DreamFactory user (you should check it out, you can start a free 14-day trial of our cloud version and our OSS version is available for free download) there’s still plenty to learn from this post!

Configuring the Sample Project

If you’d like to follow along with these examples using live data, we suggest configuring the sample application. If you haven’t already installed this application within your DreamFactory instance, click on the tab. On the left side of the screen click and next to the Address Book for JavaScript project. Scroll to the bottom of the screen and click the button. This is enough to ensure the application example data set is loaded into your DreamFactory instance, however if you want to experiment with other features you’ll also want to complete a few other configuration steps found in the aforementioned project .

In either case, head over to API docs, choose the service, and scroll down to the following endpoint:

You should see the output depicted in the following screenshot:

Viewing API Docs

If the GET request executes successfully you should receive a response Code of indicating success, as well as a JSON representation of the tables in your schema. Now that some sample data is available let’s experiment with a few GET requests. In our examples we will be querying the table using the following API endpoint:

NodeJS REST API Example

For our first example we will look at two simple NodeJS scripts. Below is an example of a native NodeJS HTTP GET request. In your favorite text editor create a new file called and enter the following code:

After updating the and fields to reflect the location and assigned application API key associated with your DreamFactory instance, save the changes and run the script via your terminal:

A large block of JSON data should be returned. If you’d like to clean it up and look a little more closely at your data you can copy the response and paste it into JSONLint. After pasting the data into the text area, click . This will accomplish two important tasks:

  1. Format your JSON into something a little more human readable.
  2. Validate that the JSON is in correct format as described by the JSON spec. If for any reason the JSON isn’t valid you will be given a hint as to what steps to take to correctly format your JSON.

That script felt a little heavy handed for just one simple GET call. Let’s try the same call again but this time we will use the ‘unirest’ module. NPM comes with NodeJS and allows users to install what are called Node modules. If you plan on doing any custom scripted services or events scripting in your DreamFactory this will also be useful. Let’s install the ‘unirest’ module using NPM, open up a shell and type:

The option installs the module globally. We recommend installing NodeJS modules globally, especially if you intend to use them in your server-side scripts. Now that you’ve installed the module open up your text editor and paste in the following code:

Save the script as and run it like so:

As with before, you’ll receive a lengthy JSON response in return. However this time it was accomplished with a lot less code with the added bonus of formatted JSON!

Python REST API Example

Maybe NodeJS isn’t your cup of tea, and instead prefer Python. Python makes REST a cakewalk with the module. Let’s install the module using pip,the Python package manager. Open up your terminal and execute:

Now that the module is installed let’s again open up a text editor and enter the following code:

Once you’ve confirmed everything is correct save the file as and again navigate to the directory where you saved your script and enter:

As with the other examples, if everything is configured properly you’ll see the JSON returned in the script output.

The DreamFactory platform also supports using Python (versions 2 and 3) to add business logic to existing API endpoints, and create new standalone APIs. You can learn more about DreamFactory’s scripting abilities in the Getting Started with DreamFactory guide.


Still other readers may wish to send HTTP API requests using PHP. No problem! Return to your editor and enter the following code:

Save the file as and run the script like so:

The DreamFactory platform also supports using Python (versions 2 and 3) to add business logic to existing API endpoints, and create new standalone APIs. You can learn more about DreamFactory’s scripting abilities in the Getting Started with DreamFactory guide.

Ruby REST API Example

Ruby has more HTTP client libraries then I can count on my fingers and toes. In this section we will cover two. Let’s first make a call using which is built into the Ruby standard library. Open your text editor and paste in the following code:

Save these changes and execute the script like so:

Now let’s try this again, however this time we are going to use the Ruby gem. This incredibly useful Ruby gem which claims to “make http fun again” can be used interactively in the command line or within your Ruby, Sinatra and Ruby on Rails applications. Lets use Ruby’s package manager to install the gem:

Once you’ve installed the gem open up your editor and paste the following code into a file called :

Save the file and execute it like so:

Perl REST API Example

Let’s move onto a Perl example. Begin by using Perl’s CPAN package manager to install the Perl module. Open up your terminal and enter the following command:

Once in the cpan shell execute this command:

After finishes installing exit the shell, open your editor, and paste in the following code:

Save the file and run it using the following command:

REST API Client Testing Tools


Insomnia is a great API testing tool that the DreamFactory team uses every day to demonstrate various platform features. It’s freely available for download via the Insomnia website, and a paid version (which we use) allows teams to share API call libraries. It’s very easy to use as the following screenshot indicates. You’ll identify the request method (GET, POST, etc), the desired URL, and pass along the API key. With the call configured, just press the Send button and the request results will appear in the right hand panel.



Like Insomnia, Postman is a very popular API testing tool, with a considerable number of additional features useful for API development. It’s interface isn’t as streamlined as Insomnia, but is nonetheless easy to use as the following screenshot indicates. You’ll identify the request method, set the URL and any headers, and press Send. The results will be output in the bottom pane.



Boom! So there you have it, 7 quick and easy examples to obtain and parse data from the DreamFactory REST API. Something else you may have noticed is that the API endpoint was used over and over again in each of the client calls without requiring a single line of server-side code, awesome!

Try DreamFactory 4.8.0

DreamFactory 4.8.0 has been released! This release focuses on user experience, notably with regards to database API generation. The most popular database connectors (MySQL, MariaDB, PostgreSQL, MS SQL Server, and Oracle) have long included a lengthy list of options, and it hasn’t been obvious which are required and which are optional. To remedy this we’ve broken the service creation form into three sections: Basic, Caching, and Optional Advanced Settings. Additionally, because the Services tab is the natural first tab new users should be clicking on after logging in, we’ve moved the tab to the second position in the navigational bar directly following the Home tab.

In upcoming releases users will see a stream of additional UX improvements intended to more effectively guide new users through the API generation process. Notably, for most basic use cases the administrator completes three tasks: generate the API, create a role-based access control (RBAC), and then associate the RBAC with a newly generated API key. Therefore after successful API generation users will be presented with a new view enumerating typical next steps. We’re also working on improving the service profile detail page, providing admins with a link list taking them directly to the service’s relevant other administrative features, such as API Docs and associated roles.

Introduction into the Java HTTP Elasticsearch REST client- April 23, 2020 Elastic Meetup

In this article, I will talk about how you can quickly create a Java client for working with the REST API. I will show you two ways to achieve the desired result quickly and efficiently. Both methods involve using third-party libraries.

But before you start creating a REST client, you need to remember the theory.

API stands for Application Programming Interface. It is a software-to-software interface, not a user interface. With APIs, applications converse with each other with no client learning or intervention.

API testing utilizes programming to send calls to the API and get the results. It regards the segment under the test as a black box. The primary objective of API testing is to confirm the correct execution and failure treatment of all the APIs (if any) preceding its coordination into an application.

REST: Representational State Transfer.

  • It’s an arrangement of functions on which the testers perform requests and receive responses. In REST, API interactions are made via HTTP protocol.
  • REST also permits communication between computers with each other over a network.
  • For sending and receiving messages, it involves using HTTP methods, and it does not require a strict message definition, unlike web services.
  • REST messages often accept the form either in the form of XML, or JavaScript Object Notation (JSON).
  1. Apache HTTPClient.

The Apache HttpComponents project is responsible for creating and maintaining a toolset of low-level Java components focused on HTTP and associated protocols.

The Apache HttpClient library greatly simplifies the processing of HTTP requests. In order to use this library, you must go to the Apache website. Read the official documentation. And add a dependency for Maven or Gradle:




compile group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5.11'

Below I will give an example of a GET request:

final HttpClient httpClient = new DefaultHttpClient();
final HttpGet httpGet = new HttpGet("http://localhost:8080");
HttpResponse response = null;
try {
response = httpClient.execute(httpGet);
} catch (IOException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
} catch (IOException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());
String line = "";
while (true) {
try {
if (!((line = reader.readLine()) != null)) break;
} catch (IOException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());

Below I will give an example of a POST request:

final HttpClient httpClient = new DefaultHttpClient();
final HttpPost httpPost = new HttpPost("http://localhost:8080");
StringEntity input = null;
try {
input = new StringEntity("id");
} catch (UnsupportedEncodingException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());
HttpResponse response = null;
try {
response = httpClient.execute(httpPost);
} catch (IOException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
} catch (IOException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());
String line = "";
while (true) {
try {
if (!((line = reader.readLine()) != null)) break;
} catch (IOException ex) {
if (LOGGER.isLoggable(Level.INFO)) {"The method is down." + ex.getMessage());

2. Jersey

Jersey is a REST framework that provides a JAX-RS (JSR-370) implementation.

Jersey framework is more than the JAX-RS Reference Implementation. Jersey provides its own API that extends the JAX-RS toolkit with additional features and utilities to further simplify RESTful service and client development. Jersey also exposes numerous extension SPIs so that developers may extend Jersey to best suit their needs.




compile group: 'com.sun.jersey', name: 'jersey-client', version: '1.19.4'

Example of a GET request:

final ClientConfig clientConfig = new DefaultClientConfig();
final Client client = Client.create(clientConfig);
final WebResource webResource = client.resource(UriBuilder.fromUri("http://localhost:8080").build());"restPath").path("resourcePath").accept(MediaType.APPLICATION_JSON).get(String.class));"restPath").path("resourcePath").accept(MediaType.APPLICATION_XML).get(String.class));

Example of a POST request:

final ClientConfig clientConfig = new DefaultClientConfig();
final Client client = Client.create(clientConfig);
final WebResource webResource = client.resource(UriBuilder.fromUri("http://localhost:8080").build());
final MultivaluedMap multivaluedMap = new MultivaluedMapImpl();
multivaluedMap.add("name1", "val1");
final ClientResponse clientResponse = webResource.type(MediaType.APPLICATION_FORM_URLENCODED_TYPE).post(ClientResponse.class, multivaluedMap);"Response " + clientResponse.getEntity(String.class));

It is possible to use your own class for POST:

final ClientResponse clientResponse = webResource.path("restPath").path("resourcePath").
type(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).post(ClientResponse.class, myPojo);"Response " + clientResponse.getEntity(String.class));

Both libraries presented in this article make it quite easy to create queries and get responses from the server, process them and output the result. Personally, I prefer the Apache Http client. Because it is quite lightweight and popular.


Client example restful

We learned to build Spring REST API for XML representation and JSON representation. Now lets learn to build Spring REST client using the Spring RestTemplate to consume the REST APIs which we have written in the linked examples.

Table of Contents 1. Spring RestTemplate class 2. Building RestTemplate Bean 3. HTTP GET Example 4. HTTP POST Example 5. HTTP PUT Example 6. HTTP DELETE Example

Note: Spring docs recommend to use the non-blocking, reactive which offers efficient support for both sync, async and streaming scenarios. will be deprecated in the future versions.

1. Spring RestTemplate class

Accessing the REST apis inside a Spring application revolves around the use of the Spring RestTemplate class. The class is designed on the same principles as the many other Spring classes (e.g., , ), providing a simplified approach with default behaviors for performing complex tasks.

Given that the class is a synchronous client and designed to call REST services. It should come as no surprise that its primary methods are closely tied to REST’s underpinnings, which are the HTTP protocol’s methods HEAD, GET, POST, PUT, DELETE, and OPTIONS.

2. How to build RestTemplate

The given below are few examples to create bean in the application. We are only looking at very simple bean definitions.

2.1. Using RestTemplateBuilder

@Bean public RestTemplate restTemplate(RestTemplateBuilder builder) { return builder .setConnectTimeout(Duration.ofMillis(3000)) .setReadTimeout(Duration.ofMillis(3000)) .build(); }

2.2. Using SimpleClientHttpRequestFactory

@Bean public RestTemplate restTemplate() { var factory = new SimpleClientHttpRequestFactory(); factory.setConnectTimeout(3000); factory.setReadTimeout(3000); return new RestTemplate(factory); }

2.3. Using Apache HTTPClient (Recommended)

@Autowired CloseableHttpClient httpClient; @Value("${}") private String apiHost; @Bean public RestTemplate restTemplate() { RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory()); restTemplate.setUriTemplateHandler(new DefaultUriBuilderFactory(apiHost)); return restTemplate; } @Bean @ConditionalOnMissingBean public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() { HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(); clientHttpRequestFactory.setHttpClient(httpClient); return clientHttpRequestFactory; }

Read More: RestTemplate Configuration with HttpClient.

2.4. Injecting RestTemplate bean

To inject the bean, use the well known annotation. If you have multiple beans of type with different configurations, use the annotation as well.

@Autowired private RestTemplate restTemplate;

3. Spring RestTemplate – HTTP GET Example

Available methods for executing GET APIs are::

  • getForObject(url, classType) – retrieve a representation by doing a GET on the URL. The response (if any) is unmarshalled to given class type and returned.
  • getForEntity(url, responseType) – retrieve a representation as ResponseEntity by doing a GET on the URL.
  • exchange(url, httpMethod, requestEntity, responseType) – execute the specified and return the response as ResponseEntity.
  • execute(url, httpMethod, requestCallback, responseExtractor) – execute the httpMethod to the given URI template, preparing the request with the RequestCallback, and reading the response with a ResponseExtractor.


@Autowired UserService userService; @GetMapping("users") public ResponseEntity<List<User>> getAll() { return new ResponseEntity<>(userService.getAll(), HttpStatus.OK); } @GetMapping("users/{id}") public ResponseEntity<User> getById(@PathVariable long id) { Optional<User> user = userService.getById(id); if (user.isPresent()) { return new ResponseEntity<>(user.get(), HttpStatus.OK); } else { throw new RecordNotFoundException(); } }

3.2. Consuming REST APIs as String

In the given example, we are fetching the API response as a JSON string. We need to use to parse it to the POJO before using it in the application.

method is pretty useful when we are getting an unparsable response from the server, and we have no control to get it fixed on the server-side. Here, we can get the response as , and use a custom parser or use a string replacement function to fix the response before handling it to the parser.

private final String URI_USERS_ID = "/users/{id}"; @Autowired RestTemplate restTemplate; //Using RestTemplate Map<String, String> params = new HashMap<String, String>(); params.put("id", "1"); //Parse the string after getting the response String userStr = restTemplate.getForObject(URI_USERS_ID, String.class, params);

Read More: Converting JSON String to Object using Jackson 2

3.3. Consuming REST API response to POJO

In the given example, we are fetching the API response directly into the domain object.

3.3.1. Using getForObject() Method
private final String URI_USERS = "/users"; private final String URI_USERS_ID = "/users/{id}"; @Autowired RestTemplate restTemplate; //Using RestTemplate // "users" User[] usersArray = restTemplate.getForObject(URI_USERS, User[].class); // "users/{id}" Map<String, String> params = new HashMap<String, String>(); params.put("id", "1"); User user = restTemplate.getForObject(URI_USERS_ID, User.class, params);
3.3.2. Using getForEntity() Method
private final String URI_USERS = "/users"; private final String URI_USERS_ID = "/users/{id}"; @Autowired RestTemplate restTemplate; //Using RestTemplate // "users" ResponseEntity<User[]> responseEntity = restTemplate .getForEntity(URI_USERS, User[].class); // "users/{id}" Map<String, String> params = new HashMap<String, String>(); params.put("id", "1"); ResponseEntity<User> responseEntity = restTemplate .getForEntity(URI_USERS_ID, User.class, params);

3.4. Sending HTTP Headers using RestTemplate

private final String URI_USERS = "/users"; @Autowired RestTemplate restTemplate; //Using RestTemplate HttpHeaders headers = new HttpHeaders(); headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON)); headers.set("X-COM-PERSIST", "NO"); headers.set("X-COM-LOCATION", "USA"); HttpEntity<String> entity = new HttpEntity<String>(headers); ResponseEntity<User[]> responseEntity = restTemplate .exchange(URI_USERS, HttpMethod.GET, entity, User[].class);

3.5. Sending URL Parameters using RestTemplate

Map<String, String> params = new HashMap<String, String>(); params.put("id", "1"); ResponseEntity<User> responseEntity = restTemplate .getForEntity(URI_USERS_ID, User.class, params);

4. Spring RestTemplate – HTTP POST Example

Available methods for consuming POST APIs are:

  • postForObject(url, request, classType) – POSTs the given object to the URL, and returns the representation found in the response as given class type.
  • postForEntity(url, request, responseType) – POSTs the given object to the URL, and returns the response as ResponseEntity.
  • postForLocation(url, request, responseType) – POSTs the given object to the URL, and returns returns the value of the header.
  • exchange(url, requestEntity, responseType)
  • execute(url, httpMethod, requestCallback, responseExtractor)


The POST API, we will consume in this example.

@PostMapping("users") public ResponseEntity<User> create(@RequestBody User newUser) { User user =; if (user == null) { throw new ServerException(); } else { return new ResponseEntity<>(user, HttpStatus.CREATED); } }

4.2. Spring RestTemplate example to consume POST API

Spring REST client using to access HTTP POST api requests.

private final String URI_USERS = "/users"; @Autowired RestTemplate restTemplate; //Using RestTemplate User newUser = new User(1, "Alex", "Golan", "[email protected]"); User createdUser = restTemplate.postForObject(URI_USERS, newUser, User.class); //Use the object as needed

5. Spring RestTemplate – HTTP PUT Method Example

Available methods are:

  • put(url, request) – PUTs the given request object to URL.


@PutMapping("users/{id}") public ResponseEntity<User> update(@RequestBody User updatedUser) { User user =; if (user == null) { throw new ServerException(); } else { return new ResponseEntity<>(user, HttpStatus.OK); } }

5.2. Spring RestTemplate example to consume PUT API

private final String URI_USERS_ID = "/users/{id}"; @Autowired RestTemplate restTemplate; //Using RestTemplate Map<String, String> params = new HashMap<String, String>(); params.put("id", "2"); User updatedUser = new User(1, "Alex", "Golan", "[email protected]"); User user = restTemplate.put(URI_USERS_ID, updatedUser, User.class); //Use the object as needed

6. Spring RestTemplate – HTTP DELETE Method Example

Available methods are:

  • delete(url) – deletes the resource at the specified URL.


@DeleteMapping("users/{id}") public HttpStatus delete(@PathVariable long id) { try { userService.delete(id); return HttpStatus.OK; } catch (Exception e) { throw new RecordNotFoundException(); } }

6.2. Spring RestTemplate example to consume DELETE API

private final String URI_USERS_ID = "/users/{id}"; @Autowired RestTemplate restTemplate; Map<String, String> params = new HashMap<String, String>(); params.put("id", "2"); //Using RestTemplate restTemplate.delete ( URI_USERS_ID, params );

Feel free to copy and modify above Spring RestTemplate examples for building the Spring REST API Consumer in your Spring WebMVC application.

7. RestTemplate Examples

Spring RestTemplate basic authentication example
Spring RestTemplate timeout configuration example
Spring RestTemplateBuilder Example
Spring RestTemplate – HttpClient configuration example
Spring Boot RestTemplate GET Example
Spring Boot RestTemplate POST Example
Spring boot JUnit example with RestTemplate
Spring boot TestRestTemplate POST with headers example
Spring ClientHttpRequestInterceptor with RestTemplate

Happy Learning !!

Sourcecode on Github

Let us know if you liked the post. That’s the only way we can improve.

6 - Create Java client for RESTful web service

Ever wondered how login/signup on a website works on the back-end? Or how when you search for "cute kitties" on YouTube, you get a bunch of results and are able to stream off of a remote machine?

In this beginner friendly guide, I will walk you through the process of setting up a RESTful API. We'll declassify some of the jargon and have a look at how we can code a server in NodeJS. Let's dive a bit deeper into JavaScript!

Get that jargon away

So, what is REST? According to Wikipedia:

Representational state transfer (REST) is a software architectural style that defines a set of constraints to be used for creating Web services. RESTful Web services allow the requesting systems to access and manipulate textual representations of Web resources by using a uniform and predefined set of stateless operations

Let's demystify what that means (hopefully you got the full form). REST is basically a set of rules for communication between a client and server. There are a few constraints on the definition of REST:

  1. Client-Server Architecture: the user interface of the website/app should be separated from the data request/storage, so each part can be scaled individually.
  2. Statelessness: the communication should have no client context stored on server. This means each request to the server should be made with all the required data and no assumptions should be made if the server has any data from previous requests.
  3. Layered system: client should not be able to tell if it is communicating directly with the server or some intermediary. These intermediary servers (be it proxy or load balancers) allow for scalability and security of the underlying server.

Okay, so now that you know what RESTful services are, here are some of the terms used in the heading:

  1. REST Client: code or an app that can access these REST services. You are using one right now! Yes, the browser can act as an uncontrolled REST client (the website handles the browser requests). The browser, for a long time, used an in-built function called XMLHttpRequest for all REST requests. But, this was succeeded by FetchAPI, a modern, promise based approach to requests. Others examples are code libraries like axios, superagent and got or some dedicated apps like Postman (or an online version, postwoman!), or a command line tool like cURL!.
  2. REST Service: the server. There are many popular libraries that make creation of these servers a breeze, like ExpressJS for NodeJS and Django for Python.
  3. REST API: this defines the endpoint and methods allowed to access/submit data to the server. We will talk about this in great detail below. Other alternatives to this are: GraphQL, JSON-Pure and oData.

So tell me now, how does REST look?

In very broad terms, you ask the server for a certain data or ask it to save some data, and the server responds to the requests.

In programming terms, there is an endpoint (a URL) that the server is waiting to get a request. We connect to that endpoint and send in some data about us (remember, REST is stateless, no data about the request is stored) and the server responds with the correct response.

Words are boring, let me give you a demonstration. I will be using Postman to show you the request and response:

The returned data is in JSON (JavaScript Object Notation) and can be accessed directly.

Here, is called an endpoint of an API. There will be a server listening on that endpoint for requests like the one we made.

Anatomy of REST:

Alright, so now we know that data can be requested by the client and the server will respond appropriately. Let's look deeper into how a request is formed.

  1. Endpoint: I have already told you about this. For a refresher, it is the URL where the REST Server is listening.
  2. Method: Earlier, I wrote that you can either request data or modify it, but how will the server know what kind of operation the client wants to perform? REST implements multiple 'methods' for different types of request, the following are most popular:
    - GET: Get resource from the server.
    - POST: Create resource to the server.
    - PATCH or PUT: Update existing resource on the server.
    - DELETE: Delete existing resource from the server.
  3. Headers: The additional details provided for communication between client and server (remember, REST is stateless). Some of the common headers are:
    - host: the IP of client (or from where request originated)
    - accept-language: language understandable by the client
    - user-agent: data about client, operating system and vendor
    - status: the status of request or HTTP code.
    - content-type: type of resource sent by server.
    - set-cookie: sets cookies by server
  4. Data: (also called body or message) contains info you want to send to the server.

Enough with the details – show me the code.

Let's begin coding a REST Service in Node. We will be implementing all the things we learnt above. We will also be using ES6+ to write our service in.

Make sure you have Node.JS installed and and are available in your path. I will be using Node 12.16.2 and NPM 6.14.4.

Create a directory and cd into it:

Initialize the node project:

The flag skips all the questions. If you want to fill in the whole questionnaire, just run .

Let's install some packages. We will be using the ExpressJS framework for developing the REST Server. Run the following command to install it:

What's there for? Express, by default, is incapable of handling data sent via POST request as JSON. allows Express to overcome this.

Create a file called and add the following code:

The first two lines are importing Express and body-parser.

Third line initializes the Express server and sets it to a variable called .

The line, initializes the body-parser plugin.

Finally, we are setting our server to listen on port for requests.

Getting data from the REST Server:

To get data from a server, we need a request. Add the following code before :

We have created a function which takes two parameters and (I will explain later) and sends a 'Hi!' as response.

takes two parameters, the route path and function to call when the path is requested by the client. So, the last line translates to: Hey server, listen for requests on the '/' (think homepage) and call the function if a request is made.

also gives us a object containing all the data sent by the client and a object which contains all the methods with which we can respond to the client. Though these are accessible as function parameters, the general naming convention suggests we name them for and for .

Enough chatter. Let's fire up the server! Run the following server:

If everything is successful, you should see a message on console saying: Server is running on port 5000.

Note: You can change the port to whatever number you want.

Open up your browser and navigate to and you should see something like this:

There you go! Your first request was successful!

Sending data to REST Server:

As we have discussed earlier, let's setup how we can implement a request into our server. We will be sending in two numbers and the server will return the sum of the numbers. Add this new method below the :

Here, we will be sending the data in JSON format, like this:

Let's get over the code:

On line 1, we are invoking the . method of ExpressJS, which allows the server to listen for requests. This function takes in the same parameters as the method. The route that we are passing is , so one can access the endpoint as or in our case . We are inlining our function instead of writing a function elsewhere.

On line 2, we have used a bit of ES6 syntax, namely, object destructuring. Whatever data we send via the request gets stored and is available in the of the object. So essentially, we could've replaced line 2 with something like:

On line 3, we are using the function of the object to send the result of the sum. Again, we are using template literals from ES6. Now to test it (using Postman):

So we have sent the data 5 and 10 as and using them as the body. Postman attaches this data to the request and sends it. When the server receives the request, it can parse the data from , as we did in the code above. The result is shown below.

Alright, the final code:

REST Client:

Okay, we have created a server, but how do we access it from our website or webapp? Here the REST client libraries will come in handy.

We will be building a webpage which will contain a form, where you can enter two numbers and we will display the result. Let's start.

First, let's change the a bit:

We imported a new package , which is provided by Node, to manipulate path cross-platform. Next we changed the request on '/' and use another function available in , ie. , which allows us to send any type of file as response. So, whenever a person tries to navigate to '/', they will get our page.

Finally, we changed our function to return the sum as JSON and convert both and to integers.

Let's create an html page, I will call it , with some basic styling:

Let's add a tag just before the closing body tag, so we don't need to maintain a file. We will begin by listening for the event and call a function accordingly:

First we need to prevent page refresh when the 'Add' button is clicked. This can be done using the function. Then, we will get the value of the inputs at that instant:

Now we will make the call to the server with both these values and . We will be using the Fetch API, built-in to every browser for this.

Fetch takes in two inputs, the URL endpoint and a JSON request object and returns a Promise. Explaining them here will be out-of-bounds here, so I'll leave that for you.

Continue inside the function:

First we are passing the relative URL of the endpoint as the first parameter to . Next, we are passing an object which contains the method we want Fetch to use for the request, which is in this case.

We are also passing , which will provide information about the type of data we are sending () and the type of data we accept as response ().

Next we pass . Remember we typed the data as JSON while using Postman? We're doing kind of a similar thing here. Since express deals with string as input and processes it according to content-type provided, we need to convert our JSON payload into string. We do that with . We're being a little extra cautious and parsing the input into integers, so it doesn't mess up our server (since we haven't implemented any data-type checking).

Finally, if the promise (returned by fetch) resolves, we will get that response and convert it into JSON. After that, we will get the result from the key returned by the response. Then we are simply displaying the result on the screen.

At the end, if the promise is rejected, we will display the error message on the console.

Here's the final code for :

I have spun up a little app on glitch for you to test.


So in this post, we learnt about REST architecture and the anatomy of REST requests. We worked our way through by creating a simple REST Server that serves and requests and built a simple webpage that uses a REST Client to display the sum of two numbers.

You can extend this for the remaining types of requests and even implement a full featured back-end CRUD app.

I hope you have learned something from this. If you have any questions, feel free to reach out to me over twitter! Happy Coding!

If you read this far, tweet to the author to show them you care. Tweet a thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started


Now discussing:

By the shoulder; a joyful smile flashed on Volodya's face. Returning home from work, I went up to my floor. was dressed in a white blazer with a large neckline and a short skirt.

1378 1379 1380 1381 1382