Java Reflection in Action

Description:

You are a Java developer. You are asked to add a simple feature to your application. But "simple" can be deceiving: you have to make many changes, in locations which can be difficult to find.

If this sounds familiar, you want to know about Java reflection. With reflection, you can work smarter by designing flexible applications to which you can easily add likely new requirements. Then, with a few code changes in easy-to-find places, you've got the job done. Reflection adds a new dimension to your programming skills. It will boost your effectiveness.

Java Reflection in Action starts from the basics. It gradually builds a complete understanding, adding as it goes reflective concepts illustrated with many small examples that are useful in real applications.

In a subplot, the book follows a programmer, George, as he tackles common but difficult tasks. In each case, George finds flexible, reflective solutions that replace the usual hard-coded ones. The power of reflection becomes clear through his story.

 

Table of Contents:

preface xiii
acknowledgments xv
about this book xvii
about the title xx
about the cover illustration xxi

1 A few basics 1

Reflection's value proposition 3

Enter George the programmer 4

Choosing reflection 5 - Programming a reflective solution 6

Examining running programs 8

Finding a method at runtime 10

Representing types with class objects 12

Representing primitive types 13 - Representing interfaces 13 - Representing array types 14

Understanding method objects 14

Using dynamic invocation 15 - Using primitives with dynamic invocation 16 - Avoiding invocation pitfalls 17

Diagramming for reflection 19

Navigating the inheritance hierarchy 20

Introspecting the inheritance hierarchy 22 - Exposing some surprises 23 - Another reflective circularity 24

Summary 26
 

2 Accessing fields reflectively 27

Serializing objects 28

Serializing to XML 29 - Choosing reflection 30 - Designing serialization with reflection 30

Finding fields at runtime 31

Understanding field objects 33

Getting and setting field values 34

Examining modifiers 35

Introducing Member 36 - Interface introspection pitfall 37 - Introspecting for instance variables 37

Accessing nonpublic members 38

Working with arrays 40

Serialization: putting it all together 41

Serializing each component 43 - Serializing instance variables 43

Using reflective serialization 45

Summary 48
 

3 Dynamic loading and reflective construction 49

George's deployment problem 50

Designing with patterns 51 - Programming a reflective solution 52 - Enhancing the factory method with reflection 54 - Combining - benefits of delegation and reflection 54

Loading classes dynamically 55

Basics of forName 55 - Getting array classes 56 - Primitives and forName 56

Constructing objects reflectively 57

Reflective construction basics 57 - Using constructor objects 57 - Constructing arrays reflectively 59

Designing for dynamic loading 60

Disadvantages of reflective construction with arguments 61 - Initializing through an interface 62

Implementing deserialization 63

Initiating deserialization 64 - Constructing the instances 65 - Restoring the object structure 66

George's serialization: limitations 69

No interaction with readObject or writeObject 69 - No handling of final instance variables 70 - Only no-argument constructors 70 - No handling of illegal XML characters 70 - Performance 71

Summary 71
 

4 Using Java's dynamic proxy 73

Working with proxies 74

George's tracing problem 76

Exploring Proxy 77

Understanding invocation handlers 79 - Handling the methods of Object 80

Implementing a tracing proxy 81

A note on factories 84

Chaining proxies 86

Structuring invocation handlers for chaining 86 - Implementing a synchronized proxy 88 - Chaining the two proxies 89

Stubbing interfaces for unit testing 90

Examining stubs 90 - Design for stubbing with Proxy 91 - Implementation of stubbing with Proxy 93

Generating SOAP remote proxies 99

Pitfalls of using Proxy 103

Summary 105
 

5 Call stack introspection 107

George's logging problem 108

Performing call stack introspection 111

Logging with call stack introspection 112

Pitfalls 114

Class invariant checking 115

Summary 120
 

6 Using the class loader 121

George's test problem 122

Essentials of ClassLoader 123

Understanding the delegation model 123 - Programming a simple class loader 127 - Reinitializing static fields: a solution 128

Multiple namespaces 130

Dynamic class replacement 132

Designing for replacement 132 - Implementing replacement 134 - Simplifying assumptions 137

Additional considerations 138

Security 139 - Don't reinvent the wheel 139 - Modifying bytecode in a class loader 140 - When not to invent a specialized class loader 140 - Additional examples 141 - Endorsed Standards - Override 142

Summary 142
 

7 Reflective code generation 143

Reflective code generation 143

Generating HelloWorld.java 145

Class-to-class transformation framework 147

C2C 148 - Args 152 - C2CConstructor 154 - C2CTransformation 157

Example: extent management 159

C2IdentitySubclassOfC and its subclasses 168

UQueue 170

Using the framework 173

Relation to Aspect-Oriented Programming 175

Summary 176
 

8 Design patterns 179

Singleton 181

Decorator class-to-class transformations 187

Proxy (again) 197

Another composition feature 201

Problematic issues in writing class-to-class transformations 201

Summary 204
 

9 Evaluating performance 207

Evaluating performance 207

Categorizing performance impact 209

Using microbenchmarks 210

Benchmarking two ways to use Proxy 214

Understanding Amdahl's Law 218

Applying Amdahl's Law 221

Summary 223

10 Reflecting on the future 225

Looking forward: Java 1.5 226

JSR 14-Generics 227 - JSR 175-Annotation Facility 229 - JSR 201-Language extensions 234 - Impact of Java 1.5 on reflective code 235

Looking forward: competition for Java reflection 236

C# 236 - Python 236 - Smalltalk 236 - CLOS 237 - Ruby 237 - Perl 237

Looking forward: Aspect-Oriented Programming 237

Looking forward: your career 238
 
appendix A Reflection and metaobject protocols 241
appendix B Handling compilation errors in the "Hello world!" program 253
appendix C UML 256
glossary 258
references 260
index 267