Web Services Interview Questions

There are basically two types of web services: 

SOAP (Simple Object Access Protocol) Web Services: It is also referred to as transport-independent messaging protocol whose main purpose is to transfer a message, and is based on XML protocol. 

RESTful (Representational State Transfer) Web Services: It is developed to fulfill the shortcomings of SOAP and to make the web services more effective. 

Some of the important features of web services include: 

• Used to standardized XML messaging system. 
• Not tied to any one programming language or any operating system. 
• Discoverable via a simple find mechanism. 
• Available over the internet or private networks. 
• Supports loosely coupled connections between systems. 
• Can be synchronous or asynchronous. 
• Supports the transparent exchange of data to facilitate business integration. 
• Supports communication among different apps with HTML, XML, WSDL, SOAP, etc. 
• Supports RPC (Remote Procedure Calls).

There are various components of web services as given below: 

• SOAP (Simple Object Access Protocol) 
• UDDI (Universal Description, Discovery, and Integration) 
• WSDL (Web Services Description Language) 
• RDF (Resource Description Framework) 
• XML (Extensible Markup Language) 

Synchronicity generally refers to the binding of the client to the function’s execution and it can be done in two ways i.e., synchronous and asynchronous. In Synchronous invocations, the client blocks and waits until the service complete its operation before continuing its work. In Asynchronous invocations, clients are allowed to invoke a service and execute other functions.

API (Application Programming Interface): It acts as an interface between two devices so that they can communicate with each other without any user intervention. Some of its features include customizable, easy integration with GUI, time effective, language-independent, etc. All APIs are not web services. 
Web Service: It facilitates interaction between two devices over a network. They are widely used for exchanging data among systems or applications. Some of its features include loosely coupled, supports document exchange, interoperability, extensibility, etc. All Web services are APIs. 

There are various tools used to test web service as given below: 

• SoapUI 
• Poster 
• Postman 
• REST client 
• JMeter

WSDL (Web Services Description Language), as the name suggests, is considered the standard format that is used to describe the availability of web services and how to access them. It is based on XML protocol for exchanging data in decentralized and distributed environments. It also describes the technical details or locates the user interface to the web service. WSDL document contains some important information as given below: 

• Method name and parameters  
• Port types 
• Service endpoint 
• Header information, etc. 

XML-RPC (Remote procedure call) is considered the most basic and simplest XML-based protocol to exchange data among different devices on a network. It uses HTTP as a transport protocol for quickly and easily transferring the information or data between two devices. XML-RPC can also be used with different programming languages such as Perl, Java, Python, C, C++, PHP, etc.

There are various features of XML-RPC that includes: 

• Platform independent 
• Allows diverse applications to communicate 
• Considered as the easiest and simplest way to get started with web services 
• Uses XML to encode its calls and HTTP as the transport protocol 

UDDI (Universal Description, Discovery, and Integration) is a directory service used for describing, publishing, and finding web services. It is also used for creating business registries. It is based on a set of web standards including HTTP, XML, SOAP, WSDL, XML Schema. Its main goal is to streamline digital transactions and e-commerce among company systems.

Some important features of UDDI include: 

• Platform independent 
• Uses WSDL for describing interfaces to web services 
• Can communicate through SOAP, Java RMI, and CORBA Protocol 
• The delineation between interface and implementation 
• Neutral in terms of protocols 

The language commonly used by UDDI is WSDL (Web Service Description Language). 

Every framework requires some type of architecture to ensure that the entire framework works perfectly as desired, the same goes for web services. Web service architecture is used to assist the developer with steps and procedures that are essential to complete the creation. Web service architecture includes three distinct roles i.e., service provider, service requester, and service registry. It also includes three different operations that include:  

Publish (Publication of Service Descriptions): A service description needs to be published so that the service requestor can locate and have access to it. It can be published anywhere depending upon the requirements of the application. 

Find (Finding of Services Descriptions): A service description is retrieved directly by a service requestor. The requestor consults the broker to locate a web service that is already published. 

Bind (Invoking of Service based on Service Description): Every service needs to be invoked. To locate, contact, and invoke the service, the service requestor initiates the interaction with the service at runtime using details of binding in the service description.  

Web service generally creates web services and provides access to the client application who wants it. Its main purpose is to implement the service and make it available on the Internet so that client applications can use it whenever required. In simple words, it is a platform that creates and hosts web services. 

Web service requestor is the client application that requests for web service to use it. Its main purpose is to use an existing web service by opening a network connection and sending an XML request. In simple words, they are consumers of the web service. 

The web service registry is basically like a ‘phone book’ for web services. It allows client applications to be able to publish new services or can locate the already existing ones. Two widely-used registry standards are generally supported by application servers i.e., ebXML (Electronic Business using XML) and UDDI (Universal Description, Discovery, and Integration). 

