1

An Interface Mechanism for Encapsulating Weaving in Class-based AOP

Naoyasu Ubayashi (Kyushu Institute of Technology)Akihiro Sakai (Kyushu Institute of Technology)Tetsuo Tamai (University of Tokyo)

March 12, 2007

SPLAT2007

2

Today’s my talk

The notion of interface is important in module compositions.

It is also important in AO weaving. We provide a new interface

mechanism Weaving-interface. This introduces a new weaving

mechanism based on component-and-connector architecture.

3

Image of our idea

ConcernComponent

(class)

ConcernComponent

(class)

ConcernComponent

(class)

ConcernComponent

(class)

weaving I/F

connector

connector

weaving I/F weaving I/F

weaving I/F Concern weavingby connectors

4

Outline

1. Motivation2. Weaving-interface & ccJava3. Example programs4. Implementation5. Related work6. Conclusion

5

1. Motivation

6

Interface in OOP A client of a class has only to be aware

of methods exposed by an interface of the class.

A class can be modified without being aware of the client if the class does not change the interface.

client of a class

component (class)programmer

component (class)programmer

interface

interface

7

However, in AOP …

It is not necessarily easy for a programmer to understand the overall behavior of a woven program because a weaving modifies the behavior of a method defined in a class.

8

Our approach

A programmer who defines a weaving has only to be aware of weaving-interfaces.

A programmer of the class can change its implementation without being aware of the client if the class conforms to its weaving-interfaces.

programmerwho connects components

component (class)programmer

component (class)programmer

weaving-interfaceComponentComponent

ComponentComponentConnectorConnector

9

2. Weaving-interface & ccJava

10

Example --- Figure editor

interface Shape { public void moveBy(int dx, int dy);}

