book

Java RMI

Name: Java RMI
Author: William Grosso
ISBN: 9781565924529

by William Grosso

October 2001

Beginner

572 pages

33h 42m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Java RMI
Dedication
A Note Regarding Supplemental Files
Preface
About This BookPart IPart IIPart IIIAbout the Example CodeConventions Used in This BookCoding ConventionsApplicationsCompiling and BuildingDownloading the Source ExamplesFor Further InformationHow to Contact UsAcknowledgments
I. Designing and Building: The Basics of RMI Applications
1. Streams
The Core ClassesInputStreamReading dataStream navigationResource managementIOExceptionOutputStreamWriting dataResource managementViewing a FileLayering StreamsCompressing a FileHow this worksSome Useful Intermediate StreamsReaders and WritersRevisiting the ViewFile Application
2. Sockets
Internet DefinitionsSocketsCreating a SocketA simple client applicationProtocols and MetadataProtocolsMetadataServerSocketsThe accept( ) methodA Simple Web ServerCustomizing Socket BehaviorSpecial-Purpose SocketsDirect Stream ManipulationSubclassing Socket Is a Better SolutionA Special-Purpose SocketFactoriesSocket FactoriesSecurityUsing SSLThe SSL HandshakeUsing SSL with JSSERegistering providersConfiguring SSLServerSocketConfiguring SSLSocketSending dataRevisiting Our Web Server
3. A Socket-Based Printer Server
A Network-Based PrinterThe Basic ObjectsThe ProtocolEncapsulation and Sending ObjectsDocumentDescriptionNetwork-Aware Wrapper ObjectsClientNetworkWrapperServerNetworkWrapperThe Application ItselfWriting the ClientRedrawing the Architecture DiagramEvolving the ApplicationWhat These Changes Entail
4. The Same Server, Written Using RMI
The Basic Structure of RMIMethods Across the WirePassing by Value Versus Passing by ReferenceThe Architecture Diagram RevisitedImplementing the Basic ObjectsThe Printer InterfaceImplementing a PrinterExamining the skeletonThe Data ObjectsDocumentDescriptionThe Rest of the ServerThe Client ApplicationSummary
5. Introducing the Bank Example
The Bank ExampleSketching a Rough ArchitectureFive Steps to a SketchThe Basic Use CaseAdditional Design DecisionsDesign PostponementsSecurityScalabilityImplications of the EnvironmentA Distributed Architecturefor the Bank ExampleProblems That Arise in Distributed ApplicationsPartial FailuresNetwork Latency

