How to do a SOAP Web Service call from Java class


This example will show you how to do a SOAP web service call from Java class. Normally you would use the web service library for invoking the SOAP service but in some cases this could be useful and quick. For example, you may have problems generating a client proxy with a web service library or if you only need some small specific parts of the response. It is just a SOAP call over HTTP or HTTPS protocol from a plain piece of Java code without using any Java library. In fact you can invoke SOAP service from any language being web service platform independent.

Now in order to consume the service or SOAP web service call from Java class, we must have the service deployed somewhere. So please read Spring SOAP WebService Producers using Gradle before consuming this SOAP service. We will create here client which will consume the service in the given link. If you want to use library to consume the service then you can read Spring SOAP WebService Consumers using Gradle


Knowledge of Java and SOAP Webservice, Java at least 1.8

Spring SOAP WebService Producers using Gradle

Example with Source Code

Finding the WSDL

In order to SOAP web service call from Java class first open the WSDl file at http://localhost:9999/ws/users.wsdl from tutorial Spring SOAP WebService Producers using Gradle.

In the WSDL file given in the above link, look for XSD, SOAP Operation and SOAP address location in the WSDL file. So you will find SOAP request name getUserDetailsRequest and SOAP response name getUserDetailsResponse. Also check for the input parameter(s) for request. Here we see only one parameter called name, which is of string type.

Request XML

We don’t need to build the response XML structure using Java code because we will get it from the server side but we need to build the request XML structure because we need to provide it as an input to the SOAP service.

Therefore if we build the request XML structure, it will look similar to below:

<soapenv:Envelope xmlns:soapenv="">
	<getUserDetailsRequest xmlns="">
		<name>Liton Sarkar</name>

SOAP Address

Now find the SOAP address location, which is used as an endpoint URL for SOAP service and at this endpoint we will connect using Java’s HttpURLConnection API.

Here the endpoint URL is http://localhost:9999/ws

SOAP Operation

Next is to find the operation name, which will be used as a SOAP Action. Here it is getUserDetails.

Creating SOAP Client

Now we have identified all the required things and are ready to create the client class.

package com.roytuts.soap.client;
import java.nio.charset.Charset;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
public class SoapClient {
	public static void main(String[] args) throws IOException {
		// Code to make a webservice HTTP request
		String responseString = "";
		String outputString = "";
		String wsEndPoint = "http://localhost:9999/ws";
		URL url = new URL(wsEndPoint);
		URLConnection connection = url.openConnection();
		HttpURLConnection httpConn = (HttpURLConnection) connection;
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		String xmlInput = "<soapenv:Envelope xmlns:soapenv=""><soapenv:Header/><soapenv:Body><getUserDetailsRequest xmlns=""><name>Liton Sarkar</name></getUserDetailsRequest></soapenv:Body></soapenv:Envelope>";
		byte[] buffer = new byte[xmlInput.length()];
		buffer = xmlInput.getBytes();
		byte[] b = bout.toByteArray();
		String SOAPAction = "getUserDetails";
		httpConn.setRequestProperty("Content-Length", String.valueOf(b.length));
		httpConn.setRequestProperty("Content-Type", "text/xml; charset=utf-8");
		httpConn.setRequestProperty("SOAPAction", SOAPAction);
		OutputStream out = httpConn.getOutputStream();
		// Write the content of the request to the outputstream of the HTTP
		// Connection.
		// Ready with sending the request.
		// Read the response.
		InputStreamReader isr = new InputStreamReader(httpConn.getInputStream(), Charset.forName("UTF-8"));
		BufferedReader in = new BufferedReader(isr);
		// Write the SOAP message response to a String.
		while ((responseString = in.readLine()) != null) {
						outputString = outputString + responseString;
		// Write the SOAP message formatted to the console.
		String formattedSOAPResponse = formatXML(outputString);
	// format the XML in pretty String
	private static String formatXML(String unformattedXml) {
		try {
			Document document = parseXmlFile(unformattedXml);
			TransformerFactory transformerFactory = TransformerFactory.newInstance();
			transformerFactory.setAttribute("indent-number", 3);
			Transformer transformer = transformerFactory.newTransformer();
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			DOMSource source = new DOMSource(document);
			StreamResult xmlOutput = new StreamResult(new StringWriter());
			transformer.transform(source, xmlOutput);
			return xmlOutput.getWriter().toString();
		} catch (TransformerException e) {
			throw new RuntimeException(e);
	// parse XML
	private static Document parseXmlFile(String in) {
		try {
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			InputSource is = new InputSource(new StringReader(in));
			return db.parse(is);
		} catch (IOException | ParserConfigurationException | SAXException e) {
			throw new RuntimeException(e);

Testing the Application

Now when you run the above Java class you will see the below output in the console.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="">
      <ns2:getUserDetailsResponse xmlns:ns2="">
            <ns2:name>Liton Sarkar</ns2:name>
               <ns2:street>Sukanta Nagar</ns2:street>

How to call over HTTPS

People who want to call SOAP webservice over https connection, use the concept of the below code example. This example shows both GET and POST method how to call SOAP webservice from plain Java code.




public class JavaSoapHttpsClient {

	public static void main(String[] args) throws Exception {
		invokeSoapService("", "POST", "<xml><body>SAOP request</body></xml>");

		invokeSoapService("", "GET", null);

	public static void invokeSoapService(final String url, final String httpMethod, final String requestXML)
			throws IOException {
		URL myUrl = new URL(url);
		HttpURLConnection conn = (HttpsURLConnection) myUrl.openConnection();

		OutputStreamWriter out = null;
		if ("POST".equals(httpMethod) && requestXML != null) {
			out = new OutputStreamWriter(conn.getOutputStream());

		BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));

		String inputLine;
		System.out.println("Response Code: " + conn.getResponseCode());
		System.out.print("Response Text: ");

		while ((inputLine = br.readLine()) != null) {

		if (out != null) {



The above piece of code is not well written but just an example on how to call over https protocol. So when you are writing your code for your application try to consider all programming standards.

That’s all. Thanks for reading.

1 thought on “How to do a SOAP Web Service call from Java class

Leave a Reply

Your email address will not be published. Required fields are marked *