* JINI TECHNOLOGY *

Technical Seminar Report

Submitted in partial fulfillment of the

Requirement for the award of the degree

Of

Bachelor of Engineering
In

Computer Science and Engineering

By

B.HEMANTH REDDY (19PT1A0538)

Under the guidance of

Mr. CH. Ravi Kumar

M.Tech, (PhD).
Head of the department, CSE Department.

Department of Computer Science and Engineering

AVANTHI'S SCIENTIFIC TECHNOLOGICAL & RESEARCH ACADEMY

November 2022
 INTRODUCTION
Jini is a service-oriented architecture that defines a programming model that

both exploits and extends Java technology. This programming model enables

the construction of secure, distributed systems consisting of federations of

well-behaved network services. Jini helps to build networks that are scalable

and flexible, which are required attributes in distributed computing

scenarios.

Jini was introduced in July 1998 by Sun Microsystems. It consists of a set of

specifications and a starter kit, which includes the implementation of Jini

technology. Both are released under the open-source Apache 2.0 License.

Jini is implemented in the Java programming language and is similar to Java

remote method invocation, except that it is more advanced.

Jini provides desirable features and facilities like non protocol dependence

and code mobility. In fact, code mobility is the key concept. Jini not only

allows for the addition of printers, storage and other devices to a network, it

also allows the devices to be detected automatically over the network

without having to reboot the system. Hardware devices declare to their own

operating systems as well as to other computers, devices and users on the

network that they have been added and are available for use. This is

possible because the devices define themselves to a network device registry

soon after they have been added.

 INDEX

CHAPTER-1:Jini Technology

1.0 Technology

1.1 overview

1.2 History

1.3 Goals

1.4 Where jini used

CHAPTER-2:Architecture of Jini Technology

2.1 Architecture Overview

2.2 Structure

2.2.1 Jini Infrastructure

2.2.2 Jini Programming Model

2.2.3 Jini Services

2.2.4 Jini 2 Platform

CHAPTER-3:Basic Concept of Jini Infrastructure

3.1 Lookup service

3.2 Discovery

3.3 How Jini Works

CHAPTER-4:Applications of Jini Technology

4.1 Managing a Printer

4.2 Managing NT Server

CHAPTER-5:Summarization

5.1 Drawbacks

5.2 Future

5.3 References
 ➢ 1.1 Jini Technology : An Overview

Jini Technology is based on Java™ technology. It Enables all

types of devices to simply connect into impromptu networks,
making access to and delivery of new network services as
simple as plugging in a telephone.It Enables all types of digital
devices to work together in a community put together without
extensive planning, installation, or human intervention. Each
device provides services that other devices in the community
may use.

An impromptu community is another way to describe what

happens when two or more devices using Jini technology come
together to share their services. It is impromptu, because the
devices do not need any prior knowledge of each other in
order to participate. Jini technology allows devices to
dynamically establish communication to share and exchange
services across a network. The impromptu community is a
dynamic environment that eliminates the need for configuring
devices or installing drivers. For example, imagine plugging a
camera into a network. The camera instantly joins the network
without drivers to install, floppies or a CD-ROM to insert, or
keyboard commands to type. The camera identifies itself and
offers its services. If the camera could talk, it would be saying:
"I'm a camera, does anyone need pictures?" You might have a
laptop that uses Jini technology to join this network. You could
access the camera, snap a photo, route it to your own disk
drive (which also uses Jini technology to communicate with
other devices), or send it to another device for printing .

These devices provide their own user or programmatic interfaces,

which ensures reliability and compatibility. The overall goal is to
turn the network into a flexible, easily administered tool on which
 resources can be found by human and computational clients. The
focus of the system is to make the network a more dynamic entity
that better reflects the dynamic nature of the workgroup by enabling
the ability to add and delete services flexibly.

➢ 1.2 History of Jini Technology:

• The idea of the Jini system sprang from Sun cofounder Bill Joy at
Sun Aspen Smallworks R&D lab in 1994.

• Under the leadership of Bill Joy and Jim Waldo.

– Ann Wollrath, the inventor and designer for Java Remote Method
Invocation (Java RMI).

– Ken Arnold, the designer of JavaSpaces™ technology.

– Bob Scheifler, a principal of the X Consortium and designer of

Lookup/Discovery.

• Based on the potential to create a ubiquitous network by

leveraging the unique distributed computing characteristics of Java
technology .

• On January 25, 1999, Jini was officially launched and the

technology is available for download.

• Sun currently has agreements with a wide range of technology

companies to develop Jini technology services, both hardware and
software . Company includes Axis, Canon, Datek, Epson, FedEx,
Mitsubishi, Norwest Mortgage, Novell, ODI, Quantum, Seagate,
Toshiba, Computer Associates, Oki, and Salomon Brothers.

• It is expected that by using Jini technology, we can enable an

infinitely connected network of services into which anyone will be
able to plug-and-participate anytime, from anywhere, using the
simplest possible technology.
➢ 1.3 Goals :

The main goal of Jini architecture is to provide a

type-safe and reliable way of providing services in the
network. It is a framework for designing and implementing
OO distributed systems. The aim is to allow services to be
easily available and removable on a network to anyone
who can reach them.

Service deployment means plugging the service to the

network, and it becomes visible and available, as easily as
possible, to those who want to use it. The service can be
pure software, hardware, or a combination of them. The
idea of a flexible network is expanded, because all the
services available are reachable to other services and
clients, and removing the service is not any harder. The
network can reorganize itself to be able to continue
working after changes.

Jini technology changes the idea of network applications

to the idea of a service-based network. Everything is a
service. The goal is that this architecture allows any
device with a processor, some memory and a network
connection to offer and use services available. Jini
contributes in implementing the services and making
them available on the network. It is also possible to
automate some implementation issues with Jini. Because
of Jini’s new programming models, the developer is
forced to acknowledge the difficulties of distributed
computing. Thus, this framework offers better capabilities
to deal with the issues, which cannot be handled by the
traditional distributed systems.
 ➢ 1.4 Where Jini Technology be Used :

Almost in every device that passes digital information in

and out like.

1. Traditional computer hardware and software.

2. Consumer appliances such as personal digital

assistants (PDAs), digital cameras, TVs, DVD players, cell
phones, and CD players.

Example :

In this example , there are three professors Bob, Sue and Dave. They
are at a different site with each site having its own network. These
networks are connected with each other by using the jinni
technology. What these professors are doing is, they are working
over a same project with the devices on their own network using the
services provided by the devices on the another network.

➢ 2.1 Architecture Overview :

Architecture

When you plug a new Jini-enabled device into a network, it

broadcasts a message to any lookup service on the network saying,
in effect, "Here I am. Is anyone else out there?" The lookup service
registers the new machine, keeps a record of its attributes and
sends a message back to the Jini device, letting it know where to
reach the lookup service if it needs help. So when it comes time to
print, for example, the device calls the lookup service, finds what it
needs and sends the job to the appropriate machine. Jini actually
consists of a very small piece of Java code that runs on your
computer or device.

Jini is a set of APIs and network protocols that can help you build
and deploy distributed systems that are organized as federations of
services. A service can be anything that sits on the network and is
ready to perform a useful function. Hardware devices, software,
communications channels -- even human users themselves -- can be
services. A Jini-enabled disk drive, for example, could offer a
"storage" service. A Jini-enabled printer could offer a "printing"
service. A federation of services, then, is a set of services, currently
available on the network, that a client (meaning a program, service,
or user) can bring together to help it accomplish some goal.

Jini defines a runtime infrastructure that resides on the network and

provides mechanisms that enable you to add, remove, locate, and
access services. The runtime infrastructure resides on the network
in three places: in lookup services that sit on the network; in the
service providers (such as Jini-enabled devices); and in clients.
Lookup services are the central organizing mechanism for
Jini-based systems. When new services become available on the
network, they register themselves with a lookup service. When clients
wish to locate a service to assist with some task, they consult a
lookup service.

➢ 2.2 Component of Jini Technology :

• Jini Services
• Jini Infrastructure
• Jini Programming Model
• Java 2 Platform
 ➢ 2.2.1 Jini Infrastructure :
