1. Aspect Oriented Programming
面向方面的编程
Institute of Computer Software
Nanjing University
2018/12/2

2. 摘要 Background and Motivation AOP AspectJ Summary
Institute of Computer Software
Nanjing University
2018/12/2

3. 摘要 Background and Motivation AOP AspectJ Summary
Institute of Computer Software
Nanjing University
2018/12/2

4. Background and Motivation
Where OOP has brought us
Reusability of components
Modularity
Less complex implementation
Reduced cost of maintenance ……
Modularity is a universal advancement over structured programming that leads to clearer and better understood software
Institute of Computer Software
Nanjing University
2018/12/2

5. Red shows relevant lines of code
Modularity in Reality
Code from org.apache.tomcat
Red shows relevant lines of code
XML
Parsing
Good Modularity
Nicely fits in one box
Institute of Computer Software
Nanjing University
2018/12/2

6. Pretty Good Modularity
Modularity in Reality
fits in two boxes
URL pattern matching
Pretty Good Modularity
Institute of Computer Software
Nanjing University
2018/12/2

7. Code tangling and scattering
Modularity in Reality
Red shows lines of code that handle logging
Code tangling and scattering
Logging
Bad Modularity
Not even in a small number of places
Not in just one place
Institute of Computer Software
Nanjing University
2018/12/2

8. History of Programming Paradigms
In the beginning: Programming in whichever way.
Monolithic programs
Institute of Computer Software
Nanjing University
2018/12/2

9. History of Programming Paradigms
Structured Programming
Functional decomposition
Modularity
Institute of Computer Software
Nanjing University
2018/12/2

10. History of Programming Paradigms
Object-Oriented Programming
Encapsulation & Inheritance
Modularity
Institute of Computer Software
Nanjing University
2018/12/2

11. Nice things of OOP Modular structure Reuse Class Design patterns
Framework
Institute of Computer Software
Nanjing University
2018/12/2

12. Some things cannot be modeled well in object hierarchies!!
Limitations of OOP
Some things cannot be modeled well in object hierarchies!!
Institute of Computer Software
Nanjing University
2018/12/2

