Home > Store > Programming > Java

Component Development for the Java™ Platform

Register your product to gain access to bonus material or receive a coupon.

Component Development for the Java™ Platform

Book

  • Your Price: $31.99
  • List Price: $39.99
  • Usually ships in 24 hours.

Description

  • Copyright 2002
  • Dimensions: 7-3/8x9-1/4
  • Pages: 368
  • Edition: 1st
  • Book
  • ISBN-10: 0-201-75306-5
  • ISBN-13: 978-0-201-75306-6

Java™ is an object-oriented language, but it is also a component-oriented platform. Java's class-loading model and rich type information makes it possible to build flexible and reusable binary components. COMPONENT DEVELOPMENT FOR THE JAVA™ PLATFORM reveals both the potential and pitfalls of developing components using the Java platform.

As a platform, Java defines the services needed to connect binary components at runtime safely and reliably. To truly take advantage of all that Java has to offer, you must consider not just development but also deployment, and not just objects but also components. COMPONENT DEVELOPMENT FOR THE JAVA™ PLATFORM delves into the component-oriented features of the Java platform, thoroughly discussing class loading, reflection, serialization, native interoperation, and code generation.

KEY TOPICS INCLUDE HOW TO:

  • Use and troubleshoot Class Loaders
  • Build dynamic and generic services through reflection
  • Control an object's serialized representation
  • Load and use native code components
  • Extend the Java class format to add custom services
  • Automate development with code generation

This is a cutting-edge approach to Java programming: An emphasis on deployment can be the best way to take advantage of some of the most valuable, yet less heralded, aspects of Java technology.



0201753065B11212001

Sample Content

Online Sample Chapter

Java Type Information and Reflection

Downloadable Sample Chapter

Click below for Sample Chapter related to this title:
hallowaych03.pdf

Table of Contents



Preface.


1. From Objects to Components.


2. The Class Loader Architecture.

Assembling an Application.

Goals of the Class Loader Architecture.

Transparency.

Extensibility.

Capability @

Configurability.

Handling Name and Version Conflicts.

Security.

Explicit and Implicit Class Loading.

Explicit Loading with URLClassLoader.

Implicit Class Loading.

Reference Type vs. Referenced Class.

ClassLoader.loadClass vs. Class.forName.

Loading Nonclass Resources.

The Class Loader Rules.

The Consistency Rule.

The Delegation Rule.

The Visibility Rule.

Delegations as Namespaces.

Static Fields are Not Singletons.

Implicit Loading Hides Most Details.

Hot Deployment.

Using Hot Deployment.

Unloading Classes.

Making Sure Classes are Collectable.

Bootclasspath, Extensions Path, and Classpath.

The Classpath.

The Extensions Path.

The Bootstrap Loader.

Debugging Class Loading.

Instrumenting an Application.

Using -verbose:class.

Instrumenting the Core API.

Inversion and the Context Class Loader.

Onward.

Resources.



3. Type Information and Reflection.

The Binary Class Format.

Binary Compatibility.

Binary Class Metadata.

From Binary Classes to Reflection.

Reflection.

Reflecting on Fields.

The Difference between get and getDeclared.

Type Errors Occur at Runtime.

Reflecting on Methods.

Reflective Invocation.

A Reflective Launcher.

Wrapping Primitive Types.

Bypassing Language Access Rules.

Exceptions Caused by Reflective Invocation.

Dynamic Proxies.

Delegation Instead of Implementation Inheritance.

Dynamic Proxies Make Delegation Generic.

Implementing InvocationHandler.

Implementing a Forwarding Handler.

The InvocationHandler as Generic Service.

Handling Exceptions in an InvocationHandler.

Either Client or Server can Install a Proxy.

Advantages of Dynamic Proxies.

Reflection Performance.

Package Reflection.

Setting Package Metadata.

Accessing Package Metadata.

Sealing Packages.

Weaknesses of the Versioning Mechanism.

Custom Metadata.

Onward.

Resources.



4. Serialization.

Serialization and Metadata.

Serialization Basics.

Serialization Skips Some Fields.

Serialization And Class Constructors.

Using readObject and writeObject.

Matching Streams With Classes.

The serialVersionUID.

Overriding the Default SUID.

Compatible and Incompatible Changes.

Explicitly Managing Serializable Fields.

ObjectInputStream.GetField Caveats.

Writer Makes Right.

Overriding Class Metadata.

Performance Problems.

Custom Class Descriptors.

Abandoning Metadata.

Writing Custom Data After defaultWriteObject.

Externalizable.

Using writeObject to Write Raw Data Only: Bad Idea.

Object Graphs.

Pruning Graphs with Transient.

Preserving Identity.

Encouraging the Garbage Collector with Reset.

Object Replacement.

Stream-Controlled Replacement.

Class-Controlled Replacement.

Ordering Rules for Replacement.

Taking Control of Graph Ordering.

Finding Class Code.

Annotation in RMI.

RMI MarshalledObjects.

Onward.

Resources.



