How can the functionality of JSP be extended?

JSP functionality can be extended in the following ways:

Using directives:
- <%@ include file="..." %>: Includes content from another file during translation.
- <%@ taglib uri="..." prefix="..." %>: Declares custom tags.
- <%@ page ... %>: Configures JSP page attributes (e.g., language, buffering).
Using Java Beans:
- Java components used for storing data and business logic. Accessed via getters and setters. Used with standard JSP actions <jsp:useBean>, <jsp:getProperty>, <jsp:setProperty>.

Using Custom Tags:

Creating custom tags to encapsulate repetitive logic or presentation. Implement interfaces Tag, SimpleTag, BodyTag, IterationTag.

// Example of a simple tag
package com.example.tags;

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

public class HelloWorldTag extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        getJspContext().getOut().write("Hello, World!");
    }
}

<!-- Example TLD file for a custom tag -->
<taglib xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
        version="2.1">

    <tlib-version>1.0</tlib-version>
    <short-name>mytags</short-name>
    <uri>http://example.com/tags</uri>

    <tag>
        <name>helloWorld</name>
        <tag-class>com.example.tags.HelloWorldTag</tag-class>
        <body-content>empty</body-content>
    </tag>
</taglib>

Using Expression Language (EL):

Simplified syntax for accessing data in JavaBeans, collections, arrays, and request parameters. Used in expressions like ${...}.

// Example Java Bean for EL usage
package com.example.beans;

public class User {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%-- Creating a JavaBean and placing it in request scope --%>
<jsp:useBean id="user" class="com.example.beans.User" scope="request"/>
<jsp:setProperty name="user" property="name" value="Alice"/>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>EL Example</title>
</head>
<body>
    <!-- Using EL to access JavaBean property -->
    <p>Hello, ${user.name}!</p>
</body>
</html>

Using JSTL (JSP Standard Tag Library):

Standard tag library providing common functions like iteration, conditionals, formatting, and XML handling.

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

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>JSTL Example</title>
</head>
<body>
    <%-- Creating a list for iteration --%>
    <c:set var="items" value='<%= new String[]{"Item A", "Item B", "Item C"} %>'/>

    <h2>List of items:</h2>
    <ul>
        <%-- Using c:forEach tag for iteration --%>
        <c:forEach var="item" items="${items}">
            <li>${item}</li>
        </c:forEach>
    </ul>

    <%-- Conditional operator --%>
    <c:if test="${items.length > 0}">
        <p>There are items in the list.</p>
    </c:if>

    <%-- Date formatting (requires java.util.Date in variable) --%>
    <%-- <fmt:formatDate value="${currentDate}" pattern="yyyy-MM-dd HH:mm:ss"/> --%>
</body>
</html>

Using Java Code (Scriptlets, Expressions, Declarations):

Embedding Java code directly into JSP pages. Though considered poor practice due to mixing presentation and logic.
- Scriptlets (<% ... %>): Execute Java code.
- Expressions (<%= ... %>): Output Java expression result.
- Declarations (<%! ... %>): Declare instance variables or methods inside the generated servlet.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Scriptlets Example</title>
</head>
<body>
    <h1>Using Scriptlets</h1>
    <%-- Scriptlet for code execution --%>
    <%
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
    %>
    <%-- Expression to display value --%>
    <p>The sum of numbers from 1 to 5 is: <%= sum %></p>

    <%! // Declaration for instance variable or method
        private String message = "This is a message from a declaration.";
        private String getMessage() {
            return message;
        }
    %>
    <p><%= getMessage() %></p>
</body>
</html>

Using Listeners:
- Reacting to web application, session, or request lifecycle events. Can be used to initialize resources or perform setup tasks.
Using Filters:
- Intercepting requests and responses. Useful for logging, authentication, request/response modification.
Using Servlets:
- Handling requests and preparing data for JSP display. Following MVC pattern.

Summary table of methods:

Method	Description	Advantages	Disadvantages	Usage examples
Directives	Configure JSP page, include files, declare tags	Simple setup, modularity (for include), tag libraries declaration	Limited functionality for business logic.	Including headers/footers, setting encoding
Java Beans	Data and logic components	Data encapsulation, reuse, EL and JSTL integration	Require use of JSP standard actions for access (though EL is better)	Storing form data, database objects
Custom Tags	User-defined tags for encapsulating display logic	Code reuse, improved JSP readability, separation of concerns	Require TLD and tag class development, more complex than scriptlets	Complex display logic, formatting, interactive components
Expression Language (EL)	Simplified data access syntax	Improved readability, less code in JSP, access to various scopes	Not meant for complex business logic.	Displaying data from JavaBeans, request parameters, headers
JSTL	Standard tag library	Standardization, common functions (conditions, loops, formatting), less scriptlets	Requires library addition to project.	Looping, conditions, internationalization, formatting
Java Code (Scriptlets)	Embedded Java code	Quick way to add logic (early stages)	Mixing presentation and logic, poor maintainability, testing, debugging	Rapid prototyping, rarely recommended in production.
Listeners	Responding to application events	Lifecycle management, resource initialization/cleanup	Do not directly interact with JSP presentation.	Connection pool setup, session caching, logging
Filters	Intercept requests/responses	Centralized processing, security, logging, data transformation	Do not directly interact with JSP presentation.	Authentication, authorization, character encoding, compression
Servlets	Controllers for request handling	MVC separation, application flow control, data preparation	Not used for direct display (usually).	Form processing, database interaction, business logic.

In modern Java EE/Jakarta EE development, using Java Code (Scriptlets, Expressions, Declarations) in JSP is considered outdated and not recommended. Prefer using JSTL, EL, and Custom Tags in combination with Servlets (MVC).