JSP: Definition, Benefits, and Form Handling

1. Definition of JSP

JavaServer Pages (JSP) is a server-side technology used to create dynamic, platform-independent web pages. JSP allows developers to embed Java code directly into HTML pages using special JSP tags. When a JSP page is requested by a client, the server processes the Java code, generates an HTML response, and sends it back to the browser.

JSP is built on top of Servlet technology. Internally, a JSP page is automatically translated into a Servlet by the JSP engine (container) before execution.

Syntax of JSP Scriptlet:

<% Java code here %>

2. Benefits of Using JSP

3. HTML File with Two Text Fields (First Name and Last Name)

File Name: index.html

<!DOCTYPE html>
<html>
  <head>
    <title>Full Name Form</title>
  </head>
  <body>
    <h2>Enter Your Name</h2>

    <!-- Form submits data to the JSP file using POST method -->
    <form action="displayName.jsp" method="post">

      <label for="firstName">First Name:</label>
      <input type="text" id="firstName" name="firstName" placeholder="Enter first name" />
        

      <label for="lastName">Last Name:</label>
      <input type="text" id="lastName" name="lastName" placeholder="Enter last name" />
        

      <input type="submit" value="Submit" />

    </form>
  </body>
</html>

Explanation:

• The form uses method="post" to send data securely.
• The action="displayName.jsp" attribute directs the form data to the JSP file for processing.
• Two text fields are created with name="firstName" and name="lastName", which are used as parameter names in JSP.

4. JSP File that Reads Form Data and Displays Full Name

File Name: displayName.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
  <head>
    <title>Display Full Name</title>
  </head>
  <body>
    <h2>Full Name Display</h2>

    <%
      // Read the form parameters sent from index.html
      // request is an implicit object in JSP (similar to HttpServletRequest in Servlet)
      String firstName = request.getParameter("firstName");
      String lastName  = request.getParameter("lastName");

      // Combine first name and last name to form the full name
      String fullName = firstName + " " + lastName;
    %>

    <!-- Display the full name in the HTML response -->
    <p><strong>First Name:</strong> <%= firstName %></p>
    <p><strong>Last Name:</strong>  <%= lastName  %></p>
    <p><strong>Full Name:</strong>  <%= fullName  %></p>

  </body>
</html>

Explanation of Key Elements:

5. Flow of Execution

User fills index.html
        |
        v
Browser sends POST request to displayName.jsp
        |
        v
JSP Container translates JSP to Servlet (internally)
        |
        v
request.getParameter() reads firstName and lastName
        |
        v
Full name is constructed and displayed in browser

Summary

• JSP is a server-side technology for building dynamic web pages by embedding Java into HTML.
• It simplifies web development compared to pure Servlets by avoiding excessive out.println() statements.
• The request.getParameter() implicit method in JSP works exactly like in Servlets to read HTML form data.
• The HTML form sends data via POST to the JSP file, which processes and displays the full name.

Multithreading in Java

What is Multithreading?

Multithreading is a feature of Java that allows concurrent execution of two or more parts (threads) of a program to maximize CPU utilization. A thread is a lightweight process that has its own files and stacks but can access shared data from other threads within the same process.

The main advantages of multithreading are:

• Provides simultaneous execution of two or more parts of a program
• Shares the same memory, making it more efficient than separate processes
• Maximizes CPU time utilization

Creating a Multithreaded Program in Java

There are two ways to create a thread in Java:

Method 1: Extending the Thread Class

A class extends the built-in Thread class and overrides its run() method.

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

public class MultiThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();  // Create thread object
        MyThread t2 = new MyThread();  // Create another thread object
        t1.start();  // Start thread 1 (calls run() internally)
        t2.start();  // Start thread 2
    }
}

Key Points:

• start() method is called to begin execution; it internally calls run()
• Do not call run() directly, as it will not create a new thread

Method 2: Implementing the Runnable Interface

A class implements the Runnable interface and provides the body of the run() method. This is preferred when the class already extends another class (since Java does not support multiple inheritance).

class MyRunnable implements Runnable {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Runnable Thread: " + i);
        }
    }
}

public class MultiThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable obj = new MyRunnable();
        Thread t1 = new Thread(obj);  // Pass Runnable object to Thread
        Thread t2 = new Thread(obj);
        t1.start();
        t2.start();
    }
}

Comparison of Both Methods

Thread Life Cycle

A thread passes through the following states:

1. New - Thread object is created
2. Runnable - start() is called
3. Running - Thread is executing
4. Blocked/Waiting - Thread is waiting for a resource
5. Terminated - Thread finishes execution

Summary

Multithreading in Java enables multiple tasks to run simultaneously, improving performance and CPU utilization. It can be implemented either by extending the Thread class or implementing the Runnable interface, with Runnable being the more flexible and commonly preferred approach.

Grid Layout and Comparison with Grid Bag Layout

Grid Layout

Grid Layout is a layout manager in Java that arranges components in a rectangular grid of rows and columns. Every cell in the grid has the same size, and each component is placed in one cell, filling the entire cell. Components are added to the grid from left to right, top to bottom.

Key characteristics of Grid Layout:

• Divides the container into equal-sized cells
• Each cell holds exactly one component
• All rows have the same height and all columns have the same width
• Components are resized to fill their cell

Syntax:

setLayout(new GridLayout(rows, cols));
// or with gaps:
setLayout(new GridLayout(rows, cols, hgap, vgap));

Example:

JFrame frame = new JFrame();
frame.setLayout(new GridLayout(2, 3)); // 2 rows, 3 columns
frame.add(new JButton("1"));
frame.add(new JButton("2"));
frame.add(new JButton("3"));
frame.setSize(300, 200);
frame.setVisible(true);

Comparison: Grid Layout vs Grid Bag Layout

Note (from notes): GridBagLayout is described as "a sophisticated, flexible layout manager that aligns components to span more than one cell. The rows in the grid can have different heights, and grid columns can have different widths." This is the key advantage over the simpler Grid Layout.

Summary

Grid Layout is best used when all components should be the same size in a uniform grid. Grid Bag Layout is preferred when the GUI requires components of varying sizes, spanning multiple cells, making it more powerful but also more complex to configure.

JavaFX: Definition, Comparison with Swing, and FlowPane Layout

1. What is JavaFX?

JavaFX is a modern Java platform that provides support for creating rich desktop applications. It offers a wide range of features including support for 2D and 3D graphics, CSS-based styling, and XML-based UI design (using FXML). JavaFX was introduced as a successor to Swing for building graphical user interfaces in Java.

2. Comparison: JavaFX vs Swing

3. FlowPane Layout in JavaFX

JavaFX provides the following built-in layout panes:

• FlowPane, HBox, VBox, BorderPane, GridPane

Definition

FlowPane is a layout pane in JavaFX that organizes nodes in a flow that wraps at the FlowPane's boundary.

Types of FlowPane

Key Points

• Nodes are placed one after another (horizontally or vertically).
• When the available space runs out, nodes wrap to the next row or column automatically.
• This is similar in concept to Java AWT's FlowLayout, but designed specifically for JavaFX.

Example Code

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.FlowPane;
import javafx.stage.Stage;

public class FlowPaneExample extends Application {
    @Override
    public void start(Stage primaryStage) {
        FlowPane flowPane = new FlowPane();

        // Adding buttons to FlowPane
        flowPane.getChildren().add(new Button("Button 1"));
        flowPane.getChildren().add(new Button("Button 2"));
        flowPane.getChildren().add(new Button("Button 3"));

        Scene scene = new Scene(flowPane, 300, 200);
        primaryStage.setTitle("FlowPane Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

How it Works

• Buttons are added to the FlowPane one after another.
• When the width of the pane is exceeded, the remaining buttons wrap to the next line automatically.
• This makes FlowPane very useful for dynamic, resizable UIs.

Summary: JavaFX is a modern GUI framework for Java that improves upon Swing with CSS/XML support and 3D capabilities. FlowPane is one of its core layout managers that arranges nodes in a flowing, wrapping manner either horizontally or vertically.