Java Reflection in Action

Ira R. Forman, Nate Forman

  • 出版商: Manning
  • 售價: $1,430
  • 貴賓價: 9.5$1,359
  • 語言: 英文
  • 頁數: 300
  • 裝訂: Paperback
  • ISBN: 1932394184
  • ISBN-13: 9781932394184
  • 相關分類: Java 程式語言

已過版

買這商品的人也買了...

相關主題

商品描述

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