How can JSP functionality be extended?

The functionality of JSP can be extended in the following ways:

• Tag Libraries (TLD)

  Custom tags allow creating own markup elements for specific logic execution. They consist of a tag declared in a TLD file (Tag Library Descriptor) and a corresponding tag handler class.

  // Example of a simple tag handler
  import javax.servlet.jsp.JspException;
  import javax.servlet.jsp.tagext.SimpleTagSupport;
  
  public class MyCustomTag extends SimpleTagSupport {
      @Override
      public void doTag() throws JspException {
          try {
              getJspContext().getOut().write("Hello from custom tag!");
          } catch (java.io.IOException e) {
              throw new JspException("Error writing output", e);
          }
      }
  }
  

• Expression Language (EL)

  EL allows access to data from various scopes (page, request, session, application) and performing simple operations like property access and method invocation. It makes JSP more readable by replacing scriptlets.

  <%-- Example of using EL to access a bean property --%>
  <p>User name: ${user.name}</p>
  
  <%-- Example of calling a method --%>
  <p>Name length: ${user.getName().length()}</p>
  

• Custom Functions (EL Functions)

  EL custom functions allow calling static Java methods directly from EL expressions. This is useful for encapsulating frequently used logic.

  // Example of a static method for EL function
  package com.example.utils;
  
  public class StringFunctions {
      public static String toUpperCase(String input) {
          if (input == null) {
              return null;
          }
          return input.toUpperCase();
      }
  }
  

  Declared in a TLD file.

  <%-- Example of using a custom EL function --%>
  <%@taglib uri="/WEB-INF/tlds/myfunctions.tld" prefix="myfn" %>
  <p>${myfn:toUpperCase(user.name)}</p>
  

• Includes (include directive or jsp:include action)

  Including other JSP pages, HTML files, or servlets allows breaking down a page into reusable components and modules.

  Mechanism	Compile-time	Runtime	Usage
  <%@ include ...%>	During compilation	During compilation	For static content
  <jsp:include ...>	During execution	During execution	For dynamic content, passing parameters

• Action Tags (jsp: prefix)

  Standard action tags provided by the JSP specification, such as jsp:useBean, jsp:setProperty, jsp:getProperty, jsp:forward, jsp:param. They provide basic functionality without scriptlets.

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

• Scriptlets (<% ... %>)

  This approach is not recommended for new development due to mixing logic and presentation, which complicates reading and maintenance. However, it was historically used for inserting arbitrary Java code into JSP.

  <% // Example of scriptlet
     String message = "Hello from scriptlet!";
     out.println("<p>" + message + "</p>");
  %>
  

• Declarations (<%! ... %>)

  Declares variables and methods at the JSP page class level. Also not recommended due to thread safety issues and readability.

  <%! // Example of declaring a variable at class level
      private int counter = 0;
  %>
  

Modern approaches focus on using EL, custom tags, and EL functions, minimizing or eliminating the use of scriptlets and declarations for better readability, maintainability, and separation of concerns.