Aspectj Cookbook

by Miles, Russ

• ISBN13: 9780596006549
• ISBN10: 0596006543
• Format: Paperback
• Copyright: 2005-01-01
• Publisher: Oreilly & Associates Inc

Summary

Many developers have expressed an interest in Aspect Oriented Programming, which takes Object Oriented programming to the next level of flexibility. But finding a practical, non-theoretical way to explore the tools and techniques of AOP-especially AspectJ, the open source AOP language for Java-has been a real problem. AspectJ Cookbook delivers the solution, with a wide variety of code recipes for solving day-to-day design and coding problems using Aspect Orientation's unique approach. The book shows readers why, and how, common Java development problems can be solved with Aspect Oriented techniques, and uses real world examples to explain why Aspect Orientation is more than just a concept.

Table of Contents

Preface	xiii
1. Aspect Orientation Overview	1	(5)
A Brief History of Aspect Orientation	1	(1)
AspectJ	2	(1)
A Definition of Aspect Orientation	2	(3)
Where to Go for More Information	5	(1)
2. Getting Started with AspectJ	6	(24)
2.1 Installing AspectJ	7	(2)
2.2 Developing a Simple Aspect	9	(3)
2.3 Compiling an Aspect and Multiple Java Files	12	(1)
2.4 Weaving Aspects into Jars	13	(2)
2.5 Weaving Aspects at Load Time	15	(2)
2.6 Generating Javadoc Documentation	17	(3)
2.7 Compiling an AspectJ Project Using Eclipse	20	(4)
2.8 Selecting the Aspects That Are Woven in a Build Within Eclipse	24	(4)
2.9 Building an AspectJ Project Using Ant	28	(2)
3. Deploying AspectJ Applications	30	(20)
3.1 Deploying a Command-Line AspectJ Application	31	(2)
3.2 Deploying an AspectJ Application as a Fully Contained Executable JAR File	33	(2)
3.3 Deploying a Java Servlet That Uses AspectJ	35	(6)
3.4 Deploying a JSP That Uses AspectJ	41	(5)
3.5 Deploying an Axis Web Service That Uses AspectJ	46	(4)
4. Capturing Join Points on Methods	50	(11)
4.1 Capturing a Method Call	50	(4)
4.2 Capturing the Parameter Values Passed on a Method Call	54	(2)
4.3 Capturing the Target of a Method Call	56	(1)
4.4 Capturing a Method When It Is Executing	57	(2)
4.5 Capturing the Value of the this Reference When a Method Is Executing	59	(2)
5. Capturing Join Points on Exception Handling	61	(6)
5.1 Capturing When an Exception Is Caught	61	(3)
5.2 Capturing the Thrown Exception	64	(1)
5.3 Capturing the Object Handling the Exception	65	(2)
6. Capturing Join Points on Advice	67	(7)
6.1 Capturing When Advice Is Executing	67	(2)
6.2 Excluding Join Points That Are a Result of Advice Execution	69	(3)
6.3 Exposing the Original Join Point When Advice Is Being Advised	72	(2)
7. Capturing Join Points on Class and Object Construction	74	(11)
7.1 Capturing a Call to a Constructor	74	(3)
7.2 Capturing a Constructor When It Is Executing	77	(2)
7.3 Capturing When an Object Is Initialized	79	(2)
7.4 Capturing When an Object Is About to Be Initialized	81	(1)
7.5 Capturing When a Class Is Initialized	82	(3)
8. Capturing Join Points on Attributes	85	(8)
8.1 Capturing When an Object's Attribute Is Accessed	85	(3)
8.2 Capturing the Value of the Field Being Accessed	88	(1)
8.3 Capturing When an Object's Field Is Modified	89	(2)
8.4 Capturing the Value of a Field When It Is Modified	91	(2)
9. Capturing Join Points Within Programmatic Scope	93	(6)
9.1 Capturing All Join Points Within a Particular Class	93	(2)
9.2 Capturing All Join Points Within a Particular Package	95	(2)
9.3 Capturing All Join Points Within a Particular Method	97	(2)
10. Capturing Join Points Based on Control Flow	99	(6)
10.1 Capturing All Join Points Within a Program's Control Flow Initiated by an Initial Join Point	99	(3)
10.2 Capturing All Join Points Within a Program's Control Flow, Excluding the Initial Join Point	102	(3)
11. Capturing Join Points Based on Object Type	105	(10)
11.1 Capturing When the this Reference Is a Specific Type	105	(3)
11.2 Capturing When a Join Point's Target Object Is a Specific Type	108	(3)
11.3 Capturing When the Arguments to a Join Point Are a Certain Number, Type, and Ordering	111	(4)
12. Capturing Join Points Based on a Boolean or Combined Expression	115	(14)
12.1 Capturing When a Runtime Condition Evaluates to True on a Join Point	115	(3)
12.2 Combining Pointcuts Using a Logical AND (&&)	118	(2)
12.3 Combining Pointcuts Using a Logical OR (||)	120	(3)
12.4 Capturing All Join Points NOT Specified by a Pointcut Declaration	123	(1)
12.5 Declaring Anonymous Pointcuts	124	(2)
12.6 Reusing Pointcuts	126	(3)
13. Defining Advice	129	(19)
13.1 Accessing Class Members	129	(2)
13.2 Accessing the Join Point Context	131	(3)
13.3 Executing Advice Before a Join Point	134	(1)
13.4 Executing Advice Around a Join Point	135	(4)
13.5 Executing Advice Unconditionally After a Join Point	139	(1)
13.6 Executing Advice Only After a Normal Return from a Join Point	140	(2)
13.7 Executing Advice Only After an Exception Has Been Raised in a Join Point	142	(1)
13.8 Controlling Advice Precedence	143	(3)
13.9 Advising Aspects	146	(2)
14. Defining Aspect Instantiation	148	(9)
14.1 Defining Singleton Aspects	148	(3)
14.2 Defining an Aspect per Instance	151	(4)
14.3 Defining an Aspect per Control Flow	155	(2)
15. Defining Aspect Relationships	157	(9)
15.1 Inheriting Pointcut Definitions	157	(2)
15.2 Implementing Abstract Pointcuts	159	(2)
15.3 Inheriting Classes into Aspects	161	(2)
15.4 Declaring Aspects Inside Classes	163	(3)
16. Enhancing Classes and the Compiler	166	(9)
16.1 Extending an Existing Class	166	(1)
16.2 Declaring Inheritance Between Classes	167	(1)
16.3 Implementing Interfaces Using Aspects	168	(2)
16.4 Declaring a Default Interface Implementation	170	(2)
16.5 Softening Exceptions	172	(1)
16.6 Extending Compilation	173	(2)
17. Implementing Creational Object-Oriented Design Patterns	175	(13)
17.1 Implementing the Singleton Pattern	176	(4)
17.2 Implementing the Prototype Pattern	180	(2)
17.3 Implementing the Abstract Factory Pattern	182	(2)
17.4 Implementing the Factory Method Pattern	184	(1)
17.5 Implementing the Builder Pattern	185	(3)
18. Implementing Structural Object-Oriented Design Patterns	188	(19)
18.1 Implementing the Composite Pattern	188	(4)
18.2 Implementing the Flyweight Pattern	192	(4)
18.3 Implementing the Adapter Pattern	196	(1)
18.4 Implementing the Bridge Pattern	197	(2)
18.5 Implementing the Decorator Pattern	199	(3)
18.6 Implementing the Proxy Pattern	202	(5)
19. Implementing Behavioral Object-Oriented Design Patterns	207	(36)
19.1 Implementing the Observer Pattern	207	(4)
19.2 Implementing the Command Pattern	211	(4)
19.3 Implementing the Iterator Pattern	215	(3)
19.4 Implementing the Mediator Pattern	218	(4)
19.5 Implementing the Chain of Responsibility Pattern	222	(5)
19.6 Implementing the Memento Pattern	227	(3)
19.7 Implementing the Strategy Pattern	230	(3)
19.8 Implementing the Visitor Pattern	233	(4)
19.9 Implementing the Template Method Pattern	237	(2)
19.10 Implementing the State Pattern	239	(1)
19.11 Implementing the Interpreter Pattern	240	(3)
20. Applying Class and Component Scale Aspects	243	(17)
20.1 Validating Parameters Passed to a Method	243	(4)
20.2 Overriding the Class Instantiated on a Call to a Constructor	247	(3)
20.3 Adding Persistence to a Class	250	(5)
20.4 Applying Mock Components to Support Unit Testing	255	(5)
21. Applying Application Scale Aspects	260	(20)
21.1 Applying Aspect-Oriented Tracing	261	(3)
21.2 Applying Aspect-Oriented Logging	264	(4)
21.3 Applying Lazy Loading	268	(6)
21.4 Managing Application Properties	274	(6)
22. Applying Enterprise Scale Aspects	280	(15)
22.1 Applying Development Guidelines and Rules	281	(2)
22.2 Applying Transactions	283	(3)
22.3 Applying Resource Pooling	286	(5)
22.4 Remoting a Class Transparently Using RMI	291	(2)
22.5 Applying a Security Policy	293	(2)
23. Applying Aspect-Oriented Design Patterns	295	(12)
23.1 Applying the Cuckoo's Egg Design Pattern	296	(2)
23.2 Applying the Director Design Pattern	298	(3)
23.3 Applying the Border Control Design Pattern	301	(3)
23.4 Applying the Policy Design Pattern	304	(3)
Appendix: The AspectJ Runtime API	307	(10)
Index	317