JavaBeans Component Model Research Articles

Design of Inventory Management System for Herat University Using Component-Based Methodology

The focus of CBSD is to assemble the previously-existing software components and to develop new and large software systems with new characteristics. It emphasizes on the use of Off the Shelf (OTS) components instead of building a system from the scratch. The first objective of this thesis is to discuss about the Component-Based Software Development (CBSD) as one of the advanced methodologies with the example of an inventory management system for Herat University, in Afghanistan. The second objective examines more closely whether CBSD can be a proper approach in Afghanistan, particularly in context of Herat University Inventory Management System (HU-IMS).This paper only focuses on selected phases such as requirement analysis and system design of HU-IMS life cycle. JavaBeans component model and user requirement analysis formulate to design the two separate components of HU-IMS (User Management and Resource Management).Both components are designed in a general way as they either can join as a part of a pre-functional system such as Higher Education Management Information System (HEMIS) or to be used for the purpose to develop new software systems. The results of the thesis confirm that considering CBSD when designing HU-IMS can be a proper approach in the Afghanistan scenario. However, the CBSD, particularly in Afghanistan context, has its own challenges and risks as all other approaches have. Since there are not many localized libraries and repositories available, the first challenge is to find and select the proper component which can be difficult and time-consuming; and the second is the adaptation and localization of the found component insomuch as most of the software developers are unfamiliar with the emerging concept.

Extending the OBJECTIVE Benchmark for Evaluation of Active Rules in a Distributed Component Integration Environment

This research presents a benchmark for the evaluation of active rules within a distributed component integration environment. The benchmark is based on the OBJECTIVE active database benchmark. Our work was specifically performed in the context of the Integration Rules (IRules) project that uses active rules for the integration of distributed software components, which are based on the Enterprise JavaBeans component model. In addition to mapping the test rules of the OBJECTIVE benchmark to the integration rules of the IRules system, we have extended the OBJECTIVE benchmark to test additional features of a component-based active rule system, such as the event detection time, the rule execution time related to the invocation of methods on components, asynchronous coupling modes, and the rule processor execution time under a heavy event load. Although the research presents specific performance evaluation results for the IRules project, the approach more generally demonstrates the manner in which an existing rule processing benchmark for a centralized environment can be adapted and extended for use in a rule-based approach to distributed component integration.

Component adaptation for event-based application integration using active rules

Enterprise applications integrate information and applications in a distributed, networked environment to develop a global application of interconnected components and applications. This paper presents the design and implementation of the wrappers generated to adapt components to a middleware environment that employs active rules to build an enterprise application using an event-driven approach to integrating distributed black-box components. The components adapted in this implementation are based on the Enterprise JavaBeans component model. An application integrator declares the components to be integrated, and may define additional attributes, relationships, and events to be used in the integration process. The metadata for the components to be integrated is used to adapt and enhance the black-box components through the use of wrappers. The wrappers act as a proxy to the black-box component. The adaptation of the wrappers provides for the storage of additional properties for component instances and for the detection of events within the components to generate event notifications. The wrappers are automatically generated from the component metadata using the Extensible Stylesheet Language. The design and implementation of the wrappers establishes a framework that supports an active approach to component-based software integration.

A state-based modelling approach to develop component-based control software for flexible manufacturing systems

In recent years, component-based software engineering has emerged as an approach to create control software for flexible and adaptive manufacturing systems. This paper presents a state-based approach to model and design software components that can be used as building blocks for flexible manufacturing control software. Adiga and Cogez's (1993) framework for modelling object-oriented manufacturing software is extended to component-based modelling and work cell control programming. The benefits of using component-based software were fully demonstrated during configuration, integration and execution of Flexible Manufacturing System (FMS) work cell operation in the Miami University Computer Integrated Manufacturing Laboratory (CIMS Lab) by using the control software described in this paper. The software was developed using the Java Programming language and the JavaBeans component model. We emphasized generic features, reusability, ease of use, and ease of maintenance in the design of these software components. We also created simulated software components that can interact with, or replace, real system components for planning, debugging and testing purposes. Once generic software components are developed and stored in a library, users with little or no programming background can rapidly integrate them into control software by using visual design tools.

M&M's: Building Binary Software Components for Supporting Mobile-Agent Enabled Applications

Mobile Agents provide a new promising paradigm for developing distributed applications. Nevertheless, although the basic concept has been around for some years and many agent platforms are available both from the industry and research community, there are currently few examples where the technology has been deployed in the real world. One important reason for this is that using the current available agent frameworks it is quite difficult to develop applications without having to center them completely on the agents and on the agent infrastructure. In this paper, we present the M&M project, taking place at the University of Coimbra. In this project, we are developing an extensive component-based framework that enables ordinary applications to use mobile agents in a flexible and easy way. By using this approach, applications can be developed using current object-oriented approaches and become able of sending and receiving agents by the simple drag-and-drop of mobility components. The framework was implemented using the JavaBeans component model and provides integration with ActiveX, which allows applications to be written in a wide variety of programming languages. By using this framework, the development of applications that can make use of mobile regents is greatly simplified, which can contribute to a wider spreading of the mobile agent technology.

Concepts and architecture of a simulation framework based on the JavaBeans component model

We report on a combination of system theoretic simulation modeling methodology with the JavaBeans component model as a basis for a component-based simulation framework. While system theory formalisms can serve as formal, mathematical foundations for modular, hierarchical modeling and simulation, the JavaBeans component model provides the appropriate implementation base. The result of the synergism is a powerful component-based simulation framework. In this paper we present the basic concepts and overall architecture of our JavaBeans modeling and simulation framework. We review the underlying system modeling formalisms for simulation modeling, sketch the layered architecture of the framework, and show elementary simulation programming and interface-based, hierarchical coupling of simulation components in more detail. Finally, we show the current state of implementation and demonstrate how simulation models can be developed using standard bean builder tools.

Supporting architectural concerns in component interoperability standards

There has been considerable work in industry on the development of component-interoperability models, such as COM, CORBA and JavaBeans. These models are intended to reduce the complexity of software development and to facilitate reuse of off-the-shelf components. The focus of these models is syntactic interface specification, component packaging, intercomponent communication, and bindings to a runtime environment. What these models lack is a consideration of architectural concerns—specifying systems of communicating components, explicitly representing loci of component interaction, and exploiting architectural styles that provide well understood global design solutions. The work described involves introducing support for architectural concerns in component models, particularly studying techniques to support notions of architectural style and explicit connectors. The JavaBeans component model has been enhanced to support component composition according to the C2 architectural style. The approach enables the design and development of applications in the C2 style using off-the-shelf Java components or `beans' that are available to the designer. The techniques underlying the approach are described, along with a composition environment called `ARABICA' that embodies these techniques. A number of important issues that must be addressed when extending component standards to support architectural concerns are identified.

Mobile Objects and Agents (MOA)

This paper describes the design and implementation of the Mobile Objects and Agents (MOA) project at the Open Group Research Institute. MOA was designed to support migration, communication and control of agents. It was implemented on top of the Java Virtual Machine, without any modifications to it. The initial project goals were to support communication across agent migration, as a means for collaborative work; and to provide extensive resource control, as a basic support for countering denial of service attacks. In the course of the project we added two further goals: compliance with the Java Beans component model, which provides for additional configurability and customization of agent system and agent applications; and interoperability, which allows cooperation with other agent systems. This paper analyses the architecture of MOA, in particular the support for mobility, naming and locating, communication, and resource management. Object and component models of MOA are discussed and some implementation details described. We summarize the lessons learned while developing and implementing MOA and compare it with related work.