Jini in a Nutshell


Jini is a simple set of Java Classes and services that allows devices (e.g., printers) and services (e.g., printing) to access each other seamlessly, adapt to a continually changing environment, and share code and configurations transparently. Jini has the potential to radically alter our use of computer networks, since it allows and encourages totally new types of services and new uses of existing networks.Jini in a Nutshell is a quick reference guide to developing services and clients using Jini. It covers ...

See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (21) from $1.99   
  • New (4) from $7.92   
  • Used (17) from $1.99   
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
Seller since 2008

Feedback rating:



New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.


Ships from: fallbrook, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Seller since 2009

Feedback rating:


Condition: New
1565927591 *BRAND NEW* Ships Same Day or Next!

Ships from: Springfield, VA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2014

Feedback rating:


Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Seller since 2014

Feedback rating:


Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Sort by
Sending request ...


Jini is a simple set of Java Classes and services that allows devices (e.g., printers) and services (e.g., printing) to access each other seamlessly, adapt to a continually changing environment, and share code and configurations transparently. Jini has the potential to radically alter our use of computer networks, since it allows and encourages totally new types of services and new uses of existing networks.Jini in a Nutshell is a quick reference guide to developing services and clients using Jini. It covers everything an experienced Java programmer needs to know to implement Jini, including tutorial chapters to get you up to speed quickly and reference chapters that analyze and explain every Java package related to Jini. Over the course of the book the authors develop a complete example program—with samples of both server and client applications.Topics covered include:

  • Setting up the Jini programming environment
  • RMI
  • Basic and advanced Jini programming
  • Jini services, including JavaSpaces
  • Jini utilities
  • Security
Jini in a Nutshell covers the Jini 1.0 specification and requires the Java 2 Platform.
Read More Show Less

Editorial Reviews

From Barnes & Noble
You know a technology is arriving when it gets its own O'Reilly Nutshell guide. Jini is arriving fast—and with it will come networks that can virtually manage themselves, adding and subtracting devices, services, and users without human intervention.

Jini In A Nutshell is two books in one. Part I is a code-rich Jini introduction for experienced Java coders who want to start building Jini software right away. Part II is a 150-page quick reference covering all the key packages that comprise Jini 1.1.

Oaks and Wong start by introducing you to Jini's fundamental concepts, walking you through setting up Jini; and presenting key Jini server and client programming techniques. You'll find chapters on leasing, remote events, service administration, transactions, security, Jini's helper services, even JavaSpaces.

The book's quick-reference encompasses net.jini.core, the basic interfaces of Jini; net.jini (packages that make up the Jini Technology Extended Platform); com.sun.jini (including coverage of some early packages that may change as the specification solidifies); and several directly relevant Java packages.

Now that Jini's far enough along to work with, you might as well be productive. With Jini In A Nutshell, you will be.

Bill Camarda

Jack J. Woehr

Jini in a Nutshell, by Scott Oaks and Henry Wong, is another excellent O'Reilly & Associates Nutshell book, one aimed at introducing us to Sun's Java-based Jini, described by the authors as "a set of specifications that enables services to discover each other on a network and that provides a framework that allows those services to participate in certain types of operations." In other words, if, in the not-too-distant future, your refrigerator decides to have a heart-to-heart with your web camera, it won't have much difficulty looking the camera up on the network and invoking services from it, as long as both entities have currently registered Jini services. You might call it "Widgets for Workgroups".

Jini in a Nutshell is divided into two parts: "Introducing Jini", a 200-page tutorial, and a "Quick Reference" of approximately equal length, which expresses the authors' rich practical insights into minute details of the relevant services and packages. "Quick Reference" may be a misnomer. The Sun Javadocs on Jini are a quick reference; Jini in a Nutshell contains much more.

After the "Quick Start", which instructs you how to run the toolchain that comes with Jini, the next subject is RMI. The authors take us up through local and remote services to activatable services, and illustrate how to proxy remote object services to be mostly independent of the RMI protocol itself.

Next is "Basic Jini Programming," which extends the RMI examples to become Jini services. "Leasing" shows how services must interact with Jini's concept of keep-alive. "Remote Events" implements listeners for callbacks. "Service Administration" illuminates the exposed APIs that allow administration of Jini services. "Miscellaneous Classes" introduces utility classes of the com.sun.jini packages. "Transactions" covers Jini's transaction API. Next is a section about the JavaSpaces Service, a persistent object store designed as a Jini service. "Helper Services" covers features such as the lease renewal service and the mailbox service, and also presents as a fully activatable Jini service the example that the reader has followed throughout the book. "Security in Jini" covers (somewhat lightly) the subject of policy and policy files.

Originally printed in March 2000, and reprinted with minor corrections in May 2000, Jini in a Nutshell has already become version-challenged, if only slightly, with the release of JDK 1.3, which changed the rules for the RMI daemon. (You now have to point to a security policy file for rmid, as in

rmid -J-Djava.security.policy=/foo/bar/java.policy.all

which was not a requirement in 1.2). JDK 1.3 wasn't stable when the book was revised for reprint. What's an author to do? In any event, the web page for the book has corrections and updates, including corrections submitted by readers but awaiting author verification, as well as the source for the examples found in the book.

The authors of Jini in a Nutshell are experienced at living up to the high expectations of O'Reilly readers. Scott Oaks, a Java technologist at Sun Microsystems, is the author of Java Security and coauthor of Java Threads, both from O'Reilly. Henry Wong, a tactical engineer at Sun Microsystems, is a coauthor of Java Threads from O'Reilly. Jini is yet another interesting expansion of Sun's Java empire, and Jini in a Nutshell is worthwhile introduction to Jini.

Jini is a simple set of Java classes and services that allow devices and services to interact with each other without device drivers. Part one of this guide introduces how to write Jini clients and services from scratch, while the second half serves as a reference of all classes related to Jini, arranged by package. Annotation c. Book News, Inc., Portland, OR (booknews.com)
Read More Show Less

