SOAP (Simple Object Access Protocol) provides a standard way for applications to communicate over the internet. Built on the XML standard, SOAP allows applications to exchange information independent of their hardware and software platforms. This article will cover how to write a basic SOAP web service using Java that can be called by other programs or devices.
Creating the Project
The first step is to create a Java project in your IDE of choice. We’ll use Eclipse in this example. Create a new Java project called “SOAPService”. You will need to add the relevant SOAP libraries to the project classpath. Common SOAP implementations for Java include Apache Axis2 and JAX-WS. For this example we will use JAX-WS (built into the JDK since Java 6).
Defining the Service Interface
All SOAP web services require a WSDL (Web Service Description Language) definition that describes the service API. To generate this definition we first need to define a Java interface that will represent the web service operations. Create a new Java interface called ‘HelloService’:
java
Copy
package com.example.soap;
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
@WebService
@SOAPBinding(style = SOAPBinding.Style.RPC)
public interface HelloService {
@WebMethod String sayHello(String name);
}
This interface defines a single web method ‘sayHello’ that accepts a String name parameter and returns a String. The WebService and SOAPBinding annotations indicate this will be exposed as a SOAP web service using the RPC style.
Implementing the Service
Now we need to create a concrete class that implements this interface. Create a new class called ‘HelloServiceImpl’ that looks like:
java
Copy
package com.example.soap;
import javax.jws.WebService;
@WebService(endpointInterface = “com.example.soap.HelloService”)
public class HelloServiceImpl implements HelloService {
@Override
public String sayHello(String name) {
return “Hello ” + name;
}
}
This class simply returns a greeting message by concatenating “Hello ” with the passed in name. The @WebService annotation assigns it to implement the HelloService interface we defined earlier.
Publishing the Service
To publish this service on a web endpoint we need to create a JAX-WS endpoint. Add the following to your HelloServiceImpl class:
java
Copy
@WebService(endpointInterface = “com.example.soap.HelloService”)
public class HelloServiceImpl implements HelloService {
// service implementation
public static void main(String[] args) {
HelloService service = new HelloServiceImpl();
Endpoint.publish(“http://localhost:9000/hello”, service);
}
}
This creates an instance of the service implementation and uses the Endpoint API to publish it on port 9000 at the relative path /hello. Now the service is exposed and waiting for SOAP requests.
Testing the Service
To test the exposed service we can generate client side artifacts that allow invoking it programmatically. Run the wsimport tool included with JAX-WS:
Copy
wsimport -keep http://localhost:9000/hello?wsdl
This will download the WSDL definition and generate Java proxy classes we can use to invoke the service. Import the generated package into a test client class:
java
Copy
package com.example.soap.client;
import generated.HelloService;
import generated.HelloServiceService;
public class Client {
public static void main(String[] args) {
HelloService service = new HelloServiceService().getHelloPort();
String response = service.sayHello(“World”);
System.out.println(“Response: ” + response);
}
}
When run, this will call the exposed web service and print the response:
Copy
Response: Hello World
Debugging and Testing
To debug and test the service further you can use tools like soapUI to send sample SOAP requests directly to the service endpoint. The service implementation logs and response payloads can also be examined. Additional tests cases covering different input parameters, error conditions etc. should also be added.
Securing the Service
For production use, security such as transport level SSL/TLS and message level authentication/authorization should be configured. The JAX-WS standard provides built-in support for WS-Security. Implementing security involves defining security policies, attaching digital signatures to messages etc. for the chosen security model.
Some key aspects when finalizing the service would be documentation of the service WSDL and operations, versioning strategy for future changes, monitoring, and handling service faults. Deployment to an application server or cloud also provides additional features like load balancing.
This covers the basics of writing a simple SOAP web service in Java using JAX-WS. SOAP continues to be widely used in enterprise integration scenarios due to its extensive tooling support, standardization and integration capabilities across platforms/languages. With tools maturity SOAP remains an important protocol for programmatic access to services over the web.