Core JINI [Paperback]

Book Description

ISBN-10: 013014469X | ISBN-13: 978-0130144690 | Publication Date: June 25, 1999 | Edition: 1

The promise of Jini is extraordinary: with Jini, any device -- from your enterprise server to your kitchen appliances -- will network smoothly, simply, and reliably. It's no wonder Jini has become one of the world's most eagerly awaited technologies -- but until recently, key details were hidden in Sun's laboratories and a couple of research labs, including Xerox PARC. Core Jini presents the first detailed, practical explanation of Jini technology -- along with all the hands-on Java code and tools coverage needed to start building Jini solutions now! Learn how Jini addresses crucial distributed networking problems that CORBA and other "traditional" technologies ignore. Review the Jini model, learning how Jini implements crucial concepts like discovery, leasing, remote events, and transactions. Then, start developing real Jini services and applications. Implement discovery using multicast request and announcement protocols; describe services with attributes; and build lookup services and browsers. Learn to manage lease negotiation and relative time; write lease interfaces; handle delegation; and use Jini's Landlord Paradigm. Then, walk step-by-step through building a robust Jini printing service. You'll find coverage of remote events; using Jini with JavaSpaces; and more -- including a complete Jini API reference, and code for a full set of Jini services. Get Core Jini and start creating Jini solutions today!

Editorial Reviews

Amazon.com Review

While Jini promises to be a potential rival to CORBA and DCOM for general distributed development, the focus of Core Jini is on using the technology to connect peripherals to networks via Java.

Traditional problems found in distributed computing--and how Jini overcomes them--are tackled first. After this overview, there is a simple "Hello World" example, as well as a solid guide to setting up and running the Jini tools. Then the book delves into Jini specifics, starting with "discovery" (which allows devices to find Jini services on the fly). The book explains in detail how Jini services advertise themselves using both multicast and unicast protocols.

Jini services are "leased" by clients, and a section on Jini's leasing protocol shows the details from both the server side and client side. All of the requirements for a "well-behaved" Jini service are summarized, along with a complete example for a print service. Core Jini gives the working Java developer all necessary technical information to do this. --Richard Dragan

Topics covered: Jini's standard and custom attributes (and how to use them with JavaBeans), lookup services in Jini (plus connection scenarios), Jini remote events, the JavaSpaces API (for sharing data between distributed processes), and distributed transactions.

From the Inside Flap

Preface

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 networked 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 devices 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 PDAs, to those building LAN-based networked systems such as for the small-office/home-office (SOHO) or remote-office/home-office (ROHO), all the way up to enterprisewide network services and possibly 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. 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 JDK1.2), 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 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 very few of these--only five. Understanding these concepts and how they connect to each other will make later reading much easier.

Chapter 4, "Deployment Scenarios," covers some scenarios 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 an example of using the RMI activation 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 understanding how to use 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, "Using Attributes to Describe Services," talks about the Jini notion of attributes . Attributes are objects that can be associated with services to provide descriptive information about them, or even provide additional functionality (such as user interfaces) to extend the behavior of services. This chapter talks about how to use attributes, and how the Jini attribute model meshes nicely with JavaBeans.

Chapter 8, "In Depth: Using Lookup Services," moves on to the next major phase in a Jin

See all Editorial Reviews

Product Details

• Paperback: 450 pages
• Publisher: Prentice Hall Ptr; 1 edition (June 25, 1999)
• Language: English
• ISBN-10: 013014469X
• ISBN-13: 978-0130144690
• Product Dimensions: 9.2 x 7 x 2.2 inches
• Shipping Weight: 3.4 pounds (View shipping rates and policies)
• Average Customer Review: 3.9 out of 5 stars  See all reviews (17 customer reviews)
• Amazon Best Sellers Rank: #3,522,784 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.