JavaBeans Components Research Articles

Metrics for reusability of java language components

Software reuse is a promising opportunity for a software development process that helps in achieving an improved quality of the developed software system. Improved quality also promotes software architecture reuse opportunities. From the past few decades, software reuse is actively gaining popularity in the form of Component Based Software Development (CBSD). The components being the basic unit in CBSD, accessing their reusability is a useful and open area of investigation. The extent of the reusability can be quantified based on the extent of intra and inter-connectivity of the attributes/ characteristics of the component. This can be computed by defining suitable metrics to measure the reusability of a component. Although, there exist some metric suites such as CK, MOOD, Halstead, McCabe’s metric, etc. for measuring the reusability of the object-oriented software systems, but they are not directly reusable in the CBSD environment. This is due to the fact that these metrics are applicable only at the class level and they do not target the interfaces of the component that are important and define the composability of the component in the CBSD environment. Therefore, this paper aims to study the reusability, flexibility, composability, and adaptability aspects of the software component. Further, based on the study conducted, we propose a reusability metric suite specially designed for the JavaBeans. This metric helps to measure the architecture level reusability of the JavaBeans. The JavaBeans component standard is specially targeted in this paper because components based on this standard are not fully explored and only a few metric suites exist for measuring the reusability of the JavaBeans. The proposed component reusability metric suite is validated both experimentally as well as against Briand’s framework.

RETRACTED ARTICLE: Constant water circulating ecological influence and remote English education system development based on sequence matching

This article discusses the development status of sequence matching and closed-loop detection, and focuses on the inherent problems in closed-loop analysis methods. By analyzing the basic theory of sequence matching, the closed-loop detection implementation method of each sequence matching is summarized, and detailed closed-loop components corresponding to sequence matching are summarized, and the existing methods for achieving different modules are summarized and their disadvantages are reviewed. In line with this, this paper focuses on the focus on the central Z Basin area of the H River domain. Combined with systematic analysis of surface water and groundwater conversion characteristics, the Z Basin annual water balance model is proposed, and the relationship between surface water and groundwater is further explained. The annual water balance model contains a nonlinear model of water circulating ecology, which fully considers the runoff of rivers under river water abundance changes and irrigation on water cycle ecology. Finally, this paper proposes a remote English education system based on JavaBean components and software architectures. After comprehensive, extensive testing and research, it reduces software development costs under this field, not only improves system reliability, but also shortens the development cycle, simplifies system maintenance measures, and ultimately makes the maximum extension and stability. With regard to system testing, a complete test will be performed through web test methods and cookie laws, performance, feasibility, compatibility, and security. This article uses a variety of test methods, a variety of test content, through comprehensive testing, which fully meets the expected requirements, promoting the system to fully meet the ability of daily learning and work requirements.

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.

Mining Reusable Software Components from Object-Oriented Source Code using Discrete PSO and Modeling Them as Java Beans

Object-based software development in the IT-industry during the last decade has focused on reusing the already developed elements. Current software development models and technologies promote software reuse by utilizing component-oriented programming. Component-oriented programming provides more effective reuse as compared to its object-oriented language counterpart. This is because a component provides more abstractness in terms of the functionality in contrast to the object-oriented software element (e.g. class/ interface). The component-based development is highly dependent on the availability of the component library that contains well-defined and already tested functionality in terms of the available components. However, the suitable availability of such component library is still a problem. The lack of a suitable component library is tackled either by designing new components from scratch or by identifying them from the existing software systems. These identified components must be transformed as per component models, such as a Java Bean, in order to increase software reuse and faster software development, and little research has been carried out in this direction. Although many approaches have been proposed to identify components from existing systems and build a component library. But, such approaches lack in transforming the identified components as per specifications of a component model. Further identification of reusable elements also needs to be more accurate and efficient. Accuracy is dependent on the structural and semantic properties of a component. A component can consist of a single or a group of individual elements of the software, and thus identifying components from a set of all elements becomes an exponentially growing problem. Such problems can be more efficiently solved using metaheuristic algorithms. Therefore, this paper targets identifying accurately the components from a singular existing software system and transform those identified components to the Java Bean component model standard. The component identification approach of this paper is based on clustering the underlying software system by utilizing a metaheuristic search-based PSO algorithm. The clusters are identified as a group containing 2/ 3/ 4 software elements. Moreover, the used fitness function is based on the structural (based on usage for member variables) and semantic relations belonging to a software. Since the PSO algorithm is generally applied to continuous problems, whereas our formulated component identification problem is discrete (due to the representation of particles) in nature. Therefore, we have also provided a mechanism through which the PSO algorithm is modified to become applicable to discrete problems. From the obtained clusters (components), the interfaces of the components are identified by identifying independent chains in call-graphs of the underlying components. Finally, these components are transformed as per the Java Bean component model specifications. The proposed approach is validated experimentally on 7 open-source object-oriented Java software systems and results are compared with competitive approaches. The obtained results confirm the correctness of the transformed component and hence their reusability.

Dynamic Component Composition

This paper presents an approach to dynamic component composition that facilita tes creating new composed components using existing ones at runtime and without any code generation. The dynamic abilities are supported by extended typenotion and implementation based on additional superstructure provided with its Java API and corresponding JavaBeans components . The new component composition is performed by building the composed prototype object that can be dynamically transformed into the new instantiable type (component). That approach demonstrates interrelations between prototype -based and class-based component-oriented programming. The component model proposed can be used when implementing user-defined types in declarative languages for event -driven applications programming.

EMPIRICAL EVALUATION AND VALIDATION OF INTERFACE COMPLEXITY METRICS FOR SOFTWARE COMPONENTS

The major drivers for complex applications are cost, efficiency, development time, understandability, usability and more importantly the maintainability. Due to their black box nature, complexity of software components is more crucial for component-based systems. This paper discusses various complexity concerns for these systems and reviews a number of complexity metrics for software components and component-based systems. As interfaces are the only source of information to know about the black-box components, this paper proposes a new interface complexity metric for these components. This metric is based on the information available in the interfaces like interface methods and properties. It also discusses the methodology to assign the weight values to these methods and properties to finally evaluate the complexity of the component. This paper validates the proposed metric against standard Weyukar's properties and empirically evaluates the metric for several Java Bean components. Finally a correlation analysis between proposed metrics and several other metrics like performance, customizability and readability is done to validate the metric.

MDABench: Customized benchmark generation using MDA

This paper describes an approach for generating customized benchmark suites from a software architecture description following a Model Driven Architecture (MDA) approach. The benchmark generation and performance data capture tool implementation (MDABench) is based on widely used open source MDA frameworks. The benchmark application is modeled in UML and generated by taking advantage of the existing community-maintained code generation “cartridges” so that current component technology can be exploited. We have also tailored the UML 2.0 Testing Profile so architects can model the performance testing and data collection architecture in a standards compatible way. We then extended the MDA framework to generate a load testing suite and automatic performance measurement infrastructure. This greatly reduces the effort and expertise needed for benchmarking with complex component and Web service technologies while being fully MDA standard compatible. The approach complements current model-based performance prediction and analysis methods by generating the benchmark application from the same application architecture that the performance models are derived from. We illustrate the approach using two case studies based on Enterprise JavaBean component technology and Web services.

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 component-based product data management system

Companies today have been attempting to expand their Internet infrastructures to cope with the growth of global business environments. In modern manufacturing industries, they are migrating their legacy product data management (PDM) systems to Web-based systems (being an essential tool of eManufacturing) to use the Internet. Accordingly, recent advances in PDM technology have dealt with the use of Web-based technology. Some research and development on Web-based PDM systems has been described in the literature, but those efforts have technical limits. They are not adequately available, secure, reliable, and scalable for global enterprise services. This paper describes the design of a component-based product data management (CPDM) system for supporting global manufacturing. The CPDM system is aimed at assuring flexibility, security, stability, and maintainability by utilizing a standard architecture of J2EE technology. The CPDM system consists of three tiers based on the J2EE architecture. The first is the presentation tier implemented as JSP/servlet components to allow users to access the system through a Web browser. The second is the business logic tier, which is implemented as Enterprise JavaBeans (EJB) components to handle the core PDM functionality. The third level is the data tier, composed of a database and vault for the physical files. To develop the components of the CPDM system, a component-based development (CBD) approach is proposed. The associated component development procedure is illustrated with examples. The CPDM system is also tested for its performance.

Component-oriented programming

Preface. 1. Introduction. 1.1 What is COP? 1.2 Why is COP important? 1.3 What is a component? 1.4 Hardware components and software components. 1.5 From OOP to COP. 1.6 Component-based software engineering. 1.7 Summary. 1.8 Self-review questions. 1.9 Exercises. 2. A Theory of Components. 2.1 Principles of COP. 2.2 Infrastructures of COP. 2.3 Component models. 2.4 Connection models. 2.5 Deployment models. 2.6 Unifying component technologies. 2.7 Summary. 2.8 Self-review questions. 2.9 Exercises. 3. COP with JavaBeans. 3.1 Overview of JavaBeans technology. 3.2 The component model of JavaBeans. 3.3 The connection model of JavaBeans. 3.4 The deployment model of JavaBeans. 3.5 Examples and lab practice. 3.6 Summary. 3.7 Self-review questions. 3.8 Exercises. 4. Enterprise JavaBeans Components. 4.1 The EJB a rchitecture. 4.2 The component model of EJB. 4.3 The connection model of EJB. 4.4 The deployment model of EJB. 4.5 Examples and lab practice. 4.6 Summary. 4.7 Self-review questions. 4.8 Exercises. 4.9 Programming exercises. 5. CORBA Components. 5.1 The COBRA component infrastructure. 5.2 The CORBA component model (CCM). 5.3 The connection model of CORBA and CCM. 5.4 The deployment model of CORBA and CCM. 5.5 Examples and lab practice. 5.6 Summary. 5.7 Self-review questions. 5.8 Exercises. 5.9 Programming exercises. 6. .NET Components. 6.1 The .NET framework. 6.2 The component model of .NET. 6.3 The connection model of .NET. 6.4 .NET component deployments. 6.5 Visual Studio .NET. 6.6 Examples and lab practice. 6.7 Summary. 6.8 Self-review questions. 6.9 Exercises. 6.10 Programming exercises. 7. COP with OSGi Components. 7.1 Overview of OSGi technology. 7.2 The component model of OSGi. 7.3 The connection model of OSGi. 7.4 The deployment model of OSGi. 7.5 Examples and lab practice. 7.6 Summary. 7.7 Self-review questions. 7.8 Exercises. 8. Web Services Components. 8.1 The Web Services framework. 8.2 The component model of Web Services. 8.3 The connection model of Web Services. 8.4 Web Services component deployment. 8.5 Examples and lab practice. 8.6 Summary. 8.7 Self-review questions. 8.8 Exercises. 8.9 Programming exercises. Appendix.

A technique for automatic component extraction from object-oriented programs by refactoring

Component-based software development (CBD) is based on building software systems from previously-existing software components. In CBD, reuse of common parts in component form can reduce the development cost of new systems, and reduce the maintenance cost associated with the support of these systems. However, existing programs have usually been built using another paradigm, such as the object-oriented (OO) paradigm. OO programs cannot be reused rapidly or effectively in the CBD paradigm even if they contain reusable functions. In this paper, we propose a technique for extracting components from existing OO programs by our new refactoring “Extract Component”. Our technique of refactoring can identify and extract reusable components composed of classes from OO programs, and modify the surrounding parts of extracted components in original programs. We have developed a system that performs our refactoring automatically and extracts JavaBeans components from Java programs. As a result of evaluation experiments, it is found that our system is useful for extracting reusable components along with usage examples from Java programs.

MZ-Platform: A Component Switching AndExecuting Environment

We have started a national research and development project of a manufacturing technology information infrastructure called MZ-Platform. MZ-Platform is a component-based software development framework, designed to support manufacturing enterprises to enhance digitalized technologies in a selfinnovative way. The major characteristic is that it can switch the running program by changing their components dynamically. It can load JavaBeans components searched by a component mining method, make connections with other active components and execute them. We show some application examples related to design and a manufacturing, such as a CAD (Computer Aided Design)

Using the philosophy of mobile agent technology for e‐service in the field of reverse engineering applications

Reverse engineering methodology paves an efficient way for simulating and manufacturing existing objects with complex shapes, and a range of applications also has shown this approach to be feasible and efficient. However, in many applications, a lot of sub‐tasks in reverse engineering are usually not done in the same place, they need to be done cooperatively over the Internet or Intranet. So, this paper is concerned with developing a novel e‐service platform for remote service in reverse engineering applications based on mobile agent technology, and some correlative enabling technologies such as data compression, security considerations, agent models and so on. The framework was programmed using the Java Sevlets and Java Beans component models, and data transferring and processing were implemented based on the dispatch/retract mechanisms of mobile agents. The mobile agent is developed with IBM's Aglets Workbench, and the feasibility of the proposed method has been verified by a case.

Model driven arcitecture is ready for prime time

The reason we're on the brink of moving toward the Object Management Group's Model Driven Architecture (MDA) is that the technologies we use have grown significantly more complex over the last few years. Moreover, technology changes faster than the businesses we're trying to support with this technology. Why would I bother to implement a bidirectionally navigable association between two Enterprise JavaBean components if I can just draw an association between two classifiers in a Unified Modeling Language diagram? Moreover, why would I go to the trouble of creating all the technical detail involved in implementing an association manually if the result of doing so is not portable? It turns out that you can employ 3GLs to specify these platforms' use as well as you might use assembly language to create a Web-based customer relationship management system; they're simply not the most appropriate way to express the system's structure and behavior.

Evaluating the performance of ejb components

As part of the Middleware Technology Evaluation (MTE) project, we conducted several experiments to explore the performance implications of two common application architectures supported by J2EE's enterprise JavaBean (EJB) component technology. One architecture promises simpler engineering and maintenance of the resulting component collection. For applications that require high performance and scalability, however, the alternative architecture might offer a better solution. Such knowledge is crucial to software architects, who must make initial design decisions early in a project, before extensive engineering has begun. An examination of two EJB-based architectures reveals differences that can significantly affect the performance and scalability of applications built on them.

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.

A design for standards-based knowledge components

THIS PAPER describes ongoing work in designing and developing modular software components that are based on open standards and conform to a specific instructional design theory. The authors identified three problems exhibited by modern authoring tool software. The identified problems are proprietary architectures, instructional design theory neutrality, and monolithic structures. To begin solving these problems, software components were written in the Java programming language as Java Beans. The Java Beans conformed to the Java Bean component architecture specification. Instructional content was then captured and tagged utilizing eXtensible Markup Language (XML), which has recently been adopted by the World Wide Web Consortium (W3C) as an open Internet standard. Finally, to promote adherence to a particular instructional theory, the prototype components were based upon the knowledge representation scheme and instructional strategy prescriptions of Merrill’s instructional transaction theory. The focus of this paper is on applied technological solutions to overcome the limitations of current authoring environments. Technological solutions have been employed to meet larger goals of improved computer-based instruction. The implications for instruction resulting from this approach are that the original goals of instructional transaction theory can be met. These goals are to enable the development of a) more effective instruction, b) more efficient instruction, c) better instructional learning environments, and d) more adaptive instruction.