Core Jini (2nd Edition) [Paperback]

W. Keith Edwards (Author)

Book Description

Series: Sun Microsystems Press Java | Publication Date: December 28, 2000

In 1999, Jini connection technology was unveiled. In 2000, corporations will begin releasing Jini-technology enabled devices, and the demand for expertise in Jini software development will soar. Jini connection technology enables any device -- from enterprise servers to kitchen appliances -- to network smoothly, simply, and reliably. Core Jini, Second Edition delivers the most thorough, practical explanation of Jini 1.1 technology -- plus all the live Java TM code experienced developers need to start building solutions right now! With a Foreword by Sun visionary Bill Joy, Core Jini is 100% authoritative, with even more code, more examples, and more troubleshooting techniques than the first edition -- all fully updated for the new Jini 1.1 technology specification! Discover how Jini technology addresses critical distributed networking problems ignored by "traditional" approaches -- and how it can simplify connectivity in both new devices and existing networks. Master the Jini 1.1 technology programming model, including crucial concepts like discovery, leasing, remote events, and transactions. Learn real-world techniques for developing Jini technology-enabled helper services and applications; implementing discovery; building lookup services and browsers; and more.

Editorial Reviews

Amazon.com Review

Newly enhanced with the latest standards from Sun Microsystems, Core Jini, Second Edition provides an in-depth and authoritative resource for building state-of-the-art distributed systems based on Jini 1.1. Aimed at the experienced Java developer seeking to apply this technology in the field, this book mixes a high-level guide describing what Jini is and how it works with plenty of practical code examples to help get you started.

The first part of Core Jini describes what Jini is, including its design philosophy and how it provides robust distributed systems for devices like printers, scanners, and digital cameras. Suitably upbeat about Jini's prospects in the marketplace, the author delivers an insider's perspective on how Jini solves many of the problems found in earlier distributed computing. The first hundred pages will help anyone understand Jini, and they are especially ideal for programmers (or managers) who want to see what this standard is all about.

The rest of the text (over 800 pages) provides a practical tutorial that puts Jini to work, starting with a "Hello, World" example. Subsequent chapters cover essential areas of Jini functionality, like discovery, leasing, and the join protocol. Besides providing actual source code, the book does a good job of showing you how to compile and run each example program. (This information is particularly necessary with Jini, where, even for testing, programs run in separate pieces in a small distributed system.) Core Jini teaches you the most common programming strategies for Jini (relying on higher-level APIs and built-in features), and also shows the lower-level APIs in separate sections for the more advanced reader who wants to know more.

Armed with this new edition, any Java developer can learn to take advantage of this late-breaking technology from Sun. All in all, this title is a comprehensive and well-presented tutorial for an exciting new standard that will allow future consumer and computing devices to communicate using Java. --Richard Dragan

Topics covered:

• Overview, history, and design philosophy of Jini 1.1
• Distributing computing essentials
• Installing and running Jini
• Classical network vs. distributed systems
• Advantages of Java and Jini for distributed computing
• Jini services
• A "Hello, World" example for Jini (including basic events and leasing)
• Jini discovery (including basics, IP multicasting, and discovery protocols)
• Searching and matching services with attributes and templates (plus JavaBeans)
• The join protocol
• Low-level service interfaces (also search APIs, events, lookup services, and federating services)
• Using the ServiceDirectoryManager
• Sample code for a Jini Lookup Service Browser
• Leasing (including lease negotiation and remote leasing APIs)
• Leased resources and the Landlord paradigm
• Responsibilities of well-behaved Jini services
• Sample code for a complete Jini print service
• Remote events (local vs. remote events, the Jini event programming model, heartbeat events, and event delegates)
• Storing objects with JavaSpaces
• Distributed transactions (including transaction managers and two-phase commits)
• Jini utility services and classes
• A primer for Remote Method Invocation (RMI)

From the Inside Flap

Introduction

This book provides a comprehensive guide to Jini, the new distributed systems technology from Sun Microsystems. Jini has the potential to revolutionize the way we build software. In a sense, Jini signals a change from a world in which devices are networked (meaning that computers simply have the ability to talk to one another) into one in which devices join together to form a true distributed system-a collection of networked components working together.

The distinction between networked systems and true distributed systems is an important one. Simple networked systems have simple communication patterns (usually peer-to-peer or client/server), and tend to be static, long-lived entities. Distributed systems, on the other hand, are composed of numerous constituent pieces. Any of these pieces can come or go without bringing down the whole system, and the system can respond to changes in its environment and its constituency in reliable and predictable ways. In a nutshell, Jini moves us from a world in which the "system" is the individual networked device, to one in which the "system" is the collection of all these devices working together.

This book serves two purposes. First, it provides a broad introduction to the core technologies of Jini. This introduction will be useful to Java developers who need to understand Jini, and to other technically-savvy readers who need to understand how Jini fits into the world, and why it is significant. Second, the book provides a deep understanding of how to build working software that leverages Jini. This second focus is intended for a range of developers, including those who are building Jini-enabled software for small devices such as Personal Digital Assistants (PDAs), to those building LAN-based (local area network) networked systems for the small-office/home-office (SOHO) or remote-office/home-office (ROHO), all the way up to those building enterprisewide network services and possibly software for the Internet itself.

These two goals of the book are largely represented by the book's two parts. Part I introduces Jini history, looks at Jini's place in the world-in particular, how Jini is different from what came before it-and provides some details on getting started with the technology and deploying it in actual use. Part II provides an in-depth look at the core Jini concepts, such as leasing, lookup, discovery, and transactions, as well as some extensive examples that illustrate particular aspects of Jini. Finally, the remainder of the book provides appendices and reference materials.

The philosophy taken by this book is that developers learn by reading code. You will no doubt notice if you page through this book, especially the chapters in Part II, that there are a great many code examples here. Some of these are "stand-alone" Jini programs-they typically introduce some concept in the smallest number of lines possible, in the interest of clarity. Others are utility programs that cover "holes" in the Jini APIs (Application Programming Interfaces). These programs will find their way into the toolchests of programmers working with Jini.

Throughout this book, though, I have provided a number of longer examples that share a common theme: Taken together, these examples can be used as applications in "live" Jini networks, and can interoperate with each other. This approach is very much in keeping with the Jini design philosophy itself-large numbers of cooperating applications working together to provide some service-and happens to be a good way to illustrate the ideas in Jini by using discrete chunks of code rather than monolithic, multithousand-line applications. Each of these examples illustrates one or more key points of the Jini architecture. They can be extended by you, and applied to any number of domains, from small, intelligent devices all the way up to enterprise software systems.

One thing this book does not provide is an introduction to Java itself. Jini is a layer atop Java-much like the Java Foundation Classes (JFC) or Java Database Connectivity (JDBC). Like these other layers, Jini introduces some new concepts and extends the Java programming model; but at its core, Jini remains pure Java. This book assumes that you are familiar with Java programming and, with one exception, does not cover the facilities available in the core Java class libraries or the language.

The one exception is the Java Remote Method Invocation system (RMI). RMI is used extensively in Jini. In fact, Jini leverages new features in RMI that only appeared in Java 2 (also popularly known as the JDK1.2 and later versions), such as the RMI activation framework. Thus, there is an RMI primer in Appendix A of this book that serves as an introduction to this technology for those who may be unfamiliar with it.A Roadmap

Part I of this book, "Foundations," provides some necessary background reading on Jini. This information will be useful for savvy readers who just need to understand Jini, what it does, and how it works. But it's also required reading for developers who want to build actual, running Jini programs-the chapters in this part highlight the philosophical differences between Jini and "classical" networked and distributed systems technologies. If you have a good understanding of this material, you're ready to build software that's consistent with the Jini aesthetic.

Chapter 1, "A New Computing Paradigm," looks at the history and motivation of Jini. You'll see how Jini is really the fulfillment of the original Java promise: of collections of software and hardware, working together simply and without administration. This chapter also covers the process of getting and installing the Jini software.

Chapter 2, "Distributed Systems," provides a glimpse at the basics of distributed systems, and how Jini differs from traditional distributed systems software. Even if you're a handy network programmer, you may want to take a look at this chapter. Jini is fairly unique in the distributed systems world, and it's interesting to see the roots of Jini and understand what problems it's good at solving.

Chapter 3, "The Jini Model," introduces the basic concepts in Jini. Fortunately there are only a handful of these. Understanding these concepts and how they connect to each other will make later reading much easier and help you to understand how all the big pieces of the Jini design fit together.

Chapter 4, "Deployment Scenarios," covers some strategies for deploying Jini services. These are development targets, if you will-ways that you as a developer can deploy Jini code that you write. Jini is perhaps unique in all the Java libraries provided by Sun in that it is specifically designed to support devices which may not have Java Virtual Machines (JVMs) embedded in them. Jini can be used to connect devices with only limited computational ability, just as it can be used to connect large servers and other machines running full-fledged JVMs. This chapter will help you understand the options available to you if you're designing for Jini.

These first four chapters comprise Part I of this book-they provide a broad introduction to the Jini technology and how it fits into the world. Part II, "Building with Jini," is a very in-depth look at particular aspects of Jini. It is designed for the professional Java developer who is writing new Jini services or building Jini-enabled devices. Some of the chapters in this part are In Depth chapters that dive deeply into a particular aspect of the Jini technology. Others are structured around large examples that show Jini being applied to real problems.

Chapter 5, "Getting Started with Jini," begins with a series of programs designed to introduce you to the core Jini concepts. This series is a set of "Hello, World"-style programs that are evolved to illustrate ideas such as lookup, discovery, leasing, and remote events. This chapter is your first introduction to building Jini software from scratch, and covers almost all the basic Jini ideas, as well as provides an example of using Java's RMI framework.

Chapter 6, "In Depth: Discovery," is an in-depth chapter looking at Jini's discovery protocols. These are the means by which Jini services notify the world of their existence, and Jini client applications learn about the clusters or "communities" of services that are available to them. We'll look under the hood at these protocols-understanding what's really going on there is key to using them effectively. By the end of this chapter, you should understand these protocols well enough to be able to implement them "by hand" if you need to.

Chapter 7, "Attributes, Templates, and Service Matching," talks about the Jini notion of attributes, which are objects that can be associated with services to provide descriptive information about them. This chapter talks about how to use attributes, how the Jini attribute model meshes nicely with JavaBeans, and the rules for how clients search for services that they need to use.

Chapter 8, "The Service Join Protocol," moves on to the next major phase in a Jini application's life cycle, the use of the Jini lookup service by other servi

See all Editorial Reviews

Product Details

• Paperback: 1008 pages
• Publisher: Prentice Hall PTR; 2nd edition (December 28, 2000)
• Language: English
• ISBN-10: 0130894087
• ISBN-13: 978-0130894083
• Product Dimensions: 9.1 x 7 x 2.5 inches
• Shipping Weight: 4.1 pounds
• Average Customer Review: 3.9 out of 5 stars  See all reviews (17 customer reviews)
• Amazon Best Sellers Rank: #3,008,608 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

5 of 5 people found the following review helpful:

5.0 out of 5 stars Well formulated, thorough and still easily accessible., August 7, 1999

By 

Stein-Erik Engbråten ([e-mail]) (Stavanger, Norway) - See all my reviews

This review is from: Core JINI (Paperback)

This is just the book I have been looking for! It explains Jini in all needed details, starting from the assumption that you know Java. It leads you the way through what exists prior to Jini, including Corba and DCOM, and what key issues they don't handle. It explains what Java makes possible, and what is needed on top of that.

One of the many strong points of the book, is that it looks at each topic from several angles. And it explains and stresses all the small, seemingly unimportant aspects that really make a big difference. "What is the big deal" type of questions, with corresponding informative answers.

The five key elements of Jini is explained at several levels of detail. In the introductory chapter they are listed with a one liner each, followed by a paragraph or two on each of them. In later chapters they are looked at in all needed detail.

Edwards is very conscious about each word and description used. There is never any misunderstanding what he wants to explain, and what each term that is used means. In this kind of a book that is one of the most important aspects.

This book is highly recommended!

11 of 14 people found the following review helpful:

3.0 out of 5 stars Unbelievably verbose, October 23, 1999

By 

Steve Yegge (Mukilteo, WA) - See all my reviews

This review is from: Core JINI (Paperback)

Don't get this one if you know Java and you're trying to come up to speed on Jini quickly. The book rambles almost endlessly. Get _The Jini(TM) Specification_ (Arnold, et. al) instead: it's much easier to read than the title would suggest.

6 of 7 people found the following review helpful:

5.0 out of 5 stars Packed with useful tips, December 8, 1999

By 

Steve Peterson (Minneapolis) - See all my reviews

This review is from: Core JINI (Paperback)

I was able to get up and running in a short period of time. An invalable book for working with a bleeding edge technology such as Jini, where the ink is barely dry on the spec

The pitfall sections and compilation and execution scripts save a lot of frustration. I wish I had a guide like this prior to learning RMI.