📜 Why Is It NOT necessary to configure standard JSP tags (like JSTL) in web.xml?

✅ Because modern JSP engines (starting from Servlet 2.4 / JSP 2.0 and later)
support automatic tag library discovery based on:

• URI declarations in the JSP file (using <%@ taglib uri="..." %>)
• TLD files (.tld) located in standard places inside the JAR files (like /META-INF/)

👉 This means that the container automatically finds and registers standard tag libraries (like JSTL)
without requiring manual mapping in web.xml.

🔥 Technically, what happens:

1. You write in your JSP:

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

1. The JSP container (e.g., Tomcat) sees the uri.
2. It automatically searches inside:
   • /WEB-INF/
   • /META-INF/ directories inside all JARs (e.g., jstl.jar, standard.jar)
3. It finds the corresponding TLD file (Tag Library Descriptor).
4. It auto-registers the tag library for you.

✅ So you don’t need to declare tag libraries in web.xml anymore.

🛠️ Historically (before JSP 2.0):

• In older systems (Servlet 2.2 or JSP 1.1/1.2),
  you had to manually map tag libraries in web.xml like this:

<taglib>
    <taglib-uri>/mytags</taglib-uri>
    <taglib-location>/WEB-INF/mytags.tld</taglib-location>
</taglib>

Otherwise, JSP pages wouldn’t know how to find your custom tags.

📢 Modern Reason:

✅ Newer JSP engines follow “declarative programming principles”:

• Everything needed for a tag library is described inside the TLD and the JAR itself.
• Deployment becomes easier, cleaner, and less error-prone.
• You can add JSTL or custom libraries simply by dropping the JARs into /WEB-INF/lib/.

🎯 Final Quick Summary

Topic	Before JSP 2.0	JSP 2.0 and later
Need web.xml config	✅ Yes, needed	❌ No, automatic discovery
How mapping works	Manual in web.xml	Auto-discovery from TLD files inside JARs
Standard tags	Harder to use	Very easy to use

---

🚀 Practical Tip for You:

• When using JSTL (or any other standard tag library),
  ✅ just include the JAR files (jstl.jar, standard.jar),
  ✅ declare the taglib URI in the JSP page,
  ✅ and you’re ready to go — no web.xml config needed!

In HTML, a line break is created with the <br> tag.

✅ In a JSP page, you just write normal HTML for line breaks, because JSP ultimately outputs HTML to the browser.

Example inside JSP:

<p>First line.<br>Second line.</p>

✅ This will render:

First line.
Second line.

🛠️ If You Need a Line Break Dynamically Using Java in JSP

If you’re writing Java code inside a JSP (inside <% %>), and want to output a line break, you must print the <br> tag manually using out:

Example:

<%
    out.println("First line.<br>");
    out.println("Second line.");
%>

✅ Again — because out writes HTML, so you must manually insert the <br>.

🔥 If You Are Using Expression Language (EL)

If you’re using ${} to output text and it already contains newline characters (\n),
newline characters are NOT automatically converted into <br> in HTML.
HTML ignores \n!

✅ You must replace \n with <br>.

Example with JSTL:

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

${fn:replace(textWithNewlines, '\n', '<br />')}

Where textWithNewlines is a String containing line breaks (newlines).

🎯 Quick Summary:

Case	How to Insert Line Break
Static text	Just use <br> in HTML
Inside Java code (<% %>)	Use out.println("...<br>...");
Inside EL output (${})	Use fn:replace to replace \n with <br />

---

📢 Important:

• HTML ignores \n and \r\n — only <br> actually produces visible line breaks.
• Always remember JSP generates HTML, so think in HTML when formatting output.

I’ll show you how to:

• Write a Java class for the tag
• Configure a TLD file (Tag Library Descriptor)
• Use your custom tag inside a JSP page
• Pass a parameter (attribute) to the tag

---

🎯 Goal:

We will create a custom tag <my:greet name="Stanley" />
that outputs:

Hello, Stanley!

🔵 Step 1: Write the Java Class for the Tag

Create a Java class that extends SimpleTagSupport.

File: GreetTag.java

package mytags;

import javax.servlet.jsp.tagext.SimpleTagSupport;
import javax.servlet.jsp.JspWriter;
import java.io.IOException;

public class GreetTag extends SimpleTagSupport {
    private String name;

    // Setter (for the attribute 'name')
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void doTag() throws IOException {
        JspWriter out = getJspContext().getOut();
        if (name != null) {
            out.write("Hello, " + name + "!");
        } else {
            out.write("Hello, Guest!");
        }
    }
}

