Component development application frame design -------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------- Frame must be robust, expandable, flexible, And support dynamic content, which requires open or sharing standards. The frame design is necessary to do: completeness, flexibility, scalability, understandability, and abstract can be used for different occasions; users can easily add and modify features, custom frame; user, and framework interaction, Document is complete. A core problem of frame design is to discover reusable design and "hotspots" to ensure full flexibility, enabling users to generate applications on an existing component, implement the ideal goal of "zero code writing". First, how to design the application framework? At present, there are fewer technologies in frame design, and it can be divided into two categories: practice method and system law. 1. Practical Law Many experts even think that the framework cannot be the result of the system design, but only one result in the design from the bottom. Practical law can also be said to be an example-driven design method. It is from several specific typical applications, abstracts similar points to build a framework, and the frame is connected to different problems, and solves different problems. During the process, it is updated, and the two steps of the design and implementation of the framework are constantly repeated. When the framework is gradually mature, it will be more and less. The specific steps are: Analysis of the problem area to determine the required framework. From a class of applications rather than a single program, a variety of different software solutions are compared, seeking the commonality of these programs and the unique features of each program. These commonality, especially those that are often used by multiple procedures will become the foundation of the framework. Then define the frame architecture and design, including the design of the user and the framework, the final tool provided by the user. Implementation of the framework. Including the implementation of the frame core class, the framework test, the trial operation of the frame, and the repeated update of the framework. Deployment of the frame. Including the provision of documents, the distribution process, providing users with technical support, maintenance, and update frameworks. This method is to generalize the extension based on the specific class and extract an abstract class. Abstraction is also a key to the framework development. However, the applicability of the framework designed according to this method relies greatly to its specific application. Since the development of the framework has repetitive, and it is necessary to in-depth understanding of the application field, it is difficult to develop according to the schedule. The designer of the frame also needs to work closely with the application developer because the framework can only be improved in the process of using it to develop applications. 2. System Method Since some people think that the design of the framework can also be obtained by the system method, people have proposed a step-by-step design method. At this time, the design is divided into two steps: the first step is the generalization of the problem. It demands the following questions: What concepts in the field can be expressed as variables, and need to be handled? Can you find some specific concepts, can they be generalized as a more abstract concept? The second step is the design of the framework. In this step, the generalization is considered in reverse to achieve the framework of each stage. In other words, the most universal framework is the most universal framework, then implement the secondary framework. As shown in Figure 1, the frame 0 is the framework that is ultimately implemented. This step needs to solve the following problem: Which part of the system may need to change? Where does users need to join their own code in the frame? Two-step design methods can avoid being limited to application-specific classes and architectures during earlier development, and facilitate use of universal design patterns. The design of the framework is a repeated process, and the expertise of the field and design in this process is also important to the framework design between the framework users and the frame developers. Because the framework is constantly repeated Gradually mature.
3. What is the design and application of the frame design and application design framework? In general, the side focus of the two is different. When designing an application system, it is required to have an in-depth understanding of important concepts in the special field. These concepts evolve into classes through modeling and act as build blocks that implement the entire application. When designing the framework, focusing on identifying a place that must be flexible, that is, "hotspots", which is the key to the framework. The component library system is based on the frame rather than a specific class, making the use of the components system more flexible. However, when constructing specific applications on the framework, the use and development of classes is always followed, and the application can be obtained by creating subclasses, configuring each component object, adjusting instance, etc. 4. Framework document documentation must include the following: The purpose of the framework, how to use the frame, the design details of the framework, etc. Second, which support tools use framework? In general, the frame without support tool is difficult to use. Any framework proposes always equipped with a series of tool software, so that the framework-based application development is practicable. These tools allow users to interact with application frameworks, configure and build new applications. The following tools are usually used: Browse tool users can take advantage of information such as the class hierarchy of the framework. Editing tool users are used to adjust and modify the properties of the frame elements, such as modifying classes or components. The help system provides wizard features for users to use this framework system, such as the HTML format. The test system is used to test the generated application system, usually support the simulation operation. Documentation Tool helps create documents for your application, such as Javadoc tools. Understanding and learning to use the framework is a fee-time job, which is also the only insufficient frame design method, so the documentation required by the framework must be ready. Configuration Management Tools Use a frame rather than a specific object to provide multiplexability, but it also brings development complexity. The frame includes various components or component libraries, one frame may need to communicate with other frameworks. A framework may also consist of other sub-frame systems, such a composition structure inevitably proposes a problem of configuring management. For example, how do you share components within multiple frames? How to assemble new frames from components or sub-frame? How to communicate and cooperate within the framework? How to interact between different frameworks? The ultimate goal of using these advanced tools is to reduce the workload of coding and memory, simplify the user's operation. Ideally, the user can implement the construction of a new system without having a code. For example, on a visual interface, you can generate an executable by selecting some icons. There are currently some similar tools, such as the Vista system developed by University of Geneva. Third, what are the famous framework systems? There are currently many framework systems, such as the frameworks of the user interfaces, MVC, ET , etc., where ET is implemented in Unix and other systems; there is Foible for other fields, Macapp, FACE (Framework Adaptive Composition Environment, etc.). Early frame systems are mostly implemented for process language, and now there is a more powerful support for software and design for software and design. Due to the complex learning curve of the framework, the language of the framework development is best to provide an effective method for the establishment of the document of the frame; the use of the framework requires high-profit transplantation; the design of the framework is also a high-level decision, very Naturally, high-level language is naturally implemented. Java language is due to platform independence and lightweight linking process, automatic garbage collection, simple language structure, standard software package, object-oriented characteristics, so that Java can be said to be a suitable language for frame constructing. There have been many framework systems that have been written in Java language now. Lec India Software Center PVT. Ltd. developed an application framework system for EJB components.
It mainly facing EJB-based applications, is a server-side framework that can solve stability and other enterprise-level features in the development of EJB components. There are now many application frameworks that use J2EE programming environments, such as a multi-layer framework developed by Pacific Technical Services, can be used to develop web application servers; JCorporate developed Expresso Framework is a use Java to build distributed, reuse , Application framework for component-based security web applications. Fourth, how to design a knowledge engineering application framework? How to extract information from the data in the age of knowledge explosion, and extract knowledge from the information has become an important application area. More and more knowledge processing applications are urgently developed, and if there is a mature and reliable knowledge processing framework system, it will greatly accelerate the development of such application systems. In response to this situation, Tsinghua University Knowledge Engineering Research Room combines its own experience, currently proposes a framework in the field of knowledge engineering applications, mainly for knowledge acquisition, transmission, management, and applications based on network computing mode, Web-based data mining and knowledge Discover, all the code is implemented in Java. The framework of the framework is applied to the framework. It is divided into the following three sub-frames: (1) Sub-specific component frame: Provide a collection of components model models in the field, and provides a unified interface for the hierarchical component model. (2) Visual assembly framework: Provide a graphical interface of the entire framework system and provides a tool for visual assembly and operating components. (3) Connection frame: interact between components, communication providing mechanisms. The distribution of each member in the frame is shown in Figure 2. The built-in frame-based component system has the following performance: realize the product-oriented, utility component library system, has open, scalability; support of frameworks, components in heterogeneous environments, interconnection and communication; realize new and old systems Compatibility; provide consistent interface allocation; follow important components standards (such as CORBA); component has transparent localization, platform-independent characteristics; system configuration, data exchange based on XML and Java standardization format; support personalized information service customization Reconfigurable. Good user learning curve. The design of the frame is also a process of loop iteration, which is updated and improved in the process of continuous application of practice. We are also constantly improving this system. At present, some public components such as electronic form automation systems, data extraction, and file conversion systems are widely used as large-scale components. The frame can make the application simple, low price, but the development framework is not an easy task. It is a repetition process that requires the field and design experience. In order to ensure the flexibility of the frame, you must extract and discover hotspots. The design pattern can simplify this process because it provides abstraction to past experience. The application framework can be highly abstract in the same field, thereby reducing development difficulty and intensity. Although the framework and component technology has already appeared for many years, it is practical, but it is not mature, there is a lot of problems to be studied. Change and Breakth - How to Know Companies-Based Software Development Method
Compared with traditional software development methods, what is the breakthrough of components?
First, architecture
The software architecture represents the high-level abstraction of the system, which is the key to the success or failure of the system. The core of its design is whether it can use duplicate system models. The traditional application system architecture is from the host-based centralized framework, and the framework of accessing the server through the network on the client's client is unable to adapt the business environment where the current business is:
Enterprises have excessively dependent on a supplier's software and hardware products. This single supplier makes the company difficult to use the compute provider's free market, and will give the important decision to calculate the infrastructure to third-party processing, which is clearly not conducive to the company's share information between partners.
It is not possible to adapt to the distributed, multi-level heterogeneous system of remote access.
The packaged application system is difficult to maintain the system with customization when there is a certain organization, so that it is difficult to meet the multi-variety of needs.
You cannot achieve analysis, design core functions, you can only realize code reuse. Today, the application system has developed into a distributed, multi-level heterogeneous system that can be remotely accessed remotely on intranet and Internet. CBSD provides a new system architecture for developing such applications. It is a standard defined, distributed, modular structure, enabling the application system to be developed into several separate parts, available in incremental ways.
Such an architecture implements the following points of the CBSD:
The application software system can be integrated and customized by internal development, third-party existing components, or the existing components purchased in the market.
Encourage reuse of core functions in various application systems, and strive to achieve analysis and design.
The system should have flexible and convenient upgrades and system modules update maintenance capabilities.
The best practices in the package can be used in the case of commercial conditions, and the existing resources can be retained. As a result, CDSD solves the reuse and heterogeneous interoperability from the system's high level abstraction, which is the problem that the distributed network system is desirable.
Second, the development process
Traditional software development processes are very different from CBSD in reuse elements and development methods. Although object-oriented technology promotes software reuse, only reuse of classes and class inheritance. There is also a large gap between the entire system and the class. In order to fill this gap, people have thought of many methods, such as system architecture, framework, design patterns, etc.
Since the emergence of components, the reuse of software has been fundamentally changed. CBSD achieves multiple levels of analysis, design, and class. Figure 1 shows its reuse element hierarchical implementation. On the analysis of the abstraction layer, reuse the element has a subsystem, class; re-use the element system architecture, subsystem architecture, design mode, frame, container, component, class, template, abstract class, etc.
On the software development method, CBSD boot software development is transformed from application system to application system integration. Building an application requires a lot of existing components modules that may be developed by different people, and have a variety of applications. In this case, the development process of the application system becomes a gradual exploration process for the consistency of the component interface, component context, and framework environment. For example, on the J2EE platform, use the EJB framework to develop application systems, mainly working on application logic, press Session Bean, Entity Bean, and utilizing JTS transaction processing services to implement application. Its main difficulties are transactional division, and components deployment and development environment configuration. In summary, the traditional software development process is a process of serial waterfall, and the CBSD is concurrent, and the process of continuously upgrading a perfect process. Figure 2 shows the differences in them.
Third, software methodology
Software methodology is from a variety of different perspectives, different ideas to understand the nature of the software. Traditional software methodology reflects the essence of the problem from the viewpoint of the machine, data, oriented, facing function, data stream, orientation, and the like. The development of the entire software makes people more and more realize that the software methodological problem should be solved according to the objective world law. Until the appearance of an object-oriented method, the software methodology has taken a big step. However, high-level reuse, distributed heterogeneous interoperability is not resolved. CBSD has developed to today's software methodology provides opportunities to solve this problem. It separates the application business and the implementation of logic and data, providing standard interfaces and frames, making software development methods into components. Therefore, software methodology is based on interface, facing behavior. Figure 3 is a process of development.
Incident, the software development methodology of CBSD should include the following aspects:
It has a clear definition to the components.
The component-based concept requires a description of the components, such as UML, JavaBean, EJB, servlet specification, and more.
The development application system must be classified according to the component, including allocating different roles.
There is a tool for supporting the feature and generating documents to ensure the implementation and quality test of component specifications.
In short, traditional software methodology is carried out from drafts, and there is no more assist in reuse. The software methodology of CBSD is much more, it is plug-and-play, based on architecture, interface-centered, combining the component organic combination, which combines the top down and bottom-up method. Fourth, the development organization
The development of traditional software is generally composed of analysts, designers, programmers and testers. For a small application system, a skilled developer may take care of the above multiple characters. But for CBSD, because component development and application system integration is often separated, the entire development process is completed by six roles, they are:
Components developers are also components suppliers, most of them are middleware components providers.
Application member integrators combine existing components into a larger component module or container for a system deployment for a system deployment.
Application system deployers deploy the basic unit to the selected platform environment or the basic framework to complete the requirements of the software customization.
Development platform server suppliers provide basic software such as servers, operating systems, and databases.
Application system development tool supplier provides component public facilities services.
System administrators configure hardware, network, and operating system, monitor and maintain application system.
These six roles have a strong professionalism, and it is not easy to make a multi-face. Currently formed components open market, but also very flaming. This is also a confusion that today's software talent war. Therefore, in the CBSD, how to organize the development team is especially important, and must organize according to the company. It is particularly important that the initial development of the development must be selected, and the unified development guidelines will ensure that each role can communicate at any time during the entire development process. In general, the Quality of CBSD determines the reuse rate of the component.
V. Structure
The construction of traditional applications is to use white box method, and the application system is fully implemented, and the application logic and data are bonded together. The configuration of the CBSD is a method of combining a white box and a black box. Component-based frames are used to support evolution: the first concept is a strong performance interface that enables component logic functions and component models to hide. Thus, the component can be replaced as long as the interface is the same.
The second concept is implicitly called, that is, in the component-based frame, the interface never distributes the address to the member, only the address is allocated after the component user is identified. Therefore, the component user may be a component agent as long as the component user is understood and returned after the reference to the component interface (the reference may be a component, or the component user, the component agent is the component, no distinguishing). The information of the component interface is not stored in the component, but is stored in a component warehouse or registration. This will ensure that the component replacement is flexible and it is easy to re-deploy the component with implicit calls. Since the implementation of the component is transparent to the user, the component can also adapt the components to various different personalized requirements. To this end, the component provides two mechanisms of self-testing and standardization. Self-inspection ensures that component interface information can be obtained without understanding the specific implementation of the component. For example, the self-test mechanism provided by JavaBean is REFLECTION and BeanInfo, and all methods of the bean component can be directly obtained by Reflection, and many of the complex information of the component can be directly obtained by BeanInfo.
Standardization allows no access to the component to modify it, such as the normalization of JavaBean is the Property Sheet and Customizer (customizer). Provide a set of simple parameters through the Property Sheet to modify the properties of the bean. Complex modifications are done by the user through customizer setting parameters.
