Objective

Understand Servlets as a core component of J2EE for generating dynamic web content. Learn the Servlet lifecycle, API, session management, and how to build and deploy a structured web application using Servlets. Apply concepts like MVC, session tracking, and request dispatching in practical scenarios.

Lecture Topics

1. Servlets: Dynamic Content Generation

• Definition: Servlets are Java programs that run on a web server to handle client requests (typically HTTP) and generate dynamic responses (e.g., HTML, JSON).
• Purpose:
  • Process form submissions, query databases, and generate dynamic web pages.
  • Serve as controllers in MVC architecture.
• Key Characteristics:
  • Platform-independent (pure Java).
  • Managed by a web container (e.g., Apache Tomcat).
  • Scalable and thread-safe (handles multiple requests concurrently).

2. Advantages of Servlets over CGI

• CGI (Common Gateway Interface):
  • Older technology where a new process is created for each request, leading to high resource usage.
• Advantages of Servlets:
  • Performance: Servlets are loaded once and reused for multiple requests, unlike CGI, which spawns a new process per request.
  • Portability: Java-based, runs on any platform with a J2EE container.
  • Resource Management: Leverages container services (e.g., connection pooling, threading).
  • Security: Managed by the container with built-in security features.
  • Ease of Use: Integrates with Java APIs (e.g., JDBC, JSTL) and frameworks (e.g., Spring).
• Example Comparison:
  • CGI: A Perl script creates a new process to generate an HTML page.
  • Servlet: A single Servlet instance handles multiple requests efficiently.

3. Servlet Life Cycle

• Stages:

  1. Loading and Instantiation: The web container loads the Servlet class and creates an instance.
  2. Initialization: The container calls the init(ServletConfig) method to initialize the Servlet.
     • Used to set up resources (e.g., database connections).
  3. Request Handling: The container calls the service(ServletRequest, ServletResponse) method for each client request.
     • For HTTP, HttpServlet dispatches to doGet(), doPost(), etc., based on the HTTP method.
  4. Destruction: The container calls the destroy() method when removing the Servlet (e.g., during undeployment).
     • Used to release resources.

• Key Methods:

  • init(ServletConfig): Called once during initialization.
  • service(ServletRequest, ServletResponse): Handles client requests.
  • destroy(): Called once before Servlet is removed.

• Example:

  public class MyServlet extends HttpServlet {
      @Override
      public void init(ServletConfig config) throws ServletException {
          System.out.println("Servlet Initialized");
      }
  
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          resp.getWriter().write("Hello from Servlet!");
      }
  
      @Override
      public void destroy() {
          System.out.println("Servlet Destroyed");
      }
  }
  
  

4. Servlet API & Deployment

• Servlet API: Provided in javax.servlet and javax.servlet.http packages.
  • Key Interfaces/Classes:
    • Servlet: Defines the contract for Servlets (init, service, destroy).
    • HttpServlet: Extends GenericServlet for HTTP-specific functionality.
    • HttpServletRequest: Provides methods to access request data (e.g., getParameter(), getHeader()).
    • HttpServletResponse: Provides methods to send responses (e.g., getWriter(), sendRedirect()).
    • ServletConfig: Configuration data for a Servlet (e.g., init parameters).
    • ServletContext: Application-wide data and resources.
• Deployment:

  • Using web.xml:

    • Map Servlets to URLs in the deployment descriptor.

    • Example:

      <servlet>
          <servlet-name>MyServlet</servlet-name>
          <servlet-class>com.example.MyServlet</servlet-class>
      </servlet>
      <servlet-mapping>
          <servlet-name>MyServlet</servlet-name>
          <url-pattern>/myServlet</url-pattern>
      </servlet-mapping>
      
      

  • Using Annotations:

    • Modern approach with @WebServlet annotation.

    • Example:

      @WebServlet("/myServlet")
      public class MyServlet extends HttpServlet {
          protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
              resp.getWriter().write("Hello, World!");
          }
      }
      
      

  • Deployment Process:

    • Package the application as a WAR file.
    • Deploy to a web container (e.g., Tomcat’s webapps/ directory).

5. Servlet Annotations