class Point implements Shape { int x, y; public int getX() { return x; } public int getY() { return y; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void moveBy(int dx, int dy) { x += dx; y += dy; }}

class Line implements Shape { Point p1, p2; public Point getP1() { return p1; } public Point getP2() { return p2; } public void setP1(Point p1) { this.p1 = p1; } public void setP2(Point p2) { this.p2 = p2; } public void moveBy(int dx, int dy) { p1.x += dx; p1.y += dy; p2.x += dx; p2.y += dy; }}

class Display { public static void update() { /* the detail is ommited */ }}

compose threeconcern components - Point - Line - Display

ComponentComponent

ComponentComponent

ComponentComponent

11

AO weaving based oncomponent-connector architecture

classDisplay

classPoint

classLine

classLogging

wDisplay wPoint wLine

wLogging

redraw

logging

export program points(update)

import program points(at set*, moveBy)

ComponentComponent

Weaving-interfaceWeaving-interface

ConnectorConnector

12

ccJava --- a language for supporting weaving-interfaces

public w_interface wPoint { pointcut change(): execution(void setX(int)) || execution(void setY(int)) || execution(void moveBy(int, int)); import before(), after() returning, around() : change();}

public w_interface wLine { pointcut change(): execution(void setP1(Point)) || execution(void setP2(Point)) || execution(void moveBy(int, int)); import before(), after() returning, around() : change();}

public w_interface wDisplay { pointcut redraw(): execution(void update()); import before(), after() returning : redraw(); export redraw();} weave {

class Pointimplements wPoint; class Line implements wLine; class Display implements wDisplay; connect(port1:wDisplay.redraw, port2:{wPoint || wLine}.change) { after() returning : port2 { port1.proceed(); }}

A class must implement methods or fields related exposed by pointcuts.

Only the program points selected by pointcuts are target of weaving.

ccJava: Class-based Crosscutting language for Java

Weaving-interfaceWeaving-interface

ConnectorConnector

13

3. Example programs

14

Example (1) --- Method composition

public w_interface wColor { pointcut change() : execution(void setColor(int)); export change();}

public w_interface wPoint { pointcut change(): execution(void setX(int)) || execution(void setY(int)) || execution(void moveBy(int, int)); import before(), after() returning, around() : change();}

weave { class Color implements wColor; class Pointimplements wPoint; connect(port1:wColor.change, port2:wPoint.change){ around() : port2 { port2.proceed(); port1.proceed();}}}

Weaving-interfaceWeaving-interface

ConnectorConnector

Color

setColor

Point

setXsetYmoveBy

behavioralcomposition

ComponentComponent

15

Example (2) --- Inter-type declaration

public w_interface wColor { pointcut color_property() : field(int color) || method(void setColor(int))|| method(int getColor()); export color_property();}

public w_interface wColorPoint extends wPoint { pointcut thisClass() : class(this); import introduce() : thisClass();}

weave { class Color implements wColor; class Pointimplements wColorPoint; connect(port1:wColor.color_property, port2:wColorPoint.thisClass) { introduce() : port2 from port1; }}

Weaving-interfaceWeaving-interface

ConnectorConnector

Color

setColorgetColor

Point

setXsetYmoveBy

structuralcomposition

ComponentComponent

color

Point

setXsetYmoveBysetColorgetColor

color

16

Example (3) --- Software evolution with ccJava

class Point implements Shape { int x, y; public int getX() { return x; } public int getY() { return y; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void moveByPlus (int dx, int dy) { x += dx; y += dy; }}

weave { class Pointimplements wPoint replacing moveBy with moveByPlus; class Line implements wLine; class Display implements wDisplay; connect(port1:wDisplay.redraw, port2:{wPoint || wLine}.change){ after() returning : port2 { port1.proceed();}}}

class Point implements Shape { int x, y; public int getX() { return x; } public int getY() { return y; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void moveBy(int dx, int dy) { x += dx; y += dy; }}

version 1 version 2ComponentComponent ComponentComponent

ConnectorConnector

Weaving-interfaces do not have to be modified !

17

Example (4) --- Interface for dealing with multiple classes

public w_interface wChange { pointcut change(): execution(void set*(..)) || execution(void moveBy(int, int)); import before(), after() returning, around() : change();}

weave { class Pointimplements wChange; class Line implements wChange; class Display implements wDisplay; connect(port1:wDisplay.redraw, port2:wChange.change){ after() returning : port2 { port1.proceed(); } }}

The scope of the weaving impact is limited to classes that implement wChange.

We have only to look at Point and Line.

Weaving-interfaceWeaving-interface

ConnectorConnector

18

4. Implementation

19

Compiler construction

ccJava code(weaving-interface)

Java code (class)

ccJava parser

AspectJ codegenerator

AspectJ code (aspect)

Aspect-Factoryclass generator

AspectJ weaver

executable program

ccJava compiler

20

Generated code

aspect wPoint { Display display = new DisplayFactory.getInstance();

pointcut change(): execution(void Point.setX(int)) || execution(void Point.setY(int)) || execution(void Point.moveBy(int, int)); after() returning: change() { display.update(); }}

public class DisplayFactory { private static Display instance = new Display(); public static Display getInstance { return instance; }}

generated aspect

generated factoryclass

weave { class Display implements wDisplay factory UserDefinedFactory; /* other definitions are omitted */}

If a programmer wants to define a specific factory class, …

21

5. Related work

22

Related work

Aspect-aware interface [Kiczales, et al. 2005]

Open modules [Aldrich2005] Crosscutting programming

interface (XPI) [Sullivan, et al. 2005]

23

Expressiveness for crosscutting descriptions

NAW NOC NOC/NAW

AspectJ 1 2 2ccJava as an open module 2 2 1ccJava using wildcard1 2 2

NWA: number of aspects or weaving-interfacesNOC: number of classes

24

Traceability of weaving impact

NOC IFW NOIF

AspectJ 1 all aspects number of aspectsAAIF(*)1 AAIF 1ccJava 1 weaving-I/Fs number of weaving-IFs

* AAIF: Aspect-aware Interface

NOC: number of classesIFW: impact factors for weavingNOIF: number of impact factors

number of all aspects > number of implemented weaving-IFs

25

6. Conclusion

26

Conclusion

A new interface mechanism Weaving-interface

A new weaving mechanism based on component-and-connector architecture

Flexible Weaving Mechanism !