Objective

Understand the fundamentals of Java 2 Platform, Enterprise Edition (J2EE), its architecture, components, and processes involved in developing, packaging, and deploying J2EE-compliant web applications. Gain insight into web application lifecycle, deployment tools, and web services support.

Lecture Topics

1. J2EE Container

• Definition: A J2EE container is a runtime environment provided by a J2EE application server (e.g., Apache Tomcat, JBoss, GlassFish) that manages the lifecycle and services of J2EE components such as Servlets, JSPs, and EJBs (Enterprise JavaBeans).
• Types of Containers:
  • Web Container: Manages web components (Servlets, JSPs).
    • Handles HTTP requests and responses.
    • Provides services like session management, security, and request dispatching.
  • EJB Container: Manages Enterprise JavaBeans for business logic (not covered in detail in this syllabus).
  • Application Client Container: Manages client-side Java applications (less common).
• Responsibilities:
  • Lifecycle management (creation, execution, destruction) of components.
  • Providing system services (e.g., threading, security, transaction management).
  • Managing resources (e.g., database connections via JDBC).
• Examples:
  • Apache Tomcat: A popular web container for Servlets and JSPs.
  • GlassFish: A full J2EE application server supporting both web and EJB containers.

2. Packaging Web Applications

• Definition: Packaging involves organizing a web application’s files (Servlets, JSPs, HTML, CSS, configuration files) into a standard format for deployment.
• Standard Structure: J2EE web applications are packaged as WAR (Web Application Archive) files.

  • WAR File Structure:

    webapp/
    ├── WEB-INF/
    │   ├── web.xml (Deployment Descriptor)
    │   ├── classes/ (Compiled Java classes, e.g., Servlets, DAOs)
    │   ├── lib/ (JAR files for libraries, e.g., JDBC drivers, Hibernate)
    ├── index.html (Static resources like HTML, CSS, JS)
    ├── jsp/ (JSP files)
    
    

  • web.xml: The deployment descriptor defines Servlet mappings, configurations, and other settings.

    • Example:

      <web-app>
          <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>
      </web-app>
      
      

  • Annotations vs. web.xml: Modern J2EE applications use annotations (e.g., @WebServlet) to reduce reliance on web.xml.

• Packaging Process:
  • Use build tools like Maven or Gradle to create a WAR file.
  • Example Maven command: mvn package generates myapp.war.
  • The WAR file is deployed to a J2EE container.

3. J2EE Compliant Web Application

• Definition: A web application that adheres to J2EE specifications, ensuring portability across J2EE-compliant servers (e.g., Tomcat, WebSphere).
• Characteristics:
  • Uses standard J2EE components (Servlets, JSPs, JDBC, etc.).
  • Follows the J2EE directory structure (e.g., WAR format).
  • Configured via web.xml or annotations.
  • Supports J2EE APIs (e.g., Servlet API, JSP API, JDBC).
• Benefits:
  • Portability: Can be deployed on any J2EE-compliant server.
  • Scalability: Leverages container services like connection pooling and clustering.
  • Interoperability: Integrates with other J2EE components (e.g., EJBs, JMS).
• Example: A web application with Servlets for handling requests, JSPs for rendering views, and JDBC for database access.

4. Deployment Tools

• Definition: Tools used to deploy WAR files to a J2EE container.