Mastering AspectJ_ Aspect-Oriented Programming

459 Pages·2004·4.69 MB·English

Mastering AspectJ
Aspect-Oriented
Programming in Java
Joseph D. Gradecki
Nicholas Lesiecki
Wiley Publishing, Inc.

Mastering AspectJ
Aspect-Oriented
Programming in Java
Joseph D. Gradecki
Nicholas Lesiecki
Wiley Publishing, Inc.
Publisher: Robert Ipsen Copyeditors: Elizabeth Welch and Tiffany Taylor
Editor: Robert M. Elliott Proofreader: Linda Seifert
Managing Editor: Vincent Kunkemueller Compositor: Gina Rexrode
Book Producer: Ryan Publishing Group, Inc.
Designations used by companies to distinguish their products are often claimed as trademarks. In all instances
where Wiley Publishing, Inc., is aware of a claim, the product names appear in initial capital or ALLCAPITAL
LETTERS. Readers, however, should contact the appropriate companies for more complete information regarding
trademarks and registration.
This book is printed on acid-free paper. ∞
Copyright © 2003 by Wiley Publishing, Inc. All rights reserved.
Published by Wiley Publishing, Inc., Indianapolis, Indiana
Published simultaneously in Canada.
No part of this publication may be reproduced, stored in a retrieval system, or transmitted in any form or by any
means, electronic, mechanical, photocopying, recording, scanning, or otherwise, except as permitted under
Section 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the
Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center,
Inc., 222 Rosewood Drive, Danvers, MA 01923, [phone], fax [phone]. Requests to the Publisher for
permission should be addressed to the Legal Department, Wiley Publishing, Inc., 10475 Crosspoint Blvd.,
Indianapolis, IN 46256, [phone], fax [phone], E-mail: [email protected].
Limit of Liability/Disclaimer of Warranty: While the publisher and author have used their best efforts in preparing
this book, they make no representations or warranties with respect to the accuracy or completeness of the
contents of this book and specifically disclaim any implied warranties of merchantability or fitness for a particu-
lar purpose. No warranty may be created or extended by sales representatives or written sales materials. The
advice and strategies contained herein may not be suitable for your situation. You should consult with a profes-
sional where appropriate. Neither the publisher nor author shall be liable for any loss of profit or any other
commercial damages, including but not limited to special, incidental, consequential, or other damages.
For general information on our other products and services please contact our Customer Care Department
within the United States at [phone], outside the United States at [phone] or fax [phone].
Trademarks: Wiley, the Wiley Publishing logo and related trade dress are trademarks or registered trademarks
of Wiley Publishing, Inc., in the United States and other countries, and may not be used without written permis-
sion. All other trademarks are the property of their respective owners. Wiley Publishing, Inc., is not associated
with any product or vendor mentioned in this book.
Wiley also publishes its books in a variety of electronic formats. Some content that appears in print may not be
available in electronic books.
Library of Congress Cataloging-in-Publication Data:
Gradecki, Joe, 1967-
Mastering Aspectj : aspect-oriented programming in Java / Joseph Gradecki, Nicholas
Lesiecki.
p. cm.
ISBN 0-471-43104-4 (PAPER/WEBSITE : alk. paper)
1. Object-oriented programming (Computer science) I. Lesiecki, Nicholas. II. Title.
QA76.64 .G715 2003
005.1’17—dc21
2002153175
Printed in the United States of America
10 9 8 7 6 5 4 3 2 1
CO NTE NTS
Acknowledgments xi
About the Authors xiii
Introduction xv
Part I Aspect-Oriented Programming Primer
Chapter 1 Introduction to AOP 1
Where OOP Has Brought Us 1
What OOADP Did for Computer Science 2
How AOP Solves OOP Problems 9
What Is AOP? 9
Development Process with AOP 10
What’s Next 12
Chapter 2 Implementing AOP 13
AOP Language Anatomy 14
AOP Language Specification 14
AOP Language Implementation 16
AspectJ 19
Example Aspect 19
What’s Next 20
Part II Introduction to AspectJ
Chapter 3 Obtaining and Installing AspectJ 21
Requirements for AspectJ 21
Downloading AspectJ 21
Installing AspectJ 23
Setting PATH 25
Setting CLASSPATH 28
Testing the Installation 28
What’s Next 30
Chapter 4 Implementing AspectJ 31
Our First AspectJ Program 32
Writing the Component First 32
Aspect Code 33
Identifying the Join Point 34
Determining the Pointcut 34
Giving Advice 35
Adding an Aspect 36
Compiling and Executing the Example 36
Adding a New Concern 37
iii
iv Contents
The Method for Returning Text 37
Logging Return Methods 38
A New Primary Concern 41
Exposing Context 43
Inter-type Declarations 44
Adding Class Code 45
Aspect Granularity 47
AspectJ Compiler Functionality 48
Specifying Source Directories 48
Weaving with JARs 49
Specifying Output to a JAR 50
Creating and Using Aspect Libraries 51
Impeding Weaving 51
Using Incremental Compiling 51
What’s Next 52
Chapter 5 AspectJ Join Points 53
The Dynamic Join Point Model 53
AspectJ Join Points 58
Join Point Signatures 60
Patterns 61
Type Name Patterns 62
Subtype Patterns 65
The Throws Pattern 65
Type Patterns 66
Reflection 66
thisJoinPoint Methods 67
thisJoinPointStaticPart Methods 70
Example Join Points 70
Method Call Reception and Execution 70
Constructor Call Reception/Execution and Object Initialization 74
Field Get/Set 75
Exception Handler Execution 77
Class Initialization 77
What’s Next 78
Chapter 6 AspectJ Pointcuts 79
Introducing Our Three Classes 79
Building Pointcuts 83
The Structure of a Pointcut 83
Using Designators 84
A Designator Quick Reference 85
Using Logical Operators to Create Designator Combinations 86
Combining Pointcuts 86
Method-Related Pointcuts 87
The Exception-Handling Designator 92
Field-Related Designators 94
Contents v
State-Based Designators 96
Control Flow-Based Designators 109
Class-Initialization Designators 118
Program Text-Based Designators 119
Dynamic Property-Based Designators 122
adviceexecution 123
preinitialization 124
Dealing with Interfaces 124
Anonymous Pointcuts 125
Using Aspects in Classes 126
Creating Factory Objects 126
Catching Java Library Calls 128
Access to Final Attributes 130
Patterns with Exceptions 130
What’s Next 130
Chapter 7 Advice 131
How to Define Advice 132
Adding Information to System.out.println() 132
The advice 133
Formal Definition 136
Issues Common to All Types of Advice 137
Passing Context to Advice 137
Advice and Exceptions 145
Types of Advice: An Overview 146
Before Advice 147
Uses 148
After Advice 154
After (Unqualified) 154
After Throwing 157
After Returning 162
Around Advice 165
Replacing getProperty() Calls 166
Proceed() 169
Advice Precedence 179
Why Does Precedence Matter? 180
Determining Precedence 180
Runtime Execution 182
Pseudo Precedence 184
What’s Next 185
Chapter 8 Inter-type Declarations 187
Simple Examples of Inter-type Declarations 188
Adding a Method to a Class 188
Introduction and Advice 196
Inter-type Members: The Mechanics 199
Types of Inter-type Members 200
vi Contents
Targets of Inter-type Declarations 202
Access Control 203
Conflicts Between Members 205
Declare Parents 208
Adding a Simple Interface 208
Declare Parents: The Mechanics 209
Interfaces with Concrete Members 212
Refactoring the Persistence Solution 212
Interfaces with Concrete Members: The Mechanics 215
Possibilities of Interfaces with Concrete Members 220
Declaring Precedence 226
An Example of Precedence 227
Declare Precedence: The Mechanics 227
Circularity 230
Effects of Precedence 231
Other Static Crosscutting 231
Statically Determinable Pointcuts 231
Custom Compilation Messages 232
Softening Exceptions 235
What’s Next 240
Chapter 9 Aspects 241
Aspect Structure 241
Writing Aspects 242
Aspect Extensions 245
Building Abstract Aspects 246
Inheriting from Classes and Interfaces 251
Aspect Instantiation and Associations 252
Singleton Aspects 253
Per-Object Aspects 253
Per-Control-Flow Aspects 256
Aspect Domination and Precedence 257
Accessing Aspect Objects 258
Aspect Privilege 259
What’s Next 261
Part III Using AspectJ
Chapter 10 Development Uses of AspectJ 263
Adopting AspectJ 263
Why Adopt AspectJ? 264
How to Put AspectJ into the Process 265
Previous Development Work 266
Backing It Out 266
Development Uses 266
Tracing 266
Condition Checks 268
Contents vii
Production Aspects 269
Loggings and Timings 269
Authorization 271
What’s Next 273
Chapter 11 Using AspectJ Tools 275
AspectJ Compiler Options 275
Filenames 276
The Structure Browser for Aspects 277
Using AspectJ IDE Extensions 281
JBuilder 281
Forte and NetBeans 288
Emacs 290
Eclipse 293
Ant 302
Debugging with AspectJ 303
An ajdb Command-line Tutorial 304
An ajdb GUI Tutorial 307
Using ajdoc 309
An ajdoc Example 310
What’s Next 311
Chapter 12 Error Handling and Common Problems 313
Compilation Errors 313
Wrong Compiler 313
Unable to Find Aspectjtools.jar 314
Out of Memory Error 315
Wrong JSDK 315
No Java Compiler 316
Extended Runtime Error Handling 317
Stack Overflow 317
Join Point Not Matching 317
Exception Throwing and Catching 322
Using TraceJoinPoints.java 323
Differentiating Between Call and Execution Designators 329
Using this() and target() 329
Effects of within/withincode 330
What’s Next 330
Chapter 13 Aspect-Oriented Examples: Patterns and Reuse 331
Reusable Persistence 332
The PersistenceProtocol Aspect 333
Applying PersistenceProtocol with Subaspects 335
Method Caching 341
Caching XML Representations 342
Design Patterns as Aspects 348
Adding Invalidation to the Aspect’s API 348