➢ Infrastructure is the set of components that enables
building a federated Jini system .

– The lookup service, which serves as a repository of

services. It reflects the current members of the federation
and acts as the central marketplace for offering and
finding services by members of the federation.

– The discovery/join protocol, a service protocol that

allows services (both hardware and software) to discover,
become part of, and advertise supplied services to the
other members of the federation .

– A distributed security system, integrated into RMI,

defines how entities are identified and how they get the
rights to perform actions on their own behalf and on the
behalf of others.

➢ 2.2.2 Jini Programming Model :

A set of interfaces that enables the construction of reliable

services, including those that are part of the infrastructure
and those that join into the federation.

– Leasing interface: defines a way of allocating and freeing

resources using a renewable, duration-based model.

– Event and notification interface: a notification mechanism

between services and resources that stretches beyond
machine boundaries.

– Transaction interface: wrapping of multiple operations on

multiple services into a single unit of work that either
completely succeeds or is rolled back.
➢ 2.2.3 Java Services :

Hand-coded using the programming model. Can be

programmed to do any task suitable for the resource.

– Services appear programmatically as objects written in the

Java programming language, perhaps made up of other
objects.

– A service has an interface which defines the operations that

can be requested of that service.

– The type of the service determines the interfaces that make

up that service and also defines the set of methods that can be
used to access the service.

– A single service may be implemented by using other services.

➢ 2.2.4 Java 2 Platform

• Java RMI( Java Remote Invocation)
Java RMI is the base infrastructure of the Jini technology,
because only RMI provides the capabilities that enable the Jini
software architecture. Java RMI allows the passing of objects,
including their behavior, by their actual Java software type.
This allows the passing of subtypes of an object where the base
type is expected, and allows the code that enables different
implementations of the same service interface to be moved to
the client of the service on demand. Without Java RMI, Jini
would not be possible.

• Java Virtual Machine (Java Virtual Machine)

A Java Virtual Machine (JVM) enables a set of computer software
programs and data structures to use a virtual machine model
for the execution of other computer programs and scripts. The
model used by a JVM accepts a form of computer intermediate
language commonly referred to as Java bytecode. This
language conceptually represents the instruction set of a
stack-oriented capability. Sun Microsystems states there are
over 4.5 billion JVM-enabled devices.

Jini Infrastructure:
The Jini TM technology infrastructure is built around the
model of clients looking for services. The notion of a service
encompasses access to information, computation, software
that performs particular tasks, and in general any component
that helps a user accomplish some goal. Services can
themselves be clients of other services, and can be grouped
together to provide higher-level functionality.

The Jini architecture requires a service to be defined in terms

of a data type for the JavaTM programming language that can
then be implemented in different ways by different instances of
the service. A service can be a member of many different types,
allowing a single service instance to provide a variety of
functionality to clients. This is a standard practice in
object-oriented software. However, the distributed nature of a
system of Jini technology-enabled services and/or devices
allows data types for the Java programming language to be
implemented in a combination of software and hardware in a
way that is unique.

The core of the idea that enables this implementation flexibility

is quite simple. Services are defined via an interface, and the
implementation of a proxy supporting the interface that will be
seen by the service client will be uploaded into the lookup
service by the service provider. This implementation is then
downloaded into the client as part of that client finding the
service. This service-specific implementation needs to be code
written in the Java programming language (to ensure
portability).

This approach to services requires that there be a piece of

code written in the Java programming language that can be
downloaded by the client of the service and some hardware
that ultimately runs the service.
➢ 3.1 LookUp Service:

The Jini Lookup service is the heart of a Jini community. The

lookup service is similar in principle to the naming service used
in other distributed computing paradigms like CORBA's COS
Naming Service. It holds the registrations of all other services
available in the Jini community. An application that wants to
use a Jini service finds the desired service by looking for the
service's registration within the lookup service. A Jini service
must register itself with the Jini lookup service in order to be
used. The Jini lookup service is just another service. The
service interface of the lookup service defines all the
operations that are possible on the lookup service. It defines
the way in which clients in a Jini community locate services.
There may be more than one instance of the lookup service
running in the community. This is to provide a certain level of
redundancy. Jini lookup services are organized into groups.
There is a default group called the public group. One can
create groups with any name. When he starts a lookup service,
he can specify which group it should hold registrations for.
When he searches for lookup services, he can specify which
groups he is interested in.

➢ 3.2 Discovery :
A client that wants to use a particular service finds the
appropriate server by looking in the Jini lookup service. But
before that the client has to locate the Jini lookup service. This
can be done by a process called discovery. Jini specification
for this defines at the network level the protocol by which
clients can find the lookup service. There are two ways in which
a client can discover the Jini lookup service:

Multicast discovery - the client sends out a multicast request of

a specified format. All Jini lookup services that come across
 the request will respond to it, and the client is said to have
discovered the lookup services.

Unicast discovery - In this, the client should attempt to connect

to a lookup server having known the existence and location of
the lookup server. This is in a sense not discovery.The discovery
protocol uses a combination of both unicast and multicast
discovery in order to find lookup servers.

➢ 3.3 How Jini Works :

➢ 3.3.1 Finding A Service :

1. A client invokes the lookup () method on a service registrar object.

2. The client passes as an argument to lookup () a service template,

an object that serves as search criteria for the query. The service
template can include a reference to an array of Class objects. These
Class objects indicate to the lookup service the Java type (or types)
of the service object desired by the client.

3. The lookup service performs the query and sends back zero to
many matching service objects. The client gets a reference to the
matching service objects as the return value of the lookup () method.

4. After receiving a service object now it’s time for the client to use
that service.

➢ 3.3.2 Using A Service :

 After receiving the service object from the server ,now it’s time
for client to use that service object to perform its tasks.Service
object can be received by many ways.

Service objects can grant clients access to the service in many

ways. The object can actually represent the entire service,
which is downloaded to the client during lookup and then
executed locally. Alternatively, the service object can serve
merely as a proxy to a remote server. When the client invokes
methods on the service object, it sends the requests across the
network to the server, which does the real work. The local
service object and a remote server can each do part of the
work as well.

Applications of Jini Technology

➢ 4.1 Managing a Printer
Consider a Scenario
 The particular example shows how alarms are forwarded from
the Jini technology-enabled resource to the network
management platform, and what actions are taken. First, the
printer is connected to the network. Through the Jini
technology and the Java Dynamic Management kit, the printer
is discovered and automatically appears on the map on the
network management platform. Second, the system
administrator, via a pop-up window on the network
management platform, accesses the Jini technology-based
lookup server directory to recover the management
application from the printer. Finally, when a problem arises, a
corresponding alarm is generated. One example might be "job
too big." When this occurs, the job is canceled from the network
management platform, via the pop-up printer management
application, and the owner warned of the cancellation. In
addition, statistics on printer usage.

➢ 4.2 Managing a NT Server

 A second example often cited is managing an NT server. As
shown in Figure 4, using the Jini technology-based lookup
service, the system administrator discovers the NT server BIOS
as the NT server is booted, and adds it to the map on the
network management platform. When the inevitable server
crash occurs, a corresponding alarm is generated to the
network management platform. Then the system administrator
again uses the lookup service directory, this time to recover the
management application from the NT server. Finally, a patch is
downloaded to the NT server, using the management
application. The NT server is rebooted, using the management
application. When the NT server is finally up and running, a
cancellation alarm appears on the network management
platform acknowledging things have returned to normal.

➢ 5. Summarization

To sum up, Jini provides an extensive framework for developing

flexible and robust distributed systems. It seems to fulfill the
expectations related to network administration work reduction
in a time when the complexity of the distributed systems keeps
growing. It also deals with network failures better than the
 traditional object-based distribution solutions, because of its
powerful and careful interface design.

A number of different distributed system frameworks exist as

