CORBA (Common Object Request

Broker Architecture) in Java:

What is CORBA?*

CORBA is a standard for distributed object

communication, enabling objects to
communicate with each other across
different languages, platforms, and
networks.
CORBA Components:*

1. Object Request Broker (ORB): Manages

communication between objects.
2. Interface Definition Language (IDL): Defines object
interfaces.
3. Stub and Skeleton: Facilitate communication
between ORB and objects.
CORBA Java Implementation:*

1. Java IDL (Interface Definition Language): Maps

IDL to Java.
2. RMI-IIOP (Remote Method Invocation over
Internet Inter-ORB Protocol): Enables CORBA
communication.

*CORBA Java Benefits:*

1. Platform independence
2. Language independence
3. Distributed computing
4. Scalability
CORBA Java Drawbacks:*

1. Complexity
2. Performance overhead
3. Security concerns
CORBA Java Example:*
Server.java*
*Hello.idl*
idl public class Server {
module HelloApp { public static void main(String[] args) {
interface Hello { // Initialize ORB
string sayHello(); ORB orb = ORB.init(args, null);
};
}; // Create Hello object
HelloImpl hello = new HelloImpl();

// Register object with ORB

orb.connect(hello);
Hello.java*
public class HelloImpl extends HelloPOA { // Start ORB
public String sayHello() { orb.run();
return "Hello, World!"; }
} }
}
Client.java*
```
public class Client {
public static void main(String[] args) {
// Initialize ORB
ORB orb = ORB.init(args, null);

// Get Hello object reference

Hello hello =
HelloHelper.narrow(orb.resolve_initial_references("Hello"));

// Invoke sayHello method

String response = hello.sayHello();
System.out.println(response);
}
}
```Interface Definition Language (IDL):

IDL is a language used to define interfaces between

systems, components, or objects.

*Purpose:*

1. Define contracts between components

2. Specify methods, parameters, and return types
3. Enable communication between different
languages and platforms
4. Provide a common understanding of interface
semantics
Characteristics:*

1. Platform-independent
2. Language-independent
3. Formal syntax
4. Self-describing

*Types of IDLs:*

1. CORBA IDL (Common Object Request Broker

Architecture)
2. COM IDL (Component Object Model)
3. RPC IDL (Remote Procedure Call)
4. Web Services Description Language (WSDL)
5. Protocol Buffers (protobuf)
*IDL Components:*

1. Interface definition
2. Method declarations
3. Parameter definitions
4. Return type specifications
5. Exception handling
Example (CORBA IDL):*
```
interface HelloWorld {
void sayHello(in string
name);
string getMessage();
};
*Benefits:*

1. Improved interoperability
2. Clear interface definitions
3. Reduced errors
4. Simplified maintenance
5. Enhanced reusability

*Tools and Frameworks:*

1. CORBA (omniORB, JacORB)

2. COM (Microsoft Visual Studio)
3. RPC (Sun RPC, XML-RPC)
4. WSDL (Apache Axis, .NET)
5. protobuf (Google Protocol Buffers)
Hello.idl (Interface Definition Language file)*
```
idl
module HelloApp {
interface Hello {
string sayHello(in string name);
};
};
```
This IDL file defines an interface `Hello` with a
single method `sayHello` that takes a string
parameter `name` and returns a string.
*HelloImpl.java (Server-side implementation)*
```
import org.omg.CORBA.ORB;
import org.omg.CORBA.PORTABLE_SERVER;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContext;

