(Pearson Education. Sun Microsystems Press) Offers a complete tutorial in the revolutionary device, Jini, which facilitates networking between devices from kitchen appliances to enterprise servers. Shows how to master Jini's architectural mode, implement discovery, integrate Jini with other technologies, and more. Softcover.
"synopsis" may belong to another edition of this title.
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
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
"About this title" may belong to another edition of this title.
Book Description Prentice Hall PTR, 2000. Paperback. Book Condition: New. Bookseller Inventory # P110130894087
Book Description Prentice Hall PTR, 2000. Paperback. Book Condition: New. 2nd. Bookseller Inventory # DADAX0130894087
Book Description Prentice Hall PTR. PAPERBACK. Book Condition: New. 0130894087 New Condition. Bookseller Inventory # NEW6.3018552
Book Description Prentice-Hall. Book Condition: New. pp. 1008. Bookseller Inventory # 5268750