Article

EMod: Platform Independent Modelling, Description and Enactment of Parameterizable EAI Patterns

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

Abstract

As enterprises merge, split up, or grow, existing legacy systems from different vendors implemented in different programming languages and running in different environments as well as roll-your-own applications have to be integrated. This fact is denoted as the Enterprise Application Integration (EAI) problem and is one of the major challenges IT departments are facing today.As a result of the need for operational flexibility and reuse, Service-Oriented Architectures (SOA) gain more and more importance as they allow for a flexible and standardised way to describe, reuse and integrate services in heterogeneous application landscapes. Enterprise Application Integration Patterns (EAI Patterns) are a means to describe integration problems using a set of patterns. The patterns therefore present nuggets of advice on how to solve complex recurring integration problems.In this paper we introduce a platform independent approach (EMod) to model, describe and enact EAI patterns in service-oriented architectures. We describe how EMod can be used to build stand-alone EAI solutions that integrate different applications in a Software as a Service (SaaS) environment. Furthermore we show how EMod can be used as a part of an application to integrate services into composite service-oriented applications. This is done by integrating EMod into the Service Component Architecture (SCA).

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... Along with the rapid development of information technologies, various applications have been developed in almost every aspect of enterprise business processes, such as supply chain management (SCM), customer relationship management (CRM), enterprise resource planning (ERP), and product lifecycle management (PLM), in order to enable organizations to improve their use of information systems in supporting their operational and financial goals [1][2][3]. A SCM application focuses on co-ordination and interenterprise supply chain upstream and downstream relationships [2]. ...
... Vasconcelos et al. [15] verified the dimensions that should be represented as part of information systems architecture of EAI. Scheibler et al. [3] introduced a platform independent approach to modeling, describing, and enacting EAI patterns in service oriented architecture. Losavio et al. [16] modeled the EAI based on Brown's conceptual model of integration, which was extended to obtain more unified and organized views in EAI by Sandoe and Saharia [17]. ...
Conference Paper
Full-text available
Organizations tend to depend on their various legacy applications in supporting their business strategies and in achieving goals. The existing legacy applications are often from different vendors. In order for an enterprise to be efficient and cost-effective, their legacy applications should be seamlessly integrated within and beyond the enterprise. Some research work in Enterprise Applications Integration (EAI) technologies analyzed the problem from the technical point of view while others proposed models for business processes integration such as syntactic and semantic integration. In this paper the EAI is considered as a design problem and is analyzed from design point of view. Environment Based Design (EBD) methodology is applied to handle the integration problem by analyzing and clarifying the design requirements to generate appropriate solutions. A case study is provided to show how the EBD can be applied within a company to generate satisfactory EAI solutions with low cost, efficiency and scalability enhancement.
... Along with the rapid development of information technologies, various applications have been developed in almost every aspect of enterprise business processes, such as supply chain management (SCM), customer relationship management (CRM), enterprise resource planning (ERP), and product lifecycle management (PLM), in order to enable organizations to improve their use of information systems in supporting their operational and financial goals [1][2][3]. A SCM application focuses on co-ordination and interenterprise supply chain upstream and downstream relationships [2]. ...
... Vasconcelos et al. [15] verified the dimensions that should be represented as part of information systems architecture of EAI. Scheibler et al. [3] introduced a platform independent approach to modeling, describing, and enacting EAI patterns in service oriented architecture. Losavio et al. [16] modeled the EAI based on Brown's conceptual model of integration, which was extended to obtain more unified and organized views in EAI by Sandoe and Saharia [17]. ...
Article
Enterprises tend to depend on various legacy applications in supporting their business strategies and in achieving their goals. In order for an enterprise to be efficient and cost-effective, their legacy applications should be seamlessly integrated within and beyond the enterprise. Some research work in enterprise applications integrations (EAI) analyzed the problem, while others proposed solution models for the syntactic and semantic integration of business processes. In this paper, the EAI is considered as a design problem and is analyzed from design point of view. Environment based design (EBD) methodology is applied to handle the integration problem by analyzing and clarifying the design requirements to generate appropriate solutions. A framework is proposed for EAI problems based on the EBD approach. A case study is also provided to show how the approach can be applied within a company to generate satisfactory EAI solutions with low cost, high efficiency, and enhanced scalability. [DOI: 10.1115/1.4007171]
... Along with the rapid development of information technologies, various applications have been developed in almost every aspect of enterprise business processes, such as supply chain management (SCM), customer relationship management (CRM), enterprise resource planning (ERP), and product lifecycle management (PLM), in order to enable organizations to improve their use of information systems in supporting their operational and financial goals [1][2][3]. A SCM application focuses on co-ordination and interenterprise supply chain upstream and downstream relationships [2]. ...
... Vasconcelos et al. [15] verified the dimensions that should be represented as part of information systems architecture of EAI. Scheibler et al. [3] introduced a platform independent approach to modeling, describing, and enacting EAI patterns in service oriented architecture. Losavio et al. [16] modeled the EAI based on Brown's conceptual model of integration, which was extended to obtain more unified and organized views in EAI by Sandoe and Saharia [17]. ...
Article
Enterprises tend to depend on various legacy applications in supporting their business strategies and in achieving their goals. In order for an enterprise to be efficient and cost-effective, their legacy applications should be seamlessly integrated within and beyond the enterprise. Some research work in enterprise applications integrations (EAI) analyzed the problem, while others proposed solution models for the syntactic and semantic integration of business processes. In this paper, the EAI is considered as a design problem and is analyzed from design point of view. Environment based design (EBD) methodology is applied to handle the integration problem by analyzing and clarifying the design requirements to generate appropriate solutions. A framework is proposed for EAI problems based on the EBD approach. A case study is also provided to show how the approach can be applied within a company to generate satisfactory EAI solutions with low cost, high efficiency, and enhanced scalability.
... They described how different SaaS application components can be combined horizontally or vertically. Scheibler et al. [22] proposed a platform-independent approach to modelling, describing and implementing enterprise application integration (EAI) patterns in a service-oriented architecture to integrate different applications into a SaaS environment. Liu et al. [23] and Zhang et al. [24] used WSCL to build SaaS services and describe SaaS models. ...
Article
Full-text available
Increasingly more enterprises are intending to deploy data management systems in the cloud. However, the complexity of software development significantly increases both time and learning costs of data management system development. In this paper, we investigate the coding-free construction of a data management system based on Software-as-a-Service (SaaS) architecture, in which a practical application platform and a set of construction methods are proposed. Specifically, by extracting the common features of data management systems, we design a universal web platform to quickly generate and publish customized system instances. Then, we propose a method to develop a lightweight data management system using a specific requirements table in a spreadsheet. The corresponding platform maps the requirements table into a system instance by parsing the table model and implementing the objective system in the running stage. Finally, we implement the proposed framework and deploy it on the web. The empirical results demonstrate the feasibility and availability of the coding-free method for developing lightweight web data management systems.
... They described how different SaaS application components can be combined horizontally or vertically. Scheibler, Mietzner, and Leymann [18] proposed a platform-independent approach to modeling, describing and implementing EAI patterns in a service-oriented architecture to integrate different applications into a SaaS environment. Liu et al. [12] and Zhang, Zhang, and Liu [27] used WSCL to build SaaS services and describe SaaS models. ...
Preprint
More and more enterprises recently intend to deploy data management systems in the cloud. Due to the professionalism of software development, it has still been difficult for non-programmers to develop this kind of systems, even a small one. However, the development of SaaS brings forth the more feasibility of coding-free software development than before. Based on the SaaS architecture, this paper presents a set of theory and method for coding-free construction of a data management system, on which our contributions involve in a practical application platform, a set of construction method and a set of interface on data exchange. By abstracting the common features of data management systems, we design a universal web platform to quickly generate and publish customized system instances. Moreover, we propose a kind of method to develop a data management system using a specific requirements table in spreadsheet. The corresponding platform maps the requirements table into a system instance through parsing the table model and implementing the objective system in the running stage. Finally, we implement the proposed framework and deploy it on web. The empirical result demonstrates the feasibility and availability of the coding-free method in developing web data management systems.
... At the enterprise level, SaaS not only helps to lower investments in IT infrastructure, but also reduces operational costs associated with the acquisition or development of EIS (Rico et al. 2016). However, the operational flexibility, cost saving, and software reuse capabilities of SaaS are often accompanied by tradeoffs, specifically as it relates to challenges of seamless integration within the EIS landscape (Scheibler, Mietzner, and Leymann 2009). Nevertheless, adoption of SaaS continues to grow, and the spending on 'as a service' offerings is forecasted to grow to $258 billion in 2020 (Goode et al. 2015). ...
Article
Software as a service (SaaS) is a service model in which the applications are accessible from various client devices through internet. Several studies report possible factors driving the adoption of SaaS but none have considered the perception of the SaaS features and the organization’s context. We propose an integrated research model that combines the process virtualization theory (PVT), the technology-organization-environment (TOE) framework and the institutional theory (INT). PVT seeks to explain whether processes are suitable for migration into virtual environments via an information technology-based mechanism as SaaS. The TOE framework seeks to explain the effects of the intra-organizational factors, while INT seeks to explain the effects of the inter-organizational factors on the technology adoption. This research addresses a gap in the SaaS adoption literature by studying the internal perception of the technical features of SaaS and technology, organization, and environment perspectives. Additionally, the integration of PVT, the TOE framework, and INT contributes to the information system (IS) discipline, deepening the applicability and strengths of these theories.
Article
For the comprehensive requirements of being dynamic, flexible, loosely coupled, and transparent of heterogeneous system integration in manufacturing enterprises, the conception of semantic gateway is proposed, and a new integration framework of heterogeneous system with the support of semantic gateway is established, to solve the semantic heterogeneous problem of heterogeneous systems and integrate the business flow of enterprises dynamically. On the basis, the semantic gateway model is established and semantic mapping standard, database adapter and service adapter of semantic gateway are deeply researched. Finally, the proposed studies are applied to the integration of heterogeneous information systems in a turbo & charger machinery manufacturing enterprise in Chongqing, and the application result is satisfying.
Thesis
Die Integration von großen IT Anwendungen ist für viele Firmen eine der bedeutendsten IT Herausforderungen, um die Geschäftsprozesse innerhalb eines Unternehmens effizient durchführen zu können. Zum einen gab es kein standardisiertes Vorgehen, wie man Integrationslandschaften konzipieren und spezifizieren konnte. Zum anderen bestand keine durchgängige Methode, die resultierenden zumeist abstrakten Architekturen in ausführbare Systeme zu überführen. Mit der Einführung von Integrationsmustern wurde ein großer Beitrag geleistet, um Integrationslandschaften einheitlich und technologieunabhängig darstellen zu können. Jedoch klaffte immer noch eine große Lücke zwischen der Modellierung und der Implementierung dieser Landschaften. Die tatsächliche Realisierung wurde durch Entwickler geleistet, indem die Landschaften interpretiert und entsprechend ausführbare Integrationslogik erstellt wurde. Diese Kluft muss geschlossen werden, damit Architekten und Entwickler besser miteinander kommunizieren und ausführbare Integrationslösungen effizienter realisiert werden können. Diese Dissertation leistet einen Beitrag, um diese Lücke zu schließen. Im Rahmen dieser Arbeit wird eine Methode entwickelt, mit der ausgehend von Integrationsmustern automatisiert ausführbare Integrationslösungen erzeugt werden können. Es wird eigens ein Lebenszyklus konzipiert, der die unterschiedlichen Phasen der Erstellung von ausführbaren Integrationslösungen beschreibt. Die Methode basiert auf der Modell-getriebenen Entwicklung. Die vormals visuellen und textuellen Repräsentationen der Integrationsmuster werden dazu in ein formales Modell überführt. Parametrisierbare Integrationsmuster dienen fortan als Grundlage der Methode. Durch die Parameter jedes einzelnen Musters kann das erwartete Verhalten eines Muster technologieunabhängig spezifiziert werden. Außerdem beschreibt das Modell die Zusammenhänge der einzelnen Muster und wie sie miteinander kommunizieren. Das Modell der parametrisierbaren Integrationsmuster wird von einem Generierungsalgorithmus verwendet, um automatisiert ausführbare Integrationslösungen zu erstellen. Der Algorithmus fügt dazu plattformspezifische Informationen hinzu, so dass eine Integrationslösung auf einer bestimmten Zielinfrastruktur ausgeführt werden kann. Ein Modell kann dabei von verschiedenen Algorithmen verwendet werden und daher in verschiedene Ausführungsumgebungen übersetzt werden. Diese Methode ist daher nicht auf bestimmte Zielinfrastrukturen beschränkt. Im Verlauf der Arbeit werden parametrisierbare Integrationsmuster auf drei sehr unterschiedlichen Infrastrukturen abgebildet und ausgeführt. Dies verdeutlicht die Allgemeinheit der Methode und die leichte Erweiterbarkeit auf neue Technologien und veränderte Anforderungen. Zur Unterstützung der Methode wird außerdem eine Werkzeugkette erstellt, die es Systemarchitekten erlaubt, eine Integrationslösung grafisch zu konzipieren. Das Werkzeug GENIUS umfasst eine graphische Modellierungsoberfläche, mit der parametrisierbare Integrationsmuster zu einer Integrationslösung zusammengefasst werden können. Außerdem werden zwei Algorithmen integriert, die ausführbare Integrationslösungen für zwei unterschiedliche Zielinfrastrukturen erzeugen. Diese Dissertation schließt somit die Lücke zwischen Architektur und Entwicklung, indem eine auf der Modell-getriebenen Entwicklung basierenden Methode entwickelt wird, mit deren Hilfe parametrisierbare Integrationsmuster als direkte Spezifikation für ausführbare Systeme dienen und automatisiert in diese Systeme überführt werden.
Thesis
Sichten auf Prozesse wurden im vergangenen Jahrzehnt von verschiedenen Forschergruppen als Graphtransformationstechnik zur vereinfachenden Darstellung von Prozessen untersucht. Sichtenfunktionen finden sich jedoch nur vereinzelt in Werkzeugen wieder, und es besteht keine gemeinsame Basis an Begrifflichkeiten und zudem kein Konsens, welche Funktionen über das Auslassen und Aggregieren von Modellelementen hinaus zu Prozesssichten gehören. Durch den Mangel an gemeinsamer konzeptioneller Basis stehen diese praxisrelevanten Funktionen nur einem eingeschränkten Nutzerspektrum zur Verfügung. Mit einem musterbasierten Ansatz zum Entwurf von Sichten auf Prozesse wird eine abstrakte Ausgangsbasis geschaffen, die die verschiedenen bestehenden Möglichkeiten von Sichten auf einer einheitlichen konzeptionellen Plattform zugänglich macht und weitgehend unabhängig von Technologien, Werkzeugen und Prozesssprachen bereitstellt. Komplexe Transformationsfunktionen werden abstrahiert und in einer einheitlichen Beschreibungsform als Sichtenentwurfsmuster in einem Musterkatalog bereitgestellt. Darauf aufbauend wird der Stand der Technik um den musterbasierten Sichtenentwurf sowie um den Entwurf sprachübergreifender Sichten erweitert. Der Entwurf sprachübergreifender Sichten macht von Übersetzungstechniken, der Darstellungsanpassung und von Zustandsübertragung Gebrauch. Mit einer Sprache für den musterbasierten Sichtenentwurf (kurz Mustersprache) können verschiedene Interessengruppen ihre individuellen Informationsbedarfe durch Anwendung und Komposition der bereitgestellten Muster als Sichtenentwurf formulieren und nach anschließender Implementierung auf Prozesse anwenden, um damit deren Komplexität auf den individuellen Bedarf zu reduzieren. Ein musterbasierter Sichtenentwurf stellt damit den Ausgangspunkt der Spezifikation komplexer Transformationen und Mechanismen zur Prozessvisualisierung dar. Neben dem planerischen Aspekt kann die Mustersprache zur musterbasierten Analyse von Sichtenfunktionen in bestehenden Ansätzen und Werkzeugen verwendet werden. Dieses Konzept erfordert die neuartige Aufgabe des Informationsdesigns im Management von Geschäftsprozessen, die ein Bindeglied zwischen Informationsbedarfen und der technischen Realisierung von Sichten in Werkzeugen schafft. Der musterbasierte Ansatz grenzt sich davon ab, Geschäftsprozesse an sich zu verschlanken und tatsächlich stattfindende Abläufe zu verändern. Geschäftsprozesse sind trotz individueller Sichten noch immer komplex. Dieser Ansatz verfolgt vielmehr das Ziel, komplexe Modelle von Geschäftsprozessen verständlicher zu machen. Der Schwerpunkt des Ansatzes besteht darin, Prozesse im Kontext verschiedener Interessengruppen mit Informationen zu vernetzen und die Prozesse bedarfsgerecht darzustellen. Nichtsdestotrotz können Prozesssichten ein Werkzeug für Vorhaben zur Verschlankung oder Optimierung von Abläufen darstellen. Compliance ist zwischenzeitlich zum Sammelbegriff für die Einhaltung von Anforderungen aus verschiedenen Quellen avanciert und dient in dieser Arbeit als zu untersuchende Einflussgröße bei der weiteren Steigerung der Komplexität: Eine zunehmende Zahl an Regularien, unternehmensinterner Richtlinien, wie auch die moralische und ökologische Verantwortung, rufen eine immense Anzahl an Anforderungen hervor, denen die ohnehin komplexen Geschäftsprozesse gerecht werden sollen. Der Stand der Technik bietet überwiegend formale Methoden an, um die geforderte Regelkonformität sicherzustellen. Diese Methoden können eingesetzt werden, um Fehlverhalten in Modellen von Geschäftsprozessen auszumachen. Sie bieten allerdings keine ausreichende Hilfestellung, wie bestehende Geschäftsprozesse umzugestalten sind, damit die darin enthaltenen Aufgaben regelkonform erledigt werden. Der Ansatz regelrealisierender Prozessfragmente (kurz rr-Fragmente) erweitert den Stand der Technik mit einer Möglichkeit zur Wiederverwendung von Prozessstrukturen, die einen Geschäftsprozess nachvollziehbar mit regelkonformem Verhalten erweitern. rr-Fragmente bieten somit Lösungsmöglichkeiten dafür an, wie bestimmte Aufgaben im Einklang mit geltenden Regeln erledigt werden können. Es wird eine Verbindung von dem Ansatz der rr-Fragmente mit Techniken zur Prüfung der Regelkonformität hergestellt und er wird im übergeordneten Kontext vom Compliance Management in Geschäftsprozessen als Baustein positioniert. Wiederverwendbare Prozessstrukturen wurden, nach bestem Wissen, zuvor nicht in den Kontext von Compliance gestellt und an die Anforderungen dieses Themenkomplexes angepasst. Aus dem entwickelten Ansatz leiten sich zahlreiche Informationsbedarfe ab, die durch Prozesssichten für Compliance abgedeckt werden können.
Article
Business Process Model and Notation (BPMN) choreography modelling depicts externally visible message exchanges between collaborating processes of enterprise information systems. Implementation of choreography relies on designing system integration solutions to realise message exchanges between independently developed systems. Enterprise integration patterns (EIPs) are widely accepted artefacts to design integration solutions. If the choreography model represents coordination requirements between processes with behaviour mismatches, the integration designer needs to analyse the routing requirements and address these requirements by manually designing EIP message routers. As collaboration scales and complexity increases, manual design becomes inefficient. Thus, the research problem of this paper is to explore a method to automatically identify routing requirements from BPMN choreography model and to accordingly design routing in the integration solution. To achieve this goal, recurring behaviour mismatch scenarios are analysed as patterns, and corresponding solutions are proposed as EIP routers. Using this method, a choreography model can be analysed by computer to identify occurrences of mismatch patterns, leading to corresponding router selection. A case study demonstrates that the proposed method enables computer-assisted integration design to implement choreography. A further experiment reveals that the method is effective to improve the design quality and reduce time cost.
Article
Under Intranet or Internet environment, it becomes more and more important how to make application systems communicate and share data seamlessly, thus eliminates the huge information isolated island, realizes the information sharing and exchange. Web services is one of the best solution for enterprise application integration (EAI). In this paper, after analyzing the architecture and the protocols of Web services, a application integration system was designed and implemented using open source development and deployment platform Eclipse and its J2EE plug-in WTP. The research results can be further applied to e- commerce, manufacturing process control, geographic information systems, numerical computing and other fields.
Conference Paper
In the context of Enterprise Application Integration individual tasks have typically been implemented using specialized EAI-vendor technology based on messaging, and quite often customer-specific implementations. Those implementations prominently exploit the Pipes-and-Filters architecture. This implementation approach is in conflict with the flow technology that is a cornerstone of the Service-Oriented Architecture for solving integration problems. In this paper, we present how this conflict can be resolved. Therefore, we first analyse the differences between Pipes-and-Filters architectures and workflow approaches in general, and present the advantages and drawbacks of each solution. Afterwards, we describe how integration solutions modelled based on the PaF architecture can be implemented using flow technology by transforming the appropriate PaF elements into appropriate workflow constructs. We then present the results of appropriate tests that show that the performance of the corresponding workflows is superior to the mapping of PaF patterns to message flows. We finish off with outlining the additional tangible and non-tangible benefits that the Workflow Management System provides, such as monitoring. In a nut shell, we illustrate that the PaF architecture does not require an own implementation, but can be converted into appropriate models to workflows for execution by an appropriate system.
Conference Paper
Modeling and execution of business processes is often performed on different levels of abstraction. For example, when a business process is modeled using a high-level notation near to business such as Event-driven Process Chains (EPC), a technical refinement step is required before the process can be executed. Also, model-driven process design allows modeling a process on high-level, while executing it in a more detailed and executable low-level representation such as processes defined in the Business Process Execution Language (BPEL) or as Java code. However, current approaches for graphical monitoring of business processes are limited to scenarios in which the process that is being executed and the process that is being monitored are either one and the same or on the same level of abstraction. In this paper, we present an approach to facilitate business-oriented process monitoring while considering process design on high-level. We propose process views for business process monitoring as projections of activities and execution states in order to support business process monitoring of running process instances on different levels of abstraction. In particular, we discuss state propagation patterns which can be applied to define advanced monitoring solutions for arbitrary graph-based process languages.
Article
The Pipes-and-Filters (PaF) Architecture has been prominently exploited in the context of Enterprise Application Integration (EAI). The individual tasks have typically been implemented using specialized EAI-vendor technology, message flows, and quite often customer-specific implementations. This implementation approach is in conflict with the flow technology that is a cornerstone of the Service-Oriented Architecture (SOA). We show in this paper how this conflict can be resolved. We first show how the PaF architecture can be implemented using flow technology by transforming the appropriate PaF patterns, in particular those used in EAI, into appropriate WS-BPEL constructs. We then present the results of appropriate tests that show that the performance of the corresponding workflows is superior to the mapping of PaF patterns to message flows. We finish off with outlining the additional tangible and non-tangible benefits that the Workflow Management System (WfMS) provides, such as monitoring. In a nut shell, we illustrate that the PaF architecture does not require an own implementation. It is sufficient to have a PaF modeling tool and then convert the appropriate models to workflows for execution by an appropriate WfMS.
Conference Paper
Full-text available
In a software product family context, software architects design architectures that support product diversification in both space (multiple contexts) and time (changing contexts). Product diversification is based on the concept of variability: a single architecture and a set of components support a family of products. Software product families need to support increasing amounts of variability, leading to a situation where variability dependencies become of primary concern. This work presents (1) a formalization of variability dependencies and (2) a case study in designing a program monitor and exception handler. The case study uses the formalization to describe variability dependencies in constraint specification language style and shows that architectural robustness is related to the type of variability dependencies.
Article
From the Book:In the spring of 1999 I flew to Chicago to consult on a project being done by ThoughtWorks, a small but rapidly growing application development company. The project was one of those ambitious enterprise application projects: a back-end leasing system. Essentially what this system does is to deal with everything that happens to a lease after you've signed on the dotted line. It has to deal with sending out bills, handling someone upgrading one of the assets on the lease, chasing people who don't pay their bills on time, and figuring out what happens when someone returns the assets early. That doesn't sound too bad until you realize that leasing agreements are infinitely varied and horrendously complicated. The business "logic" rarely fits any logical pattern, because after all its written by business people to capture business, where odd small variations can make all the difference in winning a deal. Each of those little victories is yet more complexity to the system. That's the kind of thing that gets me excited: how to take all that complexity and come up with system of objects that can make more tractable. Indeed I belive that the primary benefit of objects is in making complex logic tractable. Developing a good Domain Model (133) for a complex business problem is difficult, but wonderfully satisfying. Yet that's not the end of the problem. Such a domain model has to persisted to a database, and like many projects we were using a relational database. We also had to connect this model to a user interface, provide support to allow remote applications to use our software, and integrate our software with third party packages. All of this on a newtechnology called J2EE which nobody in the world had any real experience in using. Even though this technology was new, we did have the benefit of experience. I'd been doing this kind of thing for ages now with C++, Smalltalk, and CORBA. Many of the ThoughtWorkers had a lot of experience with Forte. We already had the key architectural ideas in our heads, we just had to figure out how to apply them to J2EE. Looking back on it three years later the design is not perfect, but it's stood the test of time pretty damn well. That's the kind of situation that is where this book comes in. Over the years I've seen many enterprise application projects. These projects often contain similar design ideas which have proven to be effective ways to deal with the inevitable complexity that enterprise applications possess. This book is a starting point to capture these design ideas as patterns. The book is organized in two parts. The first part is a set of narrative chapters on a number of important topics in the design of enterprise applications. They introduce various problems in the architecture of enterprise applications and their solutions. However the narrative chapters don't go into much detail on these solutions. The details of the solutions are in the second part, organized as patterns. These patterns are a reference and I don't expect you to read them cover to cover. My intention is that you can read the narrative chapters in part one from start to finish to get a broad picture of what the book covers, then you can dip into the patterns chapters of part two as your interest and needs drive you. So this book is a short narrative book and a longer reference book combined into one. This is a book on enterprise application design. Enterprise applications are about the display, manipulation and storage of large amounts of often complex data and the support or automation of business processes with that data. Examples include reservation systems, financial systems, supply chain systems, and many of the systems that run modern business. Enterprise applications have their own particular challenges and solutions. They are a different animal to embedded systems, control systems, telecoms, or desktop productivity software. So if you work in of these other fields, there's nothing really in this book for you (unless you want to get a feel for what enterprise applications are like.) For a general book on software architecture I'd recommend POSA. There are many architectural issues in building enterprise applications. I'm afraid this book can't be a comprehensive guide to them. In building software I'm a great believer in iterative development. At the heart of iterative development is the notion that you should deliver software as soon as you have something useful to the user, even if it's not complete. Although there are many differences between writing a book and writing software, this notion is one that I think the two share. So this book is an incomplete but (I trust) useful compendium of advice on enterprise application architecture. The primary topics I talk about are: layering of enterprise applications how to structure domain (business) logic the structure of a web user interface how to link in-memory modules (particularly objects) to a relational database how to handle session state in stateless environments some principles of distributionThe list of things I don't talk about is rather longer. I really fancied writing about organizing validation, incorporating messaging and asynchronous communication, security, error handling, clustering, application integration, architectural refactoring, structuring rich-client user interfaces, amongst others. I can only hope to see some patterns appear for this work in the near future. However due to space, time, and lack of cogitation you won't find them in this book. Perhaps I'll do a second volume someday and get into these topics, or maybe someone else will fill these, and other, gaps. Of these, dealing with message based communication is a particularly big issue. Increasingly people who are integrating multiple applications are making use of asynchronous message based communication approaches. There's much to said for using them within an application as well. This book is not intended to be specific for any particular software platform. I first came across these patterns while working with Smalltalk, C++, and CORBA in the late 80's and early 90's. In the late 90's I started to do extensive work in Java and found these patterns applied well both to early Java/CORBA systems and later J2EE based work. More recently I've been doing some initial work with Microsoft's .NET platform and find the patterns apply again. My ThoughtWorks colleagues have also introduced their experiences, particularly with Forte. I can't claim generality across all platforms that ever have been or will be used for enterprise applications, but so far these patterns have shown enough recurrence to be useful. I have provided code exampl for most of these patterns. My choice of language for the code examples is based on what I think most readers are likely to be able to read and understand. Java's a good choice here. Anyone who can read C or C++ can read Java, yet Java is much less complex than C++. Essentially most C++ programmers can read Java but not vice versa. I'm an object bigot, so inevitably lean to an OO language. As a result most of the code examples are in Java. As I was working on the book Microsoft started stabilizing their .NET environment, and their C# language has most of the same properties as Java for an author. So I did some of the code examples in C# as well, although that does introduce some risk since developers don't have much experience with .NET yet and so the idioms for using it well are less mature. Both are C-based languages so if you can read one you should be able to read both, even if you aren't deeply into that language or platform. My aim was to use a language that the largest amount of software developers can read, even if it's not their primary or preferred language. (My apologies to those who like Smalltalk, Delphi, Visual Basic, Perl, Python, Ruby, COBOL or any other language. I know you think you know a better language than Java or C#, all I can say is I do too!) The examples are there for inspiration and explanation of the ideas in the patterns. They are not canned solutions, in all cases you'll need to do a fair bit of work to fit them into your application. Patterns are useful starting points, but they are not destinations. Who This book Is ForI've written this book for programmers, designers, and architects who are building enterprise applications and who want to either improve their understanding of these architectural issues or improve their communication about them. I'm assuming that most of my readers will fall into two groups: either those with modest needs who are looking to build their own software to handle these issues, or readers with more demanding needs who will be using a tool. For those of modest needs, my intention is that these patters should get you started. In many areas you'll need more than the patterns will give you, but my intention is to provide more of a head start in this field than I got. For tool users I hope this book will be useful to give you some idea of what's happening under the hood, but also help you in making choices between which of the tool supported patterns to use. Using, say, an object-relational mapping tool still means you have to make decisions about how to map certain situations. Reading the patterns should give you some guidance in making the choices. There is a third category, those with demanding needs who want to build their own software for these problems. The first thing I'd say here is look carefully at using tools. I've seen more than one project get sucked into a long exercise at building frameworks which weren't what project was really about. If you're still convinced, go ahead. Remember in this case that many of the code examples in this book are deliberately simplified to help understanding, and you'll find you'll need to do a lot tweaking to handle the greater demands that you'll face. Since patterns are common solutions to recurring problems, there's a good chance that you'll have already come across some of them. If you've been working in enterprise applicat while, you may well know most of them. I'm not claiming to have anything new in this book. Indeed I claim the opposite—this is a book of (for our industry) old ideas. If you're new to this field I hope you'll like this book to help you learn about these techniques. If you're more familiar with the techniques I hope you'll like this book because it helps you communicate and teach these ideas to others. An important part of patterns is trying to build a common vocabulary, so you can say that this class is a Remote Facade (413) and other designers know what you mean. Martin Fowler, Melrose MA, May 2002 http://martinfowler.com
Article
With the emergence of commercial-off-the-shelf (COTS) component middleware technologies software system integrators are increasing faced with the task of integrating heterogeneous enterprise distributed systems built using different COTS tech-nologies. Although there are well-documented patterns and techniques for system integration using various middleware tech-nologies, system integration is still largely a tedious and error-prone manual process. To improve this process, component developers and system integrators must understand key properties of the systems they are integrating, as well as the integra-tion technologies they are applying. This paper provides three contributions to the study of functional integration of distributed enterprise systems. First, we de-scribe the challenges associated with functionally integrating software for these types of systems. Second, we describe how the composition of domain-specific modeling languages (DSMLs) can simplify the functional integration of enterprise dis-tributed systems by enabling the combination of diverse middleware technologies. Third, we demonstrate how composing DSMLs can solve functional integration problems in an enterprise distributed system case study by reverse engineering an ex-isting CCM system and exposing it as web service(s) to web clients who use these services. This paper shows that functional integration done using (meta)model composition provides significant benefits with respect to automation and re-usability compared to conventional integration processes and methods.
Conference Paper
Service-oriented Architecture (SOA) is one method to integrate and construct loose-coupling software systems. It turns the distributed enterprise applications and new systems into software service on Internet. Traditional enterprise application integrating (EAI) method cannot meet the requirements of operation flexibility, extensibility and loose-coupling integration. This paper proposes the function model of one service-oriented EAI platform (UAP) and its realization mechanism. By turning existing enterprise applications into one integrated system and distributing the services, UAP has provided one SOA based integrating platform for enterprise applications. The above model is implemented and validated in a J2EE application server to integrate the application systems of one group company. The experiments show that the model manifests high operation flexibility, scalability, loose-coupling character and low integrating workload.
Conference Paper
A great challenge for enterprises is the improvement of the utilization of their landscape of heterogeneous applications in complex EAI (Enterprise Application Integration) scenarios. Enterprise Application Integration Patterns help to address this challenge by describing recurring EAI problems and proposing possible solutions at an abstract level. However, EAI patterns are documentation only used by systems architects and developers to decide how to implement an integration solution. Thus, patterns do not specify how to produce the code that will actually implement the solution described by the pattern on a specific middleware. In this paper we introduce a framework that provides configuration capabilities for EAI patterns. The framework also allows to generate executable integration code from EAI patterns using a model-driven architecture approach. Furthermore, we present a tool providing this framework.
Article
69 pages Integrating enterprise applications is a challenging topic. The book "Enterprise Integration Patterns" by Gregor Hohpe and Bobby Woolf describes a collection of patterns residing in the domain of enterprise application integration using messaging. The book describes frequently recurring problems in this domain and their solution in the form of patterns. The main objective of this work is to analyze the implementation of these Enterprise Integration Patterns in Apache Camel. Apache Camel is a routing and mediation engine which implements the Enterprise Integration Patterns. It provides a framework where these patterns can be used to integrate different applications. In this work the Apache Camel platform is evaluated regarding the correct implementation of the Enterprise Integration Patterns. The result of this evaluation is then used to develop a framework, which extends the Apache Camel framework, enabling the execution of parameterized patterns. Additionally an existing graphical editor for the modeling of integration scenarios using patterns is extended. In the existing editor these modeled integration scenarios can be used to generate corresponding WS-BPEL processes. The extension implemented in this work additionally allows to generate Apache Camel based Java applications executing the modeled integration scenarios.
Article
One of the predominant problems IT companies are facing today is Enterprise Application Integration (EAI). Most of the infrastructures built to tackle integration issues are proprietary because no standards exist for how to model, develop, and actually execute integration scenarios. EAI patterns gain importance for non-technical business users to ease and harmonize the development of EAI scenarios. These patterns describe recurring EAI challenges and propose possible solutions in an abstract way. Therefore, one can use those patterns to describe enterprise architectures in a technology neutral manner. However, patterns are documentation only used by developers and systems architects to decide how to manually implement an integration scenario. Thus, patterns are not theoretical thought to stand for artefacts that will immediately be executed. This paper presents a tool supporting a method how EAI patterns can be used to automatically generate executable artefacts for various target platforms using a model-driven development approach, hence turning patterns into something executable. Therefore, we introduce a continuous tool chain beginning at the design phase and ending in executing an integration solution in a fully automatically manner. For evaluation purposes we introduce a scenario demonstrating how the tool is utilized for modelling and actually executing an integration scenario.
Article
27 pages Customizable applications play an important role in software as a service (SaaS) scenarios. SaaS application providers want to exploit economies of scale by offering the same basic application to many customers. As customers have different requirements for the same type of application, SaaS vendors must offer so-called application templates that can be customized by their customers to be tailored exactly to their needs. Therefore variability points (i.e., points in an application template that can be customized) need to be made explicit and constraints for these variability points need to be specified. We introduce variability descriptors as a means to describe variability points for SaaS application templates independent of the artifacts (such as GUI components, workflows, configuration files, etc.) that make up the application.
Conference Paper
Software as a Service (SaaS) is a new delivery model for software. Software in a SaaS model is no longer run exclusively for one customer at a customer's premise but run at a service provider and accessed via the Internet. A provider of Software as a Service exploits economies of scale by hosting and providing the same application for several different customers. However, each individual customer has different requirements for the same basic application. In order to allow each customer to customize the process layer and related artifacts of a SaaS application to their specific needs the application needs to provide a set of variability points that can be modified by customers. In this paper we describe the notion of a variability descriptor that defines variability points for the process layer and related artifacts of process-based, service-oriented SaaS applications. Furthermore we describe how these variability descriptors can be transformed into a WS-BPEL process model that can then be used to guide a customer through the customization of the SaaS application.
Conference Paper
Currently, several vendors and projects are building proprietary SaaS platforms where more and more applications are hosted in a Software as a Service business model. However, these proprietary platforms prevent that applications offered by different SaaS application vendors can be easily reused on the platforms offered by the different SaaS hosting providers. In this paper we describe a package format for composite configurable SaaS application packages for applications developed following a service oriented architecture. We show how the service component architecture (SCA) can be extended with variability descriptors and SaaS multi-tenancy patterns to package and deploy multi- tenant aware configurable composite SaaS applications.
Article
Anyone intent on developing a Java-based framework for enterprise integration would do well to keep a few things in mind. One lesson is that today's Java programmers want to write Java, not stylized or otherwise "special" Java that must incorporate framework-specific artifacts. Another lesson is that standardizing a suitable integration-focused framework would be a good idea, given that the alternative is to add yet another proprietary system to a field already rife with stove-piped solutions that don't work together. The most important lesson, however, could well be that when it comes to integration, Java can't solve it all. Making it possible for solutions outside traditional Java programming to work within the framework is thus a necessity, not a nicety. One standards effort currently targeting the business-integration space is Java Specification Request 208, entitled "Java Business Integration" (JBI). Like other JSRs in the Java Community Process, JBI obviously has to work with the Java 2 platform - in this case, both the standard and enterprise editions (J2SE and J2EE, respectively). It also wisely goes beyond the Java-centric focus in most JSRs and aims to accommodate implementation alternatives outside the pure Java space. The approach underlying JBI is a bit unusual compared to other JSRs in that it uses Web services at its core. Rather than focusing on how to build Web services using Java, it promotes an architecture that's strongly based on Web services' principles and approaches.
Realization of EAI patterns in Apache Camel Student research project Architektur eines ESBs zur Unterstu¨tzung von EAI Patterns
  • P Kolb
Kolb, P., 2008. Realization of EAI patterns in Apache Camel. Student research project (in German). Universita¨, Germany. Mierzwa, C., 2008. Architektur eines ESBs zur Unterstu¨tzung von EAI Patterns. Diploma thesis (in German), Universita¨, Germany.
Prototype for executable EAI patterns Available from: http://www.informatik.uni-stuttgart.de/cgi-bin/NCSTRL/ NCSTRL_view.pl?id¼DIP-2634&engl¼0
  • X Yuan
Yuan, X., 2008. Prototype for executable EAI patterns. Diploma thesis, Universita¨, Germany. Available from: http://www.informatik.uni-stuttgart.de/cgi-bin/NCSTRL/ NCSTRL_view.pl?id¼DIP-2634&engl¼0. Enterprise Information Systems
Enterprise service bus. Cambridge: O'Reilly Media
  • D Chappell
Chappell, D., 2004. Enterprise service bus. Cambridge: O'Reilly Media.
EAI as a service – combining the power of executable EAI patterns and SaaS From modelling to execution of enterprise integration scenarios: the GENIUS tool Software as a service: An integration perspective
  • T Scheibler
  • F Leymann
Scheibler, T. and Leymann, F., 2008. A framework for executable enterprise application integration patterns. In: K. Mertins, R. Rainer, K. Popplewell, and X. Xu, eds. 4th international conference interoperability for enterprise software and applications (I-ESA 2008). Berlin. Scheibler, T., Mietzner, R., and Leymann, F., 2008. EAI as a service – combining the power of executable EAI patterns and SaaS. In: M. Spies, G. Weber, and M. Wirsing, eds. 12th IEEE international EDOC enterprise computing conference. Munich. Scheibler, T. and Leymann, F., 2009. From modelling to execution of enterprise integration scenarios: the GENIUS tool. In: K. Geihs and K. David, eds. 16th conference – communication in distributed systems 2009 (KiVS 2009). Kassel. Sun, W., et al., 2007. Software as a service: An integration perspective. In: B.J. Kramer and K.-J Lin, eds. Service-oriented computing – ICSOC 2007. Lecture Notes in Computer Science. Berlin: Springer.
Parametrisierung von EAI Patterns Diploma thesis Direct model execution – the key to IT productivity and improving business performance. White Paper. Eclipse Foundation
  • B Druckenmuï
Druckenmuï, B., 2007. Parametrisierung von EAI Patterns. Diploma thesis (in German), Universita¨, Germany. E2E Technologies Ltd, 2008. Direct model execution – the key to IT productivity and improving business performance. White Paper. Eclipse Foundation, 2003. Eclipse Modeling Framework (EMF) [online]. Available from: http://www.eclipse.org/emf.
EAI as a service - combining the power of executable EAI patterns and SaaS. 12th IEEE international EDOC enterprise computing conference
  • T Scheibler
  • R Mietzner
  • F Leymann
  • M Spies
  • G Weber
  • M Wirsing
  • Munich
A framework for executable enterprise application integration patterns. 4th international conference interoperability for enterprise software and applications (I-ESA
  • T Scheibler
  • F Leymann
  • K Mertins
  • R Rainer
  • K Popplewell
  • X Xu