✅ Important:

• The method setName(String name) is automatically called when you use name="..." in the tag!
• doTag() defines what the tag will output.

🔵 Step 2: Create a TLD File

Create a TLD (Tag Library Descriptor) file that describes your tag.

File: /WEB-INF/mytags.tld

<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/javaee"
        version="2.1">
    <tlib-version>1.0</tlib-version>
    <short-name>MyTags</short-name>
    <uri>http://example.com/mytags</uri>

    <tag>
        <name>greet</name>
        <tag-class>mytags.GreetTag</tag-class>
        <body-content>empty</body-content>

        <attribute>
            <name>name</name>
            <required>false</required>
        </attribute>
    </tag>
</taglib>

✅ Key things:

• name: how you will call the tag (greet)
• tag-class: full class name (including package)
• attribute name="name": defines the tag’s parameter

🔵 Step 3: Use the Custom Tag in a JSP Page

Now, use your custom tag in a JSP page!

File: greet.jsp

<%@ taglib uri="http://example.com/mytags" prefix="my" %>

<html>
<head><title>Custom Tag Example</title></head>
<body>

<!-- Use our custom tag -->
<my:greet name="Stanley" />

<br>

<!-- Without providing name -->
<my:greet />

</body>
</html>

✅ Output:

Hello, Stanley!
Hello, Guest!

📜 Summary of What We Did:

Step	What We Created
Java Tag Handler	GreetTag.java (the logic)
Tag Library Descriptor	mytags.tld (the description)
JSP Page	greet.jsp (the usage)

✅ Now you have your own custom JSP tag working!

📢 Notes:

• You can add multiple attributes by writing more setters in Java (setXxx()).
• You can create tags with a body (using <jsp:doBody/>) if you need more advanced behavior.
• In modern apps, tag files (.tag) are sometimes used instead of Java classes for simple cases.

Custom JSP tags allow you to create your own new JSP tag (like <my:hello /> or <my:showDate />) that encapsulates Java logic cleanly,
instead of mixing Java code (<% %>) directly into your JSP pages.

✅ It helps you extend JSP functionality, reuse common logic, and keep JSPs clean and readable.

✅ Custom tags are server-side components that are executed during JSP processing.

---

🔥 Why Write Custom Tags?

Benefit	Reason
Cleaner JSP code	No messy Java code (<% %>)
Reusable components	Write once, use everywhere
Separation of concerns	Keep logic out of presentation
Easy for designers	Designers can use tags without needing Java knowledge
Consistency	Same logic, same output everywhere

---

🛠️ How to Write a Simple Custom Tag?

There are two main ways:

---

🔵 1. Using a Java Class (Tag Handler Class)

✅ You write a Java class that extends one of the following:

Class	Use Case
SimpleTagSupport	For simple tags (JSP 2.0 and newer) — recommended
TagSupport	For older-style, more complex tags
BodyTagSupport	For tags that operate on body content

Simple Example:

Step 1: Java Class

package mytags;

import javax.servlet.jsp.tagext.SimpleTagSupport;
import javax.servlet.jsp.JspWriter;
import java.io.IOException;

public class HelloTag extends SimpleTagSupport {
    public void doTag() throws IOException {
        JspWriter out = getJspContext().getOut();
        out.print("Hello from a custom tag!");
    }
}

Step 2: Create a Tag Library Descriptor (TLD) File

Create a mytags.tld inside /WEB-INF/.

<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/javaee"
        version="2.1">
    <tlib-version>1.0</tlib-version>
    <short-name>MyTags</short-name>
    <uri>http://example.com/mytags</uri>

    <tag>
        <name>hello</name>
        <tag-class>mytags.HelloTag</tag-class>
        <body-content>empty</body-content>
    </tag>
</taglib>

Step 3: Use Your Tag in a JSP

<%@ taglib uri="http://example.com/mytags" prefix="my" %>

<my:hello />

✅ Outputs:

Hello from a custom tag!

🔵 2. Using Tag Files (.tag)

✅ A faster and simpler way to create tags without Java coding if your logic is simple.

How?

• Create a .tag file inside /WEB-INF/tags/.
• Write normal JSP content inside it.

Example:

File: /WEB-INF/tags/hello.tag

Hello from a tag file!

Use it in JSP:

<%@ taglib tagdir="/WEB-INF/tags" prefix="my" %>

<my:hello />

✅ Much quicker — no Java classes needed!

🎯 Summary: Two Ways to Write Custom Tags

Approach	Best When	Notes
Tag Handler Class (Java class + TLD)	More complex, reusable, parameterized logic	Full power
Tag File (.tag)	Simple reusable templates	Quick and easy

---

📢 Important Advanced Points:

• You can pass attributes to custom tags (like <my:hello name="Stanley" />) by writing setters in Java class or by using attribute directive in .tag files.
• You can handle body content (the text between start and end tags) using BodyContent in classic tag handlers or <jsp:doBody /> in tag files.
• Modern JSP prefers SimpleTagSupport + .tag files style (easier and cleaner).

---

🚀 Real-World Usage

You typically create custom tags for:

• UI components (menus, buttons, panels)
• Formatting (dates, currencies)
• Custom access control (show/hide content for users with specific roles)
• Common layouts (headers, footers, sections)

---

📜 Quick Comparison to Built-in Tags

Type	Example
Built-in tag (JSTL)	<c:forEach>, <c:if>
Your custom tag	<my:hello>, <my:showDate>

✅ Same usage style, but you control the behavior!

In JSP, basic functionality (HTML + embedded Java) is sometimes not enough.
You often want to add new behaviors cleanly — without putting Java code into JSPs.

Here are the main ways to extend JSP functionality:

---

🔵 1. Custom Tags

✅ Create your own tags (like <mytags:hello />) that perform Java logic behind the scenes.

How?

• Write a Java class that extends SimpleTagSupport or implements Tag interface.
• Define the tag in a TLD (Tag Library Descriptor) file or annotate the class with @Tag.

Why?

• To hide complex Java logic from JSPs.
• Make reusable components (e.g., formatting, calculations, conditional output).

---

🔵 2. Tag Files

✅ Write simple custom tags using JSP-like syntax, without Java code.

How?

• Create a file with .tag extension inside /WEB-INF/tags/.
• It behaves like a component: can accept attributes, include logic, and output HTML.

Why?

• Faster and easier than full Java-based custom tags for simple components.
• Example: reusable panels, cards, widgets.

---

🔵 3. Expression Language (EL) Functions

✅ Extend EL by adding your own custom functions callable inside ${}.

How?

• Write static Java methods.
• Declare them inside a .tld (Tag Library Descriptor).

Example in JSP:

${my:formatPhoneNumber(phone)}

Why?

• Cleaner pages.
• More powerful dynamic expressions.
• Avoids writing scriptlets.

---

🔵 4. Servlets (as Controllers)

✅ Use Servlets to handle complex business logic outside of JSP.

How?

• Write Servlets for backend logic.
• Store results into request, session, or application attributes.
• Forward to JSP for rendering.

Why?

• Keep JSP for presentation only (View).
• Maintain MVC architecture (Model-View-Controller).

🔵 5. JSTL and Other Tag Libraries

✅ Use or create tag libraries beyond the standard JSTL.

How?

• Import third-party libraries or build your own.
• Use tags like <c:forEach>, <c:if>, <fmt:formatDate>, or any custom-built tags.

Why?

• Extend functionality declaratively.
• Reduce the need to write Java logic manually.

🔵 6. Filters

✅ Use Servlet Filters to intercept requests before they reach JSPs.

How?

• Write a Java class implementing javax.servlet.Filter.
• Configure it to intercept specific URL patterns.

Example uses:

• Authentication checks
• Logging
• Compression
• Input validation

Why?

• Keep JSPs focused on display only.
• Centralized control over behavior.

---

🎯 Quick Table Summary

Method	Purpose
Custom Tags	Build reusable logic components as tags
Tag Files	Quick reusable JSP-based tags
EL Functions	Add logic inside ${} expressions
Servlets	Move business logic out of JSPs
JSTL and Other Libraries	Use or build additional tag libraries
Filters	Preprocess requests before reaching JSP

---

📢 Final Thought:

JSP itself should remain as “dumb” as possible.
Smartness and complexity should be moved into custom tags, functions, filters, and servlets.

This keeps your application clean, scalable, and easy to maintain!

📜 The Three Ways to Include Content in JSP

Feature	<%@ include %>	<jsp:include>	<c:import>
Type	Static include	Dynamic include	Dynamic import (even external URLs)
When it happens	Translation time (before JSP becomes a servlet)	Request time (when user accesses page)	Request time
What it can include	Only local files (same web app)	Only local files (same web app)	Local files or external URLs
Syntax style	JSP directive (compile-time)	JSP action tag (runtime)	JSTL core tag (runtime)
Parameter passing	❌ No	✅ Yes (<jsp:param>)	✅ Yes (<c:param>)

---

🔵 1. <%@ include file="..." %> — Static Include

When?

• Happens at JSP translation time (when the server compiles the JSP into a servlet).

What happens?

• The contents of the included file are physically copied into the JSP page before compilation.
• Single servlet is generated.

Use for:
✅ Common page parts like headers, footers, menus that rarely change.

Syntax:

<%@ include file="header.jsp" %>

Pros:

• Simple and fast.
• Included at compile time → better performance.

Cons:

• Changes to included file require recompilation of the JSP.
• Only includes files inside your app — no external URLs.

---

🔵 2. <jsp:include page="..." /> — Dynamic Include

When?

• Happens at request time (when the user requests the page).

What happens?

• The included resource is executed separately, and its output is injected into the response dynamically.
• Still same request and response.

Use for:
✅ Including dynamic content that might change frequently (like latest news, user profile sections).

Syntax:

<jsp:include page="menu.jsp" />

You can also pass parameters:

<jsp:include page="menu.jsp">
    <jsp:param name="theme" value="dark" />
</jsp:include>

Pros:

• Always gets the fresh content of the included resource.
• You can pass parameters easily.

Cons:

• Slightly slower than static because it happens at runtime.
• Only works within your application.

🔵 3. <c:import url="..." /> — Dynamic Import via JSTL

When?

• Happens at request time (like <jsp:include>).

What happens?

• Can import content from anywhere, even an external URL like https://example.com/news.
• The fetched content is inserted into the current page or stored in a variable.

Use for:
✅ Importing dynamic content from internal or external sources.

Syntax:

<c:import url="/footer.jsp" />

or

<c:import url="https://news.example.com/latest" var="newsContent" />
${newsContent}

Pros:

• Can import external pages or APIs.
• Can store imported content in a variable (var attribute).

Cons:

• Slower for external URLs (depends on external server response).
• Need JSTL library.

---

🎯 Summary Table

Aspect	<%@ include %>	<jsp:include>	<c:import>
When?	Translation time (compile)	Request time (runtime)	Request time (runtime)
Scope	Local file	Local file	Local or external URL
Recompile needed?	Yes if included file changes	No	No
Pass parameters?	❌ No	✅ Yes (<jsp:param>)	✅ Yes (<c:param>)
Syntax type	Directive	JSP Action	JSTL Core tag

📢 Important Tip:

• Use <%@ include %> when the included content is static and rarely changes (for example, a common header or footer).
• Use <jsp:include> when you need dynamic behavior and you might need to pass parameters.
• Use <c:import> when you need to fetch remote content (like from another server) or manage output into variables.

---

🚀 Real-World Example

If you have a header.jsp, you might:

• Use <%@ include file="header.jsp" %> if the header is always the same.
• Use <jsp:include page="header.jsp"/> if you want the header to depend on the current user.
• Use <c:import> if the header needs to pull content from another site (e.g., news feed from a remote server).

Although both <c:set> and <jsp:useBean> create or work with variables/objects in JSP,
they have very different purposes and work at different levels.

---

🔵 1. <jsp:useBean>

Feature	Explanation
Purpose	To create or locate a JavaBean (Java class instance)
Scope	Page, request, session, or application (specified explicitly)
Target	JavaBeans (classes with getters/setters)
Behavior	If the bean doesn’t exist in scope, it creates a new one.
Tag	Built-in JSP Action tag (jsp:useBean)

✅ Used when you need an object instance (typically of a JavaBean) to hold structured data.

Example:

<jsp:useBean id="user" class="com.example.User" scope="session" />
<jsp:setProperty name="user" property="name" value="Stanley" />

Creates or reuses a User object and stores it in session scope.

User must have a public no-argument constructor.

🔵 2. <c:set>

Feature	Explanation
Purpose	To set a value (any object, simple value, or result of an expression) into a variable.
Scope	Page, request, session, or application (default is page scope)
Target	Any variable (String, Integer, JavaBean, Map, etc.)
Behavior	Always sets a value; does not create a new instance automatically.
Tag	Part of JSTL Core (c prefix)

✅ Used for assigning values or overwriting variables easily.

Example:

<c:set var="username" value="Stanley" scope="session" />

Simply sets "Stanley" into sessionScope.username.

✅ It can also modify JavaBean properties:

<c:set target="${user}" property="name" value="Stanley" />

Equivalent to user.setName("Stanley");

🛠️ Key Differences Table

Feature	<jsp:useBean>	<c:set>
Creates new object?	✅ Yes (if object not found in scope)	❌ No, just sets a value
Main use	Create or find a JavaBean	Set a variable or update property
Target	JavaBean class	Any object, String, Number, Collection, Map, Bean property
Part of	JSP Action Tags (jsp)	JSTL Core (c)
Scope management	Must specify explicitly in tag (optional)	Default is pageScope, but can specify others
Dependency	Needs a real Java class with getters/setters	No special class needed

---

🎯 In short:

If you need…	Use…
To create or find a JavaBean instance	<jsp:useBean>
To set or update a simple variable or a bean property	<c:set>

📢 Real-World Example Together

Example JSP:

<jsp:useBean id="user" class="com.example.User" scope="session" />
<c:set target="${user}" property="name" value="Stanley" />
<p>Hello, ${user.name}!</p>

useBean ensures there is a User object.

c:set sets the name property.

EL ${user.name} reads it.

The JSTL library is divided into five main groups (also called tag libraries),
each designed for a specific type of functionality.

Tag Group	Purpose	Prefix Example
Core Tags	Basic control flow, iteration, variables, URL management	<c:...>
Formatting Tags	Formatting text, dates, numbers, localization (i18n)	<fmt:...>
SQL Tags	Executing simple SQL queries (for prototyping)	<sql:...>
XML Tags	Working with XML data	<x:...>
Functions Tags	Common functions like string manipulation	${fn:...}

🔵 1. Core Tag Library (c)

• URL: http://java.sun.com/jsp/jstl/core
• Prefix: c
• Purpose: Basic common tasks:
  • Conditions (<c:if>)
  • Loops (<c:forEach>)
  • Variable management (<c:set>, <c:remove>)
  • Redirects (<c:redirect>)
  • Imports (<c:import>)

✅ Most commonly used part of JSTL.

🔵 2. Formatting Tag Library (fmt)

• URL: http://java.sun.com/jsp/jstl/fmt
• Prefix: fmt
• Purpose: Formatting and localization (i18n):
  • Format numbers, dates, currencies (<fmt:formatNumber>, <fmt:formatDate>)
  • Set locales
  • Access resource bundles (for multilingual sites)

Example:

<fmt:formatDate value="${now}" pattern="dd-MM-yyyy" />

🔵 3. SQL Tag Library (sql)

• URL: http://java.sun.com/jsp/jstl/sql
• Prefix: sql
• Purpose: Basic database access:
  • Query databases (<sql:query>)
  • Insert/update/delete (<sql:update>)
  • Manage data sources

⚠️ Warning: Not recommended for production.

• Only good for prototyping or simple demos.
• In real-world apps, use JDBC, JPA, or ORM frameworks (like Hibernate, Spring Data).

🔵 4. XML Tag Library (x)

• URL: http://java.sun.com/jsp/jstl/xml
• Prefix: x
• Purpose: Working with XML documents:
  • Parse XML (<x:parse>)
  • Iterate over XML nodes (<x:forEach>)
  • Output XML values (<x:out>)

Useful if your app heavily interacts with XML data.

🔵 5. Functions Tag Library (fn)

• URL: http://java.sun.com/jsp/jstl/functions
• Prefix: fn
• Purpose: Provides common functions usable inside EL (${} expressions):
  • String operations (length, contains, split, substring, etc.)
  • Collection checks

Example:

${fn:length(userList)}
${fn:toUpperCase(username)}

✅ These functions make EL much more powerful.

🎯 Final Summary Table

Tag Group	Prefix	Purpose
Core	c	Conditions, loops, variables
Formatting	fmt	Numbers, dates, i18n localization
SQL	sql	Simple database access (only demos)
XML	x	Parse, navigate XML
Functions	fn	String/collection functions

---

📢 Real-World Tip:

• ✅ In most professional projects, you mainly use Core (c), Formatting (fmt), and Functions (fn).
• ⚠️ SQL (sql) and XML (x) are less common in modern Spring, Hibernate, API-driven applications.

JSTL stands for JavaServer Pages Standard Tag Library.

✅ It’s a collection of ready-to-use, standardized custom tags for common tasks you often need in JSP, like:

• Iterating over collections
• Making decisions (if/else)
• Formatting text and numbers
• Accessing databases
• Handling XML

It replaces the need to write Java code (<% %>) inside JSPs for most standard operations, making your pages cleaner, faster to develop, and easier to maintain.

🎯 Purpose of JSTL

➔ Make JSP pages declarative (based on tags),
➔ Avoid Java scriptlets inside JSP,
➔ Help developers focus on presentation, not backend logic.

---

🔥 What Does JSTL Provide? (Main Libraries)

Library	Purpose	Tag Prefix Example
Core	Common tasks (if, loops, setting variables)	<c:if>, <c:forEach>
Formatting	Format numbers, dates, currencies	<fmt:formatNumber>, <fmt:formatDate>
SQL	Simple database operations (for prototyping only)	<sql:query>, <sql:update>
XML	XML document manipulation	<x:parse>, <x:out>
Functions	Common functions for strings and collections	${fn:toUpperCase(str)}

---

🔵 Common JSTL Core Tags

Tag	Purpose
<c:if>	Conditional logic (if)
<c:choose>, <c:when>, <c:otherwise>	Switch-case logic
<c:forEach>	Looping over arrays, collections, maps
<c:set>	Set a variable (attribute)
<c:remove>	Remove a variable
<c:import>	Import content from a URL
<c:redirect>	Redirect to another page

🛠️ How to Use JSTL in a JSP

1. Add JSTL library to your project.
   • If you use Maven:

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

Otherwise, you need to place the jstl.jar and standard.jar files in /WEB-INF/lib/.

2. Declare the taglib at the top of your JSP page.

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

Now you can use tags like <c:if>, <c:forEach>, etc.

🧠 Small Example Using JSTL

Example: Showing a user list

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

<c:forEach var="user" items="${userList}">
    <p>User: ${user.name}</p>
</c:forEach>

Here, userList is a collection (list) passed from a servlet or controller.

No Java code (<% %>) is needed in the JSP!

📢 Why is JSTL Important?

Benefit	Why It Matters
Cleaner JSP code	No need for scriptlets (<% %>)
Better separation	Presentation (JSP) separated from logic (Java classes)
Easier for designers	Non-Java people can work with JSP pages too
Reusability	Tags are reusable across many pages
Standardization	JSTL is standardized and portable across servers

---

🎯 Quick Final Summary:

Term	Meaning
JSTL	Standard set of ready-to-use tags for common tasks in JSP
Goal	Cleaner, declarative, maintainable JSP pages
Common Tags	<c:if>, <c:forEach>, <fmt:formatDate>, etc.

In JSP EL, you can’t directly call methods like request.getMethod() because EL is designed mainly for accessing attributes and properties, not for executing complex logic.

✅ However, you can still access the HTTP method indirectly using request scope attributes.

🔥 Practical Solution:

1. Expose the HTTP method as a request attribute in your Servlet before forwarding to the JSP.

Example in Servlet:

request.setAttribute("httpMethod", request.getMethod());
request.getRequestDispatcher("/yourPage.jsp").forward(request, response);

Access it in the JSP using EL:

<p>HTTP Method: ${httpMethod}</p>

✅ httpMethod will now output GET, POST, PUT, etc., depending on the client request.

🔵 Why can’t EL call request.getMethod() directly?

• EL in standard JSP only allows property access (like user.name, order.id) or simple map lookup.
• EL does not allow calling arbitrary methods like getMethod() for security and simplicity reasons.

If you write something like ${request.method}:

• EL tries to find a “method” property inside the request object (it doesn’t exist).
• Therefore it will just return null or an empty string.

---

📢 Summary:

Step	Action
1	In a servlet or JSP scriptlet, store the HTTP method in a request attribute
2	In the JSP, access it via ${httpMethod} using EL

---

⚡ Alternative (less clean way):

If you have no servlet and want to get it inside pure JSP, you can (but it’s ugly) use a scriptlet:

<%
    request.setAttribute("httpMethod", request.getMethod());
%>

Then use ${httpMethod} in EL.

✅ But better practice is to set it from a servlet/controller and keep JSP clean!

🎯 Final Key Points:

Method	Recommended?	Reason
Using Servlet to set attribute	✅ Best	Clean, follows MVC
Using JSP scriptlet to set attribute	⚠️ Acceptable	But not ideal in modern projects
Trying to call request.getMethod() directly in EL	❌ Not possible	EL can’t call arbitrary methods