Using Microcomponents and Design Patterns to Build Evolutionary Transaction Services

The evolution of existing transaction services is limited because they are tightly coupled to a given transaction standard, implement a dedicated commit protocol, and support a fixed kind of applicative participants. The next challenge for transaction services will be to deal with evolution concerns. This evolution should allow developers to tune the transaction service depending on the transaction standard or the application requirements either at design time or at runtime. The contribution of this paper is to introduce the common approach that we have defined to build various evolutionary transaction services. This common approach is based on the use of microcomponents and design patterns, whose flexibility properties allow transaction services to be adapted to various execution contexts. This approach is applied in our GoTM framework that supports the construction of transaction services implementing several transaction standards and commit protocols. We argue that using fine-grained components and design patterns to build transaction services is an efficient solution to the evolution problem and our past experiences confirm that this approach does not impact the transaction service efficiency.

[1]  Gregor Kiczales,et al.  Design pattern implementation in Java and aspectJ , 2002, OOPSLA '02.

[2]  Oscar Nierstrasz,et al.  Traits: A mechanism for fine-grained reuse , 2006, TOPL.

[3]  Tomás Bures,et al.  Microcomponent-based component controllers: a foundation for component aspects , 2005, 12th Asia-Pacific Software Engineering Conference (APSEC'05).

[4]  Anthony Nadalin,et al.  Web Services Atomic Transaction (WS- AtomicTransaction) , 2003 .

[5]  Richard N. Taylor,et al.  A Classification and Comparison Framework for Software Architecture Description Languages , 2000, IEEE Trans. Software Eng..

[6]  Thierry Coupaye,et al.  An Open Component Model and Its Support in Java , 2004, CBSE.

[7]  Romain Rouvoy,et al.  Using Attribute-Oriented Programming to Leverage Fractal-Based Developments , 2006 .

[8]  Jean-Bernard Stefani,et al.  Jonathan: an open distributed processing environment in Java , 1999, Distributed Syst. Eng..

[9]  Vivien Quéma,et al.  DREAM: A Component Framework for Constructing Resource-Aware, Configurable Middleware , 2005, IEEE Distributed Syst. Online.

[10]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[11]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[12]  Thierry Coupaye,et al.  A Component Model Engineered with Components and Aspects , 2006, CBSE.

[13]  Gordon S. Blair,et al.  The Design and Implementation of Open ORB 2 , 2001, IEEE Distributed Syst. Online.

[14]  Thierry Coupaye,et al.  A Model for Developing Component-Based and Aspect-Oriented Systems , 2006, SC@ETAPS.

[15]  Romain Rouvoy,et al.  Towards Context-Aware Transaction Services , 2006, DAIS.

[16]  Romain Rouvoy,et al.  A Component-Based Approach to Compose Transaction Standards , 2006, SC@ETAPS.

[17]  Mourad Alia,et al.  A Middleware Framework for the Persistence and Querying of Java Objects , 2004, ECOOP.

[18]  Romain Rouvoy,et al.  Towards a model-driven approach to build component-based adaptable middleware , 2004, Adaptive and Reflective Middleware.

[19]  Olivier Barais,et al.  Safe integration of new concerns in a software architecture , 2006, 13th Annual IEEE International Symposium and Workshop on Engineering of Computer-Based Systems (ECBS'06).