JSP Architecture and Lifecycle

JSP Architecture Flow

1. The client navigates to the file ending with the .jsp, and the browser initiates an HTTP request to the webserver. 
    
2. If the compiled version of the JSP file exists in the web server, it returns the file. Otherwise, the request is forwarded to the JSP engine. If the modification date on the  JSP file is older than its generated servlet, then the JSP container assumes that the JSP hasn't changed and the generated servlet still matches the JSP's contents. This makes the process more efficient and faster than other scripting languages.
    
3. The JSP engine loads the JSP file and translates the JSP to Servlet. This is done by converting all the template text into println() statements and JSP elements to Java code. This process is called translation.
    
4. The JSP engine compiles the servlet to an executable .class file. It is then forwarded to the servlet engine. This process is known as the compilation/request processing phase.
    
5. The .class file is executed by the servlet engine, which generates the output as an HTML file. The servlet engine further passes the output as an HTTP response to the webserver.
    
6. At last, the webserver forwards the HTML file to the client’s browser. The browser handles the dynamically generated HTML page exactly like a static page.

Lifecycle of JSP

A JSP lifecycle can be defined as the process that starts with its creation which is further translated into a servlet, and then the servlet life cycle comes into play.

Steps Involved in a JSP lifecycle:

• Translation
• Compilation
• ClassLoading
• Instantiation
• Initialization
• Request Processing
• Destroy
   

Translation

This phase deals with the syntactic correctness of the page. JSP code is checked by the JSP container and is parsed by it to generate the servlet source code. The web container automatically translates the index.jsp file into index.java.

Compilation 

Here, the JSP container compiles the JSP class source code. It converts the index.java file into an index.class file. The translation of the Java source to its implementation class can occur at any given time between the deployment of the JSP page into the container and processing of the JSP page.

ClassLoading 

In this phase, the servlet class loaded from the JSP source is loaded into the container. 

Instantiation 

In this phase, an instance of the class is generated. The container manages one or more instances by responding to the requests.

Initialization 

In this phase, the container invokes the init method of the JSP class. After that, servlet configuration with the init parameter is configured. Now, JSP can handle the client requests. Most often, the translation and initialization in JSP happen as soon as the first request for a JSP comes.

Request Processing 

This is the most time-consuming phase of the JSP. Here, the JSP page processes the requests from a client. The request processing phase is multi-threaded. A new thread is used for every request, and a servlet request and response object are created. After this, the _jspService() method is called. This method cannot be overridden.

Destroy 

The last phase of the JSP lifecycle is destroyed. The JSP class is unloaded or removed from the container in this phase. It is done when the application is undeployed or when the server is down. This is done using the jspDestroy() method and can be overridden.

JSP Lifecycle Methods

jspInit() 

This is declared on the JSP page. This method is called only once in the complete lifecycle of JSP. This is used to initialize configuration params in a deployment descriptor. This method can be overridden using a JSP declaration scripting element. 

_jspService()

It is invoked by the JSP container for each client request. This method passes the request and response objects. It cannot be overridden, and hence, it starts with an underscore. It is defined and declared in the HttpJspPage interface.

jspDestroy()

This is used for shutting down the application/container. This method is called only once in the complete JSP lifecycle when JSP is unloaded from the memory. This method should be overridden only to release resources created in the JSP init method.

Recommended Article: What is Servlet

Java Servlet Advantages

Java servlet offers several advantages:

• Platform Independence: Java Servlets run on any platform that supports the Java Virtual Machine (JVM), making them highly portable and platform-independent.
• Efficiency: Servlets are managed by a web server, which creates a single instance of the servlet that handles multiple requests, reducing memory consumption and improving performance.
• Security: Servlets benefit from Java's robust security features, including built-in protection against common security threats like cross-site scripting (XSS) and SQL injection.
• Scalability: Servlets can handle complex, large-scale applications with ease. The server can manage multiple servlet instances efficiently, making it suitable for scalable web applications.
• Integration with Java Ecosystem: Servlets can seamlessly integrate with other Java technologies like JSP, JDBC, and EJB, allowing for comprehensive and powerful web applications.
• Maintainability: Java Servlets use the object-oriented principles of Java, leading to cleaner, modular code that is easier to maintain and extend.
• Extensibility: Servlets can be easily extended and customized to add new functionality, making them highly flexible for various web applications.

Java Servlet Disadvantages

Along with the advantages, there are numerous disadvantages as well:

• Complexity: Writing and managing servlets can be complex compared to other web frameworks, particularly for developers new to Java.
• Manual Code Management: Servlets require manual handling of HTTP requests and responses, which can be cumbersome and error-prone compared to higher-level abstractions provided by modern frameworks.
• Lack of UI Components: Servlets focus on back-end processing and do not provide built-in support for creating user interfaces, requiring additional technologies like JSP or front-end frameworks.
• Limited Control Over HTML: Since servlets are primarily server-side components, they offer limited direct control over HTML and CSS, necessitating additional tools or frameworks for complex UI design.
• Scalability Concerns for Simple Applications: For small, simple web applications, the overhead of servlets might be overkill, as simpler solutions like PHP or lightweight frameworks could suffice.

Frequently Asked Questions

How does JSP work?

JSP (JavaServer Pages) works by converting JSP code into a servlet, which is then compiled and executed on a web server to generate dynamic web content.

What is the basic structure of a JSP code file?

A JSP file consists of directives (<%@ %>), scriptlets (<% %>), expressions (<%= %>), declarations (<%! %>), and standard HTML to create dynamic web pages.

What is called JSP?

JSP (JavaServer Pages) is a server-side technology that enables the creation of dynamic web pages using Java code embedded within HTML.

Conclusion

JSP architecture provides a robust framework for developing dynamic and interactive web applications. By converting JSP pages into servlets, it enables efficient execution on the server, improving maintainability and scalability. The architecture follows a structured approach with key components like the JSP engine, servlets, and web container, ensuring seamless integration with Java-based technologies.

• JSP code is converted into a servlet at runtime
   
• Caching is done on the JSP servlet, and it is reused until the original code is changed
   
• JSP architecture is either independent or is present as an MVC component
   
• JSP comes with many advanced features that help create and maintain a highly scalable web application