A Database Management System (DBMS) is software that allows users and applications to interact with a database. It acts as an interface between the database and end-users or programs, handling how data is stored, retrieved, and managed.

---

🔧 What a DBMS Does:

1. Data Storage – Saves data to disk in a structured way.
2. Data Retrieval – Provides query languages (like SQL) to fetch specific data.
3. Data Manipulation – Allows updating, inserting, and deleting records.
4. Access Control – Manages user permissions and security.
5. Concurrency Control – Handles multiple users accessing the database at the same time without conflict.
6. Backup and Recovery – Protects data from loss or corruption.
7. Data Integrity – Ensures consistency and correctness of data using rules and constraints.

🧱 Types of DBMS

Type	Description	Example
RDBMS (Relational)	Stores data in tables	MySQL, PostgreSQL
NoSQL DBMS	Stores unstructured or semi-structured data	MongoDB, Cassandra
In-Memory DBMS	Data stored in RAM for speed	Redis
NewSQL	Combines SQL with NoSQL scalability	CockroachDB

🎯 Why Use a DBMS?

• Centralized control over data
• Better data security and consistency
• Easier data sharing across applications
• Efficient query processing

A database is an organized collection of data that can be easily accessed, managed, and updated. It’s designed to store, retrieve, and manipulate information efficiently.

Here are key points:

• Structured: Data is usually organized into tables (rows and columns) in relational databases like MySQL or PostgreSQL, or into collections/documents in NoSQL databases like MongoDB.
• Managed by DBMS: A Database Management System (DBMS) like Oracle, MySQL, or MongoDB handles operations like querying, inserting, updating, and deleting data.
• Persistent: Data in a database is stored permanently (until explicitly removed), unlike temporary memory.
• Multi-user: Databases support access by multiple users at the same time, often with controls to prevent conflicts.

🗃 Relational Databases (RDBMS)

• Structure: Data is stored in tables (rows & columns).
• Schema: Has a fixed schema – you must define the structure (e.g., column names, types) before inserting data.
• Relationships: Uses primary keys and foreign keys to define relationships between tables.
• Examples:
  • MySQL
  • PostgreSQL
  • Oracle
  • Microsoft SQL Server
• Best for: Structured data with complex queries and relationships (e.g., banking, ERP systems).

Example:

SELECT * FROM users WHERE age > 30;

🌐 Non-relational Databases (NoSQL)

• Structure: Stores data in flexible formats:
  • Document (e.g., MongoDB)
  • Key-Value (e.g., Redis)
  • Column-family (e.g., Cassandra)
  • Graph (e.g., Neo4j)
• Schema: Schema-less – structure can change over time.
• Relationships: Usually no joins; embedding or linking data instead.
• Examples:
  • MongoDB (document)
  • Redis (key-value)
  • Cassandra (columnar)
  • Neo4j (graph)
• Best for: Unstructured or semi-structured data, high scalability, rapid development.

Example (MongoDB):

{
  "name": "Alice",
  "age": 32,
  "hobbies": ["reading", "cycling"]
}

✅ Summary

Feature	Relational (SQL)	Non-relational (NoSQL)
Data model	Tables	Documents, key-value, etc.
Schema	Fixed	Dynamic / Flexible
Relationships	Strong (joins)	Weak or embedded
Scalability	Vertical	Horizontal
Use case	Complex queries	Big data, real-time apps

📜 1. Passing a List to Thymeleaf and Looping Through It

Suppose we want to display a list of users.

---

🔵 Controller (Java):

File: HelloController.java

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.List;

@Controller
public class HelloController {

    @GetMapping("/users")
    public String showUsers(Model model) {
        List<String> users = List.of("Stanley", "Marina", "Karina", "Alex");
        model.addAttribute("users", users);
        return "users"; // users.html
    }
}

✅ We pass a List<String> called users into the model.

🔵 Thymeleaf Template:

File: users.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User List</title>
</head>
<body>

<h1>Users:</h1>

<ul>
    <li th:each="user : ${users}" th:text="${user}">User</li>
</ul>

</body>
</html>

✅ th:each loops over the list. ✅ ${user} outputs each username.

🔵 Result in Browser (localhost:8080/users):

Users:
- Stanley
- Marina
- Karina
- Alex

