CN100340984C - Method for realizing application interface integration and business integration - Google Patents

Abstract

The present invention relates to a method for realizing application interface integration and business integration, which comprises that a predefined interface frame is started, and a desired interface component of an application program is added to the interface frame; a predefined module manager is started, and a business module of the application program is added to a managed business module queue of the module manager. The present invention has the use method that when the application program is developed, a necessary component is only added to a new business in the interface frame, and a new business module is added in the module manager. Thus, the developing efficiency of the program is effectively raised, and the development cost is economized.

Description

A Method for Realizing Application Program Interface Integration and Business Integration

technical field

The invention relates to the field of application program development, in particular to a method for realizing interface integration and business integration of application programs.

Background technique

At present, the independent application software or client terminal program developed by Java needs to make and integrate the interface from scratch at the beginning of development. There are only some individual components or tool classes that can be reused in these different software developments. However, the integration of functional modules and the assembly of various interface components, which are required by almost every application, have not been abstracted. In actual development, due to the complexity and variability of the application software itself, the process of assembling different components into an application software is very complicated and trivial. Therefore, each development will take up too much time and resources, but the results may not be satisfactory.

Many of the current web servers have separated the integration function from the business processing function, such as WebLogic. Developers only need to create various EJBs according to business requirements, and the integration of these EJBs is completed by the Container automatically generated by WebLogic. This makes developing a server-side application relatively simple. The workload is much lower than doing it from scratch. This method of separating integration functions from business functions is recognized by the industry as a method that can improve software development efficiency, but it has not been applied to non-Web applications at present.

The disadvantages of the prior art are:

1. The current stand-alone application or application client does not have the concept of container. To develop a new business module, not only the business logic, but also the integration of the new business and the original business must be considered. This integration is completely repetitive work .

2. It is difficult to add new business or new demand, or to join new business, the overall interface of the software needs to be greatly adjusted.

3. The intensity of code reuse is too small, the interface code reuse rate is too low, and the development efficiency is low. At present, most of the reused codes between applications are separate components and tool classes, while the codes that integrate these independent classes are not reused. In the development process, the workload of integration accounts for the vast majority of the entire software development process. Therefore, although a large number of reusable components are used, it still cannot effectively improve development efficiency.

4. It is not conducive to an enterprise to unify the interface styles of different application programs. Since the developers of different application programs are often different, if they want to unify the interface style, they need to formulate detailed interface specifications, and then refer to them for design. In this way, it is necessary to ensure that there is an extremely complete and reasonable interface specification, otherwise, it will still cause inconsistency in the interface style. However, detailed interface specifications can only be obtained from practice through art professionals and software interface designers who spend a lot of time.

Contents of the invention

In view of the above-mentioned shortcomings in the prior art, the present invention provides a method for realizing interface integration and business integration of application programs, which can realize interface integration and business integration of application programs simply and effectively, and greatly improve the efficiency of application program development.

The method of the present invention includes: starting a predefined interface frame, adding the interface components required by the application program to the interface frame; starting a predefined module manager, adding the business module of the application program to the module manager in the queue of the managed service module.

The interface framework includes at least a menu, a tool bar and a status bar and a corresponding menu manager, a tool bar manager and a status bar manager; the interface components required by the application are added to the interface frame by modifying the The configuration file of the menu, tool bar or status bar or increase its object instance and load it through the corresponding manager.

The module manager has a module management interface and a module function interface to realize the management and operation of the application program business modules.

The module management interface implements module registration, cancellation, loading, closing and obtaining object references of other modules.

The module function interface implements module name management, inter-module event processing, inter-module cross-call, intra-module data sharing, and module initialization, reset, recovery and stop functions.

The business module is inherited from a basic module, which provides a default implementation of the interface with the module manager.

Using the method of the present invention, when developing a new business for an application program, it is only necessary to add necessary components for the new business in the interface framework, and add the new business module to the module manager. Therefore, the program can be effectively improved. Improve development efficiency and save development costs.

Detailed ways

In application program development, there is always the integration of related interfaces in order to integrate the business processing interfaces of different modules into a whole. Various public interface elements in an integrated system, such as menus, toolbars, status bars, etc., we hope that business modules can use them conveniently without being responsible for their creation and management. The relationship between a business module and the menu, toolbar, and status bar is nothing more than: when this module is loaded into the system, it needs to add some menus and toolbar buttons of its own, and may also need to add some runtime status information to the status bar; When this module is uninstalled from the system, its related menus and toolbar buttons need to be removed from the entire system. Therefore, it is a good way to implement an interface framework that has the function of allowing business modules to easily add or delete interface components such as menus and toolbar buttons. Taking the menu as an example, the business module only needs to provide the menu (this menu can be a created instance, a persistent menu object, or the configuration information used to generate the menu in a file, etc.), and use the interface provided by the interface framework , you can add one or more menus to the system or uninstall this menu from the system.

According to the above principles, we abstract the interface elements that realize the integration function to form an interface framework, which includes the multi-document integration window (MDIFrame), window manager (WindowManager), menu manager (MenuManager), toolbar ToolbarManager, StatusBarManager, OutputManager, TerminalManager, SystemSettingsManager and other interface components. Among them, MDIFrame is the main window class of the application, and all interface controls are based on this; WindowManager manages the sub-windows in MDIFrame, and is responsible for registration, cancellation, operation and display of sub-windows; MenuManager is responsible for menu management, configuration, display, etc.; ToolbarManager is responsible for the management, configuration, display, and customization of toolbars; StatusBarManager is responsible for the management and display of the status bar; OutputManager is responsible for the management of information output windows; TerminalManager is responsible for terminal security management, terminal locking and unlocking; SystemSettingsManager is responsible for managing various Module configuration items. For the convenience of use, static access methods are provided in the specific implementation, or they are made into Singleton classes. All interface components, such as menus, toolbar buttons, status bar items, etc., mainly exist in the form of XML configuration files, which can be loaded when the system starts or runs respectively. Therefore, when developing an application program, you only need to start the interface framework. For each business module, if you want to add interface elements such as menus or tool bars, you only need to configure the XML file, and then load it through the corresponding manager, or By adding an object instance, you can get your own menu or tool bar, which realizes the interface integration of the application program.

The business integration of the application program is realized by a module manager.

The module manager is a tool for module management, which is responsible for the registration, cancellation, loading, and closing of business modules. It is the running container of the business module and is responsible for the entire life cycle of the business module. It provides a unified way to access the managed business modules, and any module can interact with the module by obtaining the object reference of another module through the interface it provides.

The module manager has a module management interface IModuleManagementInterface. This interface includes module registration, cancellation, loading, closing, obtaining object references of other modules, etc. It is used by the module manager to manipulate the business modules.

The program example of the module management interface is as follows:

public interface IModuleManagerInterface

{

register()

unregister()

loadModules()

ShutdownModule()

GetReference()

...

}

In addition to implementing the module management interface, the module manager also needs to implement a module function interface IModuleInterfaceOperations, which provides module name management, inter-module event processing, cross-calling between modules, and extraction of shared data within the module. functions such as initialization, reset, recovery and stop. Among them, the module name management is used to uniquely identify a module. Event handling and cross calls between modules are used for communication between modules. Functional interfaces such as initialization, reset, recovery, and stop of the module are used to process the module when the system is in different states (such as the state before and after user login and logout). If the user logs out, the entire interface system is in a disconnected state relative to the underlying server. At this time, the module needs to be reset to release related resources. After the user logs in, it is necessary to restore the status of the module so that it is in the connected state and can work normally.

The program example of the functional interface of this module is as follows:

           
public interface ModuleInteffaceOperations

{

 getModuleName()

 processEvent()

 processCrossInvoke()

 getRemoteDataShare()
 
        

           
 initialize()

 reinitialize()

 clear()

 stop()

 isAlive()
 lock()

 unlock()

 ...

}

        

In order to facilitate the realization of the above interfaces by business modules, we provide a basic module BaseModule as the parent class of all business modules that can be managed by the module manager. It provides default implementations for all interfaces, and each business module To implement, you only need to inherit from this BaseModule and overload the interfaces you are interested in and need.

Business modules can communicate through internal events or messages, or make direct calls. A module can broadcast events, or dispatch events to a module with a known name. When you know the name of the other party, you can also make a direct call. The procedure is as follows:

interface IModuleServicesInterface

{

broadcastEvent

sendEvent

crossInvoke

...

}

Data can be shared between modules. A module can be both a provider of shared data and a consumer of shared data. As a provider of shared data, it notifies the listener when the shared data changes by letting other modules register as a data change listener. The shared data listener obtains data through the corresponding interface. The procedure is as follows:

           
interface IModuleDataShareInterface

{

addDataChangeListener

removeDataChangeListener

getDataShare

getDataShareManager

setDataShareManager

removeDataShare

notifyChangeListeners

...

}

        

In addition to event and message communication and call relationship, modules can also be manipulated. A module can manage another module and be responsible for its entire life cycle, including registration, deregistration, initialization, reset, stop, lock, etc. This allows modules to be nested. The procedure is as follows:

           
public interface IModuleManagementExtendedInterface

{

register

unregister
getReference

getModuleManager
initializeModule

reinitializeModule

stopModule

isModuleAlive

lockModule

unlockModule

...

}

        

These functions are provided in the form of the module function interface ImoduleInterfaceOperations.

Therefore, when developing an application program, it is only necessary to start the module manager and add each service module of the application program to the managed service module queue of the module manager to effectively realize the service integration function.

Claims (3)

1. A method for realizing application program interface integration and business integration, comprising: Start a predefined interface framework, and add the interface components required by the application to the interface framework; Start a predefined module manager, add the business module of the application program to the managed business module queue of the module manager, and the module manager has a module management interface and a module function interface; When any one of the first operations of registration, deregistration, loading, closing and obtaining object references of other modules is selected for execution, use the module management interface to execute the selected first operation; When any one of the second operations of module name management, inter-module event processing, cross-calling between modules, data sharing within a module, and module initialization, reset, recovery, and stop is selected for execution, the module function is used The interface performs the selected second operation. 2. The method for realizing application program interface integration and business integration as claimed in claim 1, characterized in that: said interface frame at least includes a menu, a tool bar and a status bar and corresponding menu managers, tool bar managers and Status bar manager; adding the interface components required by the application to the interface frame is achieved by modifying the configuration file of the menu, toolbar or status bar or adding its object instance and loading it through the corresponding manager of. 3. The method for realizing application program interface integration and business integration as claimed in claim 1 or 2, characterized in that: the business module is inherited from a basic module, and the basic module provides the interface between each interface of the module manager. The default implementation of .