Product Details

  • ISBN-13: 9781565927599
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 3/28/2000
  • Series: In a Nutshell (O'Reilly) Series
  • Edition description: 1 ED
  • Edition number: 1
  • Pages: 413
  • Product dimensions: 6.00 (w) x 9.00 (h) x 0.85 (d)

Meet the Author

Scott Oaks is a Java Technologist at Sun Microsystems, where he has worked since 1987. While at Sun, he has specialized in many disparate technologies, from the SunOS kernel to network programming and RPCs. Since 1995, hes focused primarily on Java and bringing Java technology to end-users. Scott also authored OReillys Java Security, Java Threads and Jini in a Nutshell titles.

Henry Wong is a tactical engineer at Sun Microsystems, where he has worked since 1989. Originally hired as a consultant to help customers with special device drivers, kernel modifications, and DOS interoperability products, Henry has also worked on Solaris ports, performance tuning projects, and multithreaded design and implementations for benchmarks and demos. Since early 1995, Henry has been involved in developing Java prototypes and supporting customers who are using Java. Prior to joining Sun, Henry earned a bachelor of science degree in chemical engineering from The Cooper Union in 1987. He joined a small software company in 1986 working on SCSI device drivers, image and audio data compression, and graphics tools used for a medical information system. When not in front of a computer, Henry is an instrument rated private pilot, who also likes to dabble in archery, cooking, and traveling to different places with his wife, Nini.

Read More Show Less

Read an Excerpt

Chapter 1: Introduction to Jini

When Sun Microsystems released their first Java-enabled browser, the animated image of Duke, Sun's Java mascot, kindled the imagination of countless developers around the world. It wasn't that an animated image on a web page was in itself a really interesting development; there were other ways to animate images on the Web already, and you could argue that the Web suffers from the overuse of pointless animations like that one.

But a large number of people caught on to the idea that it wasn't a dancing Duke that was important: it was what the dancing Duke represented. The technology behind the dancing Duke-a simple programming environment that could take advantage of the network in novel ways-started the excitement behind Java and put it at the forefront of computer software technology.

Which brings us to Jini. Jini is a simple set of Java classes and services that has the potential to create its own revolution because it allows technology to be exploited in new ways. Some people who see a Jini demonstration might look at a camera being added to a network, and devices accessing the camera, and think that nothing really amazing is happening. There are, after all, many ways for systems and network-enabled cameras to interface with each other outside of Jini, and does the world really need another NetCam?

But the technology that drives Jini and the potential impact of Jini on networkbased computing is more compelling than it might seem from the surface of a simple demonstration like this. Jini allows co-operating devices, services, and applications (and there's little distinction between these) to access each otherseamlessly, to adapt to a continually changing environment, and to share code and configurations transparently. And Jini has the potential to radically alter our use of computer service networks, since it allows and encourages new types of services and new uses of existing networks.

What Is Jini?

In a nutshell, Jini is a set of specifications that enables services to discover each other on a network and that provides a framework that allows those services to participate in certain types of operations. The set of services on a particular network is referred to as the Jini community. The Jini specification refers to the community as a djinn, but common usage seems to favor the former term (on the other hand, the term Jini community is overloaded, as we'll discuss later).

If you've heard of Jini, chances are that you heard of it terms of hardware devices. Bring your Jini-enabled laptop into a Jini-enabled conference room, and the laptop will automatically be able to find and use the services of the conference room. Want to send output to the conference room printer? Your Jini-enabled laptop will automatically find the printer, seamlessly download any drivers required by the printer, and send it output. You can pull out your Jini-enabled PDA and do the same. And when you take that PDA and go into another office, the PDA will discard knowledge of the conference room printer and automatically find the printer local to the new office.

But Jini is not about hardware and devices: Jini is about services. A Jini-enabled printer provides a print service to the network; that the particular service is provided by a piece of hardware is irrelevant. There may be a software service on the network that also provides the same print service by accepting print requests, rasterizing them, and emailing the rasterized images to a distant recipient.

There are many Jini services that are only software. The core Jini services that we'll examine in this book are examples of such services, and you could think of many others: a service that stores and forwards events would not be hardware-based, nor would a matrix multiplication service (though it could be, if you had a really great vector processor available). Jini blurs the distinction between hardware and software: in a Jini community, everything is a service. This makes Jini appropriate for a number of applications, from integrating devices onto a network to providing enterprise services within your organization.

So the excitement around Jini stems not just from the fact that it allows hardware and applications to interact: it's also that Jini is designed to allow this service interaction to happen in a dynamic, robust way. There are three basic features of this interaction:

  • The Jini environment requires no user intervention when services are brought on- or offline (other than starting the service: e.g., by turning on the Jini-enabled device or starting the Jini software service).
  • The Jini community is self-healing: it can adapt when services (and consumers of services) come and go.
  • Consumers of Jini services do not need prior knowledge of the service's implementation. Instead, the consumer loads the service implementation dynamically, with no configuration or user-intervention required.

These features make Jini ideal for a dynamic environment, where mobile computing devices come and go software-based services come and go, or where administration of services must be as simple as possible.

Jini at Work

In order to understand what Jini is, we'll present a high-level description of how a Jini community works. Then we'll look into the technology that enables the behavior that we'll describe.

Our Jini community starts in its simplest possible state: there is a single instance of the Jini lookup service running on this network. Clearly, some piece of hardware must be running this service, but it doesn't matter to us if that hardware is a PC, an IBM mainframe, or a network-enabled Jini lookup service appliance. The Jini lookup service keeps a list of all the Jini services that are available on the network.

Now say we add a Jini-enabled printer to the network. (There's a lot of meaning behind the word "add" here, but we'll address that a little later.) The printer finds the lookup service and then registers itself with the lookup service. It does this registration completely on its own as part of its startup sequence. And this illustrates the first key feature of Jini: it's designed so that user intervention is not required. At this point, there are two Jini services on the network: the lookup service and a print service.

Now let's add a laptop onto the network and start a Jini-aware word processing application on the laptop. The word processor will go out onto the network and find the lookup service (just like the printer did). Because it's not actually providing a service, it may not register with the lookup service; it may just inspect the other services that are registered. When it discovers that a print service is available, it will take appropriate action: it might, for example, enable the Print item in its File menu.

But remember that Jini communities are dynamic: the printer may not yet have been added to the community when we started the word processor. This is not a problem: the word processor can register with the lookup service to be notified when a printer is added to the network. When this notification comes, the word processor can then enable its Print menu item. Or maybe the word-processor will always have its Print menu item enabled, and when the user selects the Print menu item, only then will the word processor attempt to locate a print service. All this flexibility is built into the Jini environment. Similarly, if the printer becomes disconnected from the network, the word processor will be notified and be able to adapt itself to its new environment (e.g., by disabling the Print menu item).

This illustrates the second basic feature of a Jini community: it is self-healing. As services come and go, they register with and unregister from the lookup service. And the key feature that distinguishes this registration from other lookup services is that unregistration happens automatically. When a service registers with the lookup service, the lookup service issues it a lease which the service must periodically renew. If the power supply on the printer fails and it doesn't have a chance to unregister itself explicitly, then after a period of time, the lease will expire and the lookup service will automatically unregister the printer! This unregistration happens whenever a registered service fails to renew its lease with the lookup service, so it doesn't matter if the device running the service crashed, or if the network failed, or something else: if the service is not accessible, the service is eventually unregistered.

Self-healing works both ways. If the printer became unregistered because a component on the network failed, then when the network is fixed, the printer will automatically reregister its service with the lookup service. The printer doesn't need to know that the network was fixed, nor does a user need to intervene: the Jim code keeps track of the network's state and reregisters the printer automatically when the problem is fixed.

Now let's attempt to print. The first thing that our application must do is ask the user for certain printing parameters-whether to use landscape or portrait paper orientation, whether to print in color, and so on. The list of parameters is specific to the printer, and the dialog box that is presented to the user should reflect only those parameters that are appropriate to the printer.

This means that the application cannot have prior knowledge of the dialog box it must be able to show a dialog box that is appropriate for printers that have not yet been developed. So rather than attempting to put this sort of knowledge into the application, why not put it into the printer, since the printer is the only thing that actually knows what the dialog box should look like? Then the application can download the class definition for the dialog box from the printer on demand, instantiate the dialog box, and show it to the user.

Similarly, when the parameters are selected and it is time to print, the application must format its data into the correct printer language. The drivers that must normally be loaded by the user can once again be obtained directly from the printer itself. And this is the third major advantage to Jim: the implementation of all these services is loaded dynamically, at runtime, with no configuration.

Eventually, as services come and go, the Jim community may come to resemble Figure 1-1. There may be multiple instances of the lookup service. We might start some of the Jim services that come .with Sun's implementation of Jim, including a Jim transaction manager and a persistence service known as the JavaSpaces service. And so on: services will come and go, consumers of those services will come and go, and everything will be tied together by a common network...

Read More Show Less

Table of Contents

Preface ix
Part I Introducing Jini
Chapter 1 Introduction to Jini 3
What Is Jini? 4
Jini Technology 6
Jini and RMI 12
Jini Prerequisites 15
The Jini Community Process 15
The Sun Community Source License 16
Summary 17
Chapter 2 Getting Started with Jini 18
Downloading Jini 18
Setting Up Your Environment 21
Starting Jini Services 22
Using the Start Services GUI Tool 29
Chapter 3 Remote Method Invocation 35
Object Serialization 36
A Simple RMI Example 40
Transporting Code 45
Activation 49
Proxying RMI Services 54
Summary 56
Chapter 4 Basic Jini Programming 57
The Jini Lookup Service 57
A Simple Service and Client 59
Leasing and the Lookup Service 67
Lookup and Discovery Support Classes 71
Attributes and the Entry Interface 77
Other Service Implementations 82
Summary 85
Chapter 5 Leasing 86
The Service Interfaces 88
The Service Implementation 89
The Client Implementation 96
Lease Policies 97
Summary 101
Chapter 6 Remote Events 102
A Remote Event Example 103
Remote Events and the Jini Lookup Service 111
Summary 116
Chapter 7 Service Administration 117
Administration APIs 117
Providing a Custom Administration Interface 124
Summary 127
Chapter 8 Miscellaneous Classes 128
Collections 129
Thread Utilities 130
Parsing Command Lines 141
Summary 142
Chapter 9 Transactions 143
Overview of Transactions 143
The Client-Side Transaction APIs 145
The Jini Transaction Framework 147
Summary 154
Chapter 10 The JavaSpaces Service 155
The JavaSpaces API 156
A JavaSpaces Example 159
Embedding JavaSpaces in Services 163
Summary 167
Chapter 11 Helper Services 168
The Lookup Discovery Service 169
The Lease Renewal Service 171
The Event Mailbox Service 173
An Activatable Service Example 174
A Detachable Client 190
Summary 195
Chapter 12 Security in Jini 196
Sample Policy Files 197
Jini Policy Files 198
Jini Security Classes 200
Summary 200
Part II Quick Reference
How To Use This Quick Reference 203
Chapter 13 Service Reference 212
Fiddler 212
Mahalo 215
Mercury 217
Norm 219
Outrigger 221
Reggie 224
Chapter 14 The com.sun.jini Packages 227
Chapter 15 The net.jini.core Package 265
Chapter 16 The net.jini Packages 291
Chapter 17 The java Packages 326
Chapter 18 Class, Method, and Field Index 366
Index 377
Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)