Enterprise JavaBeans Applications Research Articles

I2SD: reverse engineering Sequence Diagrams from Enterprise Java Beans with interceptors

An Enterprise JavaBeans (EJB) interceptor is a software mechanism that provides for introducing behaviour implemented as separate code into the execution of a Java application. In this way, EJB interceptors provide a clear separation of the core functionality of the bean and other concerns, such as logging or performance analysis. Despite the beauty of the idea behind the i nterceptors, developing, testing and managing dependencies introduced by the interceptors are considered to be daunting tasks. For example, the developers can specify interceptors at multiple locations and by multiple means. However, different locations and specification means influence the order of the interceptor invocation, which is governed by more than 15 different intertwined rules defined in the EJB standard. To facilitate development of EJB applications, we have designed I2SD, Interceptors to Sequence Diagrams, a tool for reverse engineering EJB applications with interceptors to unified modeling language (UML) sequence diagrams. I2SD provides the developer with a visual feedback and can be used by quality managers to obtain insights in the ways interceptors are used in their project.

Integrated Design Supporting Business Model Stability

Enterprise JavaBeans(EJB) is Java’s component architecture for server-side distributed enterprise applications. The architecture of EJB applications is based on well-established solutions common to most distributed business systems. To utilize the architecture in an optimal way, we gave a layered and integrated optimization method based on mixed design patterns to reduce the coupling degree among tiers, classified the application architecture of the system. It reduced greatly the number of lookup JNDI and remote-calling, reduces the overhead of system and networks. It improve the extensibility and reusability of system. An example was given at last.

Static verification of component composition in contextual composition frameworks

Contextual component frameworks, such as Enterprise JavaBeans (EJB), allow for components to specify boundary conditions for the runtime context. These conditions are satisfied at runtime by services of the underlying platform, thus ensuring that the context in which components run exhibits properties that allow them to operate correctly. Depending on how components call each other, it is possible that satisfying such conditions lead to problems such as reduced performance due to redundant service execution, or permanent errors (composition mismatches), due to incompatible boundary conditions. Currently, the semantics of these boundary conditions are expressed in natural language only, making it impossible to incorporate them into an automatic analysis tool. Furthermore, early understanding of how components call each other would be necessary, but it is currently difficult to achieve by means of a tool, as the method dispatch rules in a component system differ from the dispatch rules of the programming language(s) in which they were developed. We have developed a metamodel, $${\mathbb{M}}$$, for describing boundary conditions, an analysis method, $${\mathbb{A}}$$, and a static component-level call graph extraction method for EJB applications, CHA EJB . $${\mathbb{A}}$$ uses $${\mathbb{M}}$$ models to analyze inter-component call graphs, and thus detect problems such as composition mismatches or redundancies, thus allowing for remedial action to take place. We present $${\mathbb{M}},{\mathbb{A}}$$ and CHA EJB in this article, show that $${\mathbb{A}}$$ produces correct results, and describe a prototype analysis tool implementing the three, which we used to validate our approach on two popular EJB applications.

Simplifying autonomic enterprise Java Bean applications via model-driven engineering and simulation

The goal of autonomic computing is to reduce the configuration, operational, and maintenance costs of distributed applications by enabling them to self-manage, self-heal, and self-optimize. This paper provides two contributions to the Model-Driven Engineering (MDE) of autonomic computing systems using Enterprise Java Beans (EJBs). First, we describe the structure and functionality of an MDE tool that visually captures the design of EJB applications, their quality of service (QoS) requirements, and the adaptations applied to their EJBs. Second, the paper describes how MDE tools can be used to generate code to simulate adaptive systems for verification and plug EJBs into a Java component framework that provides runtime adaptation capabilities.

Removing Redundant Boundary Checks in Contextual Composition Frameworks.

Currently, contextual component frameworks, such as Enterprise JavaBeans (EJB), provide for application modularity at the cost of reduced performance. This “endemic” is partly due to the fairly liberal execution of platform code at component boundaries. The task of such code is to satisfy boundary conditions that components have specified at deployment time. In some cases, the execution of this code becomes redundant. The overhead penalty in modular applications can be reduced or eliminated if this redundancy is removed. We have developed a method for detecting and removing such redundancies. This method can be applied to optimize EJB application servers as well as other contextual composition platforms. We have evaluated our method on a prototype, and results indicate clear runtime improvements of optimized scenarios over un-optimized scenarios. We argue that it is now possible to develop modular contextually-composing applications that are also well-performing.

Design-level performance prediction of component-based applications

Server-side component technologies such as Enterprise JavaBeans (EJBs), .NET, and CORBA are commonly used in enterprise applications that have requirements for high performance and scalability. When designing such applications, architects must select suitable component technology platform and application architecture to provide the required performance. This is challenging as no methods or tools exist to predict application performance without building a significant prototype version for subsequent benchmarking. In this paper, we present an approach to predict the performance of component-based server-side applications during the design phase of software development. The approach constructs a quantitative performance model for a proposed application. The model requires inputs from an application-independent performance profile of the underlying component technology platform, and a design description of the application. The results from the model allow the architect to make early decisions between alternative application architectures in terms of their performance and scalability. We demonstrate the method using an EJB application and validate predictions from the model by implementing two different application architectures and measuring their performance on two different implementations of the EJB platform.

A simulation model of a multi-server EJB system

Despite the fact that EJB (Enterprise Java Beans) is a widely used technology, research in the area of performance modelling of EJB application servers is quite sparse. This paper will describe how Workbench™, an advanced simulation modelling tool, can be used to build a scalable model of a multi-server EJB system that allows users to input variables that describe interactions and their constituent methods, as well as system parameters. The model will output the average time for each given user interaction and allow users to seek system improvements by changing the system parameters and workloads.

Performance and scalability of EJB applications

We investigate the combined effect of application implementation method, container design, and efficiency of communication layers on the performance scalability of J2EE application servers by detailed measurement and profiling of an auction site server.We have implemented five versions of the auction site. The first version uses stateless session beans, making only minimal use of the services provided by the Enterprise JavaBeans (EJB) container. Two versions use entity beans, one with container-managed persistence and the other with bean-managed persistence. The fourth version applies the session fasade pattern, using session beans as a fasade to access entity beans. The last version uses EJB 2.0 local interfaces with the session fasade pattern. We evaluate these different implementations on two popular open-source EJB containers with orthogonal designs. JBoss uses dynamic proxies to generate the container classes at run time, making an extensive use of reflection. JOnAS pre-compiles classes during deployment, minimizing the use of reflection at run time. We also evaluate the communication optimizations provided by each of these EJB containers.The most important factor in determining performance is the application implementation method. EJB applications with session beans perform as well as a Java servlets-only implementation and an order-of-magnitude better than most of the implementations based on entity beans. The fine-granularity access exposed by the entity beans limits scalability. Use of session fasade beans improves performance for entity beans, but only if local communication is very efficient or EJB 2.0 local interfaces are used. Otherwise, session fasade beans degrade performance.For the implementation using session beans, communication cost forms the major component of the execution time on the EJB server. The design of the container has little effect on performance. With entity beans, the design of the container becomes important. In particular, the cost of reflection affects performance. For implementations using session fasade beans, local communication cost is critically important. EJB 2.0 local interfaces improve the performance by avoiding the communication layers for local communications.