ASSIGNMENT-1

1. What are Java EE Containers?

• Definition: Java EE containers are runtime environments that provide a managed

environment for executing Java EE components like servlets, JSPs, and EJBs.

• Lifecycle Management: They handle the lifecycle of components, including instantiation,

initialization, and destruction.

• Services Provided: Containers offer services such as security (authentication and

authorization), dependency injection, transaction management, naming (JNDI), and
persistence.

• Types of Containers:

o Web Containers: Manage the execution of web components like servlets and JSPs.

o EJB Containers: Handle the execution of Enterprise JavaBeans, providing support for
transactions and remote method calls.

• Scalability and Resource Management: Containers manage resources like threads,

connections, and memory.

• Abstraction of Infrastructure: Allows developers to focus on business logic rather than

infrastructure details.

2. Servlet Interface and its Methods

• Definition: The Servlet interface defines the methods that all servlets must implement.

• Methods Overview:

o init(): Called once by the servlet container when the servlet is first loaded, used to
perform any required initialization.

o service(): Invoked for each client request, used to process requests and generate
responses (like handling HTTP requests).

o destroy(): Called before the servlet is unloaded from memory to release resources
like file handles or database connections.

o getServletConfig(): Returns a ServletConfig object containing initialization

parameters and configuration information.

o getServletInfo(): Returns information about the servlet, such as version and author
details.

• Purpose: Provides a standard structure for handling web requests in Java.

3. Life Cycle of a Servlet

• Loading and Instantiation: The servlet is loaded by the web container when it is first
requested or during server startup.
 • Initialization (init()): The init() method is called once for initialization tasks, such as setting up
resources.

• Request Handling (service()): The service() method is invoked for each request. It delegates
the request to appropriate doGet(), doPost(), etc., based on the request type.

• Destruction (destroy()): Before the servlet is removed from memory, the destroy() method is
called to clean up resources.

• Garbage Collection: The servlet object is garbage collected by the JVM after being destroyed.

4. JDBC Architecture

• Java Database Connectivity (JDBC): Allows Java applications to interact with databases.

• Components:

o JDBC API: Provides classes and interfaces for database communication.

o Driver Manager: Manages a list of database drivers.

o JDBC Drivers: Act as a bridge between the application and the database.

o Connection Interface: Represents a session with the database.

o Statement Interface: Used to execute SQL queries.

o ResultSet Interface: Holds data returned from the database.

• Layers:

o Application Layer: Contains the Java application using JDBC.

o JDBC Driver Layer: Translates Java calls into database-specific calls.

o Database Layer: The actual database being accessed.

5. Types of JDBC Drivers

JDBC drivers are categorized into four types based on their architecture and how they connect Java
applications to databases:

• Type 1: JDBC-ODBC Bridge Driver

o Description: Acts as a bridge between JDBC and ODBC (Open Database

Connectivity). It translates JDBC calls into ODBC calls and communicates with the
database through the ODBC driver.

o Advantages:

▪ Can be used to access almost any database with an ODBC driver.

▪ Simple implementation for legacy systems.

o Disadvantages:

▪ Performance is poor due to the translation overhead.

▪ Requires the ODBC driver to be installed on the client machine.

 ▪ Platform-dependent, as it relies on native code.

• Type 2: Native-API Driver (Partially Java Driver)

o Description: Uses native code libraries of the database to convert JDBC calls into
database-specific calls. The driver interacts with the database using the native
database client library.

o Advantages:

▪ Better performance compared to Type 1, as it uses native library functions.

o Disadvantages:

▪ Requires native database library installation on the client.

▪ Platform-dependent due to reliance on native code.

▪ Not suitable for web-based applications.

• Type 3: Network Protocol Driver (Middleware Driver)

o Description: Uses a middleware server to translate JDBC calls into a database-

specific protocol. The middleware communicates with the database on behalf of the
client.

o Advantages:

▪ Allows for centralized management of database connections.

▪ Can access multiple databases using the same middleware.

▪ No need for database vendor-specific client libraries.

o Disadvantages:

▪ The middleware can become a bottleneck and add latency.

▪ More complex architecture due to the additional middleware layer.

• Type 4: Thin Driver (Pure Java Driver)

o Description: Directly converts JDBC calls into the database-specific protocol using
pure Java. Does not require any native code, making it platform-independent.

o Advantages:

▪ Best performance as it communicates directly with the database.

▪ Platform-independent since it is written in pure Java.

▪ Suitable for web applications.

o Disadvantages:

▪ May not support all database features.

▪ Database-specific, so changes are needed when switching databases.

6. Two-Tier Architecture (Client-Server)

• Definition: In a two-tier architecture, a client application communicates directly with a

server, typically a database server. The client sends requests, and the server processes them
and returns the results.

• Components:

o Client: The user interface or application that interacts with the server. It handles the
presentation and user input.

o Server: The backend system (often a database server) that handles data storage,
processing, and retrieval.

• Workflow:

o The client sends a request (e.g., a database query) to the server.

o The server processes the request and sends the response back to the client.

• Advantages:

o Simplicity: Easy to design and implement, with a straightforward client-server

relationship.

o Performance: Direct communication between client and server can result in fast
responses.

o Ease of Development: Ideal for small-scale applications with a limited number of

users.

• Disadvantages:

o Scalability Issues: As the number of clients increases, the server may become
overloaded, leading to performance degradation.

o Maintenance Challenges: Updates may need to be deployed on each client machine.

o Limited Flexibility: Adding new features may require changes to both client and
server.

7. Comparison of Class and Interface, and Explanation of API

• Class:

o Definition: A blueprint for creating objects in object-oriented programming. It

defines the properties (fields) and behaviors (methods) of an object.

o Characteristics:

▪ Can contain fields (variables), methods (functions), constructors, and nested

classes.

▪ Supports inheritance (a class can extend another class).

▪ Can have access modifiers (public, private, etc.) to control visibility.

▪ Provides method implementation.

 o Example:

java

Copy code

class Car {

String model;

void drive() {

System.out.println("Driving " + model);

• Interface:

o Definition: A reference type in Java that is similar to a class but only contains method
signatures (no method implementations).

o Characteristics:

▪ Used to specify a contract that classes must follow by implementing the

interface.

▪ Cannot have instance fields; can only have static and final variables.

▪ Supports multiple inheritance (a class can implement multiple interfaces).

▪ Methods in interfaces are abstract by default (Java 8 introduced default

methods).

o Example:

java

Copy code

interface Drivable {

void drive();

• Comparison:

o Classes can be instantiated, whereas interfaces cannot be instantiated directly.

o Classes provide implementation of methods, while interfaces only provide method

signatures.

o Classes support inheritance, but interfaces are used for abstraction and defining
behaviors that multiple classes can share.

• API (Application Programming Interface):

 o Definition: A set of methods, tools, and protocols that allow software components to
communicate with each other.

o Purpose: Enables developers to use functionalities provided by libraries or

frameworks without needing to know the underlying implementation.

o Example: Java's Collections Framework provides an API for working with data
structures like lists, sets, and maps.

ASSIGNMENT-2

1. RequestDispatcher Interface

• Definition: The RequestDispatcher interface in Java is used to dispatch a request to another

resource, such as a servlet, HTML file, or JSP, on the server.

• Purpose: It enables forwarding the request to another resource or including content from
another resource in the response.

• Methods:

o forward(request, response): Forwards the request to another resource without

returning to the original servlet.

o include(request, response): Includes content from another resource in the response.

• Usage: Helps in creating modular web applications by allowing request processing to be

delegated to multiple components.

2. Methods of Cookies Class and Use of Cookies

• Definition: Cookies are small pieces of data stored on the client's machine to maintain state
across multiple requests.

• Methods in Cookie class:

o setName(String name): Sets the name of the cookie.

o setValue(String value): Sets the value associated with the cookie.

o getValue(): Retrieves the value of the cookie.

o setMaxAge(int expiry): Sets the maximum age of the cookie (in seconds).

o setPath(String path): Specifies a path for which the cookie is valid.

o setDomain(String domain): Specifies the domain for which the cookie is valid.

• Use of Cookies:

o Session Tracking: Keeps user sessions alive by storing session IDs.

o Personalization: Stores user preferences to customize the website.

o Tracking User Behavior: Tracks user activity across websites for analytics.

3. HttpSession
 • Definition: The HttpSession interface provides a way to identify a user across multiple
requests and store information about that user.

• Features:

o Session Management: Maintains user session data across multiple requests.

o Attributes Handling: Allows storage of objects (user data, shopping carts, etc.) in the
session.

o Methods:

▪ getAttribute(String name): Retrieves an object bound to the session.

▪ setAttribute(String name, Object value): Binds an object to the session.

▪ invalidate(): Ends the session.

• Usage: Commonly used for user login, shopping cart management, and tracking user-specific
data.

4. GlassFish Server

• Definition: GlassFish is an open-source application server for Java EE. It provides a server
environment for deploying and running Java EE applications.

• Features:

o Support for Java EE Standards: Fully supports the latest Java EE specifications.

o Enterprise Features: Provides clustering, load balancing, and high availability.

o Modular Architecture: Uses OSGi-based modular architecture for dynamic updates.

o Administration Console: Offers an easy-to-use web-based administration interface.

o Built-in Security Features: Includes authentication, authorization, and secure socket

layer (SSL) support.

5. Web Server and Different Web Servers

• Definition: A web server is a server software that serves web pages to clients over HTTP or
HTTPS. It handles requests from clients (browsers) and provides responses.

• Types of Web Servers:

o Apache HTTP Server:

▪ Open-source, cross-platform server.

▪ Supports modules for added functionality like URL redirection.

o Nginx:

▪ High-performance server suitable for serving static content and acting as a

reverse proxy.

▪ Scalable and handles a large number of concurrent connections.

 o Microsoft IIS (Internet Information Services):

▪ Windows-based web server that integrates seamlessly with .NET

applications.

▪ Supports various authentication mechanisms and .NET language integration.

o Lighttpd:

▪ Lightweight server optimized for high-performance and low memory usage.

o Tomcat:

▪ Specifically for Java-based web applications (servlets and JSPs).

6. Difference between URL and URI

• URI (Uniform Resource Identifier):

o A generic identifier used to identify a resource on the internet.

o Can be a URL (Uniform Resource Locator) or URN (Uniform Resource Name).

o Syntax: scheme:[//authority]path[?query][#fragment].

• URL (Uniform Resource Locator):

o A type of URI that specifies the location of a resource on the internet.

o Contains protocol (HTTP, HTTPS), host, and file path.

o Example: https://example.com/index.html.

• Key Differences:

o URI is broader, while URL is a specific type of URI.

o Every URL is a URI, but not every URI is a URL.

7. Uploading File with Java Servlet

• Steps for File Upload in Java Servlet:

o Configure MultipartConfig: Annotate the servlet with @MultipartConfig to handle

multipart/form-data requests.

o Get the Part: Use request.getPart("file") to retrieve the uploaded file.

o Read the File: Use InputStream to read the file content.

o Save the File: Write the file to the desired location on the server.

• Libraries for Easier Handling: Use libraries like Apache Commons FileUpload for managing file
uploads.

• Security Considerations: Validate file types and restrict file sizes to prevent malicious
uploads.

8. Non-Blocking I/O (NIO) in Java

 • Definition: Non-blocking I/O allows threads to continue execution without being blocked
while waiting for I/O operations to complete.

• How It Works:

o Channels and Buffers: Uses channels for data transmission and buffers for temporary
storage.

o Selectors: Allows monitoring multiple channels for events (read, write) without
blocking.

o Asynchronous Operations: Uses AsynchronousSocketChannel and

AsynchronousServerSocketChannel for network communication.

• Advantages:

o Better Scalability: Suitable for applications with many I/O-bound tasks.

o Improved Performance: Reduces the number of threads needed for handling

multiple connections.

• Disadvantages:

o Complexity: Requires more sophisticated error handling and resource management.

These answers are detailed enough to be suitable for a 6-mark question, providing clear explanations
and examples where applicable.

ASSIGNMENT-3

1. Life Cycle of JSP (Java Server Pages)

• Stages in the Life Cycle:

1. Translation Phase: JSP is translated into a servlet. The JSP file is converted into a Java
servlet source file (.java).

2. Compilation Phase: The generated servlet source file is compiled into a bytecode
(.class file).

3. Loading and Instantiation: The compiled servlet class is loaded into the JVM, and an
instance of the servlet is created.

4. Initialization (jspInit() method): Called once when the servlet instance is created,
similar to init() in servlets.

5. Request Handling (_jspService() method): For each client request, _jspService() is

called. It handles all HTTP requests.

6. Destruction (jspDestroy() method): Called when the JSP is being unloaded from
memory, similar to destroy() in servlets.

• Diagram Representation:

rust
Copy code

JSP File --> [Translation] --> Servlet (.java) --> [Compilation] --> Bytecode (.class)

--> [Loading & Instantiation] --> Initialization (jspInit) --> Request Handling (_jspService)

--> Destruction (jspDestroy)

2. Difference Between Servlet and JSP

• Nature:

o Servlet: Java code embedded with HTML content. It is a Java class.

o JSP: HTML code with embedded Java code. It is easier to write.

• Compilation:

o Servlet: Manually compiled by the developer.

o JSP: Automatically compiled into a servlet.

• Ease of Use:

o Servlet: More complex due to mixing Java code with HTML.

o JSP: Easier to write and maintain because of tag-based scripting.

• Usage:

o Servlet: Suitable for request handling and processing.

o JSP: Suitable for presentation layer.

• Lifecycle Methods:

o Servlet: init(), service(), destroy().

o JSP: jspInit(), _jspService(), jspDestroy().

3. What is JSTL? Benefits over JSP Scriptlets

• JSTL (JavaServer Pages Standard Tag Library):

o A library of custom tags, providing commonly used functionalities (loops,

conditionals, formatting) to JSP pages.

• Benefits over JSP Scriptlets:

o Readability: JSTL tags make code more readable by separating logic from HTML.

o Maintainability: Easier to maintain because the code is less cluttered with Java.

o Standardization: Provides a set of standard tags, reducing the need for custom tag
libraries.

o Reusability: JSTL can be used across different JSPs without needing to write the
same code repeatedly.

4. What is EL (Expression Language)? Explain Types of Expressions Available in EL

Expression Language (EL) is a scripting language in JSP that simplifies access to JavaBean properties,
arrays, and collections without using Java code directly. It enhances readability and separates
presentation from logic, using ${} for immediate evaluation and #{} for deferred evaluation.

Types of Expressions in EL:

1. Value Expressions (${expression}):

o Evaluates immediately.

o Example: ${user.firstName} retrieves the firstName property.

2. Deferred Evaluation Expressions (#{expression}):

o Evaluated later, often used in frameworks like JSF.

o Example: #{user.login} invokes a method on a managed bean.

EL Implicit Objects:

• param: Accesses request parameters.

o Example: ${param.username}

• header: Accesses HTTP request headers.

o Example: ${header["User-Agent"]}

• sessionScope: Accesses session attributes.

o Example: ${sessionScope.user}

Advantages:

• Readability: Reduces embedded Java code in JSP.

• Maintenance: Simplifies the JSP file maintenance.

This version is shorter and highlights the core concepts and examples clearly.

5. Six JSP Implicit Objects

• 1. request:

o Represents the HttpServletRequest object.

o Methods: getParameter(), getAttribute(), getSession().

• 2. response:

o Represents the HttpServletResponse object.

o Methods: addCookie(), sendRedirect(), setContentType().

• 3. session:

o Represents the session associated with the client.

o Methods: setAttribute(), getAttribute(), invalidate().

• 4. application:
 o Represents the ServletContext for the JSP.

o Methods: getAttribute(), setAttribute(), getRealPath().

• 5. out:

o An instance of JspWriter used to send output to the client.

o Methods: print(), flush(), clear().

• 6. config:

o Represents the ServletConfig object.

o Methods: getInitParameter(), getServletName(), getServletContext().

6. Types of JSP Tags

• 1. Directive Tags:

o Used to provide instructions to the JSP container.

o Types: <%@ page %>, <%@ include %>, <%@ taglib %>.

• 2. Scripting Tags:

o Allow Java code to be inserted into JSP.

o Types: <% ... %> (scriptlet), <%= ... %> (expression), <%! ... %> (declaration).

• 3. Action Tags:

o Used for performing actions such as including other resources or forwarding

requests.

o Examples: <jsp:include>, <jsp:forward>, <jsp:useBean>.

• 4. Custom Tags:

o User-defined tags that can be used to encapsulate reusable functionality.

o Created using tag libraries.

7. Different Classes in JSP

• 1. HttpJspPage:

o Description: An interface that extends Servlet. When a JSP is translated into a

servlet, it implements this interface.

o Key Methods:

▪ _jspService(HttpServletRequest request, HttpServletResponse response):

Handles requests, similar to service() in servlets. It is auto-generated and
should not be overridden by developers.

▪ jspInit(): Called once during the JSP initialization phase, similar to the init()
method of a servlet.
 ▪ jspDestroy(): Called when the JSP is unloaded, just like the destroy() method
in a servlet.

o Usage: Provides the standard methods that every JSP must implement after being
compiled into a servlet.

• 2. JspWriter:

o Description: Used to send output to the client's browser. It is a buffered character

output stream.

o Buffering Levels:

▪ AutoFlush: The buffer is automatically flushed to the client when full.

▪ Manual Flush: Buffer flushing is manually controlled.

o Methods:

▪ print(String s): Writes a string to the output.

▪ println(String s): Writes a string followed by a newline.

▪ flush(): Forces any buffered content to be written.

▪ clear(): Clears the buffer without writing its contents.

o Importance: Enhances performance by reducing the number of network

transmissions due to buffering.

• 3. PageContext:

o Description: An implicit object that provides access to various elements like request,
response, session, application, and configuration.

o Main Methods:

▪ getAttribute(String name): Retrieves an attribute from the page scope.

▪ setAttribute(String name, Object value): Sets an attribute in the page scope.

▪ forward(String relativeUrlPath): Forwards the request to another resource.

▪ include(String relativeUrlPath): Includes content from another resource.

o Usage: Simplifies access to other JSP components and manages page-scoped

attributes.

• 4. JspApplicationContext:

o Description: Provides a context for the entire web application. It is used for
configuring EL resolvers and other global settings.

o Usage: Often utilized in custom tag development for registering EL resolvers and
integrating with other frameworks.

• 5. JspFactory:
o Description: A factory class for creating instances of JSP implicit objects like
PageContext and JspWriter.

o Methods:

▪ getPageContext(): Returns a `PageContext