| dc.description.abstract | Component frameworks are said to support contextual composition when crosscutting
functionality is bound to component instances by declarative selection of context
properties, rather than through direct connections, such as method invocation, or derivation
mechanisms, such as inheritance. Using contextual composition, component framework
services such as synchronization, security and transaction support are bound to component
instances via method interception. Here, the term component instance is an abstraction for
whatever unit of interaction is used to access software component functionality be it an
interface, an object or a set of objects. The mechanism for declarative selection can range
from deployment descriptors, used with EJB Containers, to attribute-based annotations to
source, used with CLR contexts of the .NET Framework.
Contextual composition frameworks suffer from the lack of tailorability problem as well as
the preplanning problem. Contextual composition is employed in a range of component
frameworks including MTS contexts, EJB containers, COM+ contexts, CCM containers,
and CLR contexts. The lack of tailorability problem arises because the context properties
available are either fixed or extensible in an ad hoc manner. The preplanning problem
arises because accessing context properties constrains component architecture. Binding to
context properties involves exposing component functionality as instance methods and
supplying significant prerequisite composition infrastructure.
Aspect-oriented programming (AOP) addresses the problems of contextual composition,
but AOP solutions are difficult to adopt as they introduce language dependencies and
suffer problems with reusability. AOP offers language extensions that provide a linguistic
means of implementing new crosscutting concerns encapsulated in aspects. An emphasis
on noninvasive binding means AOP places fewer restrictions on component architecture,
but relying on language extensions forces components to align to a single language for
interoperability. Furthermore, reusability involves the customization of an aspect, which is
much more complex than declarative mechanisms used with contextual composition such
as attribute-based property selection.
This thesis introduces aspect-based properties, which avoid the restrictions of context
properties, provide language-independence and simplify reuse. Aspect-based properties
are implemented by aspects with pointcut-advice semantics, and composition is the
responsibility of the aspect weaver rather than the components being composed. The
underlying aspect model is language-independent in that it allows aspects and components
to be written in a variety of languages and freely intermixed. Aspect-based properties use
attribute-based property selection to allow reuse without the need to customise an aspect.
An implementation for standardised Common Language Infrastructure (CLI) demonstrates
aspect-based properties to be easy to adopt and to solve the problems identified with
context properties. Aspect-based properties are implemented as CLI components with
XML-based crosscutting specifications that are composed with application components
using a load-time weaver. For reusability, aspect-component bindings are written in terms
of attributes types, but for support of legacy components custom crosscutting is available
in which bindings are specified in terms of CLI metadata. Language-independence is
available in either case, which we demonstrate by weaving aspect-based properties and
components written in object-oriented, procedural and functional programming languages.
In comparison to the CLR contexts for the CLI, aspect-based properties provide a richer
join point model for better tailorability, the weaver allows them to avoid preplanning
issues, and they execute an order of magnitude faster. | en |