introduced in addition to the ones that were shortly mentioned
in this thesis. The interoperability between these techniques is
a key question, when considering the global development work
in the future. It seems that Jini is quite adaptable to these
other solutions because of its flexible nature, but there is a lot
of competition going on between vendors like, for instance, Sun
Microsystems and Microsoft Corporation. The worst scenario is
that the techniques of these competing vendors try to drop
each other out from the market instead of trying to
complement each other. In this kind of competition, the best
technology cannot always survive. More discussion about this
rigid competition can be found in. Some research is already
ongoing related to the complementing issues, and the results
seem to be very promising , especially with Jini and SLP .In
addition to the solutions for the challenges of distributed
computing, Jini offers capabilities, which are required to fulfill
the needs of modern end users of the network services.
Flexibility and spontaneity are the most important issues,
which are possible to deploy, if a Jini based system is designed
in a sophisticated way. As the degree of distribution of the
services grows all the time, security issues are also very
important. In this area, the developers of Jini still have a lot of
work to do, because Jini does not provide any security
mechanisms in addition to the basic Java environment
properties.

➢ 5.1 Drawbacks :

At any rate, some drawbacks for Jini exist. One of the most
restricting ones is that Jini is not compatible with the Kilobyte
Virtual Machine (KVM) which is a very limited VM. It is targeted
to embedded devices with approximately 128 kilobytes of
available memory. There exists a lack of interoperability,
because Jini requires some J2SE based features like RMI to
 work, and these kinds of features are too heavyweight for the
current KVM implementations. The role of the KVM is to be a
part of the new running environment of the larger developing
solution J2ME for limited-resource mobile devices. This
development environment is constructed of configurations and
profiles (Figure 5-1). Configurations include a VM, optimized
APIs and core classes for a certain type of a device, such as a
PDA or a mobile phone, which is not capable of running a
full-blown JVM. Current basic configuration for the JVM is
called Connected, Limited Device Configuration,which has been
already approved by the Java Developer Community (JDC) as a
Java Specification Request (JSR).

➢ 5.2 Future :

In general, Jini specifications are relatively loose, which is an

advantage,because it gives developers room for being creative
and innovative. The specifications define mostly behavior
related issues, which has to be taken care of when
implementing the services. All well-behaving Jini services
should be capable of fulfilling the requirements defined by the
specifications. These requirements have been discussed along
with the discovery and joint protocol issues.

It can also be a disadvantage to have so many system specific

issues in an implementation process. Without well-guided
general development paths, Jini based services can vary a lot
in the future. Of course this is also desirable from the content
point of view, but the difficulties are on the service interface
side. In theory, an infinite number of possibly different services
must be able to be implemented, but still all of them should be
reachable by all potential clients through their known
interfaces. Standardization process for these interfaces is an
enormous task, which requires very careful designing. Jini’s
integration with the intelligent agent software technology is an
interesting development path. As the Java programming
language has become common, the portability problem of
agent components has been solved for some extent. Also a VM
based code execution provides better security solutions
against hostile agents. Firstly, some guidelines are needed to
model a Jini service as a software agent to enable even more
intelligent and adaptable solutions. Secondly, Jini does not
really define a standard way for clients and services to
communicate. However, to be interoperable with general
software agents, the interaction of components must be
clearer as it is now. One solution is to integrate Jini services to
be able to communicate with agents through Agent
Communication Language (ACL). Some ways to make this
happen are presented. Because many agents are autonomous,
which means that they do not need any human intervention to
work, the Jini technology provides a good development
framework for the mobile agent technologies because of
spontaneity and a lightweight service discovery. The
advantages mentioned here are obvious, when compared to
the former work in this area.

We have a lot of electronic devices around to help us out

scheduling meetings, locating restaurants and sending
messages etc. These devices are usually focused on carrying
out a particular task e.g. playing music or warming up the food.
 The realization of the concept of ubiquitous computing is only
partly accomplished, because the technology is not invisible to
the end users yet. The trend of the future seems to be that the
end users are not required to command the devices to do
some task, but the devices perform the task independently
according to the current needs of the users.

➢ 5.3 References :
1) www. jini .org
2) www.devx.com/assets/download/4508.pdf
3)Java.sun.com/developer/technicalArticles/jini/.../Javatanks.ht
ml
4) en.wikipedia.org/wiki/Jini