public class HelloImpl extends HelloPOA {

public String sayHello(String name) {
return "Hello, " + name + "!";
}

public static void main(String[] args) {

try {
// Create ORB
ORB orb = ORB.init(args, null);
// Create HelloImpl instance
HelloImpl helloImpl = new HelloImpl();

// Register with ORB

orb.connect(helloImpl);

// Get NamingContext
NamingContext namingContext =
NamingContextHelper.narrow(orb.resolve_initi
al_references("NameService"));

// Bind HelloImpl to NamingContext

NameComponent[] name = new
NameComponent[1];
name[0] = new NameComponent("Hello");
namingContext.bind(name, helloImpl);
```
// Start ORB This Java class implements the
orb.run();
} catch (Exception e) {
`Hello` interface defined in the IDL
System.out.println("Error: " + e.getMessage()); file.
} The `sayHello` method returns a
}
}
greeting message.
CORBA Packages
rg.omg.CORBA: Core CORBA package.
rg.omg.CORBA.portable: Provides portable CORBA functionality.
rg.omg.CORBA.TypeCodePackage: Supports TypeCode operations.

DL Packages
rg.omg.IDL: Defines IDL interfaces and classes.
Other Packages
rg.omg.CosNaming: Provides a naming service for CORBA objects
rg.omg.CosTransactions: Supports transactional operations.
ome key classes and interfaces in these packages include:
rg.omg.CORBA.ORB (Object Request Broker)
rg.omg.CORBA.Object
rg.omg.CORBA.Request
rg.omg.IDL.Interface
HelloClient.java (Client-side code)* // Resolve Hello reference
``` NameComponent[] name = new
import org.omg.CORBA.ORB; NameComponent[1];
import name[0] = new
org.omg.CosNaming.NameComponent; NameComponent("Hello");
import Hello hello =
org.omg.CosNaming.NamingContext; HelloHelper.narrow(namingContext.resolv
e(name));
public class HelloClient {
public static void main(String[] args) {
// Invoke sayHello method
try { String response = hello.sayHello("John");
// Create ORB System.out.println(response);
ORB orb = ORB.init(args, null); } catch (Exception e) {
System.out.println("Error: " +
// Get NamingContext e.getMessage());
NamingContext namingContext = }
NamingContextHelper.narrow(orb.resolve }
_initial_references("NameService")); }
```
This Java class looks up the `Hello`
reference in the NamingContext and
invokes the `sayHello` method.
Steps to run:*

1. Compile IDL file: `idlj -fserver -fclient Hello.idl

2. Compile Java files: `javac *.java
3. Run server: `java HelloImpl -ORBInitialPort 1050
4. Run client: `java HelloClient –ORBInitialPort 1050

*Output:*

Hello, John!
1. *Architecture*:
- CORBA: Decentralized, broker-based architecture (Object Request
Broker).
- RMI: Centralized, stub/skeleton-based architecture.
2. *Platform independence*:
- CORBA: Supports multiple platforms and languages.
- RMI: Primarily designed for Java.
3. *Interface definition*:
- CORBA: Uses IDL (Interface Definition Language).
- RMI: Uses Java interfaces.
4. *Communication protocol*:
- CORBA: Uses IIOP (Internet Inter-ORB Protocol).
- RMI: Uses JRMP (Java Remote Method Protocol).
5. *Security*:
- CORBA: Provides robust security features.
- RMI: Limited security features.
6. *Complexity*:
- CORBA: Steeper learning curve due to IDL and ORB.
- RMI: Simpler, more intuitive API.
* When to choose CORBA over RMI:*

1. Multi-language support.
2. Multi-platform support.
3. Robust security features.
4. Decentralized architecture.

*When to choose RMI over CORBA:*

1. Java-only applications.
2. Simple, lightweight distributed systems.
3. Easy-to-use API.
 IIOP (Internet Inter-ORB Protocol) Implementation:

Implementation Steps*
1. *ORB Initialization*
- Initialize the ORB (Object Request Broker) on both client and server sides.
- Specify the IIOP port number.
2. *Object Registration*
- Register the CORBA object with the ORB on the server side.
- Obtain an Interoperable Object Reference (IOR) for the object.
3. *Client Request*
- Create a client request using the IOR.
- Marshal (serialize) the request data.
4. *Server Response*
- Receive the client request.
- Demarshal (deserialize) the request data.
- Process the request and send a response.
5. *Connection Establishment*
- Establish a connection between client and server using TCP/IP.
- Use the IIOP protocol for data exchange.
*IIOP Message Structure*

1. *Message Header*

- Version
- Message type (request or response)
- Message size
2. *Request or Response Data*

- Operation name
- Parameters (marshaled)
3. *Error Handling*

- Error codes
- Error messages
Java Implementation Example*
Using Java IDL (Interface Definition Language) and Java ORB:
// IDL file (Hello.idl)
module HelloApp {
interface Hello {
string sayHello(in string name);
};
};
// Server-side implementation (HelloImpl.java)
public class HelloImpl extends HelloPOA {
public String sayHello(String name) {
return "Hello, " + name + "!";
}
}
// Client-side code (HelloClient.java)
public class HelloClient {
public static void main(String[] args) {
// Initialize ORB
ORB orb = ORB.init(args, null);
// Obtain Hello object reference
Hello hello =
HelloHelper.narrow(orb.resolve_initial_references
("Hello"));
// Invoke sayHello method
String response = hello.sayHello("John");
System.out.println(response);
}
}
*Explanation:*

This line of code is used in the CORBA client to obtain a reference to the `Hello` object.
*Step-by-Step Breakdown:*

1. `orb.resolve_initial_references("Hello")`:

- `orb`: The ORB (Object Request Broker) instance.

- `resolve_initial_references`: Method to resolve an initial reference.
- `"Hello"`: The name of the reference to resolve.

2. `HelloHelper.narrow(...)`:

- `HelloHelper`: A helper class generated by the IDL compiler.

- `narrow`: Method to narrow an object reference to a specific type.

3. `Hello hello = ...`:

- `Hello`: The interface type.

- `hello`: The variable to hold the reference.
What happens:*

1. The client asks the ORB to resolve the initial reference named "Hello".
2. The ORB returns a generic object reference.
3. The `HelloHelper.narrow` method converts the generic reference to a `Hello`
interface reference.
4. The resulting reference is assigned to the `hello` variable.

*Purpose:*

This line enables the client to access the `Hello` object's methods, such as `sayHello`,
through the `hello` variable. CORBA Naming Services:

*
 CORBA Naming Services

• Provide a way to name and resolve objects in a distributed system.

• It allows clients to locate and access objects without knowing their
exact location.
Key Concepts

1.Naming Context: A hierarchical structure for

organizing named objects.
2. Name: A unique identifier for an object.
3. Binding: Associating a name with an object
reference.
4. Resolution: Finding an object reference given its
name.
*CORBA Naming Service Architecture*

1. *Naming Service*: Manages naming contexts and bindings.

2. *Naming Context*: Contains named objects and sub-contexts.
3. *Client*: Uses naming service to resolve object references.

*CORBA Naming Service Interfaces*

1. *NamingContext*: Provides methods for creating, binding, and

resolving names.
2. *NameComponent*: Represents a single component of a name.
3. *Name*: Represents a complete name.
*Methods*

1. *bind*: Associates a name with an object reference.

2. *rebind*: Replaces an existing binding.
3. *resolve*: Returns an object reference given its name.
4. *list*: Returns a list of bindings in a naming context.
5. *destroy*: Removes a binding or naming context.

*CORBA Naming Service Benefits*

1. *Decoupling*: Clients and servers are decoupled.

2. *Flexibility*: Objects can be relocated without affecting clients.
3. *Scalability*: Supports large-scale distributed systems.
*Example Code (Java)*
```
// Create a naming context
NamingContext namingContext =
NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));

// Create a name component

NameComponent nameComponent = new NameComponent("Hello");

// Create a name
Name name = new Name();
name.add(nameComponent);

// Bind an object reference to the name

Hello hello = new HelloImpl();
namingContext.bind(name, hello);

// Resolve the object reference

Hello resolvedHello = (Hello) namingContext.resolve(name);
```
*Example 1: Simple Naming Service* // Client-side code (HelloClient.java)
public class HelloClient {
public static void main(String[] args) {
``idl // Initialize ORB
// IDL file (Hello.idl) ORB orb = ORB.init(args, null);
module HelloApp {
```// Resolve naming context
interface Hello { NamingContext namingContext =
string sayHello(in string name); NamingContextHelper.narrow(orb.resolve_initial_references("Na
}; meService"));
}; // Create name component
NameComponent nameComponent = new
// Server-side implementation NameComponent("Hello");
(HelloImpl.java)
// Create name
public class HelloImpl extends HelloPOA { Name name = new Name();
public String sayHello(String name) { name.add(nameComponent);
return "Hello, " + name + "!";
// Resolve Hello object reference
} Hello hello = HelloHelper.narrow(namingContext.resolve(name));
}
// Invoke sayHello method
String response = hello.sayHello("John");
System.out.println(response);
```
}
}
* NameComponent*

- Represents a single component of a name.

- A string that identifies a specific object or
context.
- Can be thought of as a directory or folder name.

*Name*

- Represents a complete name, composed of one

or more `NameComponent`s.
- Uniquely identifies an object or context.
- Can be thought of as a full path to a file.
- `NameComponent` = Directory or folder name
(e.g., "Documents")
- `Name` = Full path to a file (e.g.,
"/Users/John/Documents/report.txt")

*CORBA Naming Service Methods*:

1. `bind(Name name, Object obj)`: Bind an object

to a name.
2. `resolve(Name name)`: Resolve an object
reference given its name.
3. `list(Name name, BindingListHolder bindings)`:
List bindings under a given name.
*Example Code*:

```
// Create a name component
NameComponent nc = new NameComponent("Documents");

// Create another name component

NameComponent nc2 = new NameComponent("report");

// Create a name
Name name = new Name();
name.add(nc);
name.add(nc2);
In this example:
// Bind an object to the name
namingContext.bind(name, myObject); - `nc` and `nc2` are `NameComponent`s.
- `name` is a `Name` composed of `nc` and
`nc2`.
- `myObject` is bound to the `name`.
*Example 1: Simple Naming*

```
// Create a naming context
NamingContext namingContext =
NamingContextHelper.narrow(orb.resolve_initial_referenc
es("NameService"));

// Create a name component

NameComponent nc = new NameComponent("Hello");

// Create a name
Name name = new Name();
name.add(nc);

// Bind an object to the name

Hello hello = new HelloImpl();
namingContext.bind(name, hello);
```
*Example 3: Resolving a Name*

```
// Create a naming context
NamingContext namingContext =
NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));

// Create name components

NameComponent nc1 = new NameComponent("Bank");
NameComponent nc2 = new NameComponent("Account");

// Create a name
Name name = new Name();
name.add(nc1);
name.add(nc2);

// Resolve the object reference

Account account = AccountHelper.narrow(namingContext.resolve(name));
```
CORBA Programming Models:

There are two primary programming models in CORBA:

1. *Static Invocation Model*

- Clients use pre-compiled stubs to invoke operations on remote objects.

- Stubs are generated from IDL files using tools like idlj.
- Pros: Efficient, fast, and type-safe.
- Cons: Less flexible, requires recompilation for changes.

2. *Dynamic Invocation Interface (DII)*

- Clients dynamically construct and invoke requests on remote objects.

- No pre-compiled stubs are required.
- Pros: Flexible, supports dynamic typing, and runtime changes.
- Cons: Slower performance, more complex.
*Other CORBA Programming Models*

1. *Object-by-Value (OBV)*

- Objects are passed by value, not reference.

- Supports distributed object replication.

2. *Object-by-Reference (OBR)*

- Objects are passed by reference.

- Supports shared object access.
*Static Invocation Model Example (Java)*

```
// IDL file (Hello.idl) // Client-side code (HelloClient.java)
module HelloApp { public class HelloClient {
interface Hello { public static void main(String[] args) {
string sayHello(in string name); // Initialize ORB
}; ORB orb = ORB.init(args, null);
};
// Obtain Hello object reference
// Server-side implementation Hello hello =
(HelloImpl.java) HelloHelper.narrow(orb.resolve_initial_referen
public class HelloImpl extends HelloPOA { ces("Hello"));
public String sayHello(String name) {
return "Hello, " + name + "!"; // Invoke sayHello method
} String response = hello.sayHello("John");
} System.out.println(response);
}
}
Dynamic Invocation Interface (DII) Example // Client-side code (HelloClient.java)
(Java)* public class HelloClient {
public static void main(String[] args) {
// Initialize ORB
```
ORB orb = ORB.init(args, null);
// IDL file (Hello.idl)
module HelloApp { // Obtain Hello object reference
interface Hello { org.omg.CORBA.Object obj =
string sayHello(in string name); orb.resolve_initial_references("Hello");
};
}; // Create DynamicInvocationInterface
DynamicInvocationInterface dii =
DynamicInvocationInterfaceHelper.narrow(obj);
// Server-side implementation
(HelloImpl.java) // Invoke sayHello method dynamically
public class HelloImpl extends HelloPOA { Request request = dii.create_request("sayHello");
public String sayHello(String name) { request.add_in_arg("name", "John");
return "Hello, " + name + "!"; request.invoke();
} String response =
} request.return_value().extract_string();
System.out.println(response);
}
}
```
JAR file - Java archive file

Archive file - An archive file is a container that stores

one or more files, often compressed, to reduce storage
space and simplify file management.

• A JAR file is a compressed archive file that contains

Java classes, libraries, and resources.

• It's used to distribute and package Java applications,

libraries, and frameworks .
Creating a JAR (Java Archive) File:
*Method 2: Using Eclipse*
*Why Create a JAR File?*
1. Create a new Java project.
2. Select Project > Export...
1. Package related classes and resources.
3. Choose "JAR file" and click Next.
2. Simplify distribution and deployment.
4. Select classes and resources to include.
3. Improve security and encryption.
5. Choose destination and click Finish.
4. Reduce file size.

*Steps to Create a JAR File:*

*Method 1: Using Command Line* *Method 3: Using IntelliJ IDEA*

1. Open terminal/command prompt. 1. Open Project Structure (Ctrl+Shift+Alt+S).

2. Navigate to the directory containing 2. Select Modules > [module name] >
your .class files. Packaging.
3. Use the `jar` command: 3. Click "+" and select "JAR" from the
jar cvf myjar.jar *.class dropdown.
4. Choose classes and resources to include.
c: Creates a new JAR file. 5. Click Apply and OK.
v: Verbose mode, displays detailed output.
f: Specifies the JAR file name.
Action:
This command creates a JAR file named myjar.jar and
adds all .class files in the current directory to it.
*Example 1: Command Line*
Suppose we have a simple Java program `HelloWorld.java`:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Compile and create a JAR file:
bash
javac HelloWorld.java
jar cvf hello.jar *.class
This command creates a JAR file named hello.jar and adds all .class files in the
current directory to it.

output
added manifest
adding: Hello.class(in = 456) (out = 294)(deflated 35%)
adding: HelloWorld.class(in = 123) (out = 98)(deflated 20%)
*What is a Manifest File?]
A manifest file (MANIFEST.MF) is a text file contained within a JAR file.
It provides metadata about the JAR file's contents, such as:
1.Version information
2.Author and copyright details
3.Main class (entry point)
4.Classpath settings
Dependencies

The manifest file is typically located in the JAR file's:

META-INF/MANIFEST.MF
**Format:]
The manifest file follows a specific format:
Manifest-Version: 1.0
Created-By: 1.8.0_292 (Oracle Corporation)
Built-By: John Doe
Main-Class: com.example.HelloWorld
*Example 2: Eclipse*

1. Create a new Java project "HelloWorld".

2. Create a package `com.example` and add `HelloWorld.java`.
3. Right-click project > Export... > JAR file > Next.
4. Select classes and resources > Finish.

*Example 3: IntelliJ IDEA*

1. Create a new Java project "HelloWorld".

2. Create a package `com.example` and add `HelloWorld.java`.
3. Open Project Structure (Ctrl+Shift+Alt+S).
4. Select Modules > HelloWorld > Packaging.
5. Click "+" and select "JAR".

*Running the JAR File*

bash
java -jar hello.jar

Output:
Hello, World!
MULTI-TIER APPLICATION
DEVELOPMENT
Unit - 4
 Multi-Tier Architecture

• Multi-tier architecture is a software design

pattern that separates an application into
multiple layers or tiers, each with a specific
responsibility.
• This separation enables scalability,
maintainability, and flexibility.
 Tiers in Multi-Tier Architecture

• Presentation Tier (Client-Side)

• Application Tier (Server-Side)
• Data Tier (Database)
 Presentation Tier (Client-Side):
• Handles user interaction and displays data.
• Technologies: HTML, CSS, JavaScript, JSP,
Servlets
• Responsibilities:
• User interface
• Data validation
• User experience
 Application Tier (Server-Side):
• Processes business logic, interacts with data
storage.
• Technologies: Java Servlets, JavaServer Faces
(JSF), Spring MVC
• Responsibilities:
• Business logic
• Data processing
• Integration with data tier
 Data Tier (Database):
• Stores and manages data.
• Technologies: Relational databases (MySQL,
PostgreSQL), NoSQL databases (MongoDB)
• Responsibilities:
• Data storage
• Data retrieval
• Data manipulation
Java Technologies for Multi-Tier Development
• Presentation Tier
• JavaServer Pages (JSP)
• JavaServlets
• JavaServer Faces (JSF)
• HTML, CSS, JavaScript

• Application Tier
• Java Servlets
• JavaServer Faces (JSF)
• Spring MVC
• Enterprise JavaBeans (EJB)

• Data Tier
• JDBC (Java Database Connectivity)
• Hibernate
• JPA (Java Persistence API)
 Benefits of Multi-Tier Architecture

• Scalability
• Maintainability
• Flexibility
• Reusability
• Improved security
 Server-Side Programming

• Server-side programming refers to the process of writing

code that runs on a web server, handling requests from
clients (web browsers), and returning responses.
• Key Characteristics:
• Server-side execution: Code runs on the server, not on
the client's browser.
• Request-response model: Clients send requests, servers
process and respond.
• Dynamic content generation: Servers generate content
based on requests.
 Server-Side Programming Languages:

• Java
• Python
• Ruby
• PHP
• Node.js (JavaScript)
• ASP.NET (C#, VB.NET)
• Go
 Server-Side Frameworks:

• Java: Spring, Hibernate, Play Framework

• Python: Django, Flask, Pyramid
• Ruby: Ruby on Rails, Sinatra
• PHP: Laravel, CodeIgniter, Symfony
• Node.js: Express.js, Koa.js, Hapi
 Server-Side Technologies:

• Servlets
• JSP (JavaServer Pages)
• ASP (Active Server Pages)
• CGI (Common Gateway Interface)
• FastCGI
 Server-Side Programming Tasks:

• Request handling: Processing client requests.

• Data storage: Interacting with databases.
• Authentication: Verifying user identities.
• Authorization: Controlling access to
resources.
• Content generation: Creating dynamic
content.
 Server-Side Programming Benefits:

• Improved security: Sensitive data stays on the

server.
• Centralized management: Easier maintenance
and updates.
• Scalability: Servers can handle multiple
requests.
• Flexibility: Support for multiple programming
languages.
 Server-Side Programming Challenges:

• Performance optimization: Ensuring fast

response times.
• Security threats: Protecting against attacks.
• Scalability issues: Handling high traffic.
• Complexity: Managing complex server-side
logic.
 Servlet?

• A Servlet is a Java class that extends the

javax.servlet.http.HttpServlet class and is used to handle
HTTP requests and responses.
• Characteristics of Servlets:
• Platform Independent: Servlets can run on any operating
system.
• Server-Side: Servlets run on the server, not on the client's
browser.
• Dynamic Content: Servlets can generate dynamic content.
• Multi-Threading
 Types of Servlets:

• Generic Servlet: Extends

javax.servlet.GenericServlet.
• HTTP Servlet: Extends
javax.servlet.http.HttpServlet.
 Generic Servlet
• A Generic Servlet is a Java class that extends the
javax.servlet.GenericServlet class.
• It provides a basic implementation of the Servlet interface.
Characteristics
• Protocol-independent: Can handle any protocol (e.g., HTTP, FTP, SMTP)
• Abstract class: Cannot be instantiated directly
• Provides basic Servlet functionality: init(), service(), destroy()
Methods
• init(ServletConfig config): Initializes Servlet
• service(ServletRequest req, ServletResponse res): Handles requests
• destroy(): Destroys Servlet
Usage
• Useful for creating custom protocol handlers
• Can be used as a base class for other Servlets
 HTTP Servlet
• An HTTP Servlet is a Java class that extends the javax.servlet.http.HttpServlet class.
• It provides a specialized implementation of the Servlet interface for handling HTTP
requests.
Characteristics
• Protocol-specific: Designed for HTTP protocol
• Concrete class: Can be instantiated directly
• Provides HTTP-specific functionality: doGet(), doPost(), etc.
Methods
• doGet(HttpServletRequest req, HttpServletResponse resp): Handles HTTP GET requests
• doPost(HttpServletRequest req, HttpServletResponse resp): Handles HTTP POST requests
• doPut(HttpServletRequest req, HttpServletResponse resp): Handles HTTP PUT requests
• doDelete(HttpServletRequest req, HttpServletResponse resp): Handles HTTP DELETE
requests
Usage
• Most commonly used Servlet type
• Suitable for web applications
 Key Differences

• Protocol: Generic Servlet is protocol-

independent, while HTTP Servlet is specific to
HTTP.
• Methods: Generic Servlet has service()
method, while HTTP Servlet has doGet(),
doPost(), etc.
• Usage: Generic Servlet is useful for custom
protocols, while HTTP Servlet is suitable for
web applications.