📜 2. Conditionally Rendering Based on Role (th:if / th:unless)

Suppose we want to show admin-only buttons if the user is an admin.

---

🔵 Controller (Java):

Add to your HelloController.java:

@GetMapping("/dashboard")
public String showDashboard(Model model) {
    model.addAttribute("username", "Stanley");
    model.addAttribute("role", "ADMIN"); // or "USER"
    return "dashboard"; // dashboard.html
}

🔵 Thymeleaf Template:

File: dashboard.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Dashboard</title>
</head>
<body>

<h1>Welcome, <span th:text="${username}">User</span>!</h1>

<div th:if="${role == 'ADMIN'}">
    <button>Manage Users</button>
    <button>View Admin Reports</button>
</div>

<div th:unless="${role == 'ADMIN'}">
    <p>You are a regular user.</p>
</div>

</body>
</html>

✅ th:if shows admin buttons only if role is "ADMIN". ✅ th:unless shows different content if the user is not an admin.

---

🔵 Result:

• If role == ADMIN ➔ sees Manage Users buttons.
• If role == USER ➔ sees “You are a regular user.” message.

📜 3. Using Fragments (Header/Footer/Layout Reuse)

Suppose you want one common header and footer for every page.

---

🔵 Create a Fragment File:

File: /templates/fragments/header.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>

<div th:fragment="siteHeader">
    <header style="background-color: lightblue; padding: 10px;">
        <h1>My Website</h1>
        <nav>
            <a href="/hello">Home</a> |
            <a href="/users">Users</a> |
            <a href="/dashboard">Dashboard</a>
        </nav>
    </header>
</div>

</body>
</html>

✅ th:fragment="siteHeader" defines a reusable fragment.

🔵 Now Include the Header in Other Pages

Example for dashboard.html:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Dashboard</title>
</head>
<body>

<div th:replace="fragments/header :: siteHeader"></div>

<h2>Dashboard Content Goes Here</h2>

</body>
</html>

✅ th:replace="fragments/header :: siteHeader" means:

• “Find the file /fragments/header.html“
• “Use the part named siteHeader“
• “Insert it here at runtime.”

---

🔵 Result:

Every page that uses this will automatically get a common consistent header.

---

🎯 Final Quick Summary

Feature	Example
Looping	<li th:each="item : ${items}">
Conditional rendering	<div th:if="${role == 'ADMIN'}">
Fragments reuse	<div th:replace="fragments/header :: siteHeader">

✅ Clean. ✅ Reusable. ✅ Professional structure.

---

📢 Important Extras:

• You can nest fragments (layouts).
• You can pass parameters into fragments.
• You can compose layouts like master pages.

We’ll create a Spring Boot app that:

• Maps a URL /hello
• Passes a dynamic user name
• Displays it using Thymeleaf template

🔵 1. Project Setup

✅ Maven dependencies in pom.xml:

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot Starter Thymeleaf -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
</dependencies>

✅ These two starters are enough!

🔵 2. Create the Main Application Class

File: src/main/java/com/example/demo/DemoApplication.java

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

✅ This starts your Spring Boot app.

🔵 3. Create a Controller

File: src/main/java/com/example/demo/controller/HelloController.java

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("username", "Stanley");
        return "hello"; // Return the template name (hello.html)
    }
}

✅ This controller:

• Handles GET request to /hello
• Adds a username attribute into the model
• Returns the view hello.html

🔵 4. Create a Thymeleaf Template

File: src/main/resources/templates/hello.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello Page</title>
</head>
<body>

<h1 th:text="'Hello, ' + ${username} + '!'">Hello, Guest!</h1>

</body>
</html>

✅ Here:

• th:text dynamically replaces the content of <h1> at runtime.
• If username = "Stanley", the browser will see:

<h1>Hello, Stanley!</h1>

🔵 5. Run the Application

✅ Run DemoApplication.java (main() method).

Open your browser and go to:

http://localhost:8080/hello

You will see:

Hello, Stanley!

🎉 Congratulations! You have a working Spring Boot + Thymeleaf mini project!

---

🎯 Quick Full Architecture Overview

Layer	Code
Controller	HelloController.java (handles /hello request)
Template Engine	Thymeleaf (renders hello.html)
View (HTML page)	hello.html uses ${username}

