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!
Sprache
Verlagsort
Verlagsgruppe
Zielgruppe
Für höhere Schule und Studium
Maße
Breite: 235 mm
Dicke: 55 mm
Gewicht
ISBN-13
978-0-13-014469-0 (9780130144690)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Klassifikation
W. Keith Edwards is a member of research staff at Xerox Palo Alto Research Center (PARC). He has worked in R&D and as a consultant to several leading companies, including Sun, and holds a Ph.D. from Georgia Tech's Graphics, Visualization and Usability Center.
PART I. FOUNDATIONS.
1. A New Computing Paradigm.
Jini History. The Jini Vision. Not Just for Consumer Electronics. Jini Becomes Public. Licensees. Community Source Licensing. Getting and Installing Jini. Installing Java. Downloading the JDK from Sun. Unpacking the Distribution. Examining the Distribution. Installing Jini. Downloading Jini from Sun. Unpacking the Distribution. Examining the Distribution. Set Up Your Environment. Setting Your PATH. Setting Your CLASSPATH. Start the Jini Run-time Services. Starting Required Services via the GUI. Running the GUI. Starting Required Services via the Command Line. Start the Web Server. Start the RMI Activation Daemon. Start the Lookup Service. Running the Sample Program. Further Reading and Resources.
2. Distributed Systems.
What's So Hard about the Network? Classical Networked Systems. The Network Is Not Transparent. Performance and Latency. New Failure Modes. Concurrency and Consistency. New Paradigms in Distributed Computing. The Need for Strong Typing. Practical Remote Polymorphism. Remoteness Is Part of the Interface, Not the Implementation. Further Reading.
3. The Jini Model.
Jini Design Center. Simplicity. Reliability. Scalability. Device Agnosticism. What Jini Is Not. Jini Is Not a Name Server. Jini Is Not JavaBeans. Jini Is Not Enterprise JavaBeans. Jini Is Not RMI. Jini Is Not a Distributed Operating System. The Five Key Concepts of Jini. Discovery. The Discovery Protocols. Supporting Multiple Communities. Lookup. Publishing a Service. Downloadable Proxies. Finding a Service. Common Interfaces, Divergent Implementations. Leasing. Time-Based Resource Reservation. Third-Party Leasing. Third-Party Leasing and Delegation. Using Leases in Practice. Leasing versus Garbage Collection. Remote Events. Remote versus Local Events. How Jini Uses Events. Event-Programming Model. Generic Delegates. Adding Application Behaviors to the Event Pipeline. Events and Leasing. Sequence Numbers and Transactions. Transactions. Ensuring Data Integrity. Two-Phase Commit. Two-Phase Commit in Jini. Using Jini Transactions. What's Next?
4. Deployment Scenarios.
What Does It Mean to Be a Jini Service? How to Use Jini for Your Devices and Services. Jini on General-Purpose Computers. Jini on Java-Enabled Devices. Jini and Java Subsets. Even More Limited Java Environments. Versioning. Jini Using Device Proxies. Requirements for Jini Infrastructure Services. When Is Jini Appropriate? When Is Jini Not Appropriate? Further Reading. What's Next?
PART II. BUILDING WITH JINI.
5. Getting Started with Jini.
Running the Jini Services. Developing with Deployment in Mind. Run Multiple HTTP Servers. Watch Out for Codebase Problems. Always Set a Security Manager. Pay Attention to Security Policies. Take Care with CLASSPATH. Consider Bundling Downloadable Code into a JAR File. Summary. A First Jini Program: Hello, World. Writing the Service Proxy. The "Wrapper" Application. Using Discovery and Lookup. Last Details. Using Service Templates to Search for a Service. Looking Up a Service. Compiling and Running the Examples. Compiling. Start an HTTP Server for the Service. Set Up a Security Policy File. Running. Extending Hello World with Events. Writing a Remote Event Listener. Soliciting Events via Notify(). Compiling and Running the Code. Compiling. Generating the RMI Stubs. Start an HTTP Server to Export the Client's Downloadable Code. Running. Hello World with Leasing. A Simple Approach. Compiling and Running the Code. Compiling. Running. Using an Activatable Back-End Process. Compiling and Running the Example. Compiling. Generating the RMI Stubs. Running. What's Next?
6. In Depth: Discovery.
What's Discovery? Groups Partition the Community Namespace. Types of Discovery. Requirements for Discovery. An Overview of Discovery. An IP Multicast Primer. Service-Initiated Discovery. Lookup Service-Initiated Discovery. "Direct" Discovery. Using Discovery in Applications. DiscoveryListeners Are Informed of Discoveries. DiscoveryEvents Encapsulate Discovery Information. Using LookupDiscovery to Control Multicast Discovery. An Example. Security and LookupDiscovery. Compiling and Running the Program. Using LookupLocator to Control UnicastDiscovery. An Example. Compiling and Running the Program. Under the Hood: The Discovery Protocols. The Multicast Request Protocol. Communication Flow. Packet Format. Using the Multicast Request Protocol. The Multicast Announcement Protocol. Communication Flow. Packet Format. Using the Multicast Announcement Protocol. The Unicast Discovery Protocol. Communication Flow. Packet Format. Using Unicast Discovery. An Example. Compiling and Running the Program. Other Internal Discovery Issues. Multicast Restrictions and Guidelines. Multicast Routing Infrastructure. Security. Host and Network Requirements. Interfaces for Discovery Implementors. Summary. What's Next?
7. Using Attributes to Describe Services.
Attributes Basics. What Are Attributes? The Special Semantics of Attributes. Search Using Attributes. Who Changes Attributes? The Standard Attributes. Writing New Attributes. An Example: A Capacity Attribute. Attributes and Beans. Using Entry Beans to Map Entries to Beans. How Are Entry Beans Found? The Entry Bean Class. The Standard Entry Beans. An Example: A Capacity Bean. A Second Bean Example: Using GUI Beans. Further Reading.
8. In Depth: Using Lookup Services.
Overview of Lookup. Lookup Services Are Jini Services. How Services Use Lookup. How Clients Use Lookup. Publishing a Service Proxy: The Join Protocol. The JoinManager Class. Managing Service IDs. Using the JoinManager in Applications. Compiling and Running the Example. Using Attributes through the JoinManager. Restricting Changes to ServiceControlled Attributes. How Clients Use Lookup Services. The Client Life Cycle. Searching for Services. The Search APIs. How Are Templates Matched? An Example: Searching for Service Information. Compiling and Running the Example. Soliciting Events from a Lookup Service. Specifying When Events Should Be Sent. Using Notify() to Ask for Events. Receiving Events. An Example: Using Events to Find Services. Compiling and Running. Other Client Issues. You Cannot Change a Service's Attributes Without Going through the Service. Downloaded Service Proxies Are Not Leased. Service IDs Are Unique Across Lookup Services. Miscellaneous Lookup APIs. Federating and Administering Lookup Services. A Quick Overview of Service Administration. Lookup Administrative Interfaces. Administering the Reggie Lookup Service Implementation. Federating Lookup Services. Compiling and Running. Example: A Lookup Service Tunnel. Compiling and Running. Further Reading. Summary. What's Next?
9. A Jini Lookup Service Browser.
What Does a Browser Do? Using the Browser. Building Administration Components. DestroyAdminPanel. StorageLocationAdminPanel. A ListBox for Managing Sets. DiscoveryAdminPanel. JoinAdminPanel. AdminPanel. JList Cell Renderers for Common Jini Types. LookupCellRenderer. ServiceCellRenderer. AttrCellRenderer. The Core Browser Framework. Storing Data in Lists. Using Discovery. Receiving Service Events. Handling List Events. The Browser Class. Building and Running the Browser. What's Next?
10. In Depth: Leasing.
Reliability in Distributed Systems. The Need for Self-Healing. The Need for Evolvability. Leasing as a Solution. The Leasing Approach. Issues in Leasing. Relative versus Absolute Time. Lease Negotiation. Leasing Done by Third Parties. The Cost of Leasing. Building Lease Consumers. The Lease Interface. Determining When a Lease Expires. Canceling a Lease. Renewing a Lease. Ensuring That Leases are Serialized Correctly. Batching Leases for Performance. The LeaseMap Interface. Higher-Level APIs for Lease Consumers. A Leasing Service. An Overview of a Leasing Service. Remote Leasing APIs. Events and Listeners for Remote Leasing. Leasing Service Implementation. Compiling and Running the Example. Leasing in Practice. Who Handles Lease Renewals? The Perils of Leasing. Delegation to an External JVM Versus Delegation to an Internal Class. Summary. What's Next?
11. Exporting Leased Resources.
Leasing Interfaces and Implementations. The Landlord Paradigm. Identifying Leased Resources. Implementing the Landlord Interface. An Example. Compiling and Running the Examples. Summary. What's Next?
12. The Well-Behaved Service.
The Responsibilities of a Service. Service Administration. Administration through Delegation. Administrative Interfaces. Implementation of Administrative Delegates. An Example: Administering the LeaseService. Providing User Interfaces for Services. Several Approaches to Providing UIs. Summary. What's Next.
13. A Complete Example: The Print Service.
Requirements for a Printing Service. A Service Writer's Toolkit. A Superclass for Services. A Tool for Administration. Defining the Print Service API. Communicating with Clients: Events and Listeners. The Remote Printing Interface. The Print Service Proxy. Printer Administration APIs and UIs. Internals of the Print Service. Printing. Persistent Data Formats. Implementing Print Service Administration. A Print Client. Compiling and Running the Examples. Ideas for Future Work. Summary. What's Next?
14. In Depth: Remote Events.
The Need for Notifications. Jini Event Design Center. How Remote Events Differ from Local Events. Out of Order Delivery. Partial Failures. Latency Versus Computation. Addressing Application Semantics. The Jini Event Programming Model. The RemoteEvent Class. Event Types. Sequence Numbers, Idempotency, and Ordering. Application-Specified Return Data. The RemoteEventListener Interface. Dealing with Errors. Other Event Interfaces. An Example: Heartbeat Events. A Toolkit for Event Registrations. A Simple Event Generator. Event Types and Sequence Numbers. Defining a Cookie Type. Persistent Data. Registering for and Sending Events. A Client to Test the HeartbeatGenerator. Compiling and Running the Heartbeat Examples. Third-Party Event Delegates. Designing for Composition. Composition in Practice. How Events are Delivered through the Pipeline. Setting up the Pipeline. Pipelines from the Generator Perspective. Pipelines from the Listener Perspective. Leasing Across Delegates. An Example: An Event Mailbox. The EventMailbox Service. A Mailbox Client. Compiling and Running the Examples. Summary. What's Next?
15. JavaSpaces.
What Is JavaSpaces? A Filesystem for Objects. Attribute-Based Search. Predecessors to JavaSpaces. Getting and Installing JavaSpaces. Downloading JavaSpaces from Sun. Unpacking the Distribution. Examining the Distribution. Set Up Your Environment. Start the Run-time Services. Starting Required Services via the GUI. Starting the Required Services via the Command Line. Transient and Persistent JavaSpaces. The JavaSpaces Programming Model. Transactions, in Brief. JavaSpaces APIs. Write(). Read() and ReadIfExists(). Take() and TakeIfExists(). Notify(). Snapshot(). An Example: Persistent Event Logging with JavaSpaces. Design for Searchability. A Community Watcher. A Consumer of Logged Event Data. Compiling and Running the Programs. Applying JavaSpaces to Distributed Computing Problems. Further Reading. What's Next?
16. Distributed Transactions.
Consistency and the Evils of Partial Failure. A Classical Transaction Model. Two-Phase Commit. Transactions in Jini. The Players in Jini Transactions. Programming with Jini Transactions. The Transaction Manager. Creating Transactions. The Transaction Interface. Transaction Participants. Using Transactions with JavaSpaces. Compiling and Running the EntryMover. Other Transaction Issues and Idioms. Transactions and Visibility. Nesting Transactions. Events and Sequence Numbers. Using Transactions to Hide Data. Summary.
PART III. APPENDICES.
Appendix A: An RMI Primer.
Overview of RMI. Remote Interfaces. Stubs and Skeletons. Serialization. Parameters and Return Values. Dynamic Code Loading. Security Implications. Marshalled Objects. Building with RMI. Compiling the Example. Running the Programs. The Activation Framework. Players in Activation. Using the Activation Framework. "Lazy" References. Deactivation. Getting the Most from the Activation Daemon. Further Reading.
Appendix B: Common Java and Jini System Properties.
Index.