5. Customizing Class Loading.

Java 2 Security.

The Role of Class Loaders.

Custom Class Loaders.

Pre-Java 2 Custom Class Loaders.

Class Loading Since SDK 1.2.

A Transforming Class Loader.

Protocol Handlers.

Implementing a Handler.

Installing a Custom Handler.

Choosing Between Loaders and Handlers.

Getting Past Security to the Loader You Need.

Reading Custom Metadata.

Example: Version Attributes.

Serializable Classes as Attributes.

Reading Attributes During Class Loading.

Debugging Support.

Onward.

Resources.



6. Interop 1: JNI.

Why Interoperate?

The Dangers of Native Code.

Finding and Loading Native Code.

Name Mappings.

Type Mappings.

Overloaded Names.

Loading Native Libraries.

Class Loaders and JNI.

Common Errors Loading Native Libraries.

Troubleshooting Native Loading.

Calling Java from C++.

Minimizing Round Trips.

Performance Comparisons.

Differences Between JNI and Reflective Invocation.

Error Handling in JNI.

Failures in Native Code.

Handling C++ Exceptions.

Handling Java Exceptions from Native Code.

Throwing Java Exceptions from Native Code.

Resource Management.

Interacting with the Garbage Collector.

Managing Native Resources.

Managing Arrays.

Managing Strings.

Onward.

Resources.



7. Generative Programming.

Why Generate Code?

Object Oriented Approaches to Modeling Variabilities.

Thinking in Terms of Bind Time.

Separating Specification From Bind Time.

Choosing a Specification Language.

Reuse Requires More than One Use.

A Little Domain Analysis is a Dangerous Thing.

Why Generate Code with Java?

Type Information Acts As a Free Specification Document.

Class Loading Supports Flexible Binding Modes.

Java Source is Easy To Generate.

Java Binary Classes are Easy To Generate.

Code Generation Boosts Performance.

Levels of Commitment to Code Generation.

A Taxonomy of Bind Times and Modes.

Code Generation in RMI.

Code Generation in JSP.

Code Generation in EJB.

The Deployment Descriptor.

Alternate Implementations.

Generating Strongly Typed Collections.

Code Generation Language versus Target Language.

Generating Custom Serialization Code.

Onward.

Resources.



8. Onward.

Where We Are.

Where We Are Going.

Resources.



Appendix—Interop 2: Bridging Java and Win32/COM.


Index. 0201753065T11262001

Preface

This book is about developing components using the Java platform. In this book, the term component has a very specific meaning. A component is an independent unit of production and deployment that is combined with other components to assemble an application.

To elaborate on this definition, consider the difference between objects and components. An object represents an entity in the problem domain, while a component is an atomic piece of the installed solution. The object and component perspectives are complementary, and good designs take account of both.

Modern development platforms such as Java provide the infrastructure that developers need to create classes and components. To support object-oriented programming, Java provides encapsulation, inheritance, and polymorphism. To support components, Java provides loaders and rich type information. This book assumes that you already understand object-oriented programming in Java, and it explains how to use Java's component infrastructure effectively.

Loaders are responsible for locating, bringing into memory, and connecting components at runtime. Using Java's loaders, you can

  • Deploy components at fine granularity.
  • Load components dynamically as needed.
  • Load components from other machines on the network.
  • Locate components from custom repositories.
  • Create mobile code agents that live across multiple virtual machines.
  • Import the services of non-Java components.

Loaders manage the binary boundaries between components. In a world of distributed applications and multiple component suppliers, loaders locate and connect compatible components.

Type information describes the capabilities of some unit of code. In some development environments type information is present only in source code. In Java, type information is not merely a source code artifact; it is also an intrinsic part of a compiled class and is available at runtime through a programmatic interface. Because Java type information is never "compiled away," loaders use it to verify linkages between classes at runtime. In application programming, you can use type information to

  • Serialize the state of Java objects so that they can be recreated on another virtual machine.
  • Create dynamic proxies at runtime, to provide generic services that can decorate any interface.
  • Translate data into alternate representations to interoperate with non-Java components.
  • Convert method calls into network messages.
  • Convert between Java and XML, the new lingua franca of enterprise systems.
  • Annotate components with application-specific metadata.
Type information automates many tasks that might otherwise be coded by hand, and it helps to make components forward compatible to platforms of the future.

Who Should Read This Book

You should read this book if you want to design, develop, or deploy substantial applications in Java. Taking a full-lifecycle view of a Java application requires that you consider not just objects, but components. This book is about the core features of Java as a component platform: class loaders, reflection, serialization, and interoperation with other platforms. You should already know the basics of Java syntax and have some experience in object-oriented programming with Java.

This book is not specifically about high-level Java technologies, such as Remote Method Invocation (RMI), Enterprise JavaBeans (EJB), JINI, Java Server Pages (JSP), servlets, or JavaBeans, but understanding the topics in this book is critical to using those technologies effectively. If you learn how to use the component services described here, you will understand how these high-level technologies are built, which is the key to employing them effectively.

Security is also an important aspect of component development and deployment. It is too complex a topic to handle fairly here, and it deserves its own book-length treatment. (See Gon99 for coverage of security on the Java platform.)

Organization of the Book

The chapters of this book fall into three sections. Chapter 1 introduces components. Chapters 2 through 6 explain loaders and type information on the Java platform. Chapter 7 shows more advanced uses of these services.

Chapter 1 introduces component-oriented programming. Component relationships must be established not only at compile time, but also at deployment and runtime. This chapter asks the key questions of component programming and relates them to the Java platform services discussed in subsequent chapters. Though the other chapters might be read out of order, you should definitely read this chapter first.

Chapter 2 shows how to use and troubleshoot class loaders. Class loaders control the loading of code and create namespace boundaries between code in the same process. With class loaders you can load code dynamically at runtime, even from other machines. Class loader namespaces permit multiple versions of the same class in a single Java virtual machine. You can use class loaders to reload changed classes without ever shutting down the virtual machine. You will see how to use class loaders, how the class loader delegation model creates namespaces, and how to troubleshoot class loading bugs. You will also learn to effectively control the bootclasspath, extensions path, and classpath.

Chapter 3 introduces Java type information. Java preserves type information in the binary class format. This means that even after you compile your Java programs, you still have access to field names, field types, and method signatures. You can access type information at runtime via reflection, and you can use type information to build generic services that add capability to any object. You will see how to use dynamic invocation, dynamic proxies, package reflection, and custom attributes. Chapter 3 also includes a discussion of reflection performance.

Chapter 4 shows how Java serialization uses reflection. Serialization is a perfect example of a generic service. Without any advance knowledge of a class's layout, serialization can ship both code and state from one virtual machine to another across time or space. You will see how the serialization format embeds its own style of type information and how you can customize that representation. You will also see how to extend default serialization, replace it entirely with custom externalization code, or tune it to handle multiple versions of a class as code evolves. You will then learn how to validate objects being deserialized into your application and how to annotate serialized objects with instructions for finding the correct class loader.

Chapter 5 returns to class loaders and shows you how to implement your own. While the standard class loaders are dominant in most applications, custom class loaders allow you to transform class code as classes are loaded. These transformations could include decryption, adding instrumentation for performance monitoring, or even building new classes on-the-fly at runtime. You will see how to tie your custom class loaders into Java's security architecture, how to write a custom class loader, and how to write protocol handlers that can customize not just how you load classes, but also how you load any other type of resource.

Chapter 6 presents the Java Native Interface (JNI) as a basic means of controlling the boundary between Java code and components written in other environments. JNI provides a set of low-level tools for exposing Java objects to platform native code and native code to Java objects. You will learn to use the JNI application programming interface (API) to translate between Java and native programming styles—which differ markedly in their approach to class loading, type information, resource management, error handling, and array storage. Understanding the deficiencies of JNI sets the stage for Appendix A, which describes a higher-level approach.

Chapter 7 discusses using Java metadata to automate the creation of source code or bytecode. Generated code is a high-performance strategy for reuse because you generate only the exact code paths that you will need at runtime. The chapter first presents JSP and EJB as examples of existing applications that auto-generate code, and then it introduces some ideas for code generation in your own programs.

Appendix A returns to interoperation. By building on the code generation techniques from Chapter 7, Appendix A shows you how to build an interoperation layer between Java and another component platform: Win32/COM. This chapter uses the open source Jawin library as an example, to show you how to generate Java stubs for Win32 objects, and vice versa.

Sample Code, Website, Feedback...

Unless specifically noted otherwise, all the sample code in this book is open source. You can download sample code from the book's website at http://staff.develop.com/halloway/compsvcs.html.

Unless otherwise noted, the code in this book is compiled and tested against the Java 2 Software Development Kit (SDK) version 1.3. Most of the code in the book will work identically under SDK versions 1.2, 1.3, and 1.4. Where this is not the case, the text will include a specific reference to the appropriate SDK version.

The author welcomes your comments, corrections, and feedback. Please send email to stu@develop.com.



0201753065P11212001

Bibliography

Download the Bibliography related to this title.

Index

A

Abandoning metadata, 124-130
Abstract classes, 61
Abstract methods, 61
AccessControlException class, 78, 157, 177
AccessibleObject class, 77, 215
Account object, 263
Accounts class, 263
Activatable class, 150
AddRef method, 293
AllocHandle, 231
AllocObject class, 216-217
AnnotateClass method, 147
AnnotatedOutputStream class, 148
Annotating components, XVI
Apartments, 297
App library, 200
AppClassLoader, 45
Applets, 25-26
Application class, 22
Application class loader, 37
Applications
assembling, 11-14
assembling with components, 3
bypassing or ignoring settings, 14
configuration settings, 12
data resources, 12
dynamic, 12
growing and evolving, 4-5
instrumenting, 44-45
linking correctly, 13-14
looking for resources, 13
modifying, 12
sharing components, 11
splitting into components, 11-12
ArrayList, 142
Arrays
incrementing elements, 234
Java definition of, 233
managing, 233-239
pinning, 236
read-only traversal, 236-237
storing, 233, 235
Assembling
applications, 11-14
components, 12
ATL (Active Template Library), 307
Attribute class, 102, 181
attribute_info structure, 99
Auctioneer interface, 244
AuctioneerImpl class, 245
Audit class, 84
Automating tasks, XVI