---

📢 Important Extras:

• Thymeleaf templates must be placed inside src/main/resources/templates/.
• Thymeleaf automatically resolves .html files — you don’t need to add .html in the controller (return "hello" not "hello.html").
• Thymeleaf provides many more features: loops (th:each), conditionals (th:if), fragment reuse (th:fragment), etc.

📜 What is Thymeleaf?

✅ Thymeleaf is a modern server-side Java template engine
that is used to generate HTML, XML, JavaScript, CSS, or even plain text dynamically.

✅ It is mainly designed for web applications, but can also be used for email templates or any kind of dynamic content generation.

✅ Thymeleaf is often used as a replacement for JSP (JavaServer Pages) in modern Spring Boot and Spring MVC applications.

🔵 Key Characteristics of Thymeleaf

Feature	Description
Template Engine	Processes HTML/XML templates on the server
Natural Templates	Templates can be opened directly in a browser even without a server (they look like normal HTML!)
Expression Language	Provides ${...}, th:* attributes to insert dynamic data
Spring Boot Integration	Very tightly integrated with Spring Boot (auto-configured)
Flexible Outputs	Can generate HTML5, XML, JavaScript, Text, etc.
Reusable Fragments	Supports templates and fragments (like header, footer reuse)
Conditionals and Loops	Easily write if/else, for each directly in HTML

🔥 Small Example of Thymeleaf in a HTML Page

Suppose you have a Java controller that sets a model attribute:

model.addAttribute("username", "Stanley");

In your Thymeleaf template (welcome.html), you can use:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Welcome</title>
</head>
<body>

<h1 th:text="'Hello, ' + ${username} + '!'">Hello, Guest!</h1>

</body>
</html>

✅ The line:

<h1 th:text="'Hello, ' + ${username} + '!'">Hello, Guest!</h1>

Will replace the default content “Hello, Guest!” with “Hello, Stanley!” at runtime.

🔵 Some Important Thymeleaf Attributes

Attribute	Purpose
th:text	Set the inner text of an element
th:href	Set the href attribute of a link
th:src	Set the src attribute of an image
th:if / th:unless	Conditional display of elements
th:each	Looping over collections (like forEach)
th:fragment	Define a reusable piece of HTML
th:replace	Replace part of a page with a fragment

🛠️ Example of a Loop with Thymeleaf

Suppose you have a list of products:

model.addAttribute("products", List.of("Apple", "Banana", "Cherry"));

In Thymeleaf:

<ul>
    <li th:each="product : ${products}" th:text="${product}">Product</li>
</ul>

✅ Will generate:

<ul>
  <li>Apple</li>
  <li>Banana</li>
  <li>Cherry</li>
</ul>

🎯 Why is Thymeleaf Popular?

Reason	Explanation
Natural Templates	You can open them directly as static HTML when designing.
Spring Support	Full integration with Spring MVC and Spring Boot.
Modern Syntax	Clean, HTML5-compliant, powerful expressions.
Reusable Components	Layouts, fragments, template inheritance.
Safe Evaluation	Graceful handling of nulls, missing values, etc.
Easy learning curve	Especially for those who already know HTML and basic Java.

---

📢 In short:

✅ Thymeleaf is like JSP for modern Spring Boot applications — but smarter, cleaner, and much easier to work with.

✅ It uses pure HTML files with special attributes (th:*) to dynamically insert data.

🚀 Quick Real-World Usage

• Spring Boot auto-configures Thymeleaf.
• Place your .html files inside /resources/templates/.
• Thymeleaf renders pages dynamically with model data.
• You can build full web apps without touching JSP!

📜 Is a Session object always created in a JSP page?

✅ By default:
Yes, a session object is automatically created for every user in a JSP page — unless you explicitly tell the JSP engine not to create one.

---

🔥 Why?

Because in the default JSP page directive,
the attribute:

<%@ page session="true" %>

is implicitly set.

✅ So every time a user accesses a JSP page:

• If a session already exists ➔ it reuses it.
• If there is no existing session, the server creates a new HttpSession automatically.

And you can access it directly via the implicit session object in JSP:

<%
    session.setAttribute("username", "Stanley");
%>

No need to manually create it — it’s already there.

🔵 When a Session is NOT created?

If you explicitly tell the server not to create sessions by setting:

<%@ page session="false" %>

✅ Then:

• The session object will not exist.
• If you try to access session, you’ll get a compilation error or a runtime exception.

🛠️ Practical Example:

1. Default behavior (session created automatically)

<%@ page session="true" %> <!-- Default, even if not written -->
<html>
<body>
<%
    session.setAttribute("loggedIn", true);
%>
Welcome!
</body>
</html>

✅ session is automatically created.

Disable session creation

<%@ page session="false" %>
<html>
<body>
<!-- Trying to use 'session' here would cause error -->
Welcome!
</body>
</html>

✅ No session object available.

📢 Important Practical Notes:

Topic	Answer
Default session behavior	✅ Session is created
How to disable session	<%@ page session="false" %>
What happens without session?	session implicit object is unavailable
Why might you disable it?	Static pages, APIs, resources that don’t need user state (better performance)

🎯 Final Quick Summary:

Question	Answer
Is session created by default in JSP?	✅ Yes
Can you disable session creation?	✅ Yes, with <%@ page session="false" %>

🚀 Bonus Tip:

• Static resources (like product catalog pages, public blogs) often disable sessions to improve performance.
• Login pages, user dashboards need sessions to track users.

✅ Yes, absolutely — you can use JavaScript inside a JSP page, just like you would in any normal HTML page!

Because JSP ultimately generates an HTML page that is sent to the browser,
and JavaScript is a client-side technology, the browser sees and executes it as usual.

---

📜 How to Use JavaScript in a JSP Page?

You just write JavaScript inside <script> tags like in normal HTML.

Example:

<html>
<head>
    <title>JSP + JavaScript Example</title>
    <script>
        function greet() {
            alert('Hello from JavaScript!');
        }
    </script>
</head>
<body>
    <h1>Welcome!</h1>
    <button onclick="greet()">Click me</button>
</body>
</html>

✅ When the user clicks the button, the browser executes the JavaScript greet() function.

🛠️ Mixing JavaScript and JSP Dynamically

You can also inject dynamic values from the server (JSP variables) into JavaScript.

Example:

<%
    String username = "Stanley";
%>

<html>
<head>
    <script>
        function greet() {
            var user = "<%= username %>";
            alert('Hello, ' + user + '!');
        }
    </script>
</head>
<body>
    <button onclick="greet()">Greet User</button>
</body>
</html>

✅ This way:

• username is a server-side Java variable.
• It gets injected into the JavaScript before the page is sent to the client.

The browser only sees the final HTML+JavaScript.

⚠️ Important Cautions:

Caution	Why it Matters
Proper escaping needed	If your JSP variable contains quotes, newlines, etc., it could break the JavaScript.
JavaScript runs in the browser, not on the server	You cannot access session, request, server objects directly in JavaScript.
Separate responsibilities	JSP handles dynamic page generation, JavaScript handles dynamic behavior after page load.

---

📢 In short:

✅ JSP + JavaScript is natural and common.
✅ JSP generates the page, JavaScript runs inside the browser.
✅ Inject dynamic values carefully using <%= %> or ${} (EL).

---

🎯 Quick Real-World Usage Examples:

• Show user name dynamically in JavaScript popup.
• Pass server-side config values into JavaScript variables.
• Enable/disable buttons based on server values.
• Initialize charts, graphs, forms using dynamic data generated by JSP.

🔵 1. Configuring the JSP Servlet (Optional)

The server (like Tomcat) has an internal servlet for handling JSPs, called the JSP servlet.
You can explicitly declare and configure it in web.xml if needed.

✅ Example:

<servlet>
    <servlet-name>jsp</servlet-name>
    <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
    <init-param>
        <param-name>fork</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>3</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
</servlet-mapping>

✅ What’s happening:

• You map all URLs ending with .jsp to the internal JspServlet.
• fork=false is a configuration option (you can set many others, like buffering size, development mode, etc.).
• load-on-startup=3 means the servlet will be initialized when the server starts (priority 3).

🔵 2. Configuring JSP Properties (Advanced)

You can also configure special behaviors for JSP pages globally using <jsp-config> in web.xml.

✅ Example:

<jsp-config>
    <jsp-property-group>
        <url-pattern>*.jsp</url-pattern>
        <page-encoding>UTF-8</page-encoding>
        <scripting-invalid>true</scripting-invalid>
        <el-ignored>false</el-ignored>
        <include-prelude>/WEB-INF/jspf/header.jspf</include-prelude>
        <include-coda>/WEB-INF/jspf/footer.jspf</include-coda>
    </jsp-property-group>
</jsp-config>

✅ What this does:

• Applies to all .jsp pages (url-pattern).
• Sets UTF-8 encoding.
• Disables scripting (no <% %> allowed if scripting-invalid=true — enforces clean JSP).
• Forces EL (Expression Language) to be enabled (el-ignored=false).
• Automatically includes a header and footer file on every JSP page.

🔵 3. Error Page Mapping (JSP Error Handling)

You can also map errors to JSP error pages:

<error-page>
    <error-code>404</error-code>
    <location>/errors/notfound.jsp</location>
</error-page>

<error-page>
    <exception-type>java.lang.Throwable</exception-type>
    <location>/errors/error.jsp</location>
</error-page>

✅ Now if an error occurs, the user is forwarded to a friendly JSP error page.

🧠 Quick Overview Table

Task	How it’s configured
Map JSP files to JspServlet	<servlet> + <servlet-mapping>
Set page settings (encoding, EL, includes)	<jsp-config>
Define global error pages	<error-page>

---

📢 Important Notes:

• In most simple or modern Spring Boot applications, you don’t manually configure JSPs in web.xml — it’s handled automatically.
• Explicit JSP servlet mapping is mainly used when you need custom tuning or fine-grained control.
• Custom settings like development mode, checkInterval, genStringAsCharArray, etc., can also be configured as <init-param>s.

---

🎯 Final Quick Summary:

Aspect	Explanation
JSP servlet mapping	Map .jsp files to the container’s JSP servlet.
JSP properties	Set page encoding, scripting rules, EL behavior, automatic includes.
Error pages	Redirect errors to JSP error handlers.
Optional now	But still useful for fine control.

---

🚀 Practical Real-World Tip:

If you ever need to disable scriptlets (<% %>) across all JSPs,
✅ set:

<scripting-invalid>true</scripting-invalid>

in web.xml!

✅ This forces developers to write clean tag-based JSP code — much better for real-world apps.

✅ JSTL (especially Core and SQL libraries) has built-in error handling mechanisms
that allow you to catch and manage exceptions gracefully inside the JSP, without crashing the page.

You don’t always need to forward to a special error page — sometimes you can catch errors inline.

🔵 Key Concepts in JSTL Error Handling

Feature	Description
errorPage and isErrorPage	Same as normal JSP pages (for big/serious errors)
<c:catch> tag	Catch exceptions that happen during JSTL actions inside a JSP page
JSTL SQL error handling	Special attributes like varStatus to capture database errors
Silent failure (optional)	JSTL often fails gracefully without throwing exceptions into the page

🔥 1. Using <c:catch> to Handle Errors Locally

<c:catch> is a JSTL tag that catches exceptions happening inside its body and stores them into a variable.

✅ Syntax:

<c:catch var="error">
    <%-- Code that might throw exception --%>
</c:catch>

<c:if test="${not empty error}">
    <p>Error occurred: ${error.message}</p>
</c:if>

✅ If an error happens, it will be caught and stored into error variable instead of breaking the page.

📜 Practical Example:

Imagine dividing by zero:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<c:catch var="error">
    <%
        int x = 5 / 0; // This will throw ArithmeticException
    %>
</c:catch>

<c:if test="${not empty error}">
    <p style="color:red;">An error occurred: ${error.message}</p>
</c:if>

✅ Output:

An error occurred: / by zero

Page does not crash!

User sees a friendly message.

🔵 2. Error Handling in JSTL SQL Tags

When using JSTL SQL tags (like <sql:query>, <sql:update>),
errors can happen (like bad connection, bad query).

✅ You can capture errors using the var and varStatus attributes.

Example:

<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>

<sql:query var="result" dataSource="jdbc/mydb">
    SELECT * FROM unknown_table
</sql:query>

<c:if test="${not empty result.error}">
    <p style="color:red;">SQL Error: ${result.error}</p>
</c:if>

