Java RMI. William Grosso. Publisher: O'Reilly. First Edition October For example, hohounsmolathe.ga is an address. public static final int PDF = 1;. With Java RMI, you'll learn tips and tricks for making your RMI code excel. The book provides strategies for working with serialization, threading, the RMI registry . (including topics like RMI and CORBA) and the Java technologies that support them (for example, Java IDL and RMI-IIOP), then this tutorial is for you. RMI by William Grosso, an O'Reilly publication. heading graphics, and two PDF files .
|Language:||English, Spanish, Hindi|
|Genre:||Business & Career|
|Distribution:||Free* [*Registration needed]|
collection, JNDI, and CORBA. In short, a treasure trove of valuable. RMI knowledge packed into one book. Java RMI Dedication Preface About This Book. Java Distributed Computing: RMI. Jim Farley. O'Reilly Java Conference This tutorial will provide an overall introduction to Java Remote Method Invocation. Java enterprise in a nutshell, O'Reilly, 3rd Edition, Available free on-line through Safari (see information page). • Many more books on the subject in the.
A programmable concurrency control service for real-time object request brokers.
Google Scholar Harrison, T. Google Scholar Mowbray, J. Inside Corba. Reading, MA: Addison-Wesley. Google Scholar Orfali, R. New York: Wiley and Sons. Google Scholar Padmanabhan, V.
Using predictive prefetching to improve world wide web latency. Computer Communication Review 26 3 : Google Scholar Pedersen, R. Object request broker software technology: applications in an advanced open systems avionics architecture.
Google Scholar Soller, J. Testing a Distributed Application The RMI Registry Naming Services The RMI Runtime Factories and the Activation Framework Advanced Topics Using Custom Sockets Dynamic Classloading Security Policies Multithreaded Clients HTTP Tunneling By a distributed application, I mean a set of programs running in different processes and quite possibly on different machines which form, from the point of view of the end user, a single application.
Application, on the other hand, refers to one or more programs executing inside one or more JVMs that, to the end user, appear to be a single program. RMI is a robust and effective way to build distributed applications in which all the participating programs are written in Java.
Because the designers of RMI assumed that all the participating programs would be written in Java, RMI is a surprisingly simple and easy framework to use.
Not only is RMI useful for building distributed applications, it is an ideal environment for Java programmers learning how to build a distributed application.
I don't assume you know anything about distributed programs or computer networking. We'll start from the ground up and cover all the concepts, classes, and ideas underlying RMI.
I will also cover some of the more advanced aspects of Java programming; it would be irresponsible to write a book on RMI without devoting some space to topics such as sockets and threading. In order to get the most out of this book, you will need a certain amount of experience with the Java programming language.
You should be comfortable programming in Java; you should have a system with which you can experiment with the code examples like many things, distributed programming is best learned by doing ; you should be fairly comfortable with the basics of the JDK 1. About This Book This book covers an enormous amount of ground, starting with streams and sockets and working its way through the basics of building scalable client-server architectures using RMI.
While the order of chapters is a reasonable one, and one that has served me well in introducing RMI to my students at U. Berkeley Extension, it is nonetheless the case that skipping around can sometimes be beneficial.
For example, Chapter 10, which discusses object serialization, really relies only on streams from Chapter 1 and can profitably be read immediately after Chapter 4 where the first RMI application is introduced. The book is divided into three sections.
Part I starts with an introduction to some of the essential background material for RMI. After presenting the basics of Java's stream and socket libraries, we build a simple socket-based distributed application and then rebuild this application using RMI.
At this point, we've actually covered most of the basics of building a simple RMI application. The rest of Part I Chapters Chapter 5 through Chapter 9 presents a fairly detailed analysis of how introducing a network changes the various aspects of application design. These chapters culminate in a set of principles for partitioning an application into clients and servers and for designing client-server interaction.
Additionally, they introduce an example from banking which is referred to repeatedly in the remainder of the book. After finishing the first section, you will be able to design and build simple RMI applications that, while not particularly scalable or robust, can be used in a variety of situations.
Part II builds on the first by drilling down on the underlying technologies and discussing the implementation decisions that must be made in order to build scalable and secure distributed applications. That is, the first section focuses on the design issues associated with the clientserver boundary, and the second section discusses how to make the server scale.
As such, this section is less about RMI, or the network interface, and more about how to use the underlying Java technologies e.
The distinction between the second and third sections is that everything covered in the second section is essential material for building a sophisticated RMI application and hence should be at least partially understood by any programmer involved in the design or implementation of an RMI application.
The topics covered in Part III are useful and important for many applications but are not essential knowledge. What follows is a more detailed description of each chapter in this book.
Part I Chapter 1 Streams are a fairly simple data structure; they are best thought of as linear sequences of bytes. They are commonly used to send information to devices such as a hard drive or over a network.
This chapter is a background chapter that covers Java's support for streams. It is not RMI-specific at all. Chapter 2 Sockets are a fairly common abstraction for establishing and maintaining a network connection between two programs. Socket libraries exist in most programming languages and across most operating systems.
This chapter is a background chapter which covers Java's socket classes. Chapter 3 This chapter is an exercise in applying the contents of the first two chapters. It uses sockets and streams to build a distributed application. Consequently, many of the fundamental concepts and problems of distributed programming are introduced. Because this chapter relies only on the contents of the first two chapters, these concepts and problems are stated with minimal terminology.
Chapter 4 This chapter contains a translation of the socket-based printer server into an RMI application.
Consequently, it introduces the basic features of RMI and discusses the necessary steps when building a simple RMI application. This is the first chapter in the book that actually uses RMI. Chapter 5 The bank example is one of the oldest and hoariest examples in client-server computing. Along with the printer example, it serves as a running example throughout the book. Chapter 6 The first step in designing and building a typical distributed application is figuring out what the servers are.
That is, finding which functionality is in the servers, and deciding how to partition this functionality across servers. This chapter contains a series of guidelines and questions that will help you make these decisions.
Chapter 7 Once you've partitioned an application, by placing some functionality in various servers and some functionality in a client, you then need to specify how these components will talk to each other.
In other words, you need to design a set of interfaces. This chapter contains a series of guidelines and questions that will help you design and evaluate the interfaces on your servers. Chapter 8 After the heady abstractions and difficult concepts of the previous two chapters, this chapter is a welcome dive into concrete programming tasks. In it, we give the first of many! Chapter 9 The final chapter in the first section rounds out the implementation of the bank example.
In it, we build a simple client application and the launch code the code that starts the servers running and makes sure the clients can connect to the servers. It's easy to use serialization, but using it efficiently and effectively takes a little more work.
This chapter explains the serialization mechanism in gory detail. Chapter 11 This is the first of two chapters about threading. It covers the basics of threading: