This document is going to explain how you can use the in-built "simple" services that come with River. More specifically:. The instructions assume that you're building from source as checked out from the SVN trunk. Currently this is necessary because the code snippets below use methods and classes which, at time of writing, haven't made it into the latest binary release yet. Having said that, the code you will need in the binary release isn't to far removed from what you'll see below, so you can progress with the binary release if you want to and are happy odifying the code. If you are going to use the latest release then you will still need to download from the SVN trunk some of the Windows BAT files mentioned below.

Author:Grozshura Vijora
Language:English (Spanish)
Published (Last):25 March 2015
PDF File Size:5.21 Mb
ePub File Size:7.94 Mb
Price:Free* [*Free Regsitration Required]

JavaSpaces is a new distributed object system being proposed by Sun as a package at a higher level than the existing RMI and object serialization facilities built into Java. JavaSpaces provides a distributed, persistent object system that is roughly modeled after earlier shared memory systems, such as LINDA.

This appendix provides an overview of the general JavaSpace architecture as currently described in the draft JavaSpace specification. This appendix only includes the core elements of the specification, without discussing any proposed features that may or may not be in the final API. The distributed application paradigm supported by JavaSpaces is one in which remote agents interact with each other indirectly through shared data object spaces.

Objects are stored in a JavaSpace in the form of entries. Clients write entries into the space, read entries from the space, or take entries from the space, as shown in Figure C Access to the entries in JavaSpaces is through a small set of basic operations:.

Send a notification through a given event handler if entries that match a template are added to the space. A notification request has a time-out period associated with it: if a matching entry isn't added within the time-out period, the notify request fails and is dropped from the JavaSpace. Multiple basic operations can be assembled into transactions that group basic operations into a single, atomic aggregate operation. There can be many clients and many JavaSpaces in a given distributed application.

One client, and even one transaction from one client, can access multiple JavaSpaces. So instead of one agent sending a message to another, or invoking a remote method directly on another object within an agent, agents interact by writing and reading objects in JavaSpaces.

An important feature of the JavaSpaces specification is that all operations on a given JavaSpace are considered unordered. If you have multiple threads or multiple remote agents issuing operations on a JavaSpace, and for some reason you want to impose some order on the operations, then it's up to you to synchronize your threads or agents as needed.

Each JavaSpace holds data in the form of entries , which can either be read , written , or taken from a JavaSpace. Each entry has one or more fields that are used to match incoming requests from clients.

Each request to read, take, or be notified about an entry includes a template for the entry to match. In order for an entry in the JavaSpace to match, the entry must be of the same type as the template object. Each field in the template can either have a non- null value, which must match the fields in a matching entry in the JavaSpace, or a null value, which matches any value in that field.

All operations on JavaSpaces are "transactionally secure," which means that each operation or transaction is either entirely committed or entirely noncommitted to a JavaSpace. So if a write to a JavaSpace succeeds, then you can be assured that the Entry was written and will appear in the next client read or take operation on the space. An operation on JavaSpaces can be either in the form of a simple operation, or a group of operations within a single Transaction.

The authors of the JavaSpace specification make a point of distinguishing JavaSpaces from a distributed database system. A JavaSpace knows the type of its entries, and can compare field values, but it doesn't understand anything about the structure of the data in its entries. An entry in a JavaSpace is a serialized copy of the object written to the space, and entries returned to clients as a result of read or take operations are separate copies of the objects in the space.

All rights reserved. Java Distributed Computing. Entry and EntryRep.


Appendix C. JavaSpaces

This article begins a second thread of the Jiniology series. In June , Bill Venners launched Jiniology with an overview of Jini technology -- a powerful new infrastructure for building and deploying distributed systems that are organized as federations of services. This thread, which will be featured every other month in this column, focuses on JavaSpaces, a core Jini service from Sun Microsystems that provides a high-level means of creating collaborative and distributed applications. If you're building applications with Jini, you'll want to know how to use JavaSpaces to coordinate the participants in a Jini federation.


Patrick May

Jini is a distributed computing technology developed by Sun Microsystems. It is now being continued under the auspices of the Apache River project. This page provides some background information about Jini, a description of one of the most common patterns used in Jini systems, and a simple introductory example. Peter Deutsch of Sun Labs is known for his list of Eight Fallacies of Distributed Computing : The network is reliable Latency is zero Bandwidth is infinite The network is secure Topology doesn't change There is one administrator Transport cost is zero The network is homogeneous Deutsch noted "All prove to be false in the long run and all cause big trouble and painful learning experiences. Jini directly addresses each of the fallacies Deutsch described. Jini supports the development and deployment of highly available, highly reliable distributed systems despite the unreliability of the underlying machines, operating systems, and networks.

Related Articles