Aspect-Based Properties

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.