The implementation of web services generally depends on technologies that are often organized in a layered stack. Examining the web service protocol stack is considered as the second option for viewing the web service architecture. In simple words, it is the set of protocols that are used to explore and execute web services. Currently, the web service protocol stack has four layers as given below:

Service Transport: It is generally responsible to transport messages between applications. It basically defines technology standards for communication and allows messages or information to move across the network without any difficulty. It uses HTTP, SMTP, FTP, and DEEP protocols to transfer information.  
XML Messaging: It is generally responsible to encode messages into XML format so that one can understand these messages at either end. This layer generally includes XML-RPC and SOAP.  
Service Description: It is generally responsible to describe the public interface to a specific web service. WSDL is generally used to handle service descriptions.
Service Discovery: It is generally responsible to centralize service into a common registry and provides easy functionality for publishing or finding web services. UDDI is generally used to handle service discovery.

REST (Representational State Transfer) is a stateless client-server architecture style used for developing applications that are accessible over the web. It is a type of web service whose main goal is to make web services more effective. It can be defined as the web service that uses HTTP methods for implementing the REST architecture. Unlike SOAP which is protocol-based, Restful services are architecturally based. It does not contain any contract or WSDL file.  

There are several advantages of RESTful web services as given below: 

• Platform independent. 
• Simple and easy to implement and test. 
• Support different formats such as JSON, XML, HTML, etc. 
• Can be written in different programming languages and executed on any platform. 
• Lightweight, manageable, scalable, and reusable. 
• Faster and provide better performance. 
• Consume less bandwidth and resources. 
• A lot of automation framework is available

The protocol used by RESTful web services is HTTP. 

Statelessness is basically a condition or restriction where RESTful web services are not allowed to keep a client state on the server as per the REST architecture. Clients are responsible to pass their context to the server. To process the client’s request, the server then further stores this context.  

Advantages:  

• No need to maintain previous interactions with clients.
• Independent treatment of each method request.
• Less complexity and simplified application design.

Example: Simple GET Request using NodeJS

We have the following sample data in users.json file.
Filename: users.json

{
  "user1" : {
     "name" : "gourav",
     "password" : "password1",
     "profession" : "officer",
     "id": 1
  },
  
  "user2" : {
     "name" : "nikhil",
     "password" : "password2",
     "profession" : "teacher",
     "id": 2
  }
}

Implement our RESTful API listUsers using the following code in a server.js file.
Filename: server.js

// Requiring module
var express = require('express');
var app = express();
var fs = require("fs");
// Sample GET API
app.get('/listUsers', function (req, res) {
  fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
     console.log( data );
     res.end( data );
  });
})
// Server setup
var server = app.listen(8081, function () {
  var host = server.address().address
  var port = server.address().port
  console.log("Example app listening at http://%s:%s", host, port)
})

Now open a browser and go to http://127.0.0.1:8081/listUsers,  we will get the following response:

{
  "user1" : {
     "name" : "gourav",
     "password" : "password1",
     "profession" : "officer",
     "id": 1
  },
  
  "user2" : {
     "name" : "nikhil",
     "password" : "password2",
     "profession" : "teacher",
     "id": 2
  }
}

Some of the HTTP methods that can be used with RESTful web services include: 

• GET: Used to get and read a resource. 
• POST: Used to create a new resource. 
• PUT: Used to update existing resources. 
• DELETE: Used to delete the resource. 
• PATCH: Used to apply partial modifications to a resource.

REST API generally returns the following status codes in HTTP response:

• 200 OK
• 201 Created
• 202 Accepted
• 302 Found
• 400 Bad Request
• 401 Unauthorized 
• 404 Not Found
• 405 Method Not Allowed
• 409 Conflict
• 500 Internal Server Error

SOAP (Simple Object Access Protocol) is an XML-based protocol that is used to access web services. It is simply used to interchange data or information between two devices or computers using request and response based on XML format over transport protocols like HTTP, SMTP, etc. 

Advantages: 

• Language and Information independent. 
• Can be written in different programming languages or operating systems. 
• Provide data transport for web services.  
• Can extend HTTP for XML messaging. 
• Defines and uses its own WS security. 
• Easy to debug and eliminate firewall issues. 

The SOAP message is basically an ordinary XML document consists of three parts as given below: 

SOAP Envelope: It is a mandatory element that identifies XML documents as a SOAP message. It simply defines the start and the end of the message.  

SOAP Header: It is an optional element that contains header information.  

SOAP Body: It is a mandatory element that contains call and response information. It includes XML data consisting of the message that is being sent. 

The following block depicts the general structure of SOAP XML request and response: 

XML Request 

<Envelope xmlns=?http://schemas.xmlsoap.org/soap/envelop/?>   
<Body>   
    <getCourseDetailRequest xmlns=?http://udemy.com/course?>   
       <id>course1</id>   
    <getCourseDetailRequest>   
</Body>   
</Envelope>  

XML Response 

<SOAP-ENV:Envelope xmlns:SOAP-ENV=?http://schemas.xmlsoap.org/soap/envelope/?>   
      <SOAP-ENV:Header />          <!?empty header-->   
       <SOAP-ENV:Body>             <!?body begin-->   
              <ns2:getCourseDetailsResponse xmlns:ns2=?http://in28mi> <!--content of the response-->   
               <ns2:course>   
                <ns2:id>Course1</ns2:id>   
                <ns2:name>Spring<ns2:name>   
                <ns2:description>10 Steps</ns1:description>   
                </ns2:course>   
                </ns2:getCourseDetailResponse>   
           </SOAP-ENV:Body>    <!?body end-->   
</SOAP-ENV:Envelope>  

SOA (Service Oriented Architecture) is basically an architectural approach that is specially designed to support service orientation. It enabled services to communicate or interact across different platforms and languages to form applications. Applications in SOA are developed on the basis of services. It can be easily implemented using different protocols such as HTTP, JMS, HTTPS, RPC, RMI, etc.  

Some of its advantages include:  

• Easy to integrate. 
• Services are platform-independent. 
• Manage complexity so that integration becomes more manageable. 
• Services are easier to test and debug. 
• Easily available to any requester. 

The three primary security issues of web services include: 

• Confidentiality 
• Authentication 
• Network Security 

Components that are needed to be published while deploying a web service includes: 

• Web Application Directory 
• Webservice.asmx File 
• Webservice.Disco File 
• Web.Config File 
• Bin Directory 

Sun-jaxws.xml file is simply used to provide endpoint details when JAX-WS web services are deployed as a standard WAR archive on a servlet container like Tomcat. It is also available in the WEB-INF directory. 

Example: 

<?xml version="1.0" encoding="UTF-8"?> 
<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0"> 
 <endpoint 
    name="HelloWorldWS" 
    implementation="org.arpit.javapostsforlearning.webservice.HelloWorldImpl" 
    url-pattern="/HelloWorldWS"/> 
</endpoints> 

Distributed technologies are in high demand nowadays because of the increasing ratio of distributed applications. It simply enables segmenting of application units and transferring these units to various computers on different networks. 

No, there is no need for a special application to have access to the Web service. One can access web applications from any of the applications that support XML-based object requests and responses. 

The two Microsoft solutions for distributed applications include:

• .NET Web Services 
• .NET Remoting

Some important annotations of the JAX-RS API include: 

• @Path: It is specially used to specify the relative path of resource class and methods. This annotation can be used on any class or method in code. It binds the URI pattern to a Java method.
• @GET, @PUT, @POST, @DELETE, @HEAD: It is specially used to specify HTTP request type for a method. These annotations can be specified on the JAX-RS method.
• @Produces: This annotation is specially used to specify HTTP responses generated by web services.
• @Consumes: This annotation is specially used to specify HTTP Requests.  
• @PathParam: It is specially used to specify parameters to path value by parsing.  

JAX-RS (Java API for RESTful web services) is basically an essential part of the Java EE platform that is being used for developing or building RESTful web services. There are basically two important implementations of JAX-RS API: 

• Jersey 
• RESTEasy 

Some important annotations of JAX-WS include: 

• @WebService 
• @WebMethod 
• @SOAPBinding 
• @WebResult 
• @WebServiceClient

JAX-WS (Java API for SOAP Web Services) is basically an essential part of the Java EE platform that is being used for developing or building SOAP web services and clients that communicate using XML. It enables developers to write message-oriented and RPC-oriented web services. There are basically two important implementations of JAX-WS: 

RPC Style: It generates WSDL documents on the basis of the method name and its parameters. There are no type definitions present in the WSDL document.

Document Style: In this, one can transport XML messages as a part of SOAP requests unlike in RPC-style web service.  

Java web services is basically a type of web service that is being designed to develop and deploy basic web service on the Java platform. Java web service applications perform communication through WSDL and these applications can be accessed by different programming languages including .Net, PHP, etc. Two ways to write java web application code include SOAP and RESTful. 

EIS (Entrust Identification Service): It is basically generated from Entrust security platform which allows or enables the corporates simply to handle and control the identities that are trusted to perform transactions for web service transactions.  

EPS (Entrust Privacy Service): It deals with security and confidentiality simply by encrypting data. It is done to make sure that only concerned parties or authorized ones can have access to data. 

