Introduction to Java Swing

Swing is a Java Foundation Classes (JFC) library and an extension of the Abstract Window Toolkit
(AWT). Java Swing offers much-improved functionality over AWT, new components, expanded
components features, and excellent event handling with drag and drop support.
Swing is a set of API (API - set of classes and interfaces).
Swing is provided to Design Graphical user interfaces.
Swing is an Extension library to the AWT (Abstract Window Toolkit).
Includes New and improved components that have been enhancing the looks and functionality of
GUIs.
Swing can be used to build the standalone Swing GUI Apps as Servlets and Applets.
It employs model view design architecture.
Swing is more portable and more flexible than AWT. The Swing is built on top of the AWT.
Swing is Entirely written in Java.
Java Swing Components are platform independent and the Swing components are lightweight.
Swing supports a pluggable look and feel and also provides more powerful components such as
tables, lists, scroll panes, color chooser, tabbed pane etc.
Further Swing follows MVC.

Java AWT Java Swing

1. Java AWT is an API to develop GUI application in Java.

1. Swing is a part of Java Foundation Classes and is used to creat
2. Components of AWT are heavy weighted. 2. The Components of Java Swing are light weight.
3. Components are platform dependent. 3. Components are platform independent.
4. Execution Time is more than Swing. 4. Execution Time is less than AWT.
5. AWT Components require [Link] package. 5. Swing components require [Link] package.

MVC Architecture
The model-view-controller (MVC) architectural pattern is employed by swing components. This
pattern separates the application into three interconnected components. Model -> Represents the
data and business logic.
View -> Displays the data from the model to the user.
Controller -> Handles user input and updates the model and view accordingly.

Basic Swing Components

Text Field (JTextField): Allow users to input single-line text.
Buttons (JButton): Trigger action when clicked.
Toggle Button: A button with two states: selected and unselected.
JCheckbox: A component allowing the user to select or deselect an option.
Radio Button: Typically used in groups where only one option can be selected at a time within that
group.
import [Link].*;
import -> The statement is used to make classes from other packages accessible within the current
source file.
[Link] -> Core package that provides a set of classes for building GUIs.
* -> Wild card character indicates all public classes within the package should be imported.

Applets and Application

Applets:
- Designed to be embedded within web pages and run in a web browser.
- While historically used, applets are largely considered obsolete due to security concerns and rise
of web technologies.

Applications:
- Standalone Java programs that run directly on a user's OS, providing robust user experience.
- Swing is primarily used for developing these standalone desktop applications.

Pluggable Look and Feel

Swing pluggable look and feel allows developers to change the visual appearance of an application
at run-time without altering the underlying code. This means a Swing application can be made to
look like Windows, MacOS or Linux.
 RMI(REMOTE METHOD INVOCATION)
RMI stands for Remote Method Invocation. It is a mechanism that allows an object residing in one
system (JVM) to access/invoke an object running on another JVM.

RMI is used to build distributed applications; it provides remote communication between Java
programs. It is provided in the package [Link].

Architecture of an RMI Application

In an RMI application, we write two programs, a server program (resides on the server) and a client
program (resides on the client).

• Inside the server program, a remote object is created and reference of that object is made
available for the client (using the registry).

• The client program requests the remote objects on the server and tries to invoke its
methods.

The following diagram shows the architecture of an RMI application.

Let us now discuss the components of this architecture.

• Transport Layer − This layer connects the client and the server. It manages the existing
connection and also sets up new connections.

• Stub − A stub is a representation (proxy) of the remote object at client. It resides in the client
system; it acts as a gateway for the client program.

• Skeleton − This is the object which resides on the server side. stub communicates with this
skeleton to pass request to the remote object.

• RRL(Remote Reference Layer) − It is the layer which manages the references made by the
client to the remote object.

Working of an RMI Application

The following points summarize how an RMI application works −

 • When the client makes a call to the remote object, it is received by the stub which eventually
passes this request to the RRL.

• When the client-side RRL receives the request, it invokes a method called invoke() of the
object remoteRef. It passes the request to the RRL on the server side.

• The RRL on the server side passes the request to the Skeleton (proxy on the server) which
finally invokes the required object on the server.

• The result is passed all the way back to the client.

Marshalling and Unmarshalling

Whenever a client invokes a method that accepts parameters on a remote object, the parameters
are bundled into a message before being sent over the network. These parameters may be of
primitive type or objects. In case of primitive type, the parameters are put together and a header is
attached to it. In case the parameters are objects, then they are serialized. This process is known
as marshalling.

At the server side, the packed parameters are unbundled and then the required method is invoked.
This process is known as unmarshalling.

RMI Registry

RMI registry is a namespace on which all server objects are placed. Each time the server creates an
object, it registers this object with the RMIregistry (using bind() or reBind() methods). These are
registered using a unique name known as bind name.

To invoke a remote object, the client needs a reference of that object. At that time, the client fetches
the object from the registry using its bind name (using lookup() method).

The following illustration explains the entire process −

Goals of RMI

Following are the goals of RMI −

• To minimize the complexity of the application.

• To preserve type safety.

• Distributed garbage collection.

• Minimize the difference between working with local and remote objects.

To write an RMI Java application, you would have to follow the steps given below −

• Define the remote interface

• Develop the implementation class (remote object)

• Develop the server program

• Develop the client program

• Compile the application

• Execute the application

Defining the Remote Interface

A remote interface provides the description of all the methods of a particular remote object. The
client communicates with this remote interface.

To create a remote interface −

• Create an interface that extends the predefined interface Remote which belongs to the
package.

• Declare all the business methods that can be invoked by the client in this interface.

• Since there is a chance of network issues during remote calls, an exception

named RemoteException may occur; throw it.

Developing the Implementation Class (Remote Object)

We need to implement the remote interface created in the earlier step. (We can write an
implementation class separately or we can directly make the server program implement this
interface.)

To develop an implementation class −

• Implement the interface created in the previous step.

• Provide implementation to all the abstract methods of the remote interface.

Following is an implementation class. Here, we have created a class named ImplExample and
implemented the interface Hello created in the previous step and provided body for this method
which prints a message.
Developing the Server Program

An RMI server program should implement the remote interface or extend the implementation class. Here, we
should create a remote object and bind it to the RMIregistry.

To develop a server program −

• Create a client class from where you want invoke the remote object.

• Create a remote object by instantiating the implementation class as shown below.

• Export the remote object using the method exportObject() of the class
named UnicastRemoteObject which belongs to the package [Link].

• Get the RMI registry using the getRegistry() method of the LocateRegistry class which belongs to the
package [Link].

• Bind the remote object created to the registry using the bind() method of the class named Registry. To
this method, pass a string representing the bind name and the object exported, as parameters.

Developing the Client Program

Write a client program in it, fetch the remote object and invoke the required method using this object.

To develop a client program −

• Create a client class from where your intended to invoke the remote object.

• Get the RMI registry using the getRegistry() method of the LocateRegistry class which belongs to the
package [Link].

• Fetch the object from the registry using the method lookup() of the class Registry which belongs to
the package [Link].

To this method, you need to pass a string value representing the bind name as a parameter. This will return you
the remote object.

• The lookup() returns an object of type remote, down cast it to the type Hello.

• Finally invoke the required method using the obtained remote object.

Compiling the Application

To compile the application −

• Compile the Remote interface.

• Compile the implementation class.

• Compile the server program.

• Compile the client program.

Executing the Application

Step 1 − Start the rmi registry using the following command.

Step 2 − Run the server class file.

Step 3 − Run the client class file.