java distributed computing.pdf

Using the Examples in Applets (Java Distributed Computing)

Table of Contents

Appendix A. Using the Examples in Applets....................................................................................................1

A.1. Whiteboard Applet........................................................................................................................................1

A.2. Class Downloads...........................................................................................................................................6

Appendix B. CORBA Services...........................................................................................................................7

B.1. Naming Service.............................................................................................................................................7

B.1.1. Comparison to the RMI Registry...............................................................................................................8

B.2. Event Service.................................................................................................................................................9

B.3.3. Comparison to the Java Security API.........................................................................................15

B.4. Other Key CORBA Services.......................................................................................................................16

Appendix C. JavaSpaces..................................................................................................................................17

C.1. Overview of JavaSpaces..............................................................................................................................17

C.2. Entry and EntryRep.....................................................................................................................................19

C.3. Transactions................................................................................................................................................20

C.4. The JavaSpace Interface..............................................................................................................................20

C.4.1. write()..........................................................................................................................................21

C.4.2. read()...........................................................................................................................................21

C.4.3. take()............................................................................................................................................21

D.3. The java.rmi.server Package.......................................................................................................................31

Preface................................................................................................................................................................40

0.1. What Does This Book Cover?........................................................................................................41

0.1.1. Organization....................................................................................................................41

0.2. Who Should Read This Book?........................................................................................................42

0.3. About the Source Code...................................................................................................................43

0.4. Conventions Used in This Book.....................................................................................................44

0.5. Acknowledgments...........................................................................................................................45

1.1. Anatomy of a Distributed Application............................................................................................46

1.2. Requirements for Developing Distributed Applications.................................................................47

1.3.2. Abstract Interfaces..........................................................................................................50

1.3.3. Platform Independence...................................................................................................51

1.3.4. Fault Tolerance Through Exception Handling...............................................................51

Using the Examples in Applets (Java Distributed Computing)

i

Table of Contents

Preface

1.3.5. Network Support.............................................................................................................51

1.3.6. Security...........................................................................................................................52

1.3.6.1. Runtime environment..................................................................................................58

1.3.6.2. Secure remote transactions..........................................................................................59

1.3.7. Multithreading Support...................................................................................................59

2.1. Sockets and Streams.......................................................................................................................60

2.1.1. IP Addressing..................................................................................................................62

2.3.1. Loading Classes from the Network................................................................................74

3.1. Why Distribute Objects?.................................................................................................................74

3.2. What's So Tough About Distributing Objects?...............................................................................75

3.2.1. Creating Remote Objects................................................................................................80

3.2.2. Remote Method Calls.....................................................................................................80

3.2.3. Other Issues.....................................................................................................................81

3.3.1. Object Interface Specification........................................................................................81

3.3.2. Object Manager...............................................................................................................82

3.3.3. Registration/Naming Service..........................................................................................84

3.3.4. Object Communication Protocol....................................................................................85

3.3.5. Development Tools.........................................................................................................86

3.5. CORBA...........................................................................................................................................88

3.5.4. Client Stubs.....................................................................................................................91

3.5.5. A CORBA Solver...........................................................................................................91

3.5.5.1. The IDL interface.........................................................................................................92

3.5.5.2. The client stubs............................................................................................................93

3.5.5.3. The server skeleton and implementation.....................................................................93

3.5.5.4. The Solver client..........................................................................................................93

3.5.5.5. Pulling it all together....................................................................................................94

3.6. Java RMI.........................................................................................................................................96

3.6.1. Remote Object Interfaces................................................................................................99

3.6.2. Server Implementations..................................................................................................99

3.6.3. The RMI Registry.........................................................................................................100

3.7.2. Other Differences..........................................................................................................103

3.7.3. The Bottom Line...........................................................................................................108

4.1. Thread and Runnable....................................................................................................................109

Using the Examples in Applets (Java Distributed Computing)

ii

Table of Contents

Preface

4.2. Making a Thread...........................................................................................................................109

4.2.1. Implementing Runnable................................................................................................110

