An Aspectoriented Weaving Mechanism Based on Component and Connector Architecture

1
An Aspect-oriented Weaving Mechanism Based on
Component and ConnectorArchitecture
ASE 2007

• Naoyasu Ubayashi (Kyushu Institute of Technology)
• Akihiro Sakai (Kyushu Institute of Technology)
• Tetsuo Tamai (University of Tokyo)
• November 8, 2007

2
Aspect-oriented Programming
AOP is a programming paradigm in which
crosscutting concerns are modularized as aspects.
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
behavior of a woven program).
Display updating
pointcut
after (FigureElement fe) (call(void set(..))
target(fe) fe.display.update(fe)
AspectJ
advice
3
Todays my talk

• 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
4
Image of our idea
weaving I/F
weaving I/F
weaving I/F
Contribution Proposal of Component-based
AOP Architectural AOP Towards MDD Our approach
is effective for software modularity, evolution,
and reuse.
Concern Component (class)
Concern Component (class)
Concern Component (class)
connector
connector
weaving I/F
Concern weaving by connectors
Concern Component (class)
5
Outline

• Motivation
• Weaving-interface ccJava
• Example programs
• Implementation
• Conclusion Future work

6
1. Motivation
7
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.

component (class) programmer
interface
client of a class
component (class) programmer
interface
8
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.

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

Component
weaving-interface
component (class) programmer
Connector
Component
programmer who connects components
component (class) programmer
10
Related work

• AAIF Aspect-aware interface Kiczales 2005
• Open modules Aldrich 2005
• Crosscutting programming interface (XPI)
  Sullivan 2005

An interface is determined only once the complete
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.
Our Approach Software Architecture !!
An interface for specifying rules for designing
aspects and classes public aspect XPointChange
/ The purpose of / pointcut change()
execution(void Point.setX(int))
11
2. Weaving-interface ccJava
12
Example --- Figure editor
Component
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 /
Component
Three concern components are woven together by
component and connector architecture based on
weaving-interface.
Component
13
AO weaving based oncomponent-connector
architecture
Weaving-interface
wDisplay
wPoint
wLine
redraw
class Display
class Point
class Line
change
Component
redraw change
Connector
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 Display public static void update()

wLogging
class Logging
14
Weaving-interface in ccJava
ccJava Class-based Crosscutting language for Java
Weaving-interface
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()
Port Definition
Weaving-interfaceConnector is a kind
of ADL (Architecture Description Language)
Connector descriptions depend on only
weaving-interfaces. Architecture can be
represented by Weaving-interface connector.
Coordination Type Before After Around introduce
Connector
weave class Point implements wPoint class
Line implements wLine class
Display implements wDisplay connect(port1wDisp
lay.redraw, port2wPoint
wLine.change) after() returning port2
port1.proceed()
Port Connection
Coordination Code
15
3. Example programs
16
Example (1) --- Method composition
Weaving-interface
Component
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 Point implements wPoint
connect(port1wColor.change, port2wPoint.change)
around() port2 port2.proceed()
port1.proceed()
Point
Color
setX setY moveBy
setColor
behavioral composition
Connector
17
Example (2) --- Class composition
(Inter-type declaration)
Weaving-interface
Component
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 Point implements
wColorPoint connect(port1wColor.color_property
, port2wColorPoint.thisClass)
introduce() port2 from port1
Color
Point
color
setX setY moveBy
setColor getColor
structural composition
Connector
Point
color
setX setY moveBy setColor getColor
18
Example (3) --- Software evolution with ccJava
version 1
version 2
Component
Component
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
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
Connector
weave class Point implements wPoint
replacing moveBy with moveByPlus
class Line implements wLine class
Display implements wDisplay connect(port1wDisp
lay.redraw, port2wPoint
wLine.change) after() returning
port2 port1.proceed()
Renaming
Weaving-interfaces do not have to be modified !
19
Example (4) --- Interface for dealing with
multiple classes
Weaving-interface
public w_interface wChange pointcut
change() execution(void set(..))
execution(void moveBy(int, int)) import
before(), after() returning, around()
change()
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
Connector
weave class Point implements wChange
class Line implements wChange class
Display implements wDisplay connect(port1wDisp
lay.redraw, port2wChange.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.

20
EvaluationExpressiveness for crosscutting
descriptions
NAW NOC NOC/NAW AspectJ (AAIF) 1 2 2 ccJava
as an open module 2 2 1 ccJava using
wildcard 1 2 2
DisplayUpdating
wPoint wLine
Good
Weak
wChange
Good
Cannot crosscut multiple classes
Can crosscut multiple classes
NAW number of aspects or
weaving-interfaces NOC number of classes
(Point, Line)
21
EvaluationTraceability of weaving impact
Linguistic reasoning is difficult
Linguistic reasoning is easy
NOC IFW NOIF AspectJ 1 all aspects number of
aspects AAIF 1 AAIF 1 ccJava 1 weaving-I/Fs num
ber of weaving-IFs
Weak
Good
Good
number of all aspects gt number of implemented
weaving-IFs
NOC number of classes IFW impact factors for
weaving NOIF number of impact factors
22
4. Implementation
http//posl.minnie.ai.kyutech.ac.jp/
23
Compiler construction


ccJava code (weaving-interface)
Java code (class)
ccJava parser
ccJava compiler
AspectJ code generator
Aspect-Factory class generator

AspectJ code (aspect)
AspectJ weaver
executable program
24
Generated code
generated aspect
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 factory class
If a programmer wants to define a specific
factory class,
weave class Display implements wDisplay
factory UserDefinedFactory / other
definitions are omitted /
25
6. Conclusion Future work
26
Conclusion

• A new interface mechanism Weaving-interface
• A new weaving mechanism based on
  component-and-connector architecture

Flexible Weaving Mechanism !
27
Future work

• Component-and-connector architecture for
  integrating OOP and AOP
• Integration of weaving-interface and traditional
  OO interface