How to do a SOAP Web Service call from Java class?

I understand your problem boils down to how to call a SOAP (JAX-WS) web service from Java and get its returning object. In that case, you have two possible approaches:

1. Generate the Java classes through wsimport and use them; or
2. Create a SOAP client that:
   1. Serializes the service's parameters to XML;
   2. Calls the web method through HTTP manipulation; and
   3. Parse the returning XML response back into an object.

About the first approach (using wsimport):

I see you already have the services' (entities or other) business classes, and it's a fact that the wsimport generates a whole new set of classes (that are somehow duplicates of the classes you already have).

I'm afraid, though, in this scenario, you can only either:

• Adapt (edit) the wsimport generated code to make it use your business classes (this is difficult and somehow not worth it - bear in mind everytime the WSDL changes, you'll have to regenerate and readapt the code); or
• Give up and use the wsimport generated classes. (In this solution, you business code could "use" the generated classes as a service from another architectural layer.)

About the second approach (create your custom SOAP client):

In order to implement the second approach, you'll have to:

1. Make the call:
   • Use the SAAJ (SOAP with Attachments API for Java) framework (see below, it's shipped with Java SE 1.6 or above) to make the calls; or
   • You can also do it through java.net.HttpUrlconnection (and some java.io handling).
2. Turn the objects into and back from XML:
   • Use an OXM (Object to XML Mapping) framework such as JAXB to serialize/deserialize the XML from/into objects
   • Or, if you must, manually create/parse the XML (this can be the best solution if the received object is only a little bit differente from the sent one).

Creating a SOAP client using classic java.net.HttpUrlConnection is not that hard (but not that simple either), and you can find in this link a very good starting code.

I recommend you use the SAAJ framework:

SOAP with Attachments API for Java (SAAJ) is mainly used for dealing directly with SOAP Request/Response messages which happens behind the scenes in any Web Service API. It allows the developers to directly send and receive soap messages instead of using JAX-WS.

See below a working example (run it!) of a SOAP web service call using SAAJ. It calls this web service.

import javax.xml.soap.*;public class SOAPClientSAAJ {    // SAAJ - SOAP Client Testing    public static void main(String args[]) {        /*            The example below requests from the Web Service at:             https://www.w3schools.com/xml/tempconvert.asmx?op=CelsiusToFahrenheit            To call other WS, change the parameters below, which are:             - the SOAP Endpoint URL (that is, where the service is responding from)             - the SOAP Action            Also change the contents of the method createSoapEnvelope() in this class. It constructs             the inner part of the SOAP envelope that is actually sent.         */        String soapEndpointUrl = "https://www.w3schools.com/xml/tempconvert.asmx";        String soapAction = "https://www.w3schools.com/xml/CelsiusToFahrenheit";        callSoapWebService(soapEndpointUrl, soapAction);    }    private static void createSoapEnvelope(SOAPMessage soapMessage) throws SOAPException {        SOAPPart soapPart = soapMessage.getSOAPPart();        String myNamespace = "myNamespace";        String myNamespaceURI = "https://www.w3schools.com/xml/";        // SOAP Envelope        SOAPEnvelope envelope = soapPart.getEnvelope();        envelope.addNamespaceDeclaration(myNamespace, myNamespaceURI);            /*            Constructed SOAP Request Message:            <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:myNamespace="https://www.w3schools.com/xml/">                <SOAP-ENV:Header/>                <SOAP-ENV:Body>                    <myNamespace:CelsiusToFahrenheit>                        <myNamespace:Celsius>100</myNamespace:Celsius>                    </myNamespace:CelsiusToFahrenheit>                </SOAP-ENV:Body>            </SOAP-ENV:Envelope>            */        // SOAP Body        SOAPBody soapBody = envelope.getBody();        SOAPElement soapBodyElem = soapBody.addChildElement("CelsiusToFahrenheit", myNamespace);        SOAPElement soapBodyElem1 = soapBodyElem.addChildElement("Celsius", myNamespace);        soapBodyElem1.addTextNode("100");    }    private static void callSoapWebService(String soapEndpointUrl, String soapAction) {        try {            // Create SOAP Connection            SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory.newInstance();            SOAPConnection soapConnection = soapConnectionFactory.createConnection();            // Send SOAP Message to SOAP Server            SOAPMessage soapResponse = soapConnection.call(createSOAPRequest(soapAction), soapEndpointUrl);            // Print the SOAP Response            System.out.println("Response SOAP Message:");            soapResponse.writeTo(System.out);            System.out.println();            soapConnection.close();        } catch (Exception e) {            System.err.println("\nError occurred while sending SOAP Request to Server!\nMake sure you have the correct endpoint URL and SOAPAction!\n");            e.printStackTrace();        }    }    private static SOAPMessage createSOAPRequest(String soapAction) throws Exception {        MessageFactory messageFactory = MessageFactory.newInstance();        SOAPMessage soapMessage = messageFactory.createMessage();        createSoapEnvelope(soapMessage);        MimeHeaders headers = soapMessage.getMimeHeaders();        headers.addHeader("SOAPAction", soapAction);        soapMessage.saveChanges();        /* Print the request message, just for debugging purposes */        System.out.println("Request SOAP Message:");        soapMessage.writeTo(System.out);        System.out.println("\n");        return soapMessage;    }}

About using JAXB for serializing/deserializing, it is very easy to find information about it. You can start here: http://www.mkyong.com/java/jaxb-hello-world-example/.

Or just use Apache CXF's wsdl2java to generate objects you can use.

It is included in the binary package you can download from their website. You can simply run a command like this:

$ ./wsdl2java -p com.mynamespace.for.the.api.objects -autoNameResolution http://www.someurl.com/DefaultWebService?wsdl

It uses the wsdl to generate objects, which you can use like this (object names are also grabbed from the wsdl, so yours will be different a little):

DefaultWebService defaultWebService = new DefaultWebService();String res = defaultWebService.getDefaultWebServiceHttpSoap11Endpoint().login("webservice","dadsadasdasd");System.out.println(res);

There is even a Maven plug-in which generates the sources: https://cxf.apache.org/docs/maven-cxf-codegen-plugin-wsdl-to-java.html

Note: If you generate sources using CXF and IDEA, you might want to look at this: https://stackoverflow.com/a/46812593/840315

I found a much simpler alternative way to generating soap message.Given a Person Object:

import com.fasterxml.jackson.annotation.JsonInclude;@JsonInclude(JsonInclude.Include.NON_NULL)public class Person {  private String name;  private int age;  private String address; //setter and getters below}

Below is a simple Soap Message Generator:

import com.fasterxml.jackson.databind.DeserializationFeature;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.SerializationFeature;import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.StringUtils;import com.fasterxml.jackson.dataformat.xml.XmlMapper;@Slf4jpublic class SoapGenerator {  protected static final ObjectMapper XML_MAPPER = new XmlMapper()      .enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)      .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)      .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)      .registerModule(new JavaTimeModule());  private static final String SOAP_BODY_OPEN = "<soap:Body>";  private static final String SOAP_BODY_CLOSE = "</soap:Body>";  private static final String SOAP_ENVELOPE_OPEN = "<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">";  private static final String SOAP_ENVELOPE_CLOSE = "</soap:Envelope>";  public static String soapWrap(String xml) {    return SOAP_ENVELOPE_OPEN + SOAP_BODY_OPEN + xml + SOAP_BODY_CLOSE + SOAP_ENVELOPE_CLOSE;  }  public static String soapUnwrap(String xml) {    return StringUtils.substringBetween(xml, SOAP_BODY_OPEN, SOAP_BODY_CLOSE);  }}

You can use by:

 public static void main(String[] args) throws Exception{        Person p = new Person();        p.setName("Test");        p.setAge(12);        String xml = SoapGenerator.soapWrap(XML_MAPPER.writeValueAsString(p));        log.info("Generated String");        log.info(xml);      }