✅ If the query fails, you can detect it using result.error.

⚠️ Important: JSTL SQL tags are for prototyping/demo only — not recommended in real apps (use JDBC, JPA, or Spring Data for production).

🔵 3. JSTL Default Behavior (Silent Failures)

✅ Some JSTL tags (like <c:forEach>) fail silently if they encounter minor problems:

• Empty collections → no exception.
• Missing variables → just an empty output.

Example:

<c:forEach var="item" items="${nonexistentList}">
    <p>${item}</p>
</c:forEach>

• Even if nonexistentList is null, no crash — JSTL just skips the loop.

✅ Fail-safe by design — to keep user pages alive.

🎯 Summary Table

Feature	Handling
Big page-wide exceptions	Use errorPage + isErrorPage
Local small exceptions	Use <c:catch> to capture and handle
SQL-related errors	Use varStatus.error or handle inside <c:catch>
Silent failures	JSTL skips minor errors gracefully

---

📢 Important Practical Tip:

In professional projects, combine:

• JSTL local error handling (<c:catch>) for small recoverable errors
• Centralized error pages (via web.xml) for big application failures

✅ That gives you the best user experience and system reliability.

In JSP, you can handle errors in two main ways:

Approach	Description
1. Using errorPage and isErrorPage page directives	Forward to a special JSP page when an error occurs
2. Using centralized web.xml error handling	Map errors globally to error pages (by status code or exception type)

✅ You can use one or both approaches, depending on how big your project is!

---

🔵 1. Handle Errors Using errorPage and isErrorPage Attributes

This is local JSP-level error handling.

---

📜 Step 1: Mark the Main JSP

At the top of your main JSP page (where an error might happen), you declare:

<%@ page errorPage="error.jsp" %>

If an exception occurs inside this page, the request is automatically forwarded to error.jsp.

📜 Step 2: Create the Error JSP Page

At the top of error.jsp, declare:

<%@ page isErrorPage="true" %>

• This allows access to the exception implicit object.

Inside error.jsp, you can show error details:

<html>
<body>
  <h2>An error occurred:</h2>
  <p>Exception: ${exception}</p>
  <p>Message: ${exception.message}</p>
</body>
</html>

✅ exception is an implicit object of type Throwable.

🔵 2. Handle Errors Globally Using web.xml

This is application-wide centralized error handling.

You can configure specific error codes or exception classes.

---

📜 Example: Define in web.xml

<error-page>
    <error-code>404</error-code>
    <location>/errors/notfound.jsp</location>
</error-page>

<error-page>
    <exception-type>java.lang.NullPointerException</exception-type>
    <location>/errors/nullpointer.jsp</location>
</error-page>

<error-page>
    <exception-type>java.lang.Throwable</exception-type>
    <location>/errors/generalerror.jsp</location>
</error-page>

• If a page is not found (404), the user is sent to notfound.jsp.
• If a NullPointerException occurs, user is sent to nullpointer.jsp.
• If any other exception happens, user is sent to generalerror.jsp.

✅ This works even outside JSPs — it covers Servlets too!

🧠 What Happens Internally?

Step	Action
Error happens	Exception thrown or HTTP error (e.g., 404)
Container checks	web.xml for mappings, or errorPage directive
Forward request	To the specified error page
Error page	Displays error information (optionally using ${exception})

🛠️ Important Notes:

• Error pages must be outside of public access (e.g., place them inside /WEB-INF/) if you don’t want users to access them directly.
• Use isErrorPage="true" if you want to access exception object in error JSP.
• Customize error message for users (don’t show full stack trace in production).

---

🎯 Quick Comparison

Method	When to Use
errorPage directive	Handle errors locally (page-specific)
web.xml configuration	Handle errors globally (for the whole app)

---

🚀 Example Full Setup

Main page (main.jsp):

<%@ page errorPage="error.jsp" %>

<%
    int x = 5 / 0; // This will throw an exception
%>

Error page (error.jsp):

<%@ page isErrorPage="true" %>
<html>
<body>
    <h1>Something went wrong!</h1>
    <p>Error Type: ${exception}</p>
    <p>Message: ${exception.message}</p>
</body>
</html>

✅ If an exception occurs in main.jsp, the server automatically forwards to error.jsp and displays the error info.