EES (Entrust Entitlement Service), generally refers to a service that verifies entities that attempt to access a web service. 

Wsimport is basically a command-line tool that processes an existing WSDL file to generate all required web service artifacts for a web service client to access the published web services. It also supports a top-down approach for developing JAX-WS web services. In simple words, it generates Java classes from WSDL. 

DISCO (Discovery), as the name suggests, is a Microsoft technology that is being used to discover web services. It is the process of locating and interrogating web service descriptions which is a preliminary step for having access to web services over the Internet.  The organization that provides web services generally provides a DISCO file on its server that includes the links of all the available web services so that it can be used within the local network. 

BEEP (Blocks Extensible Exchange Protocol) is basically an IETF (Internet Engineering Task Force) framework that is generally used to develop network application protocols. One can create these new protocols for different applications such as instant messaging, network management, file transfer, content syndication, etc. It is directly layered over TCP. BEEP has various in-build features such as authentication, security, initial handshake protocol, error handling, etc. 

using System;   
using System.Web.Services;   
using System.Xml.Serialization;   
[WebService(Namespace="http://localhost/MyWebServices/")]   
public class FirstService : WebService  
{   
  [WebMethod]   
  public int Add(int a, int b)  
  {   
  return a + b;   
  }   
 [WebMethod]   
  public String SayHello()  
  {   
  return "Hello World";   
  }   
}  

In REST-based web services, URI (Uniform Resource Locator) is generally used to locate resources on the server that is hosting the web service. Each resource in service will have at least one URI that is used to identify it. Web services clients generally use URI to access the resource. Its format is given below: 

<protocol>://<service-name>/<ResourceType>/<ResourceID>

Security is considered a very important feature in any web application. It is essential in web services so that we can make confidential or sensitive information and transactions more reliable. In web services, the security is attained through SSL (Service Socket Layer) that helps in developing EST (Entrust Secure Transaction) platform.

.NET Remoting: It is a method that enables objects to communicate or interact with each other across application domains, processes, and machine boundaries, whether application components are present in one computer or different computers across the entire world. 

.NET Web service: It is a method that enables cross-platform integration by using XML, HTTP, and SOAP for communication among two devices over WWW. It simply shares business logic, processes, and data through programmatic interfaces across a network.

Both of them are powerful technologies that provide suitable frameworks and thus support the development of distributed technologies and application integration. There is some difference between these two technologies as given below. 

HTTP Handles are generally used to implement web services in .NET because HTTP handles interrupt requests to .asmx files. 

The main purpose of @XmlRootElement is to transform or convert Java objects to XML and vice versa. It is generally the base common annotation used for JAXB API. It uniquely associates a root element with a class.  

JAXP (Java API for XML Processing) is basically a Java API that allows parsing, transform, validate, and queries XML files with DOM (Document Object Model), SAX (Simple API for XML), or StAX (Streaming API for XML) Parsers/Parsing interfaces. It is used for processing XML data using applications that are written in Java programming language.  

JAXB (Java Architecture for XML Binding) is basically a Java standard that is used to define how Java objects get converted into XML and vice-versa. Using Java facilitates the reading and writing of XML. It makes it easier to access XML documents from applications that are written in the Java programming language. There are three different packages in JAXB binding framework that includes: 

• xml.bind 
• xml.bind.util 
• xml.bind.helper 

The web service method that is read-only and safe is the GET method, and the web service methods that are idempotent are PUT and DELETE operations. Idempotent refers to the operations whose results will always be the same even if these operations are invoked so many times.  

Spring WS (Web Service) is basically a product of the spring community whose main focus is to develop document-driven web services. It only aims to facilitate contract-first SOAP service development. It allows the development of web services that are flexible.

No, Spring-WS does not support the contract's last development approach. It only supports the contract-first development approach.

Web services are very important as they provide standardized web protocols I.e., HTTP or HTTPS simply to interoperate, communicate, and exchange information in XML format via the internet. Some of its advantages include:  

• Allows devices to talk to each other and share data or services between themselves. 
• Makes the application platform and technology independent. 
• Uses standardized standard protocol for communication.  
• User SOAP over HTTP protocol so that one can use their low-cost internet for implementing web services. 
• Allows business logic of different systems to be available over the web. 
• Can be used at the same time by many client applications. 

Web services are considered as one of the key elements of programmable Web that allows individuals to communicate and share relevant information on two applications over the same network. It has become an essential and critical element of development for web developers. These services are effectively used to participate in and set up B2B transactions. The above given are the most important interview questions regarding Web services. Sharpen your knowledge before you face the interviewer.

Recommended Resources:

Web API Interview

REST API Interview