javaAssignment.4.txt

#1. Apache Tomcat Server (What it is & why it matters)

**Apache Tomcat** is an open-source **web server and servlet container** used to run Java-based web applications.

### Core Role

Think of Tomcat as the **execution engine** for Java web apps:

* It receives HTTP requests from browsers
* Processes them using Java Servlets/JSP
* Sends back HTTP responses (HTML, JSON, etc.)

### Key Capabilities

* Runs **Servlets and JSP (JavaServer Pages)**
* Handles HTTP communication
* Manages application lifecycle
* Provides a lightweight alternative to full enterprise servers like WildFly

### Simple Flow

1. User enters URL
2. Request hits Tomcat
3. Tomcat maps request → Servlet
4. Servlet processes logic
5. Response returned to browser

---

# 2. Lifecycle of a Web Application

A Java web application goes through a defined lifecycle managed by Tomcat.

### Phases

### 1. **Loading**

* Tomcat loads the application when deployed

### 2. **Initialization**

* Calls `init()` method of Servlets
* Happens once when the app starts

### 3. **Request Handling**

* Each request triggers `service()` → `doGet()` / `doPost()`

### 4. **Destruction**

* When app stops, `destroy()` is called
* Resources are released

### Lifecycle Summary

```
Load → init() → service() → destroy()
```

---

# 3. Directory Structure of a Web Application

Standard Java web apps follow a strict structure called **WAR structure**.

### Typical Structure

```
MyApp/
│
├── index.html
├── css/
├── js/
├── images/
│
└── WEB-INF/
    ├── web.xml
    ├── classes/
    │   └── (compiled .class files)
    └── lib/
        └── (JAR files)
```

### Explanation

* **index.html / JSP files**
  → Frontend pages

* **WEB-INF/**
  → Protected folder (not directly accessible from browser)

* **web.xml**
  → Deployment descriptor (defines Servlets, mappings)

* **classes/**
  → Compiled Java classes

* **lib/**
  → External libraries (JAR files)

---

# 4. Process of Web Application Development

This is the **end-to-end workflow**.

### Step-by-step

### 1. Requirements & Design

* Define what the app should do

### 2. Frontend Development

* HTML, CSS, JavaScript

### 3. Backend Development

* Write Servlets / JSP / business logic

### 4. Configuration

* Define mappings in `web.xml` or annotations

### 5. Compilation

* Convert `.java` → `.class`

### 6. Testing

* Run locally on Tomcat

### 7. Deployment

* Move app to server

---

# 5. Packaging a Web Application

Packaging means converting your app into a **deployable unit**.

### Standard Format: WAR File

**WAR = Web Application Archive**

Example:

```
MyApp.war
```

### How it works

* It is basically a **ZIP file**
* Contains:

  * HTML/JSP files
  * WEB-INF folder
  * Classes and libraries

### Command (Manual way)

```bash
jar -cvf MyApp.war *
```

### Why Packaging Matters

* Easy deployment
* Standardized structure
* Portable across servers

---

# 6. Build & Deploy Using IDE + Tomcat

Let’s break this down into a practical workflow.

---

## Step 1: Setup Environment

* Install JDK
* Install **Apache Tomcat**
* Install IDE (e.g., Eclipse IDE or IntelliJ IDEA)

---

## Step 2: Create Web Project

In IDE:

* File → New → Dynamic Web Project
* Name: `MyApp`
* Select Tomcat server

---

## Step 3: Create Servlet

Example:

```java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class HelloServlet extends HttpServlet {
    public void doGet(HttpServletRequest req, HttpServletResponse res)
    throws IOException {
        res.setContentType("text/html");
        PrintWriter out = res.getWriter();
        out.println("<h1>Hello World</h1>");
    }
}
```

---

## Step 4: Configure Mapping

In `web.xml`:

```xml
<servlet>
    <servlet-name>Hello</servlet-name>
    <servlet-class>HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>Hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
```

---

## Step 5: Build the Project

* IDE compiles automatically
* Generates `.class` files in `WEB-INF/classes`

---

## Step 6: Deploy to Tomcat

### Option A: Automatic (IDE)

* Right-click project → Run on Server

### Option B: Manual

* Export WAR file
* Copy to:

```
Tomcat/webapps/
```

---

## Step 7: Run Application

Start Tomcat:

* Access in browser:

```
http://localhost:8080/MyApp/hello
```

---

# Final Mental Model (Important)

Think of the whole system like this:

* **Browser** → sends request
* **Tomcat** → receives & routes
* **Servlet** → processes logic
* **Response** → sent back to browser