Java Additional Topics

Java Web Services

Last Updated : 16 Oct 2026

The Java Web Services enable web based interactions online with HTTP or HTTPS within various software systems. Services allow various software to interoperate no matter the language that is used, the operating system and even the architecture that was used and so on.

These two are the common web services during the development of web based applications that can be categorized as either SOAP and RESTFull. SOAP implements a strict message exchange protocol based on XML whereas REST is based on a rather undefined style and utilizes standard HTTP methods such as GET, POST, PUT or DELETE.

Java; As for the creation of the web services, there are many libraries in Java and to use a web service too. The most utilised patterns for developing Java Web Services are implementing JAX-WS pattern, which is Java API for XML Web Services for the SOAP environment as well as the JAX-RS which is Java API for RESTful Web Services for the REST environment.

Constructing a JAX-WS-Based SOAP Web Service

Java SOAP web services are created using the JAX-WS standard. It makes XML communications based on the SOAP protocol possible for communication. The main benefits of SOAP-based services are consistent message dependability, standardised security, and transactions.

Example: Simple Calculator SOAP Service

Step 1: Create the Interface

import javax.jws.WebService;
import javax.jws.WebMethod;
@WebService
public interface CalculatorService {
    @WebMethod
    public int add(int a, int b);
    @WebMethod
    public int subtract(int a, int b);
}   

Step 2: Implement the Service

import javax.jws.WebService;
@WebService(endpointInterface = "com.example.CalculatorService")
public class CalculatorServiceImpl implements CalculatorService {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
    @Override
    public int subtract(int a, int b) {
        return a - b;
    }
}   

Step 3: Publish the Service

import javax.xml.ws.Endpoint;
public class CalculatorServicePublisher {
    public static void main(String[] args) {
        Endpoint.publish("http://localhost:8080/calculator", new CalculatorServiceImpl());
        System.out.println("Calculator Service is running at http://localhost:8080/calculator");
    }
}   

Step 4: Test the Service

This will create the WSDL (Web Services Description Language) at http://localhost:8080/calculator?wsdl. With the use of programs like Postman or SOAP-UI, you may test the service.

Building a RESTful Web Service with JAX-RS

JAX-RS is a specification that helps to fashion RESTful web services in Java more easily. Namely, because of their effectiveness and capacity to adapt, REST services are used in the online and mobile platforms more than SOAP services. They are also lighter than SOAP services The following annotations show that commenting, asking, following, answer, and question annotations are light-weight SOAP services. Annotations applied on JAX-RS provide the information regarding the RESTful endpoints.

Example: RESTful CRUD API for Managing Users

Step 1: Define the Model

public class User {
    private int id;
    private String name;
    private String email;
    // Constructors, Getters, and Setters
}   

Step 2: Create the Service

import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.HashMap;
import java.util.Map;
@Path("/users")
public class UserService {
    private static Map<Integer, User> users = new HashMap<>();
    private static int idCounter = 1;
    @GET
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    public User getUser(@PathParam("id") int id) {
        return users.get(id);
    }
    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public User createUser(User user) {
        user.setId(idCounter++);
        users.put(user.getId(), user);
        return user;
    }
    @PUT
    @Path("/{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public User updateUser(@PathParam("id") int id, User user) {
        user.setId(id);
        users.put(id, user);
        return user;
    }
    @DELETE
    @Path("/{id}")
    public void deleteUser(@PathParam("id") int id) {
        users.remove(id);
    }
}   

Step 3: Configure the Application

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;
@ApplicationPath("/api")
public class UserApplication extends Application {
}   

Step 4: Deploy and Test Deploy the application to a servlet container like Apache Tomcat or GlassFish. You can then access the endpoints via HTTP:

GET user by ID: GET /api/users/{id}
Create a new user: POST /api/users
Update a user: PUT /api/users/{id}
Delete a user: DELETE /api/users/{id}

Next TopicImplicitly Typecasting in Java

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.