Register your product to gain access to bonus material or receive a coupon.
JavaSpaces in Practice
- By Phil Bishop, Nigel Warren
- Published Sep 20, 2002 by Addison-Wesley Professional.
Book
- Sorry, this book is no longer in print.
About
Features
- Focuses on patterns for designing and evolving entries from the basics to advanced distributed data structures
- Covers design and idioms associated with remote events, code mobility, and both transient and persistent spaces.
- Highlights some practical applications including implementing smart proxies, location based services and agent systems, together with guidlines and tips for testing and tuning Javaspaces
- Supporting materials available at www.jsip.info
Description
- Copyright 2003
- Dimensions: 7-3/8x9-1/4
- Pages: 256
- Edition: 1st
- Book
- ISBN-10: 0-321-11231-8
- ISBN-13: 978-0-321-11231-6
This book shows developers how to use JavaSpaces to build practical, scalable, distributed systems.
- The authors are pioneers in the use of JavaSpaces to build real systems that solve real problems.
- It will increase the understanding of where JavaSpaces are applicable, and how to use them effectively within your system architecture.
- Well written and clearly presented, practical implementation guide for JavaSpaces.
- The book is endorsed by Jim Waldo: Distinguished Engineer at Sun Microsystems, lead architect for the Jini networking technology and JavaSpaces.
- Follows on from Bishop and Warren's classic: Java in Practice.
Programmers with some experience in Java.
User level:
Intermediate.
Philip Bishop specializes in the design and implemenation of large scale systems for organizations ranging from utility companies to investment banks.
Nigel Warren is co-founder and Director of Technology at IntaMission Ltd, where he researches and designs agile and evolvable software infrastructures for next generation distributed systems.
Sample Content
Table of Contents
NOTE: Each chapter concludes with a Summary.)
Acknowledgements.
Preface.
1. Introduction.
Foundations and Terms.
Distribution Using Spaces
The Javaspaces Interface
The Structure of Spaces
I. ENTRIES.
2. Designing Entries.
Background.
An Initial Entry.
Entry Wrapping.
Interfaces for Entries.
Factories for Entries.
Design Alternative.
Entries for Existing Frameworks.
The Payload Idiom.
3. Evolving Entries.
Maintaining Compatibility.
Standard Techniques and Data Loss.
Using Inheritance to Add Fields.
Removing Fields from Entries.
Evolving Nested Key Fields.
An Alternative to Nested Key Fields.
Problems with Entry Evolution.
4. Simple Distributed Data Structures.
Simple Data Structures.
Ordered Data Structures.
Iterating.
5. Hierarchical Distributed Data Structures.
Organizational Structures.
Complex Matching.
Generic Distributed Trees.
II. MECHANICS.
6. Codebases.
Basic Requirements.
The Codebase System Property.
7. Remote Event-based Idioms.
Introducing Remote Events.
The Handback Event Handler.
Object Interactions.
Adding Event Handlers at Runtime.
Leases.
Event Registration.
Sequence Numbers.
Transactions.
Leases And Transactions.
Using An Event Mailbox.
Reliability.
8. Code Mobility Behaviour-based Idioms.
Introducing Code Mobility.
What Goes on Behind the Scenes?
Introducing Behavior-based Idioms.
Building an Employee System.
Using Subclassing to Modify Behavior at Runtime.
Using Classloaders to Modify Behavior at Runtime.
Security and Mobile Code.
9. Using Transient and Persistent Spaces.
Transient Spaces.
Persistent Spaces.
Accessing Different Spaces.
Specifying Storage Models with Entries.
Mixing Snapshots.
Registering the Mixed Proxy.
III. APPLICATION.
10. Process Coordination.
Request-Response Model.
Implementing the Model.
Coordinating Multiple Services.
11. Location-based Services.
Location-Based Systems.
Packit Shifters - Case Study.
Finding Locatables in a Space.
12. Bidding and Agent Systems.
A Time Bidding System.
Typesafe Constants with Spaces.
Agents and Spaces.
The Customer Agent.
The Driver Agents.
Letter Counter Service.
13. Testing Space-based Systems.
A Space Logging System.
A Local Logging Proxy.
Reviewing the Design.
The JavaSpace Logging Service.
Alternative Designs 2.
14. Tuning Space-based Systems.
A Lightweight Counter.
Tuning Local Code.
Using Snapshot.
Imitating Snapshot.
General Entry Optimizations.
Date Matching.
Time and Spaces.
Server Tuning.
Conclusion.
Appendices.
A: Code Listings.
B: Tips and Rules in This Book.
References.
Index.
Preface
This is a book about how to use JavaSpaces to build practical distributed systems. Over the last few years we have helped clients and friends to build space-based systems. In this book we have tried to record the information and practices that we found useful when going about this task. During this time it has been a delight to discover that Spaces inherently solve many of the problems traditionally associated with building scalable distributed systems. That is not to say that they are a panacea, but when we look back at other methods we have used over the past couple of decades to build and connect distributed software systems, it now seems impossible to consider building a "real" distributed system without a JavaSpace. In fact this is the same kind of reaction we had to Java when it was first launched. Of course, Spaces are not appropriate for all systems. Sometimes, for example, a simple http server will suffice, but as systems become more complex JavaSpaces provide an escape route from the traditional issues of partial failure and ever-increasing complexity. In fact, one of the aims of this book is to increase your understanding of where Spaces are applicable and how to use Spaces effectively within your system’s architectures. Our goal when we started writing this book was to avoid repeating too much work covered in other books on this subject, most notably work in
So as this book is not a beginner’s guide to using or understanding JavaSpaces we would strongly recommend that you get your hands on a copy of that book if you find that some of the terminology or concepts here are not exp- licitly explained.
This book is grouped into three parts:
l
entries;l
mechanics;l
application.Part 1 on entries, covers entry design, evolution, and distributed data structure design.
Part Two covers designs and idioms associated with remote events, code mobility, and combining the use of both transient and persistent space.
Part Three deals with the practical design and application of space-based systems.
Chapter summary
Part 1: Entries
The first four chapters of this part cover designing entries and data structures and some of the forces that influence their design. There is plenty more on designing space-based systems in the other sections too, but they build on some of the principles discussed in this first section.
Chapter 1: Introduction
In the first chapter we are going to take a look at JavaSpaces in general, starting with some foundation principles and outlining the terms that we intend to use throughout the book. We will also be taking a brief peek "under the hood" to see how Spaces are built, and the differences between transient and persistent Spaces.
Chapter 2: Designing entries
In the first chapter in the entries section we take a look at designing entries. We start off with a simple entry and discuss the rules governing its design. With this under our belt, we then go on to look into the issues relating to encapsulation, and describe various idioms that can be used to help hide the public nature of entries — these include Entry Wrapping, Interfaces, Factories, and how to design entries to work with existing interfaces. The chapter concludes by looking at the payload idiom, which can be used to reduce the indexing burden on a JavaSpace.
Chapter 3: Evolving entries
The second chapter in this section discusses the implications of evolving entry classes to satisfy new requirements as systems change over time. Initially we investigate the standard Java technique used for maintaining class compatibility and how it can result in data loss under some circumstances. We then discuss why the standard technique can’t be used for top-level entries, and look at the "inheritance for additions" idiom, which solves the data loss problem. We then investigate the implication of evolving classes used as key fields (in an entry) and conclude by proposing alternative designs.
Chapter 4: Simple distributed data structures
This is the first of two chapters that look at the forces affecting the design of distributed data structures. We start off by looking at some simple examples of ordered and unordered data structures and how we can use them to help us build a system that records and reports on errors encountered by other Jini services. Topics covered in this chapter include fixed/variable-sized arrays, stacks, queues, and a discussion about generic versus explicit arrays. The chapter concludes by looking at how to iterate over distributed data structures by using the "timeout iterator" idiom.
Chapter 5: Hierarchical distributed data structures
In the second of the two chapters about distributed data structures we look at how to design hierarchical data structures such as graphs and trees. We take the example of a large organizational hierarchy which is represented in XML and iteratively examine the forces that affect how we can go about designing a useful data structure to hold this data in a JavaSpace. Topics covered include how to edit subtrees, move and delete nodes, matching on subtree and tree walking.
Part 2: Mechanics
The second part of this book deals with some of the mechanisms behind space-based designs; these include behavior-based idioms, remote events, and code mobility, plus how to dynamically update your entry’s behavior at runtime. This section presents an interesting set of idioms that build on some of the earlier examples by making space-based systems more dynamic and flexible.
Chapter 6: Codebases
Chapters 7 and 8 require an understanding of how to take advantage of the Java platform’s ability to dynamically load classes at runtime from remote clients/services. This is a reference chapter which you can refer back to if you encounter any problems later on.
Chapter 7: Remote event-based idioms
In this chapter we take a look at how to use remote events effectively and some of the potential side-effects/pitfalls. We cover how to reuse event listeners and illustrate how the remote event’s "handback" object can be used to dynamically select the correct handler for that event type. The chapter concludes by covering leasing, transactions, sequence numbers, and how the Event Mail Box service can be used in conjunction with a space-based client.
Chapter 8: Code mobility — behaviour-based idioms
This chapter starts off by looking at how code mobility plays a big part in he Jini world and how services register with the Jini Lookup Service. Using this knowledge we start to build a simple employee system that is dynamically updateable. Initially we implement a solution that uses subclassing, then we briefly delve into how class loaders work and present another simple model that allows you to update the behavior associated with an entry while the system is running. The chapter concludes by taking a brief look at the security issues that need to be considered when untrusted code is downloaded/executed.
Chapter 9: Using transient and persistent JavaSpaces
In this chapter we investigate how to use both transient and persistent JavaSpaces together in a single system. By using a marker interface with entries, we develop a model where short-lived entries can take advantage of a faster transient space, while longer-lived entries are written to a persistent space. In this chapter we introduce the concept of adapter proxies, which are also used in later chapters.
Part 3: Application
In the final part of the book we look at some practical applications for JavaSpaces. The first chapter in this section examines the well-known request-response model and describes how using JavaSpaces can result in more robust and flexible designs. The remaining chapters describe possible designs for bidding and location-based systems, followed by a look at how to build a logging system to track what’s going in and out of a JavaSpace. We finish off by looking at some tuning tips.
Chapter 10: Process coordination
In the opening chapter of the final section, we take a look at the well-known request—response model used in many three-tier architectures, and examine how using JavaSpaces to decouple the participants results in more robust and flexible systems.
Chapter 11: Location-based services
This chapter looks at location-based services implemented with Spaces, and discusses how the use of generic or more abstract classes can help to reduce complexity and increase flexibility and future growth in these and other Spaces- based systems. We show how the inherent matching properties of Spaces can be used to implement powerful searching strategies, and make use of their inherent parallel character to optimize the searches.
Chapter 12: Bidding and agent systems
In this chapter we look at a very simple system in which agents bid to deliver parcels of various sizes in order to effectively share work and distribute resources.
Chapter 13: Testing space-based systems
Debugging space-based systems can be tricky, so in this chapter we present a simple, but flexible, logging model to record what’s gone in and out of the space, who put it there or removed it. We examine several different models and logging strategies that you can use to help you figure out what’s going on in the space.
Chapter 14: Tuning space-based systems
In this chapter we look at some of the details of building efficient and effective clients of a space; that is, those that use the resources available to them (in terms of the systems hardware) effectively. They not only go faster, but they also use memory and other computer resources well.
Appendix A: Code listings
This appendix contains the code listings to the utility classes used throughout this book, plus some of the classes we don’t list in full.
Appendix B: Tips and rules in this book
This appendix contains a summary of the tips and rules dotted through this book, alongside the text.
The book’s website
The source code for the examples in this book and the referenced utility classes can be downloaded from the book’s website (http.jsip.info).
0321112318P07292002