13. A motivating example: Tracing
class Point{
void set (int x, int y){
TraceSupport.traceEntry(“Point.set”);
this.x =x; this.y=y;
TraceSupport.traceExit(“Point.set”); }
Institute of Computer Software
Nanjing University
2018/12/2

14. Java API Example Same code repeated 16 times in java.io.File
package java.io;
public class File implements java.io.Serializable{
private String path; …
public boolean exists(){
SecurityManager security = System.getSecurityManager();
if(security!=null){
security.checkRead(path); }
return exits0();
public boolean canRead(){
return canRead0();
Same code repeated
16 times in java.io.File
Institute of Computer Software
Nanjing University
2018/12/2

15. Crossing cutting concerns
Institute of Computer Software
Nanjing University
2018/12/2

16. What is a concern?
A particular goal, concept, or area of interest (requirement)
A software system contains:
Business (application) logic concerns
System-level concerns
Institute of Computer Software
Nanjing University
2018/12/2

17. Crosscutting Concerns
Crosscutting is how to characterize a concern than spans multiple units of OO modularity
Crosscutting concerns resist modularization using normal OO construct
Institute of Computer Software
Nnjing University
2018/12/2

18. Separation of Concerns (SoC)
Object-Oriented Programming separates and encapsulates some concerns
Others end up tangled and scattered
Basic problem
N dimensions of concerns
1 dimension of implementation structure
Tyranny decomposition
Institute of Computer Software
Nanjing University
2018/12/2

19. Approaches to SoC Composition Filters
Multi-dimensional Separation of Concerns
Adaptive Programming
Aspect-Oriented Programming
Was developed at Xerox PARC （施乐公司 帕洛阿尔托研究中心）
(Related) Meta-Object Protocol (MOP)
Reflective programming, meta-object protocol
Institute of Computer Software
Nanjing University
2018/12/2

20. 摘要 Background and Motivation AOP AspectJ Summary
Institute of Computer Software
Nanjing University
2018/12/2

21. The AOP Idea Many cross-cuts aren’t random!
They serve specific purposes
They have well-defined structure
So…let’s capture the cross-cutting structure in a modular way to better support for “Separation of Concerns”
Institute of Computer Software
Nanjing University
2018/12/2

22. Two central problems AOP tries to solve
Code tangling
One module, many concerns
Code scattering
One concern, many modules
Example:
logging
Institute of Computer Software
Nanjing University
2018/12/2

23. Two central problems AOP tries to solve
Institute of Computer Software
Nanjing University
2018/12/2

24. AOP approach to SoC Institute of Computer Software 2018/12/2
Nanjing University
2018/12/2

25. Prism Analogy Crosscutting concerns Implement each concern separately
Weave concerns together
Crosscutting concerns
Institute of Computer Software
Nanjing University
2018/12/2

26. Basic Mechanisms of AOP
Aspect
Advice
Pointcut
Weaving
Institute of Computer Software
Nanjing University
2018/12/2

27. Summary so far
AOP is a software development technique that complements and extends OOP
Provides new and powerful ways to modularize “crosscutting concerns”
Crosscutting concerns: Behavior that cuts across class boundaries
AspectJ is the leading implementation of AOP that extends Java’s OOP model
Institute of Computer Software
Nanjing University
2018/12/2

28. 摘要 Background and Motivation AOP AspectJ Summary
Institute of Computer Software
Nanjing University
2018/12/2

29. What is AspectJ?
A simple and practical aspect-oriented extension to Java
A general purpose AO language
Based on over ten years of research at Xerox PARC
Launched in 1998
Transferred to Eclipse.org in 2002
Latest version: AspectJ
2018/12/2

30. Design assumptions Real Community Users Java compatibility
Writing aspects
Reading aspects
Idioms
How effective for concerns
Modular, reusable and easy to develop and maintain
Java compatibility
Upward compatibility
Platform compatibility
Tool compatibility
Programmer Compatibility
Institute of Computer Software
Nanjing University
2018/12/2

31. AspectJ Compilation Process
Application
modules
.java or jar files
Application
System
weaving
ajc: javac extension
Aspects
.aj files
Institute of Computer Software
Nanjing University
2018/12/2

32. Dynamic VS Static crosscutting
Dynamic crosscutting
define additional behavior to run at certain well- defined points in the execution of the program
Static crosscutting
modify the static structure of a program (e.g., adding new methods, implementing new interfaces, modifying the class hierarchy)
Institute of Computer Software
Nanjing University
2018/12/2

33. Concepts in AspectJ Join Points 连接点 Pointcut 切入点 Advice 通知 Aspect 方面
Introduce 引入
Institute of Computer Software
Nanjing University
2018/12/2

34. High level View of AspectJ
Advice
advice body
pointcut
join point
Java Program
Institute of Computer Software
Nanjing University
2018/12/2

35. Join Points Model
Join point is a well-defined point in a program’s execution
Method call:
public void move(int dx, int dy){
setX(_x+dx);
setY(_y+dy); }
Method call join point
Institute of Computer Software
Nanjing University
2018/12/2

36. More Join Points public void setX(int x){ _x = x; }
Method execution join point
Field set join point
Institute of Computer Software
Nanjing University
2018/12/2

37. All Join Points method & constructor execution
method & constructor call
field get & set
exception handler execution
static & dynamic initialization
dynamic joinpoints (cflow, cflowbelow)
Institute of Computer Software
Nanjing University
2018/12/2

38. Pointcuts
Pointcut:
Predicate on join points: selecting a collection of joinpoints
Example: call (void Point.setX(int))
Wildcard characters are allowed. The following pointcut matches any method call to the methods of the class Point whose names begin with “set”
call (void myPackage..*Point.set*());
Institute of Computer Software
Nanjing University
2018/12/2

39. Executions of methods with the specified sig.
Named Pointcuts
Can be a Named set of join points
Capture all the executions of the
<void Point.setX(int)> or <void Point.setY(int)> method
Name and parameters
Executions of methods with the specified sig.
pointcut move():
execution (void Point.setX(int)) ||
execution (void Point.setY(int)); or
Institute of Computer Software
Nanjing University
2018/12/2

40. More on Pointcuts Basic pointcuts and pointcuts composition
Pointcuts can be composed as boolean expressions with “&&”, “||” and “!”
Pointcuts can have arguments
Institute of Computer Software
Nanjing University
2018/12/2

41. Pointcut Designators call, execution (method or constructor)
get, set (field)
within (type), withincode(method or constructor)
this, target (type or id)
args(type or id list)
cflow, cflowbelow(pointcut)
handler, throwing (exception type)
combine with ||, && and !
use *, + and .. wildcards
bind arguments (autoboxing!), this, target

42. Advice
Code that runs before, after, or around (instead of) a join point
Type of advice
Pointcut it applies to
after() returning(): move() {
//code here runs after each move }
Institute of Computer Software
Nanjing University
2018/12/2

43. Advice Types in AspectJ
Before advice: runs at the moment join point is reached, before method runs
After advice: runs at the moment control returns through join point, just after method
After, after returning, after throwing
Around advice: runs when join point is reached and has control over whether method itself runs at all
Institute of Computer Software
Nanjing University
2018/12/2

44. Aspects
Example:
Aspect HistoryUpdating{ pointcut move(): execution(voidPoint.setX(int)) || execution(voidPoint.setY(int)); after() returning: move() { //code here runs after each move }
Institute of Computer Software
Nanjing University
2018/12/2

45. Aspects
Mix everything we’ve seen up to now and put it one or more modular units called Aspects.
Looks a lot like a class!
Can contain pointcuts, advice declarations, methods, variables ….
Institute of Computer Software
Nanjing University
2018/12/2

46. How it works Short answer: bytecode modification
Institute of Computer Software
Nanjing University
2018/12/2

47. A first example Institute of Computer Software 2018/12/2
Nanjing University
2018/12/2

48. What it does Sample Code Institute of Computer Software 2018/12/2
Nanjing University
2018/12/2

49. AspectJ’s Introductions
An introduction is an aspect member that allows to
Add methods to an existing class
Add field to an existing class
Extend an existing class with another
Implement an interface in an existing class
Convert checked exceptions into unchecked exceptions
Institute of Computer Software
Nanjing University
2018/12/2

50. Introduction examples
public int foo.bar(int x);
private int foo.counter;
declare parents: mammal extends animal;
declare parents: MyThread implements MyThreadInterface;
Institute of Computer Software
Nanjing University
2018/12/2

51. Some Advanced Topics Aspect Extension (Inheritance) example
Institute of Computer Software
Nanjing University
2018/12/2

52. Some Advanced Topics Aspect Creation (Association)
Aspect instance
Single (static) vs. Multiple (dynamic)
Default: Singleton, created when program begins
Object (Class) association:
perthis, pertarget
Controlflow association
Percflow, percflowbelow
Aspect & Advice Precedence & Interactions
Institute of Computer Software
Nanjing University
2018/12/2

53. Performance impact See “Advice Weaving in AspectJ”
“The implementation of advice weaving introduces very little performance overhead when compared to the same functionality coded by hand.”
Does make it easy to create performance destroying code…
But allows powerful optimizations
Institute of Computer Software
Nanjing University
2018/12/2

54. AspectJ Terminology
a join point is a well-defined point in the program flow
a pointcut is a group of join points
advice is code that is executed at a pointcut
introduction modifies the members of a class and the relationships between classes
a compile time declaration introduces a compile time warning or error upon detection of certain usage patterns
an aspect is a module for handling crosscutting concerns
Aspects are defined in terms of pointcuts, advice, and introduction
Aspects are reusable and inheritable
Institute of Computer Software
Nanjing University
2018/12/2

55. Dynamic AOP Systems Creating aspects at run-time
Specifying pointcuts at run-time
Dynamic code translation (or some special feature of the run-time environment)
Enabling/disabling aspects at run-time
Pointcuts are dynamic: it can be decided only at run-time whether advices have to be executed or not (based on run-time values, call-stack, etc.)
Institute of Computer Software
Nanjing University
2018/12/2

56. Other Java AOP sightings
AspectWerkz: load-time/run-time weaving, AOP constructs defined using javadoctags
BEA: AOP framework for Weblogic
JBoss AOP framework
AOP with interceptors
Spring framework
Limited AOP with proxies
J2EE without EJB
AspectJ2EE
JasCo …
Institute of Computer Software
Nanjing University
2018/12/2

57. Other Aspect-Oriented Languages
AspectC
AspectC++
Aspect.Net
Lightweight Python AOP
AspectL(Lisp)
AspectML
AspectPHP
Institute of Computer Software
Nanjing University
2018/12/2

58. Middleware & System Level Applications
Security
Transaction
Persistence
Mobility
Realtime& Embedded Systems OS ……
Institute of Computer Software
Nanjing University
2018/12/2

59. AOSD
AOSD is a promising approach to encapsulate and modularize crosscutting concerns
AOSD is not a substitute of the OO paradigm but an extension to it.
Institute of Computer Software
Nanjing University
2018/12/2

60. AOSD
Institute of Computer Software
Nanjing University
2018/12/2

61. A fast development area
AOP
Aspect-Oriented Programming
AOSD
Aspect-Oriented Software Design (Development)
AORE (AOR)
Aspect-Oriented Requirements Engineering
AOM
Aspect Oriented Modeling
Institute of Computer Software
Nanjing University
2018/12/2

62. Where to Get More Information
The AspectJ website
AOSD website
Books
Mastering AspectJ
AspectJ in Action
Google 
Institute of Computer Software
Nanjing University
2018/12/2

63. 作业（本次作业不用提交） 运行demo程序，研究AspectJ的语法、编译过程 思考为什么说AOP不会取代OOP，而是对OOP 的补充？
Institute of Computer Software
Nanjing University
2018/12/2