Knowledge of middleware-based software development methods

Compared with traditional software development methods, what are the breakthroughs in middleware-based software development methods?

I. Architecture

The software architecture represents the high-level abstraction of the system. It is the key to the success or failure of the system design. The core of its design is whether repeated system models can be used. The traditional application system architecture, from a host-based centralized framework to a network-based client-to-server access framework, cannot adapt to the current business environment of enterprises. The reason is:

Enterprises rely too much on the software and hardware products of a vendor. This single vendor makes it difficult for enterprises to take advantage of the free market of computing vendors and hand over important decisions on computing infrastructure to third parties for processing, which is obviously not conducive to sharing information between partners.

Distributed, multi-level heterogeneous systems that cannot adapt to remote access.

It is difficult for an encapsulated application system to use customization to maintain the system when an organization needs to meet changing requirements.

The core functions of analysis and design cannot be reused, but code can be reused at most.

Nowadays, application systems have developed into distributed, multi-level heterogeneous systems that can be remotely accessed by various clients on the Intranet and Internet. CBSD provides a new system architecture for developing such an application system. It is a standard-defined, distributed, and modular structure that allows the application system to be divided into several independent parts for development and can be developed in incremental mode.

This architecture achieves the following objectives of CBSD:

It can integrate and customize application software systems through existing middleware developed internally, provided by a third party, or purchased on the market.

Encourage reuse of core functions in various application systems and strive to achieve reuse of analysis and design.

All systems should have flexible and convenient upgrades and system module update and maintenance capabilities.

Encapsulate the best practice cases and enable them to be used and retain existing resources when business conditions change.

From this we can see that cdsd solves reusability and heterogeneous interoperability from the high-level abstraction of the system, which is exactly what the distributed network system wants to solve.

Ii. Development Process

The traditional software development process is very different from CBSD in terms of reuse elements and development methods. Although object-oriented technology promotes software reuse, it only achieves reuse of classes and class inheritance. There is still a large gap between the entire system and the class. To fill this gap, people once thought about many methods, such as system architecture, framework, and design pattern.

Since the emergence of middleware, software reuse has fundamentally changed. CBSD enables analysis, design, and class reuse at multiple levels. Figure 1 shows its layered Implementation of reusable elements. At the analysis abstraction layer, reusable elements include subsystems and classes; at the design layer, reuse elements such as system architecture, subsystem architecture, design pattern, framework, container, middleware, class library, template, and abstract class.

In terms of software development methods, CBSD guides software development from application system development to application system integration. Many existing middleware modules need to be reused to build an application system. These middleware modules may be developed by different people at different times and have different purposes. In this case, the development process of the application system becomes the gradual exploration process of the middleware interface, middleware context, and framework Environment consistency. For example, on the J2EE platform, the main task of developing an application system using the EJB framework is to design and develop the application logic according to Session Bean and Entity Bean, JTs transaction processing service is used to implement the application system. The main difficulty is Transaction Division, middleware deployment, and development environment configuration. In summary, the traditional software development process is a serial waterfall and pipeline process, while CBSD is a process of Concurrent evolution and continuous upgrade and improvement. Figure 2 shows their differences.

Iii. Software Methodology

Software methodology is to understand the essence of software from different perspectives and different ideas. Traditional software methodologies reflect the essence of problems from machine-oriented, data-oriented, process-oriented, function-oriented, data-oriented, and object-oriented perspectives. The entire software development process makes people increasingly realize that software methodology problems should be solved according to the laws of the objective world. It was not until the emergence of object-oriented methods that the software methodology took a big step. However, the difficulties of High-Level Reuse and distributed heterogeneous interoperability have not yet been solved. Only today has CBSD provided an opportunity to solve this problem in software methodology. It separates application services from implementations, that is, the separation of logic and data. It provides standard interfaces and frameworks to turn software development methods into a combination of middleware. Therefore, the software methodology is an interface-oriented behavior-oriented design. Figure 3 shows the development process.

To sum up, the CBSD software development methodology should include the following aspects:

Define the middleware.

The middleware-based concept requires the description technology and specifications of middleware, such as UML, JavaBean, EJB, and Servlet specifications.

The development application system must be divided by middleware pruning, including assigning different roles.

Provides tools to verify middleware features and generate documents to ensure implementation and quality testing of middleware specifications.

In short, the traditional software methodology goes from top to bottom and does not provide more assistance for reuse. CBSD's software methodology is much richer. It is plug-and-play, based on the architecture, interface-centric, and organically combines middleware, it combines top-down and bottom-up methods for development.

Iv. Development Organization

The Development Organization of traditional software is generally composed of analysts, designers, programmers and testers. For a small application system, a skilled developer may take into account multiple roles. However, for CBSD, middleware development and application system integration are often separated, so the entire development process is completed by six roles:

Middleware developers are also middleware suppliers, most of which are middleware providers.

The Application Middleware integrator combines existing middleware into larger middleware modules or containers for an application field as the basic unit for system deployment.

The Application System deployer puts the basic unit of system deployment into the selected platform environment or basic framework to fulfill the software customization requirements.

The development platform server supplier provides basic software such as servers, operating systems, and databases.

The application system development tool supplier provides middleware public facilities services.

The system administrator configures the hardware, network, and operating system, and supervises and maintains the application system.

These six roles are very professional and it is not easy to take into account multiple roles. Currently, the middleware open market has been formed and is still very popular. This is also a confusion in today's software talent competition. Therefore, in CBSD, it is especially important to organize a development team according to the talents of the company. Particularly important: the standard framework and unified development guidelines must be selected at the initial stage of development to ensure that all roles can communicate with each other at any time throughout the development process. Generally, the quality of CBSD personnel determines the middleware reuse rate.

5. Constructor

The traditional application software is constructed using the white box method. The implementation of the application system is all in the code, and the application logic and data are bonded together. The construction of CBSD is a combination of white and black boxes. The middleware-based framework uses two concepts to support evolution: the first concept is that middleware has a strong performance interface, which hides the implementation of the middleware Logic Functions and middleware models. In this way, middleware can be replaced as long as the interfaces are the same.

The second concept is implicit calling. In a middleware-based framework, no addresses are directly allocated to the middleware interfaces. addresses are allocated only after the middleware users are identified. Therefore, the middleware user only needs to understand the interface requirements and the returned information after the reference is provided for the middleware interface (this reference may be a middleware or a middleware proxy. For middleware users, middleware proxy is middleware, which does not need to be differentiated ). The middleware interface information is not stored in the middleware, but stored in the middleware warehouse or the registry. In this way, the middleware replacement is flexible and it is easy to redeploy the middleware by Using implicit calls. Because the implementation of middleware is transparent to users, it also enables middleware to adapt to various Personalized Requirements. Therefore, middleware provides two mechanisms: self-check and standardization. Self-check ensures that the middleware interface information can be obtained without knowing the specific implementation of the middleware. For example, the self-check mechanism provided by Javabean is reflection and beaninfo. through reflection, all methods of bean middleware can be directly obtained, and many complex information of middleware can be directly obtained through beaninfo.

Normalization allows you to modify it without accessing the middleware. For example, the normalization provided by Javabean is property sheet and customizer ). The property sheet provides a set of simple parameters to modify bean attributes. Complex modifications are completed by setting parameters through the customizer.

 

 

Source: http://hi.baidu.com/coolbattier/blog/item/313e40f4d883466cddc4741b.html