Key differences between CGI and Servlet

Common Gateway Interface (CGI)

CGI stands for Common Gateway Interface, a standard protocol used in web development to facilitate the communication between an HTTP server and external applications. CGI enables web servers to execute external programs, usually scripts or applications, to generate web content dynamically. When a user requests a page that requires CGI, the web server executes the relevant script and sends the output, often in HTML format, back to the user’s browser. This process allows for interactive capabilities on a webpage such as form handling, generating customized content, or managing user sessions. CGI scripts can be written in various programming languages including Perl, Python, and PHP. Although considered somewhat outdated and less efficient than newer technologies like server-side scripting and APIs, CGI is foundational in understanding web technology interaction.

Functions of CGI:

  • Dynamic Content Generation:

CGI allows websites to generate and display content dynamically based on user interactions, time of access, or other data. Instead of serving static HTML pages, a CGI program can create personalized content for each user, such as different greeting messages based on the time of day.

  • Handling User Input:

CGI is particularly useful for processing and responding to user inputs from web forms. For example, when a user fills out a form on a website and submits it, a CGI script can process this data, perform required actions (like updating a database or sending an email), and generate an appropriate response based on this input.

  • Database Interaction:

CGI scripts can interact with databases to retrieve, update, or delete data. This is essential for applications like online shopping carts, user management systems, and other dynamic services that require back-end data storage and retrieval.

  • Session Management:

CGI can be used to manage sessions in web applications, maintaining state information over the stateless HTTP protocol. This can involve tracking user activities during a session and storing user-specific data, such as login credentials or shopping cart contents, across multiple page requests.

  • Security Implementation:

CGI scripts can implement security measures, like authentication and authorization, to ensure that only valid users can access certain web resources or execute specific actions.

  • Interfacing with Other Systems:

CGI can serve as a bridge to connect web applications with other systems or software components, enabling integration across different environments and enhancing application capabilities.

Example of CGI:

An example of CGI (Common Gateway Interface) can illustrate how a simple CGI script processes user input from a web form. Here, we’ll use Perl, a popular language for CGI scripting due to its text-handling capabilities.

Scenario: Suppose we want to create a CGI script that takes user input through an HTML form, processes it, and then displays a customized greeting message.

Step 1: Create the HTML Form

<!DOCTYPE html>

<html lang=”en”>


    <meta charset=”UTF-8″>

    <title>CGI Form Example</title>



    <form action=”/cgi-bin/hello.cgi” method=”post”>

        <label for=”name”>Enter your name:</label>

        <input type=”text” id=”name” name=”name”>

        <input type=”submit” value=”Submit”>




Step 2: Write the CGI Script (hello.cgi)

Here’s a basic Perl script that reads the name parameter from the form and generates an HTML page with a greeting.


use strict;

use warnings;

use CGI;

# Create a new CGI object

my $query = new CGI;

# Read the ‘name’ parameter from the form

my $name = $query->param(‘name’);

# Generate the HTTP header and start the HTML

print $query->header;

print $query->start_html(‘Hello’);

# If the name was provided, print a greeting

if ($name) {

    print “<h1>Hello, $name!</h1>”;

} else {

    print “<h1>Hello, mysterious stranger!</h1>”;


# End the HTML

print $query->end_html;

# End the script

Step 3: Set up and Permissions

  • Place the HTML file on a web server in a directory accessible to visitors.
  • Place the CGI script in the CGI-bin directory (or another directory configured to execute CGI scripts) of your server.
  • Make sure the CGI script is executable and that the server has Perl installed. This is typically done using a command like chmod +x hello.cgi.

Step 4: Test the Application

  • Open the HTML form in a browser.
  • Input a name and submit the form.
  • The form data is sent to the CGI script, which processes it and displays a greeting.


  • Ensure your server supports CGI and is configured to execute Perl scripts.
  • The Perl script must include the shebang line (#!/usr/bin/perl) at the top to indicate the script interpreter.
  • This example demonstrates the basic functionality of CGI, showing how data can be taken from a user, processed server-side, and responded to without any page pre-rendering or AJAX.


Servlet is a Java programming language class used to extend the capabilities of servers that host applications accessed via a request-response programming model. Typically used to build web applications, Servlets can respond to any type of request but are commonly used for extending web servers, handling HTTP-specific requests. When a Servlet is triggered by a web request, it can dynamically generate web content, manage session information, or interact with databases. Servlets are managed by a Servlet container, part of a web server or an application server, which handles the lifecycle of the Servlet, including initialization, service requests, and destruction. Servlets offer a robust and scalable solution for creating dynamic web content and building interactive applications on the Java platform.

Functions of Servlet:

  • Request Handling:

Servlets efficiently handle client requests (HTTP requests) that come to the server. Upon receiving a request, a servlet processes it and produces a response that is sent back to the client. This can include processing form data, performing calculations, or any other business logic.

  • Response Generation:

After processing the request, servlets generate responses. This response can be in various forms, such as HTML, JSON, or XML, and it’s used to display content on the client’s browser or communicate with other applications.

  • Session Management:

Servlets provide ways to manage sessions through the HttpSession interface. This is vital for maintaining state between multiple requests from the same user, allowing applications to remember information like user login details and preferences across several page accesses.

  • Database Interaction:

Servlets can interact with databases to perform operations like insert, update, delete, and retrieve data. This is facilitated through JDBC (Java Database Connectivity) within the servlet, making it a powerful tool for creating dynamic, data-driven web applications.

  • Concurrency Management:

Servlets handle multiple requests simultaneously using threading, a fundamental feature of Java. The servlet container creates new threads for handling new requests to a servlet, ensuring efficient management of multiple simultaneous user requests without degrading performance.

  • Security Features:

Servlets support secure web applications through various security measures such as HTTPS support, data encryption, user authentication (using login credentials), and authorization (ensuring that resources are accessed only by users who have permission).

  • Integration with Other Java EE (Enterprise Edition) Components:

Servlets can be integrated with other Java EE technologies like JavaServer Pages (JSP), JavaBeans, EJB (Enterprise JavaBeans), and JMS (Java Message Service). This integration supports the development of robust, scalable, and maintainable enterprise applications.

  • Configurable:

Servlets are highly configurable through deployment descriptors (web.xml or annotations in the code). These configurations control aspects like URL mappings, initialization parameters, and security constraints.

Example of Servlet:

To demonstrate how a servlet works, let’s create a simple Java servlet that handles a GET request to display a greeting message. We’ll assume you have some familiarity with setting up Java servlets in an environment like Apache Tomcat or another servlet container.

Step 1: Write the Servlet Code

Create a new Java file named This servlet will override the doGet method to send a simple greeting message to the client.

import javax.servlet.*;

import javax.servlet.http.*;



public class GreetingServlet extends HttpServlet {


    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // Set response content type to HTML


        // Get the writer object to send text data to the client

        PrintWriter out = response.getWriter();

        // HTML to be sent to the client


        out.println(“<h1>Hello, welcome to my servlet!</h1>”);




Step 2: Compile the Servlet

You need to compile this Java file. This typically requires having the servlet-api.jar available in your classpath, which comes with your servlet container (like Tomcat).

javac -classpath “.:/path/to/servlet-api.jar”

Step 3: Deployment

  1. Create the Deployment Descriptor (web.xml):

Place this file in the WEB-INF directory of your web application.

<web-app xmlns=””














  1. Place the Compiled Class:

Ensure your compiled .class file (GreetingServlet.class) is placed in the WEB-INF/classes directory.

  1. Start the Server:

Deploy your application by placing your application folder under the webapps directory of your servlet container (e.g., Tomcat). Start/restart the server.

Step 4: Testing the Servlet

  • Open a web browser.
  • Navigate to http://localhost:8080/yourAppName/greet. Adjust the port and context path based on your server and application setup.

This will display the message “Hello, welcome to my servlet!” in the browser, showing that the servlet is working as expected.


  • Ensure that your servlet container (e.g., Tomcat) is properly installed and configured.
  • This example provides a basic introduction to servlets, primarily focusing on handling a GET request. Servlets can handle much more complex scenarios involving POST requests, session management, and interaction with other Java components or databases.

Key differences between CGI and Servlet

Aspect CGI Servlet
Programming Language Language-independent Java-specific
Execution Speed Slower execution Faster execution
Memory Usage High (new process) Low (thread-based)
Concurrency Handling Process-based Thread-based
Integration with Java Limited Seamless
Platform Dependency Platform-independent JVM-dependent
State Management More complex Easier with sessions
Scalability Less scalable Highly scalable
Lifecycle Management OS handles processes Managed by container
Performance Overhead Higher (process creation) Lower (reuse of threads)
Development Complexity Generally simpler Requires Java knowledge
Security Depends on implementation Strong (Java ecosystem)
Portability Good across platforms Limited to Java platforms
Deployment Requires script handling Packaged as WAR files
Typical Usage Legacy systems Modern web applications

Key Similarities between CGI and Servlet

  • Purpose:

Both CGI and Servlets are used to extend the functionality of web servers. They enable the dynamic generation of web pages in response to user requests, allowing for interactive and dynamic content rather than static web pages.

  • Server-Side Processing:

CGI scripts and Servlets both operate on the server side. They handle HTTP requests, process data, and then send responses back to the client, facilitating server-side computation and logic.

  • Handling HTTP Requests:

Both technologies are capable of handling HTTP requests and generating HTTP responses. They can process input data from web forms, interact with other web resources, and produce HTML, XML, or other types of responses based on the user’s interaction.

  • Web Forms and User Input:

CGI and Servlets can manage and process data submitted by users through web forms. This includes retrieving form data, processing it according to business logic, and storing or manipulating data in databases.

  • Support for Databases:

Both CGI scripts and Servlets can be used to interact with databases. They can perform operations such as querying, updating, and managing data, which is essential for dynamic content generation and application-specific tasks.

  • State Management:

While their approaches might differ, both technologies provide mechanisms for managing state over the stateless HTTP protocol. This is crucial for maintaining user sessions and providing a continuous interactive experience across multiple web pages.

error: Content is protected !!