Activatable Jini services: Implement RMI activation
A fundamental shift is taking place in the systems architectures of major software vendors. Presently, the industry aims to deliver services via software in such a way that users can interact with these services virtually anywhere, at any time, from any device. This new paradigm has been compared to a dial tone; practically anywhere in the world, one can pick up a phone and immediately hear a dial tone. Software services like banking, insurance, news, inventories, sales leads, and travel schedules may soon be as accessible as that familiar hum. IBM's WebSphere, HP's e-speak, and Microsoft's Microsoft.Net are all different manifestations of this ambitious desire, as is Sun's Jini.
Browse user interfaces for Jini services
In this article, introduces you to a simple ServiceUI-based example service. Then shows you how to build an application for browsing and launching user interfaces for Jini services.
Browse User Interfaces for Jini Services
The ServiceUI specification developed by the Jini.org community defines a suggested procedure for attaching user interfaces to Jini services. In this article, Jeffrey Peden introduces you to a simple ServiceUI-based example service. Then he shows you how to build an application for browsing and launching user interfaces for Jini services.
Cleaning Up After Jini Services
In this article, I look at a fundamental issue with
network-mobile code: clients (such as Jini browsers) that load
objects of which they have no prior knowledge cannot invoke
cleanup methods on those objects. I propose a solution to this
problem, using the finalize() method declared in class Object.
Finding Services with the Jini Lookup Service
In this article, I look at ways Jini clients can search for
desired services in the Jini lookup service. I describe both
the flexibility of the lookup service as well as its inherent
limitations. I proposes a way that the ServiceRegistrar
interface could evolve, and describes the Jini team's response.
How to Add a UI to a Jini Service
This article gives a brief history of the ServiceUI project at
jini.org. It provides a glimpse into the nascent Jini Community
process, and gives a link to the current ServiceUI proposal.
Jini and PvC
Jini provides an open solution for network interoperability issues in a distributed computing environment.This means that Jini does the following: * Finds and connects services on a network * Creates reliable sets of services out of unreliable parts, including the network itself * Deals with networks that are very large or last a very long time * Enables components of a service to change at any time without interrupting the service. Jini network technology is built on the Java platform and provides an infrastructure to deliver services to devices within a network, regardless of connectivity, wire protocol, and transport protocol.
Make room for JavaSpaces
The design of any space-based application typically revolves around one or more distributed data structures. These are data structures that exist in a space where multiple processes can access and work on them at the same time -- something that is often difficult to achieve in distributed computing models.
Make Room for JavaSpaces, Part I
This article teaches you about a simple, yet powerful, new
network and distributed programming tool: JavaSpaces. It
explains the basic concepts of the JavaSpaces programming model
and introduces the compact JavaSpaces API.
Make Room for JavaSpaces, Part II
This article examines Jini's dynamic class-loading ability,
showing how it enables the exchange of executable content
through JavaSpaces and how you can leverage it to develop a
powerful general-purpose compute server.
Make Room for JavaSpaces, Part III
In this article, author Suzanne Hupfer uses a simple game
service example to show you how to use spaces and their
operations to coordinate your Jini applications.
Make Room for JavaSpaces, Part IV
Jini transactions help build distributed applications that
operate correctly in the presence of partial failure. To date,
Jini transactions remain one of the less frequently used
features of Jini. This article provides a brief overview of
Jini transactions and shows how you can use them with the
JavaSpaces service..
Make Room for JavaSpaces, Part V
A space-based compute server is a powerful, all-purpose
computing engine that accepts tasks, computes them, and returns
results. In this article, Susanne Hupfer shows how to use Jini
transactions to make the compute server application from Part 2
more robust and multiple JavaSpace services to make it more
scalable.
Make Room for JavaSpaces, Part VI
In this article, Susanne Hupfer introduces you to distributed
data structures -- the common set of building blocks that are
used in practically every space-based program. She shows you
how to build and use a versatile channel distributed data
structure, and illustrates its use in a distributed
MP3-encoding application.
Object Mobility in the Jini Environment
In this article, Frank Sommers provides background to the use of mobile objects in Jini, and describes the Java class loading and object serialization architectures that make mobile code possible. He then offers a tutorial on setting up Jini services so that you can make your code available for download by clients.
Object versus Document, Part I
In this article, the first of three parts, I compare the
traditional approach to client-server interaction, using
protocols and documents, with Jini's approach of using objects
and interfaces. This first part looks at how objects and
documents differ when servers interact with client programs
that have no client-side user.
Object versus Document, Part II
This article fleshes out the advantages and disadvantages of
objects compared to documents when sending a service across the
network to software, in the absence of a client-side user.
Object versus Document, Part III
In this article, Bill Venners compares objects and documents
from a user's perspective. Whereas the previous articles in the
series focused on clients that operate autonomously, this
article focuses on clients that connect network-delivered
services to human users.
Objects, the Network, and Jini
This article introduces Sun Microsystems's Jini technology;
demonstrates how Jini enables services on a network to find
each other through the processes of discovery, join, and
lookup; and explains how Jini's architecture brings the
benefits of object-oriented programming to the network.
Observing JavaSpace-Based Systems, Part I
This article, the first of a two-part series, describes the challenge of understanding and debugging JavaSpace-based systems, and presents a local logging architecture that allows you to record and analyze the behavior of such systems.
Observing JavaSpace-Based Systems, Part II
This article, the second of a two-part series, describes the challenge of understanding and debugging JavaSpace-based systems, and presents a logging service architecture that allows you to record and analyze the behavior of such systems.
Separating UI and Functionality
This article describes the basic architecture for Jini services
that have UIs. It shows how separating the UI of a Jini service
from the functionality enables Jini services to be accessed
from many different kinds of computers and devices.
Survival of the fittest Jini services, Part 1
This article is the first in a four-part series on designing and deploying highly dependable Jini services to ensure the quality of Web services in the age of calm computing.
Survival of the fittest Jini services, Part 2
This article describes transactions as a programming tool used to design reliable computations, and shows how multiple Jini services can dependably cooperate via transactions.
Survival of the Fittest Jini Services, Part I
In the future, the industry will be motivated to develop dependable methods of software-to-software interaction on the network, where unreliable components will be eliminated automatically, resulting in the survival of the fittest services. This article is the first in a four-part series on designing and deploying highly dependable Jini services.
Survival of the Fittest Jini Services, Part II
Developers should distinguish between the systems themselves and the computations they wish to perform on them. While a distributed system, or parts of it, might fail occasionally, computations performed on those systems can still be highly dependable. This shows how multiple Jini services can dependably cooperate via transactions.
Survival of the Fittest Jini Services, Part III
The Jini Transaction Specification defines a transaction coordinator for the two-phase commit protocol, as well as a default transaction semantics guaranteeing ACID properties. This article explains the default transaction semantics, and offers guidelines for its implementation in services based on activatable RMI objects.
Unleash mobile agents using Jini
Mobile agents are powerful, versatile, and possibly most
important fun to work with. Java provides an ideal
implementation platform, furnishing tools that help streamline
complex software applications. Java's Jini framework
facilitates mobile agent application development, providing key
features for distributed network programming. This article
gives insight into using Jini as a foundation for mobile
agents.
Using Objects to Configure Jini Network Services
Secure large-scale Java distributed computing is at the heart of Jini 2.0. Every aspect of building a secure distributed computing environment is configurable in Jini. This article provides a tutorial on using the Jini service configuration model, and illuminates the decisions by the Jini architects to rely on objects for service configuration.
Files
