SOAP (Simple Object Access Protocol) is a protocol used for exchanging structured information in the implementation of web services. Java provides the JAX-WS (Java API for XML Web Services) API for creating and consuming SOAP-based web services. In this article, we will demonstrate step-by-step how to implement SOAP-based services using JAX-WS in Java.
JAX-WS is a part of the Java EE (Enterprise Edition) and provides a framework for building and deploying SOAP-based web services in Java. JAX-WS allows developers to create web services from Java classes (known as endpoint classes) and exposes these services through WSDL (Web Services Description Language).
JAX-WS simplifies the process of creating SOAP services by providing annotations and tools for generating necessary artifacts, such as the WSDL file and client code. It supports both RPC (Remote Procedure Call) and document-style SOAP messages.
To begin implementing SOAP-based services with JAX-WS, you need to set up a Java development environment. If you are using Maven, add the following dependencies to your pom.xml file:
<dependencies>
<dependency>
<groupId>javax.xml.ws</groupId>
<artifactId>jaxws-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.core</groupId>
<artifactId>jersey-server</artifactId>
<version>2.31</version>
</dependency>
</dependencies>
These dependencies include the JAX-WS API and other necessary libraries for creating and running SOAP web services in Java. You can also use a simple Java SE environment with a standalone servlet container (such as Apache Tomcat) for deploying your services.
To create a SOAP-based web service using JAX-WS, you need to define a Java class that will serve as the endpoint. This class should contain methods that will be exposed as web service operations.
import javax.jws.WebMethod;
import javax.jws.WebService;
@WebService
public class EmployeeService {
@WebMethod
public String getEmployeeDetails(int id) {
// Logic to retrieve employee details based on id
return "Employee ID: " + id + ", Name: John Doe, Role: Developer";
}
}
The EmployeeService class is annotated with @WebService, which marks it as a web service. The method getEmployeeDetails is annotated with @WebMethod, making it available as an operation that can be invoked over SOAP.
Once the endpoint class is created, you can publish the web service using the Endpoint class provided by JAX-WS. This class allows you to expose the service and make it accessible over a network.
import javax.xml.ws.Endpoint;
public class EmployeeServicePublisher {
public static void main(String[] args) {
// Create the web service endpoint
EmployeeService employeeService = new EmployeeService();
// Publish the web service to a specific URL
Endpoint.publish("http://localhost:8080/employeeService", employeeService);
System.out.println("Web service is published at http://localhost:8080/employeeService");
}
}
In this example, the EmployeeServicePublisher class publishes the EmployeeService web service at the specified URL (http://localhost:8080/employeeService). You can change the URL to suit your requirements.
When you publish a JAX-WS web service, a WSDL file is automatically generated. The WSDL describes the available operations, input/output messages, and data types used in the service. You can access the WSDL by appending ?wsdl to the service URL.
http://localhost:8080/employeeService?wsdl
Visit the above URL in your browser, and you will see the WSDL for the EmployeeService. This WSDL defines the structure of the SOAP messages and the available operations.
Once the web service is published, you can create a client to consume the service. JAX-WS provides a Service class to create a proxy for the web service and invoke its methods.
import javax.xml.ws.Service;
import java.net.URL;
public class EmployeeServiceClient {
public static void main(String[] args) throws Exception {
// Create a URL pointing to the WSDL of the service
URL url = new URL("http://localhost:8080/employeeService?wsdl");
// Create a service object
Service service = Service.create(url, new QName("http://example.com/", "EmployeeService"));
// Get the port (proxy) to the web service
EmployeeService employeeService = service.getPort(EmployeeService.class);
// Call the web service method
String response = employeeService.getEmployeeDetails(123);
System.out.println("Response: " + response);
}
}
The EmployeeServiceClient class demonstrates how to create a client to consume the SOAP web service. The Service class is used to create a proxy object that allows invoking the getEmployeeDetails method remotely.
To test the SOAP-based service, run the service publisher class and the client class. The service will be accessible at the specified URL, and the client will call the service and print the response.
In this article, we demonstrated how to implement SOAP-based web services in Java using JAX-WS. We created a simple EmployeeService class, published it as a SOAP web service, and consumed it with a client. JAX-WS simplifies the process of creating and exposing SOAP services and provides the necessary tools to work with WSDL and SOAP messages. By understanding JAX-WS, you can build robust and platform-independent web services in Java.