6. Deciding on the Remote Server
A Little Bit of BiasImportant Questions WhenThinking About ServersDoes Each Instance of the Server Requirea Shared/Scarce Resource?Memory, in general, is not an issue hereSockets in RMI aren’t a limitation eitherAn example of a resource limitationMoving things to a singleton resource object handles this problemApplying this to Bank versus AccountsHow Well Does the Given Server Replicate/Scaleto Multiple Machines?Applying this to Bank versus AccountsCan a Single Server Handle a Typical Client Interaction?How many of the servers does the client need to know about during the courseof a typical conceptual operation?Applying this to Bank versus AccountsHow Easy Is It to Make a Server Handle Multiple Simultaneous Clients?Applying this to Bank versus AccountsHow Easy Is It to Tell Whether the Code Is Correct?Applying this to Bank versus AccountsHow Fatal Is a Server Failure?Applying this to Bank versus AccountsHow Easy Is It to Gracefully Extend the Software and Add New Functionality?Applying this to Bank versus AccountsShould We Implement Bank or Account?
7. Designing the Remote Interface
Important Questions When Designing Remote InterfacesShould We Pass Method Objects?Applying this to the Account interfaceShould We Pass Objects as Argumentsor Use Primitive Values?Applying this to the Account interfaceShould We Receive Objects as Return Valuesor Receive Primitive Values?Applying this to the Account interfaceDo Individual Method Calls Waste Bandwidth?Applying this to the Account interfaceIs Each Conceptual Operation a Single Method Call?Iterators, againApplying this to the Account interfaceDoes the Interface Expose the Right Amount of Metadata?Applying this to the Account interfaceHave We Identified a Reasonable Set of Distributed Exceptions?Applying this to the Account interfaceBuilding the Data ObjectsData Objects Don’t Usually Have Functional MethodsInterfaces Give You the Data ObjectsAccounting for Partial Failure
8. Implementing the Bank Server
The Structure of a ServerImplementing the ServerA Server That Extends UnicastRemoteObjectA Server That Does Not Extend UnicastRemoteObjectExtending UnicastRemoteObjectThe benefits of UnicastRemoteObjectThe costs of UnicastRemoteObjectGenerating Stubs and SkeletonsGetting Rid of the Skeletons
9. The Rest of the Application
The Need for Launch CodeThe Idea of a Server LifecycleOur Actual Launch CodeBuild Test ApplicationsBuild the Client ApplicationDon’t Hold Connections to a Server You’re Not UsingValidate Arguments on the Client Side Whenever ReasonableThe Actual Client ApplicationDeploying the Application
II. Drilling Down: Scalability
10. Serialization
The Need for SerializationDrilling Down on Object CreationUsing SerializationObjectOutputStreamThe “write” methodsThe stream manipulation methodsMethods that customize the serialization mechanismObjectInputStreamThe “read” methodsThe stream manipulation methodsMethods that customize the serialization mechanismHow to Make a Class SerializableImplement the Serializable InterfaceMake Sure That Instance-Level, Locally Defined StateIs Serialized ProperlyDeclaring transient fieldsImplementing writeObject() and readObject( )Declaring serialPersistentFieldsMake Sure That Superclass State Is Handled CorrectlyOverride equals( ) and hashCode( ) if NecessaryMaking DocumentDescription SerializableImplement the Serializable interfaceMake sure that instance-level, locally defined state is serialized properlyMake sure that superclass state is handled correctlyOverride equals() and hashCode( ) if necessaryThe Serialization AlgorithmThe Data FormatA Simplified Version of the Serialization AlgorithmWritingReadingRMI Customizes the Serialization AlgorithmannotateClass( )replaceObject( )Maintaining Direct ConnectionsVersioning ClassesThe Two Types of Versioning ProblemsHow Serialization Detects When a Class Has ChangedImplementing Your Own Versioning SchemePerformance IssuesSerialization Depends on ReflectionSerialization Has a Verbose Data FormatIt Is Easy to Send More Data Than Is RequiredThe Externalizable InterfaceComparing Externalizable to SerializableOne Final Point
11. Threads
More Than One ClientBasic TerminologyThe Calling StackThe HeapThreadsMutexesApplying This to the Printer ServerThreading ConceptsControlling Individual ThreadsCoordinating Thread ActivitiesCache ManagementAssigning Priorities to ThreadsSupport for Threads in JavaObjects Have Associated Mutex VariablesThe effects of synchronization on the thread’s local cacheAcquiring the same lock more than onceThread Manipulation Methods Defined on ObjectThe wait methodsThe notify methodsClassesStarting a thread is easyStopping a thread is harderUsing Runnable instead of subclassing ThreadUseful methods defined on the Thread classDeadlockThreading and RMI
12. Implementing Threading
The Basic TaskGuidelines for ThreadingStart with Code That WorksAbove All Else, Ensure Data IntegrityApplying this to the bank exampleMinimize Time Spent in Synchronized BlocksSynchronize around the smallest possible block of codeDon’t synchronize across device accessesDon’t synchronize across secondary remote method invocationsBe Careful When Using Container ClassesConcurrent modification exceptionsThe other containersUse Containers to Mediate Interthread CommunicationImmutable Objects Are Automatically ThreadsafeAlways Have a Safe Way to Stop Your ThreadsBackground Threads Should Have Low PriorityApplying this to the bank examplePay Careful Attention to What You SerializeUse Threading to Reduce Response-Time VarianceLimit the Number of Objects a Thread TouchesAcquire Locks in a Fixed OrderUse Worker Threads to Prevent DeadlocksPools: An Extended ExampleThe Idea of a PoolTwo Interfaces That Define a PoolA First Implementation of PoolingProblems with SimplePoolThe Creation ThreadAdding a Return ThreadGradually Shrinking the PoolTwo Additional Considerations When Implementing a PoolThe initial-resource creation strategyThe difference between the steady-state size and the maximum-pool sizeSome Final Words on Threading
13. Testing a Distributed Application
Testing the Bank ApplicationWhat We’re TestingHow to Test a ServerTesting the Bank ApplicationBuild simple test objectsBuild aggregate tests that test entire use casesBuild a threaded tester that repeatedly performs these testsBuild a thread container that launches many threads and stores the resultsof the test in an indexed structureBuild a reporting mechanism
14. The RMI Registry
Why Use a Naming Service?BootstrappingInstalling a new printerWhen Are Naming Services Appropriate?The RMI Registrybind( ), rebind( ), and unbind( )lookup( ) and list( )The RMI Registry Is an RMI ServerBootstrapping the RegistryExamining the RegistryQuerying the RegistryLaunching an Application-Specific RegistryLimitations of the RMI RegistryDirectories and EntriesFilesystemsYellow pagesThe general idea of directories and entriesSecurity Issues
15. Naming Services
Basic Design, Terminology,and RequirementsHierarchiesOperations on contextsQuery by AttributeAttributes are string-valued, name-value pairsRequirements for Our Naming ServiceOur Use CaseFederation and ThreadingFederationThe Context InterfaceValue Objects Represent Sets and ListsPaths, Names, and Attributes Are All DistinctNull Arguments Are OkayAttributes Are Single ValuedContexts Are Handled by a Separate Set of MethodsContexts, When Bound as Contexts, Have No AttributesContexts Can Create Subcontexts DirectlyThere Are No Remote IteratorsThe Value ObjectsAttributeSetPath and ContextListContextImplNameAttributeSetPairRemoteHolderContextHolderContextImplBootstrappingVersion 2.0Switching Between Naming ServicesAdapting the Bank ExampleModifying the launch codeModifying the client codeThe Java Naming and Directory Interface (JNDI)The Context InterfaceUsing JNDI with the Bank Example
16. The RMI Runtime
Reviewing the Mechanics of a Remote Method CallHow RMI Solves the Bootstrapping ProblemDistributed Garbage CollectionOrdinary Garbage CollectionDefining Network GarbageLeasingThe Actual Distributed Garbage CollectorThe Unreferenced InterfaceRMI’s Logging FacilitiesThe Standard LogThe Specialized LogsThe Debugging LogOther JVM ParametersBasic Java ParametersXmsXmxBasic RMI Parametersjava.rmi.server.randomIDssun.rmi.server.exceptionTraceTransport Layer Parameterssun.rmi.transport.connectionTimeoutsun.rmi.transport.tcp.readTimeoutsun.rmi.transport.proxy.connectTimeoutParameters That Affect the Distributed Garbage Collectorjava.rmi.dgc.leaseValuesun.rmi.dgc.client.gcIntervalsun.rmi.dgc.server.gcIntervalsun.rmi.dgc.checkIntervalsun.rmi.dgc.cleanInterval
17. Factories and the Activation Framework
Resource ManagementFactoriesRevisiting Our Basic DesignImplementing a Generic FactoryA Basic FactoryModifying the Existing ApplicationThe consequences for the clientThe consequences for the naming serviceThe consequences for the account serversA Better FactorySome Prior ArtBuilding on the Account-Locking MechanismThe new factoryThe new accountThe launch code and the clientPersistence and the Server LifecycleActivationCode Changes Necessary for ActivationMaking a server into an activatable objectModifying our launch codeDeploying an Activatable SystemActivationDesc, ActivationGroupDesc, and ActivationGroup in More DetailShutting Down an Activatable Serverrmid Command-Line Arguments-port-log-stop-CActivation Parametersjava.rmi.activation.activator.classjava.rmi.activation.portsun.rmi.activation.execTimeoutsun.rmi.activation.snapshotIntervalsun.rmi.rmid.maxstartgroupsun.rmi.server.activation.debugExecA Final Word About Factories
III. Advanced Topics
18. Using Custom Sockets
Custom Socket FactoriesCreating Custom Socket FactoriesImplementing SerializableImplementing equals( ) and hashCode( )Incorporating a Custom Socket into an ApplicationModifying Ordinary ServersModifying Activatable ServersModifying the Default ServersFailure handlersInteraction with Parameters
19. Dynamic Classloading
Deploying Can Be DifficultClassloadersHow Classes Are LoadedHow Dynamic Classloading WorksA Redeployment ScenarioA Multiple-Deployment ScenarioThe Class ServerRequesting a ClassReceiving a ClassHandling JAR filesSun’s Class ServerUsing Dynamic Classloadingin an ApplicationServer-Side ChangesNaming-Service ChangesClient-Side ChangesDisabling Dynamic Classloading Entirely
20. Security Policies
A Different Kind of Security ProblemPermissionsThe Types of PermissionsAWT permissionsFile permissionsSocket permissionsProperty permissionsSecurity ManagersInstalling an Instance of SecurityManagerHow a Security Manager Worksjava.security.debugSetting Up a Security PolicyThe Three Policy FilesSetting the application-specific policy fileInside a Policy FileUsing Security Policies with RMIPolicy ToolSome Final Words
21. Multithreaded Clients
Different Types of Remote MethodsPrinter-Type MethodsReport-Type MethodsHandling Printer-Type MethodsA First Pass at a SolutionBetter SolutionsClient-side pollingPolling code in the printer applicationServer-side callbacksDefine a client-side callback interfaceImplement the client-side interfaceHandling Report-Type MethodsChapter 7 RevisitedServer-evaluation modelsIterators on the client sideImplementing Background Downloading on the Client SideGeneralizing from These Examples
22. HTTP Tunneling
FirewallsCGI and Dynamic ContentThe Common Gateway InterfaceServletsHTTP TunnelingHow RMI Tunnels MessagesNaming services and “the server machine”A Servlet Implementationof HTTP TunnelingThe Servlet CodeModifying the Tunneling MechanismThe Bank via HTTP TunnelingDrawbacks of HTTP TunnelingDisabling HTTP Tunneling
23. RMI, CORBA, and RMI/IIOP
How CORBA WorksCORBA Contains Other Things TooThe Bank Example in CORBADefining the InterfaceGenerating Stubs and SkeletonsThe ServerThe Launch and Client CodeA Quick Comparison of CORBA and RMIRMI on Top of CORBAThe Fine PrintConverting the Bank Example to RMI/IIOPCommunicating via CORBA
Index
About the Author
Colophon
Copyright

Overview

Java RMI contains a wealth of experience in designing and implementing Java's Remote Method Invocation. If you're a novice reader, you will quickly be brought up to speed on why RMI is such a powerful yet easy to use tool for distributed programming, while experts can gain valuable experience for constructing their own enterprise and distributed systems.With Java RMI, you'll learn tips and tricks for making your RMI code excel. The book also provides strategies for working with serialization, threading, the RMI registry, sockets and socket factories, activation, dynamic class downloading, HTTP tunneling, distributed garbage collection, JNDI, and CORBA. In short, a treasure trove of valuable RMI knowledge packed into one book.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 1565924525Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills