JSP Introduction and Lifecycle

JavaServer Pages (JSP) let you write HTML pages with embedded Java logic, instead of writing HTML by hand inside a servlet's println() calls. A JSP file looks mostly like an ordinary HTML page, with special tags for the dynamic parts — but that appearance is deceiving, because a JSP page is never executed directly. Behind the scenes, the container translates every JSP into a full Java servlet, compiles it, and then runs it exactly like any other servlet.

This relationship — JSP is really "a servlet written the easy way" — explains almost every behavior JSP has, from its implicit objects to its lifecycle stages, and is the single most important fact to internalize before learning JSP syntax.

From .jsp File to Running Servlet

The container performs this translation the first time a JSP page is requested (or ahead of time, if precompiled): it reads the .jsp file, generates an equivalent Java source file (a servlet class extending HttpJspPage, which itself extends the same servlet lineage you already know), compiles that source into bytecode, and loads it. HTML markup in the JSP becomes out.println() calls in the generated servlet; Java code you wrote in scriptlets is copied nearly verbatim into the generated _jspService() method.

The Five Lifecycle Stages

Because a JSP becomes a servlet, its lifecycle closely mirrors the servlet lifecycle, with one extra stage at the front for the translation step.

• Translation — the .jsp file is converted into Java source code (a servlet class), performed once per page unless the source changes.
• Compilation — the generated Java source is compiled into a .class file, again performed once (until the JSP is modified).
• Initialization — jspInit() runs once, analogous to a servlet's init().
• Execution — _jspService() runs once per request, analogous to a servlet's service(); you never write this method yourself, the container generates it from your page.
• Destruction — jspDestroy() runs once when the container removes the page, analogous to destroy().

Why This Matters in Practice

Because JSP compiles to a servlet, the first request to a freshly deployed JSP page is noticeably slower than subsequent ones — that first hit pays the translation-and-compilation cost. It also explains why a JSP syntax error shows up as a compilation error referencing a generated file with a name like product_jsp.java, which can look confusing until you know that file is auto-generated from your page.

Example

<%-- welcome.jsp --%>
<html>
<body>
  <h2>Welcome to Webnest Studio</h2>
  <p>Today's date on the server: <%= new java.util.Date() %></p>
</body>
</html>

<%-- Conceptually, the container generates and runs code equivalent to: --%>
<%--
public void _jspService(HttpServletRequest request, HttpServletResponse response) {
    out.println("<html><body>");
    out.println("<h2>Welcome to Webnest Studio</h2>");
    out.println("<p>Today's date on the server: " + new java.util.Date() + "</p>");
    out.println("</body></html>");
}
--%>

Browser output:
Welcome to Webnest Studio
Today's date on the server: Mon Sep 21 00:00:00 UTC 2026

Exercise

Using the lesson's A minimal JSP page and the servlet-like structure it compiles into conceptually example, create a small implementation or design sketch that demonstrates A JSP page is translated into a servlet, compiled, and executed — it is not interpreted directly.. Add a test case or scenario that would catch Assuming a JSP file is interpreted line-by-line like a script — it is fully translated into a servlet and compiled, not interpreted., and describe the expected result.

Quick quiz

Interview questions