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

33
1 An Aspect-oriented Weaving Mechanism Based on Component-and- Connector Architecture 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

Upload: derek-baldwin

Post on 31-Dec-2015

223 views

Category:

Documents


4 download

TRANSCRIPT

Page 1: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 2: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 3: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 4: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

My talk

ASE’07 + Current work

4

Page 5: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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).

Page 6: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 7: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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.

Page 8: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

8

Outline

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

Page 9: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

9

1. Motivation

Page 10: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 11: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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.

Page 12: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 13: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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 !!

Page 14: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

14

2. Weaving-interface & ccJava

Page 15: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 16: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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() { }}

Page 17: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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)

Page 18: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

18

3. Example programs

Page 19: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 20: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 21: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 22: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 23: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 24: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 25: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

25

4. Implementation

Page 26: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 27: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 28: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 29: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 30: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

30

6. Conclusion & Current ongoing work

Page 31: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

31

Conclusion

A new interface mechanism Weaving-interface

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

Flexible Weaving Mechanism !

Page 32: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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

Page 33: 1 An Aspect-oriented Weaving Mechanism Based on Component-and-Connector Architecture Naoyasu Ubayashi (Kyushu Institute of Technology) February 12, 2008

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