Introduction to Java Web ApplicationsTo display "Hello, World" on the web using Java, you need to create a web application. This involves a server-side component written in Java that responds to HTTP requests from web browsers (clients). The standard for building web applications in Java is the Java Servlet API, which defines how Java programs interact with web servers. 
Key components typically involved: - Client: A web browser (e.g., Chrome, Firefox) that sends HTTP requests.
- Web Server / Servlet Container: Software like Apache Tomcat, Jetty, or WildFly that hosts the Java web application. It manages the application's lifecycle, processes incoming HTTP requests, and delegates them to the appropriate Java components (Servlets).
- Java Servlet: A Java class that extends
HttpServlet and implements methods to handle specific HTTP request types (e.g., GET, POST).
Core Component: Java ServletsA Servlet is a Java class that extends the capabilities of servers that host web sites. While servlets can respond to any type of request, they are commonly used to extend web servers, providing a component-based, platform-independent method for building dynamic web applications. For a simple "Hello, World" display, we typically implement the doGet() method of an HttpServlet. This method is invoked when a client sends an HTTP GET request to the servlet's configured URL. Inside this method, we obtain a PrintWriter object from the HttpServletResponse and use it to write the response (usually HTML) directly back to the client's browser. Simple Hello World Servlet CodeHere's the minimal Java code for a servlet that displays "Hello, World": import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
// The @WebServlet annotation maps this servlet to the URL pattern "/hello"
// When a request comes to a URL ending with "/hello" within this application,
// this servlet will be invoked.
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
// This method is called when an HTTP GET request is made to this servlet.
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set the content type of the response to HTML, indicating to the browser
// how to interpret the response body.
response.setContentType("text/html");
response.setCharacterEncoding("UTF-8"); // Ensure proper character encoding
// Get a PrintWriter object to send the response back to the client.
// This is where you write the actual content that the browser will display.
PrintWriter out = response.getWriter();
try {
// Write the HTML content directly to the client's browser.
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<title>Hello, World!</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Hello, World!</h1>");
out.println("<p>This is a simple Java Servlet example.</p>");
out.println("</body>");
out.println("</html>");
} finally {
// It's good practice to close the PrintWriter to release resources.
out.close();
}
}
}
Explanation of Key Elements: @WebServlet("/hello"): This annotation (available since Servlet API 3.0) maps this HelloServlet class to the URL path /hello. When a browser requests a URL like http://your-server/your-app-context/hello, this servlet will handle it.extends HttpServlet: This makes our class a specialized Servlet capable of handling HTTP requests. HttpServlet provides convenient methods like doGet(), doPost(), etc.doGet(HttpServletRequest request, HttpServletResponse response): This method is overridden to handle HTTP GET requests.request: An object containing information about the client's request (e.g., headers, parameters, URL).response: An object used to send data back to the client (e.g., setting content type, writing HTML).
response.setContentType("text/html"): This crucial line tells the client's browser that the content being sent back is HTML, so the browser should render it accordingly.response.getWriter(): Returns a PrintWriter object, which is used to send text-based response data (like HTML) to the client.out.println(...): These lines write the HTML content directly into the HTTP response body, which the browser then receives and displays.
Project Setup and DependenciesTo compile and run this servlet, you'll need a Java Development Kit (JDK) and typically a build automation tool like Maven or Gradle. Maven pom.xml configuration (minimal): <project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>my-hello-app</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging> <!-- Crucial for web applications -->
<properties>
<maven.compiler.source>11</maven.compiler.source> <!-- Your JDK version -->
<maven.compiler.target>11</maven.compiler.target> <!-- Your JDK version -->
<jakarta.servlet.version>5.0.0</jakarta.servlet.version> <!-- For Servlet API 5.0+ -->
<!-- Or for older Servlet API (3.x-4.x / Java EE) use:
<javax.servlet.version>4.0.1</javax.servlet.version>
-->
</properties>
<dependencies>
<!-- Servlet API dependency -->
<dependency>
<groupId>jakarta.servlet</groupId>
<artifactId>jakarta.servlet-api</artifactId>
<version>${jakarta.servlet.version}</version>
<scope>provided</scope> <!-- Provided by the servlet container (e.g., Tomcat) -->
</dependency>
<!-- For older Servlet API (3.x-4.x / Java EE):
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${javax.servlet.version}</version>
<scope>provided</scope>
</dependency>
-->
</dependencies>
<build>
<finalName>${project.artifactId}</finalName> <!-- Sets the WAR file name -->
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.3.2</version> <!-- Ensure WAR plugin is used -->
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
The scope for the Servlet API dependency is set to provided. This means the Servlet Container (like Tomcat) will provide this library at runtime, so it doesn't need to be bundled within your .war file, keeping the deployment artifact smaller. Typical Project Structure (for a Maven web application): my-hello-app/
├── pom.xml
└── src/
└── main/
├── java/
│ └── com/
│ └── example/
│ └── HelloServlet.java (Your servlet code goes here)
└── webapp/ (Contains web resources)
└── WEB-INF/
└── web.xml (Optional: if using annotations, this file might be empty or absent.
It's used for traditional servlet mappings or other configurations.)
Building and Deployment1. Compile and Package: Use your chosen build tool (e.g., Maven) to compile the Java code and package it into a .war (Web Application Archive) file. mvn clean package
This command will typically create a file named my-hello-app.war (based on in pom.xml) inside the target/ directory of your project. 2. Deploy to a Servlet Container: Copy the generated .war file (e.g., my-hello-app.war) into the webapps directory of your Servlet Container (e.g., Apache Tomcat, usually located at TOMCAT_HOME/webapps). Tomcat will automatically unpack and deploy the application. 3. Start the Server: Ensure your Tomcat server (or whichever container you are using) is running. Accessing the ApplicationOnce your application is deployed and the server is running, open your web browser and navigate to the following URL: http://localhost:8080/my-hello-app/hello
localhost:8080: This is the default address and port for many local Tomcat installations. Your actual port might vary.my-hello-app: This is the context path of your application. By default, Tomcat uses the name of the deployed .war file (without the .war extension) as the context path./hello: This is the specific URL pattern defined by the @WebServlet("/hello") annotation in your HelloServlet class.
You should then see a web page in your browser displaying "Hello, World!" as an heading. Modern Simplification: Spring BootWhile Servlets are the foundational technology for Java web applications, modern development often leverages frameworks like Spring Boot to significantly simplify setup, configuration, and deployment. Spring Boot applications can be run as standalone executable JARs with an embedded web server (like Tomcat, Jetty, or Undertow), eliminating the need for separate .war files and manual server deployment. Example with Spring Boot: import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication // Marks this as a Spring Boot application entry point
@RestController // Marks this class as a REST controller to handle incoming web requests
public class HelloWorldApplication {
public static void main(String[] args) {
// Starts the Spring application, including the embedded web server
SpringApplication.run(HelloWorldApplication.class, args);
}
// Maps HTTP GET requests to the root path "/"
@GetMapping("/")
public String hello() {
// Returns the string directly as the HTTP response body
return "Hello, World!";
}
}
To run this Spring Boot example:
1. Create a Maven or Gradle project and add the spring-boot-starter-web dependency.
2. Place the HelloWorldApplication.java file in your project.
3. Run the main method of HelloWorldApplication (e.g., from your IDE or via mvn spring-boot:run).
4. Open your web browser and navigate to http://localhost:8080/. Spring Boot handles all the underlying Servlet API integration, web server setup, and configuration, allowing developers to focus solely on the application's business logic and endpoints. | 
