Core JINI - Softcover

Edwards, W. Keith

Softcover

ISBN 10: 013014469X ISBN 13: 9780130144690

Publisher: Prentice Hall Ptr, 1999

Synopsis

The first detailed, practical explanation of Jini technology describes how Jini addresses crucial distributed networking problems that COBRA and other "traditional" technologies ignore, as well as in-depth explanations of live Java code. Original. (Intermediate).

About this title

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

About this edition

• Publisher: Prentice Hall Ptr
• Publication date: 1999
• ISBN 10: 013014469X
• ISBN 13: 9780130144690
• Binding: Paperback
• Edition number: 1
• Number of pages: 832