1 an aspect-oriented weaving mechanism based on component-and-connector architecture naoyasu...

1

An Aspect-oriented Weaving Mechanism Based on Component-and-ConnectorArchitecture

Naoyasu Ubayashi (Kyushu Institute of Technology)

February 12, 2008

Naoyasu Ubayashi, Akihiro Sakai, and Tetsuo Tamai, “An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture”, In ASE’07, pp.154-163

POSL Research Group

Aspect-oriented programming Reflection Coordination language Modeling language Architecture description language (ADL) Domain-specific language (DSL) Formal methods

2

http://posl.minnie.ai.kyutech.ac.jp/

Principles of Software Languages

Recent publications

CAiSE 2009 (21st International Conference on Advanced Information Systems)

Naoyasu Ubayashi, Genya Otsubo, Kazuhide Noda, and Jun Yoshida: An Extensible Aspect-oriented Modeling Environment (to appear).

ICST 2008 (1st IEEE International Conference on Software Testing, Verification, and Validation)

Naoyasu Ubayashi, Jinji Piao, Suguru Shinotsuka, and Tetsuo Tamai: Contract-based Verification for Aspect-oriented Refactoring.

ASE 2007 (22nd IEEE/ACM International Conference on Automated Software Engineering)

Naoyasu Ubayashi, Akihiro Sakai, and Tetsuo Tamai: An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture.

ASE 2005 (20th IEEE/ACM International Conference on Automated Software Engineering)

Naoyasu Ubayashi, Genki Moriyama, Hidehiko Masuhara, and Tetsuo Tamai: A Parameterized Interpreter for Modeling Different AOP Mechanisms.

ICSE 2005 (27th IEEE/ACM International Conference on Software Engineering)

Tetsuo Tamai, Naoyasu Ubayashi, and Ryoichi Ichiyama: An Adaptive Object Model with Dynamic Role Binding.

3

My talk

ASE’07 + Current work

4

5

Aspect-oriented Programming

AOP is a programming paradigm in which crosscutting concerns are modularized as aspects.

Display updating

after (FigureElement fe): (call(void set*(..)) && target(fe) { fe.display.update(fe); }

advice

pointcut

AspectJ

Problem

A concern considered crosscutting in one situation might be primary in others. It is not desirable to fix a certain concern as either primary or crosscutting.

It is not easy to understand software architecture (the overall behaviorof a woven program).

6

Our research

We provide a new weaving mechanism based on component-and-connector architecture.

We propose a new interface mechanism called Weaving-interface.

We provide a new AOP language called ccJava.

ccJava: Class-based Crosscutting language for Java

7

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

Contribution

Proposal of

Component-based AOPArchitectural AOP

Towards MDD

Our approach is effective forsoftware modularity, evolution, and reuse.

8

Outline

1. Motivation2. Weaving-interface & ccJava3. Example programs4. Implementation5. Conclusion & Current work

9

1. Motivation

10

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

11

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.

12

Our approach – Weaving-interface

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

ConcernComponent

(class)

ConcernComponent

(class)

ConcernComponent

(class)

ConcernComponent

(class)

weaving I/F

connector

connector

weaving I/F weaving I/F

weaving I/F

Component-based AOPArchitectural AOP

Related work

AAIF: Aspect-aware interface [Kiczales 2005] Open modules [Aldrich 2005] Crosscutting programming interface (XPI)

[Sullivan 2005]An interface is determined only once thecomplete system is known

Point implements FigureElement void setX(int): DisplayUpdating - after returning DisplayUpdating.change();

Aspects can be woven to only exposed program points.Open modules support crosscutting within only one class.

An interface for specifying rules for designing aspects and classes

public aspect XPointChange {/* The purpose of … */ pointcut change(): execution(void Point.setX(int)) || …}

Our Approach

Software Architecture !!

14

2. Weaving-interface & ccJava

15

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 */ }}

Three concern components are woven together by component and connector architecture based on weaving-interface.

ComponentComponent

ComponentComponent

ComponentComponent

16

AO weaving based oncomponent-connector architecture

classDisplay

classPoint

classLine

classLogging

wDisplay wPoint wLine

wLogging

redraw + changeComponentComponent

Weaving-interfaceWeaving-interface

ConnectorConnector

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; }}

change

redraw

class Display { public static void update() { }}

17

Weaving-interface in ccJavapublic 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(); }}

ccJava: Class-based Crosscutting language for Java

ConnectorConnector

Port Definition

Port Connection

CoordinationCode

Weaving-interfaceWeaving-interface

Coordination TypeBeforeAfter

Aroundintroduce

Connector descriptions depend on only weaving-interfaces.

Architecture can be represented byWeaving-interface + connector.

Weaving-interface+Connector

is a kind of

ADL(Architecture Description

Language)

18

3. Example programs

19

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

20

Example (2) --- Class composition (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

21

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 !

Renaming

22

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

ConnectorConnectorclass 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; }}

23

Evaluation:Expressiveness for crosscutting descriptions

NAW NOC NOC/NAW

AspectJ (AAIF) 1 2 2ccJava as an open module 2 2 1ccJava using wildcard1 2 2

NAW: number of aspects or weaving-interfacesNOC: number of classes (Point, Line)

wPoint wLine

wChange

Good

Weak

Good

DisplayUpdating

Cannot crosscut multiple classes

Can crosscut multiple classes

24

Evaluation: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

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

number of all aspects > number of implemented weaving-IFs

Weak

Good

Good

Linguistic reasoning is

difficultLinguistic

reasoning is easy

25

4. Implementation

26

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

27

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, …

Verifiable AO MDD

Not only programming-level but also design-level notion

ADL for bridging a gap between architectural design and implementation

28

Architectural Design

Weaving-interface

Java

Designs and verifies an architecture represented by a set of weaving-interfaces

(Alloy-based architecture verification)

Implements verified weaving interfaces

ccModeler & ccJava

29

Architectural Design

Weaving-interface

Java

ccModeler

ccJava

Designs and verifies an architecture represented by a set of weaving-interfaces

Implements verified weaving interfaces

Architecture Design & verification

Refinement

30

6. Conclusion & Current ongoing work

31

Conclusion

A new interface mechanism Weaving-interface

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

Flexible Weaving Mechanism !

Current work -- From Weaving-interface to Archface

Archface: architectural interface for bridging a gap between design modeling and implementation

Archface integrates not only design modeling with its implementation but also AO with OO.

32

Example: Observer Pattern

33

Archface

ImplementationIn archface, a collaborative architecture is specified by a set of ports based on the pointcut mechanism.

Pointcut-based interface