4.2.2. Extending Thread..........................................................................................................111

4.3. Managing Threads at Runtime......................................................................................................111

4.3.1. Synchronizing Threads.................................................................................................112

4.3.2. Thread Groups..............................................................................................................112

4.3.3. Priorities........................................................................................................................117

5.2. The java.security Package.............................................................................................................120

5.2.1. Architectural Overview.................................................................................................123

5.2.1.1. The User API.............................................................................................................124

5.2.1.2. The Provider API.......................................................................................................126

5.2.2. The Core Security API..................................................................................................126

5.3. Identities and Access Control.......................................................................................................128

5.3.1. Access Control Lists.....................................................................................................128

5.4. Keys: Public, Private, and Secret..................................................................................................128

5.4.1. Secret Keys...................................................................................................................129

5.4.2. Public Key Methods......................................................................................................129

5.4.3. Keys in the Java Security API......................................................................................132

5.5.3. An Authenticating Credit Agent...................................................................................135

5.6.1. Ciphers for Secure Data Transfers................................................................................139

5.6.2. Back to Our Credit Agent.............................................................................................140

5.7. Choosing a Cryptographic Algorithm...........................................................................................143

5.7.1. Features of Cryptographic Algorithms.........................................................................143

5.7.1.1. Level of protection.....................................................................................................144

5.7.1.2. Sophistication and complexity...................................................................................145

5.7.1.3. One−, two−, and many−way cryptography...............................................................145

5.7.1.4. Design issues..............................................................................................................149

5.7.1.5. Financial and legal issues..........................................................................................149

5.7.2. Available Algorithms....................................................................................................149

5.7.2.1. Encryption techniques................................................................................................149

6.3. Message Processing......................................................................................................................151

6.3.1. Asychronous vs. Synchronous Message Handling.......................................................152

6.3.2. A Basic Message Processor..........................................................................................152

Using the Examples in Applets (Java Distributed Computing)

iii

Table of Contents

Preface

6.4.1. Heterogeneous Argument Lists....................................................................................154

6.4.2. Objects as Message Arguments....................................................................................154

6.4. Fixed Protocols.............................................................................................................................155

6.5. Adaptable Protocols......................................................................................................................156

6.5.1. Variable Number of Arguments...................................................................................156

6.5.2. Variable Message Argument Types..............................................................................157

6.5.3. Adaptable Message Types............................................................................................160

7.1. An Overview of JDBC..................................................................................................................174

7.1.1. Data Retrieval Example................................................................................................181

7.1.2. The API at a Glance......................................................................................................181

7.1.2.1. DriverManager...........................................................................................................181

7.1.2.2. Connection.................................................................................................................187

7.1.2.3. Statement...................................................................................................................189

7.1.2.4. ResultSet....................................................................................................................194

7.2.1. JDBC Driver Configurations........................................................................................194

7.2.2. Defining the Data Objects.............................................................................................194

7.2.3. A Scheduling Example.................................................................................................195

7.2.4. JDBC−Enabled Data Objects.......................................................................................195

7.2.6.2. Distributed objects from the data server....................................................................198

8.2. Coping with Limited Bandwidth..................................................................................................202

8.2.1. Monitoring Bandwidth..................................................................................................210

8.2.2. Managing Bandwidth....................................................................................................211

8.2.3. Levels of Monitoring and Management........................................................................211

8.4.1. Raw Data Monitoring...................................................................................................213

8.4.2. Real Data Monitoring...................................................................................................221

8.3. Scope of This Chapter...................................................................................................................224

8.4. Monitoring Bandwidth..................................................................................................................224

8.5. Bandwidth Management...............................................................................................................225

8.5.1. Streaming Multimedia..................................................................................................225

8.5.2. Web Browsing..............................................................................................................225

9.3. A Basic Collaborative Infrastructure............................................................................................237

9.3.1. Building the Infrastructure with Message Passing.......................................................242

9.3.2. Collaborating with RMI................................................................................................247

Using the Examples in Applets (Java Distributed Computing)

iv