This article connects the web layer (Servlets, MVC, Spring), build automation (Maven, Gradle), and testing patterns (Selenium POM).

How Java Handles Web Requests

Java web development stands on a simple idea:
Receive an HTTP request → Process it → Return a response.

Everything else builds on top of this.

1. Servlets

A Servlet is the lowest-level Java class that accepts HTTP requests.

Flow:
Browser → HTTP request → Servlet → Response

Servlet container (like Apache Tomcat) handles:

• Creating Servlet instances

• Calling init(), service(), destroy() lifecycle

• Managing threads for each request

It’s powerful but comes with heavy boilerplate.

---

2. Java Server Pages (JSP)

JSP was introduced to reduce boilerplate by embedding Java directly inside HTML.
Conceptually similar to EJS in Node.js.

Good for:

• Small apps

• UI generation
  Bad for:

• Large applications

• Mixing logic + UI

• Maintainability

---

3. Spring MVC

Spring MVC brought structure.

• @Controller handles requests

• @RequestMapping maps URLs

• Uses DispatcherServlet (front controller)

• Clean separation: Controller → Service → Repository → View

Much more maintainable than Servlets or JSP.

---

4. Spring Boot

Spring Boot sits on top of Spring MVC and solves the biggest pain: configuration.

• Embedded Tomcat (no manual server setup)

• Auto-configured MVC

• Auto-configured Servlets

• Zero XML

• Faster development, fewer moving parts

---

5. Spring Security

Provides authentication and authorization.
Supports:

• JWT

• OAuth2

• Session authentication

• Custom filters

Designed to integrate smoothly with MVC and microservices.

---

6. Spring Cloud Gateway

In microservices, you need:

• Routing

• Load balancing

• Central authentication

• Logging and monitoring

Spring Cloud Gateway provides all these using reactive programming (Project Reactor).

---

Maven

Maven is a declarative build automation tool that uses XML (POM.xml) to define project configuration.
It focuses on convention over configuration, meaning most project structures and build steps follow standard patterns.

Key Concepts (with explanations)

POM (Project Object Model)

The XML file that defines the project’s metadata, dependencies, plugins, build steps, profiles, and reports.
Maven reads this POM for every command you run.

Maven Build Lifecycle

Maven builds follow three core lifecycles:

• clean → removes previous build outputs

• default → compile → test → package → install → deploy

• site → generates documentation

Each lifecycle contains phases that run in order.

Dependencies

Maven resolves dependencies from:

• Local Repository → your machine’s .m2

• Central Repository → default online repo

• Remote Repositories → company/internal repos

Dependency scopes:

• compile → needed at compile time

• runtime → only at runtime

• test → only during tests

• provided → provided by container (ex: Tomcat)

Plugins

Every action (compile, package, run tests, generate JAR/WAR) is done by plugins.

Important Maven Commands

• mvn dependency:tree → see dependency graph

• mvn clean install → compile, test, package, install

• mvn -Dmaven.test.skip=true package → skip tests

• mvn -X → debug mode

• mvn archetype:generate → create project template

When Maven is Ideal

• When you want predictable builds

• When teams prefer XML and static configuration

• When working with existing enterprise Java apps

---

Gradle

Gradle is a flexible, programmatic build tool using Groovy/Kotlin DSL.
It focuses on performance, customization, and incremental builds — often 2–10× faster.

Key Concepts (with explanations)

Build Scripts (build.gradle)

Instead of XML, Gradle uses Groovy/Kotlin code.
Your build is code, meaning:

• shorter syntax

• loops, conditions, functions allowed

• easier customization

Tasks

Gradle = tasks.
A task is a unit of work (compile, test, copy files, run app).

You can write tasks like:

task hello {
    doLast {
        println "Hello Gradle"
    }
}

Plugins

Plugins add functionality (Java plugin, application plugin, Spring Boot plugin).

Dependency Configurations

• implementation → used to compile

• api → exposed to others using your module

• compileOnly → compile but not runtime

• runtimeOnly → only needed when running

• testImplementation → testing

Repositories

Gradle supports:

• Maven Central

• Google repo

• Local repo

• Custom repo

Gradle Wrapper

Creates:

• gradlew (Linux/Mac)

• gradlew.bat (Windows)

This lets you run Gradle without installing it manually.

Useful Commands

• gradle build

• gradle clean

• gradle test

• gradle tasks

• gradle dependencies

• grale build -x test → skip tests

• gradle build --scan → generate a build performance report

When Gradle is Ideal

• Microservices, modern cloud apps

• When build speed matters

• When customization is required

• When using Kotlin/Groovy DSL is preferred

Direct Comparison

---

Extras: Selenium + TestNG + Page Object Model

POM (Page Object Model) is a design pattern for test automation.

Concept

One Java class per page.

Example:

LoginPage.java  
HomePage.java  
ProfilePage.java

Each class contains:

• WebElements (@FindBy)

• Actions (login, click, enterText)

Benefits:

• Reusability

• Maintainability

• Cleaner test classes