B

Base interface loaded implicitly, 34
Base class fields and serialization, 109
Binary boundaries between components, XVI
Binary classes, 58, 66, 252
data structures, 64-65
introspecting against, 57
metadata, 63-64
Binary compatibility, 58-62
Bind modes, 251, 253-255
Bind times, 244, 246-247, 251, 253-255
changing priorities, 249
separating specification from, 247-249
blowUpWorld method, 59
BMovie class, 58-61
Bootclasspath, 41-43
Bootstrap class loader, 36, 41-43, 48
Boss class, 141, 146

C

C++
calling Java from, 208-217
exception handling, 218-219
method declarations, 196
parameters with multiple levels of indirection, 196
Call stack logging, 46
Callee class, 189
Caller class, 189
Caller class loader, 21
CallVoidMethod method, 213, 219
CallVoidMethodA method, 221
Capability, 16
CauseConfusion methods, 199
CComBSTR class, 307
Chars API, 239
checkPermission method, 299
Child loader and classes, 49
Circular reference problems during resolution, 141-142
Class class, 21, 67-68, 70, 123
Class loader architecture, 5, 11
assembling applications, 14
capability, 16
configurability, 16
explicit class loading, 19
extensibility, 15-16
goals, 14-17
handling name and version conflicts, 16-17
security, 17
transparency, 15
Class loader delegation model, 5
Class loaders, 11, 14, 55, 281
applet, 25
caller's, 21
choosing, 174-175
configuration options, 36
consistency rule, 23-24
context, 5
crossing boundaries, 72
custom, 5, 153-190
delegation, 24-25, 27
effective use of, 14
exotic designs, 15-16
explicit use of, 29
getting past security to, 175-177
hierarchy, 52
holding cache of classes, 35-36
hot deployment, 29-34
installing all classes under, 52
instantiating, 53, 177
interaction with, 36
inversion, 49-55
JNI (Java Native Interface), 202-204
keeping in memory, 36
limited sharing of classes, 25
loading arbitrary resources, 22-23
meeting common needs, 16
memory, 35
multiple versions of native code, 203
overriding findLibrary method, 202
parent, 24
role, 157-159
rules, 23-29
security hole, 177
since SDK 1.2, 160-162
source-aware, 23
system, 25
transforming, 162-167
visibility rule, 25-26
Class loading, 55
capable, 16
debugging, 43-49
dynamic, 28-29, 251
easily configurable, 16
errors, 28
explicit, 18-23
implicit, 19-23, 24, 29
name conflicts, 16-17
reading attributes during, 183-188
supporting flexible binding modes, 251
version incompatibilities, 16-17
Class object, 18, 35
ClassCastException class, 144
Class-controlled object replacement, 137-139
Classes
already-loaded, 23-24
child loader, 49
compatibility, 66
compatible and incompatible changes, 117-118
configuring loading, 36-43
core, 25
customizing descriptors, 124
deploying multiple versions simultaneously, 17
diagnosing loading problems, 44
discovering fields, 68
dynamic proxies, 57
dynamically discovering characteristics, 66
dynamically loading, 19
extensible loading, 15-16
extensions path, 39-41
externalizable, 125-127
finding code, 147-150
garbage collecting, 36-37
in class loader hierachy, 50
incremental changes, 30
invisible, 60
loaded at different times, 27
loaded by bootstrap class loader, 41
loaded from classpath, 41
loaded from different locations, 27
loading, 37-39
loading resources for, 5
loading wrong version, 28
locating, 5, 38-39
matching streams with, 113-118
memory, 35
naming rule, 16-17
nonexistent, 60
overwriting metadata, 122-123
package names, 16
parent loader, 49
permissions, 155-157
postponing linking, 21
preventing creation of multiple instances, 28
public methods, 69
referencing nonexistent or invalid entry, 60
referencing other classes, 49
referring to another class, 19
relationship between old and new versions, 34
sealed JAR files, 178
security, 25, 41
separating serialized form from in-memory representation, 138
serializable, 106-109
serving old version, 17
tracing loading, 45
type information, 67
unintended references, 35
unloading, 35-36
verified, 41
version-reconciliation, 5
versions, 14
visibility, 23
ClassEx file, 102
ClassFormatError, 166
Class-level metadata, 94
Class-level object replacement, 137-140
Class-level resolution, 140
ClassLoader class, 17-18, 20-21, 95, 147, 153, 158-159, 175-176
checking another path, 202
convenience constructor, 25
modifications, 160-161
ClassLoader object, 35
ClassNotFoundError class, 43
ClassNotFoundException class, 18, 19, 113
ClassNotter class, 165-167
Class-oriented design, 3
Classpath class loader, 36, 37-39
-classpath command-line switch, 37-38
CLASSPATH environment variable, 37, 38
Client applications, 2
Client class, 61-62
Client code, 30
Clients, 33
installing dynamic proxies, 90-91
reference of base class or interface type, 34
reference of implementation type, 34
state of original object available to server factory, 34
Close method, 133, 232
close method, 302
Code
bind times, 244, 246-247
choosing specification language, 249
commonalities, 243-244
controlled sharing, 28
domain analysis, 243
ease of generating, 251
generation, 5-6
generation boosting performance, 252
generation language, 270-271
high in class loader hierarchy, 50
integrity endangered, 24
in-the-large generation, 252-253
Code (con't.)
in-the-small generation, 253
levels of commitment to generation, 252-253
loading, 36
reasons for generating, 243-250
reuse requiring multiple use, 249
RMI (Remote Method Invocation) generation, 255-257
separating specification from bind time, 247-249
sharing, 5
trusted, 175
Code attribute, 101
CodeBase attribute, 155
Collections
generic, 267
strongly-typed, 267-271
COM (Component Object Model), 285-286, 290-291
apartments, 297
context model, 297
error handling, 295-296
GUID (Globally Unique ID), 291
local loader, 291-292
object lifecycle, 293-294
platform impedance, 290
security, 298-299
stubs, 297
thread affinity, 296-298
type discovery, 294-295
type information, 292-293
com.develop package, 269
com.develop.benchmark package, 92
com.develop.hello package, 95
com.develop.jawin.tools package, 311
Com.develop.version.audit property, 188
COMException class, 295-296, 310
Commonalities, 243
Compilers and custom virtual machine attributes, 101
Compile-time binding, 247
Component approach, 3, 6-9
Component-oriented design, 3
Components, XV, 3
annotating, XVI
binary boundaries between, XVI
bloated, 5-6
class loaders, 281
concurrency protection mechanisms, 297
control over fitting together, 12-13
deployment, 12-13
EJB (Enterprise JavaBeans), 264-265
extending, 6
loading configuration information, 5
locating, 12
mobile, 105
multiple versions, 12
non-Java, XVI
platforms, 12
rogue, 12
sharing, 11
splitting applications into, 11-12
thread-affine, 296-297
type information, 281
unable to find, 12
COMSharedStubBuilder class, 311
COMSharedStubDriver class, 311, 314
Configurability, 16
Connect method, 170
Consistency rule, 23
breaking, 24
forbidding unloading and reloading from single loader, 31
implicit class loading, 29
Constant pool, 63-64
ConstantValue attribute, 101
Constructor class, 72-73, 77
Constructors
serialization, 110-111
throwing exception, 82
Contact interface, 1-2
Contact management domain, 6-9
Contact management systems, 1
ContactFinder interface, 1-2
Contacts, 2
Containers
code generation, 266-267
EJB (Enterprise JavaBeans), 264-265
Container-transaction element, 263
Context class loader, 5, 49-55
Context loader, 53
Context model, 297
contextLocalize method, 298
CORBA, 197
Core API
classes, 26, 46
instrumenting, 46-49
loading packages, 41
protecting integrity, 26
Core classes, 25
recompiling subset, 42
replacing, 42, 49
Core packages, loading, 36
-cp command-line switch, 37-38
createClassLoader method, 158
createPoint method, 31
Critical APIs, 237-238, 239
Critical array API, 239
Critical region, 238
Critical string API, 239
Cross-platform communication, 6
CrunchArray method, 292
current directory (.), 19
custom attributes, 5
Custom class loaders, 5, 153-190
adding configuration options, 16
pre-Java 2, 159
Custom metadata, 98-102
debugging support, 188-189
reading, 177-189
reading attributes during class loading, 183-188
serializable classes as attributes, 179-182
version attributes classes, 178-179
Custom serialization code, 271-276
Custom type formats, 300
Customizing class descriptors, 124

D

Data
alternate representations, XVI
structures and binary classes, 64-65
Data(N) classes, 149
DataInput interface, 124
DataOutput interface, 124, 130
DCOM, 197
Debugging
custom metadata support, 188-190
replacing core classes, 42
Debugging class loading
instrumenting Core API, 46-49
tracing class loading, 45
-verbose:class flag, 45
Default field data, 119
DefaultReadObject method, 119, 120
DefaultWriteObject method, 124-125, 128, 129
Defective PointImpl listing, 30defineClass method, 158-162, 165, 187, 216
definePackage method, 95
delegate method, 88-89
Delegation rule, 24-25
Delegation, 25
of class loaders, 24-25, 27
generic, 84-85
instead of implementation inheritance, 83
as namespaces, 27
object-oriented design, 5
delete method, 156
DeleteGlobalRef method, 225-226
DeleteLocalRef method, 226-227, 229
DemoLogging class, 85-86
Deployer, 13-14
Deployment
discouraging analysis of, 4
simplify, 23
Deployment descriptor, 263-265
Deployment-time binding, 247
deposit method, 262, 263
Deserialize-on-demand, 149-150
Deserializing objects, 113
Design-time binding, 247
Developer's machine, 4
Development environments, XVI
DiplomaticContact interface, 3
Directories and extensions path, 40
-Djava.security.manager flag, 156
DLLs (Dynamic Link Libraries)
error reporting, 302
loader architecture, 299-300
object lifecycle, 301-302
security, 303
thread affinity, 302
type discovery, 302
type information, 300-301
doGet method, 257-258
Domain analysis, 5, 243, 250
Dynamic applications, 12
Dynamic bind mode, 254
Dynamic bindings, 251
Dynamic class loading, 28-29, 251
Dynamic proxies, XVI, 57, 251, 254, 256-257, 565
advantages, 91
generating on-the-fly, 91
Dynamic proxies (con't.)
generic delegation, 84-85
implementing forwarding handler, 86-87
implementing InvocationHandler interface,
85-86
installed by client or server, 90-91
InvocationHandler interface as generic service, 87-89
method call forwarding, 87
reflective invocation, 83

E

Early binding, 252
Earth singleton, 138
Echo1 class, 65
Eiffel programming language, 16
EJB (Enterprise JavaBeans), XVII, 254
alternate implementations, 265-267
bean object, 261
containers, 264-265
deployment descriptor, 261, 263-265
entity beans, 260
generic classes, 265
home interface, 260, 261
remote interface, 260, 261
serialization, 105
session beans, 260
skeletons, 264
stubs, 264
Element array API, 235-236, 239
Enable methods, 134
Encapsulation, XV
EnsureLocalCapacity API, 230
EnsureLocalCapacity method, 228-229
Enterprise applications, 282
Entity beans, 260
Environment variables, 201-202
equals method, 86
Error 82, 205
Error handling
COM (Component Object Model), 295-296
JNI (Java Native Interface), 217-223
Errors and class loading, 28
Exception class, 295
ExceptionCheck method, 219-221
ExceptionClear method, 220, 223
ExceptionOccurred method, 219-221
Exceptions
declared and binary compatibility, 61-62
handling with InvocationHandler interface, 89
reflective invocation, 81-83
Exceptions attribute, 101
Explicit class loading, 18-23
Explicit loading APIs, 21
Explicitly
loading from URL, 18
managing serializable fields, 119-124
ExtClassLoader, 45
Extensibility, 15-16
Extensions, loading, 36
Extensions class loader, 36, 48
Extensions loader, 39-40, 45
Extensions path, 39-41
Externalizable class, 125-127
Externalizer class, 271, 273

F

Field class, 72-73, 77
Fields, 60
File URL, 18
FilePermission permission, 155, 157
final class, 61
final fields, 79-81
finalize method, 232, 293, 294, 301, 302
finally block, 232
FindBestMatch method, 229-230
FindClass method, 102, 160, 165, 183, 216, 219, 226
FindContact interface, 1
Finding class code, 147-150
findLibrary method, 202
FindResources method, 183
Flexible binding modes, 251
Foo class, 43
ForgetToLoadLibrary class, 205
FormatMessage function, 295, 302
forName method, 21, 216
Forwarding handler, implementing, 86-87
FuncPtr function, 310
Function pointers, 72

G

Garbage collector, 35
classes, 36-37
encouraging, 132-133
interacting with, 224-231
local references, 224
gc method, 204
Generating stubs, 311-316
GeneratorBase class, 271
Generators, 247-248, 249
Generic collections, 267
Generic delegation and dynamic proxies, 84-85
Generic interceptors, 83
Generic services, XVI, 87-89
Generic skeletons, 256
Generic stubs, 308
get method, 72
GetAnswer method, 194, 197
getBadDateValue method, 90
getClass method, 35
getClassLoader method, 19, 35, 41
GetContentType method, 170
GetDate method, 170
getDeclared method, 72
getDeclaredField method, 70-71, 210
getDeclaredFields method, 69
getDeclaredXXX accessor method, 68-70
GetErrorInfo function, 295
getExpiration method, 170
GetField class, 121, 275
getField method, 70-71, 123-124, 210
GetFieldID method, 210
getFields method, 69
getGoodDateValue method, 90
getInputStream method, 170
GetIntArrayElements method, 236, 237
GetIntArrayRegion method, 235
getInterfaces method, 67
GetLastError function, 302
getMethod method, 73, 75
GetMethodID method, 213
getModifiers method, 69-70
getOutputStream method, 170
getParent method, 24, 44
GetPrimitiveArrayCritical method, 238
GetProcAddress function, 299, 310
getProtectionDomain method, 162
GetRegion method, 240
getResource method, 22, 165
getResourceAsStream method, 22
getResources method, 22
getSuperclass method, 67
getSystemClassLoader method, 25
getTargetException method, 82
GetTokenInformation Win32 API, 300-301, 302
getURLBase method, 165
getVersionInfo method, 187
getXXX accessor method, 68-70
Global references, 224-225, 226
GP (generative programming), 243
binary classes, 252
bind modes, 253-255
bind times, 253-255
class loading supporting flexible binding modes, 251
code generation boosting performance, 252
code generation language, 270-271
custom serialization code, 271-276
domain analysis, 250
ease of generating Java source code, 251
EJB (Enterprise JavaBeans) code generation, 260-267
generating stubs, 311-316
inputs and outputs, 254-255
JSP (Java Server Pages) code generation, 257-260
levels of commitment to code generation, 252-253
marshalling architecture, 303-311
reasons for generating code, 243-250
strongly-typed collections, 267-271
target language, 270-271
type information as free specification document, 250-251
GUID (Globally Unique ID), 291

H

Handler class, 169, 174
hashCode method, 86
HashMap class, 24
Header files, 300
Hello.jsp servlet, 257, 258-259
Helper components, 253
Hot deployment, 29-34
HRESULT type, 295
Humanoid class, 106-107, 113

I

IDL (Interface Definitions Language), 292-293
IDL files, 300
IIDs, 294
IllegalAccessException class, 78, 81
IllegalArgumentException class, 81, 226
Implementation class, 34
Implicit class loading, 19-23, 24, 29
Implicit class references, 20
InadequateNationalInfrustructure class, 61
Incompatible changes, 62
IncompatibleClassChangeError class, 60
Infoset, 282
Inheritance, XV
delegation instead of, 83
extensible design with, 2
modeling variabilities, 245-246
multiple, 83
object-oriented design, 5
InnerClass attribute, 101
Installed optional packages
completely trusted by virtual machine, 40-41
loading, 39-41
security, 40-41
InstantiationException class, 81
Instruction strings, 309-311
Instrumenting
applications, 44-45
core API, 46-49
int return type, 197
Integer class, 75
Integer.class class, 75
Integer.TYPE class, 75
Interceptors, 83
Interface stubs, generating, 314-316
Interfaces, 72, 294
Internal name collisions, 17
Intrinsic functions, 307
Introspecting against binary classes, 57
Introspection, 57
InvalidClassException class, 116, 118, 123
Invariants, 16
Inversion
avoiding problems, 50
context class loader, 49-55
InvocationHandler interface, 87, 254
as generic service, 87-89
handling exceptions, 89
implementing, 85-86
InvocationHandler.invoke method, 87
InvocationTargetException class, 82, 89
invoke method, 86, 87, 265
isCompatibleWith API, 96
ItemImpl class, 246
itf1 variable, 295
itf5 variable, 295
itfs array, 85
ITypeInfo interface, 292
ITypeLib interface, 292
IUknown interface, 293

J

J2EE implementation, 53
-jar command-line switch, 38
JAR files
adding version information, 95-96
extensions loader, 40
sealing packages, 97
Java
accessing code libraries not written in, 192
accessing platform-specific resources, 192
calling from C++, 208-217
code and dotted notation, 63-64
converting to XML, XVI
direct access to system memory, 191-192
hand-tuned, peak performance code, 192
IDE wizards, 72
loaders, XV-XVI
memory protections, 193
multiple inheritance, 196
passing parameters by value, 196
reasons for generating code, 250-253
serialization, 5
tasks ill-suited for, 191-192
type information, XVI
WORA (write-once, run-anywhere), 191
Java 2 SDK, XIX, 118
Java launcher, 230
Java Reflection API, 57, 66-72, 101-102
Java Virtual Machine Specification, 103
JavaBeans, XVII, 66-67, 105
javah utility, 199, 206-207
java.io.DataOutputStream stream, 114
Java.io.Externalizable class, 125
java.io.File.pathSeparatorChar constant, 38
java.io.NotSerializableException class, 108
java.io.ObjectOutputStream wrapper stream, 108
java.io.Serializable interface, 106
java.lang package, 75
java.lang.Class class, 67, 102
java.lang.ClassLoader class, 207-208, 216
java.lang.IllegalArgumentException class, 226
java.lang.Package class, 94
java.lang.reflect package, 67
java.lang.reflect.Constructor class, 216
java.lang.reflect.Field class, 68
java.lang.reflect.Method class, 71
java.lang.reflect.Modifiers class, 70
java.lang.String class, 64
java.library.path system property, 201-202
java.net.URL class, 168
java.net.URLConnection class, 169
java.net.URLStreamHandler class, 169
javap utility, 65
java.policy file, 41
java.protocol.handler.pkgs property, 173
java.rmi.MarshalledObject class, 150
java.rmi.RemoteException class, 289
java.security.AccessControlContext class, 158
java.security.CodeSource class, 155
java.security.Permission class, 155
java.security.Policy class, 155
java.security.ProtectionDomain class, 158
java.security.SecureClassLoader class, 161-162
java.util package, 267
java.util.Date class, 87-88
java.util.Stack class, 269
JavaVM pointer, 218
Jawin, 285
COM threading rules, 298
instruction strings, 310-311
translucent stubs, 286-289
Win32 stubs, 301
JCFE (Java Class File Editor), 102, 181
JconstructorID type, 216
JCP (Java Community Process), 282
JINI, XVII, 105
jint return type, 197
JNDI (Java Naming and Directory Interface), 262
JNI (Java Native Interface), 6, 79, 191, 285-286
APIs for field access, 210
APIs for method access, 213
array region APIs, 234
calling C-style API, 212
calling Java from C++, 208-217
class loader and construction functions, 216
class loaders, 202-204
cross-platform standard, 193
error handling, 217-223
finding and loading native code, 194-208
handling C++ exceptions, 218-219
handling Java exceptions from native code, 219-222
improving performance by precalculating jfieldIDs, 211-212
jobject references, 224
layer of indirection, 195
loading native libraries, 199-202
minimalist mapping from Java types to C++ types, 197
minimizing round trips, 211-213
name mappings, 195
name-mangling scheme, 198
overloaded names, 198-199
passing arrays, 233
performance comparisions, 214
reflection, 215
reflective invocation and, 214-217
resource management, 223-240
stubs, 287
throwing Java exceptions from native code, 222-223
troubleshooting native loading, 207-208
type mappings, 195-197
virtual machine, 192
JNI_ABORT flag, 236-237
JNI_COMMIT flag, 236-237
JNICALL macro, 197
JNIEnv type, 197, 208, 218, 222-223
JNIEnvUtil class, 221, 222
JNIEXPORT macro, 197
JNI_OnLoad method, 212, 220-221, 222, 226
JNI_OnUnload method, 226
JNI_VERSION_1_2 method, 212
jobject references, 224
jobject type, 197, 208, 210
JSP (Java Server Pages), XVII, 251, 253, 254
code generation, 257-260
generator language for Java, 270-271
strongly-typed stack classes, 268-269
_jspService method, 258

L

Late binding, 252
Launcher and command line processing, 39
LaunchVehicle interface, 98-99
LD_LIBRARY_PATH environment variable, 201
LICENSE file, 49
LineNumberTable attribute, 101
Linking
application correctly, 13-14
methods at runtime, 59
native libraries, 199-202
with full paths, 200
ListBaseTypes class, 67
ListByLastName console client, 2
ListMostFields class, 69-70
LittleEndianOutputStream, 310
load method, 200-202
loadClass method, 21, 47, 159-161
LoaderDemo class, 19, 27-28
Loading native libraries, 199-202
LoadLibrary Win32 function, 310
loadLibrary method, 200-202, 205-206, 299
LoadMe class, 19, 20, 27-28
LoadMeAlso class, 20
LoadMeBase class, 20
LoadMeThree class, 20
LoadMeToo class, 20
LoadNonExistentLibrary class, 205
LoadTheWrongLibrary class, 206
Local references, 224, 226, 227
LocalVariableTable attribute, 101
Locating components, 12
logConstructor method, 46
Logging call stacks, 46
LoggingHandler class, 85-86

M

-m switch, 95
MadScientist class, 58-61
Main class, 49
Mars singleton, 138
MarshalledObject class, 150
Marshalling architecture, 6, 286-287
generic stubs, 308
instruction strings, 309-311
shared stubs, 303-307
Message object, 149
MessageBoxW function, 300, 309-311
Metadata, 57, 66
abandoning, 124-130
accessing from packages, 96
binary classes, 63-64
binary compatibility, 58-62
class-level, 94
correct units for numeric arguments, 98
custom, 98-102
externalizable classes, 125-127
overwriting, 122-123
reading custom, 177-189
serialization, 105-106
setting for packages, 95-96
skipping, 127
supplementing, 197
tables of allowable state transitions, 98
version information, 94
Method class, 71, 72-73, 77, 256, 257
Methods
call forwarding, 87
converting to network messages, XVI
invalid arguments, 81
invisible, 60
linking at runtime, 59
nonexistent, 60
overloaded, 198
reflection, 71-72
small-grained, 211
throwing exception, 82
virtual and non-virtual invocation, 215
midl compiler, 292
Mobile components, 105
Modifying applications, 12
Money class, 263
Moving corrected PointImpl, 33
MTA (multi-threaded apartment), 297
Multiple inheritance, 83, 196

N

Name conflicts, 16-17
Name mappings, 195
Namespaces, delegations as, 27-28
Naming rule, 16-17
Native code
bypassing language protection modifiers, 193
calling Java constructor, 216
dangers of, 193-194
failures, 217-218
finding and loading, 194-208
global references, 224-225
handling Java exceptions, 219-222
loading, 204
reflective access, 209
throwing Java exceptions, 222-223
type-safety, 193
native keyword, 194
Native libraries
common errors loading, 205-207
loading, 199-202
loading old version, 204
troubleshooting loading, 207
visible across all class loaders, 203
Native methods
instantiating Person class, 79
loading, 200
populating fields, 81
shared stubs implementation, 305-306

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership