KR100697246B1 - Method and system of developing a software with utilizing extended metadata of component under component-based development environment - Google Patents

Abstract

The present invention relates to a component-based software development technology, and relates to an active binding technology that can develop software by hierarchically assembling components provided by a specific component development platform. The present invention provides a technique that enables the assembly of components developed independently by different developers into a multi-layered and / or distributed structure by extending the metadata to include the dependency contract specification of the component.

The present invention automatically generates and implements a glue component that assembles and combines components having metadata of mutually independent form as a server and a client, so that large-scale distributed systems can be edited in a sequential form, and component assembly is time-series. Fine-grained visualization of method invocations simplifies component assembly and software maintenance and modification.

Component, Active Binding, Glue Code, Visual Studio, Component Based Code, Object Oriented Code.

Description

METHOD AND SYSTEM OF DEVELOPING A SOFTWARE WITH UTILIZING EXTENDED METADATA OF COMPONENT UNDER COMPONENT-BASED DEVELOPMENT ENVIRONMENT}

1 is a diagram illustrating a message transfer structure between components devised to apply a component-based software development method according to the present invention.

2A and 2B show a joining method for assembling components in accordance with the prior art and a joining method for assembling components in accordance with the present invention, respectively.

3 is a process flow diagram for implementing and assembling components for component-based software development in accordance with the present invention.

4 is a process flow diagram illustrating one embodiment of a component implementation method that includes client-side metadata regarding service invocations provided by subcomponents in accordance with the present invention.

5 illustrates a preferred embodiment of a method of assembling components in accordance with the present invention.

6 is a process flow diagram illustrating one embodiment of an automatic generation method in accordance with the present invention for a glue component that mediates message transfer between components in accordance with the present invention.

7A-7E are diagrammatic representations of one embodiment of implementing components in a development tool provided in accordance with the present invention.

8A-8M show in sequence one embodiment of assembling components in a development tool provided in accordance with the present invention.

<Explanation of symbols for the main parts of the drawings>

310: Client component

311, 312: metadata

320: server component

          330 glue component

410: Component A

420: Component B

712: smart bind

713: Dialog

811: Component assembly project

812: Component assembly edit window

813: Solution Explorer

814: Assembly Tool Pane

815: Object Lifeline

816: Property Window

817: message

818: client-side metadata

819: server-side metadata

820, 821: Combo Box

822: Message Properties dialog

823: glue code

824: code

825: Service method of glue component

826: Glue Component Project

827, 828: messages

829, 830: Glue Component Project

831: Annotated signature

832: Arbitration Code

The present invention relates to a Component-Based Software Development (CBD) technology, and more particularly, a number of components that are developed to have a unique interface by various developers and are supplied to the market in binary code form. It is about how to develop software by assembling each other, new component metadata formats, development tools for implementing them, and development environment systems.

More specifically, the present invention provides not only server-side metadata related to a service called standard provided by an existing component, but also a client-side related to a service call specification for subcomponents. Side) Provides a way to implement a component to include metadata.

In addition, the present invention automatically generates a glue component template code in order to match the heterogeneous mutual call / call signatures that the server and client components independently developed in component assembly have. And a method for implementing the same, and a method and a method for assembling a component to enable flexible message flow control by allowing a message to be transferred between a server component and a client component through an automatically generated glue component. And an implementation system.

Recently, due to the advent of embedded systems and ubiquitous computing, the demand for various softwares has soared and changes are frequently required for the already developed software. There is a demand for software production technology that can rapidly develop software.

However, as existing software production technologies such as structural techniques, information engineering-based development methods, or object-oriented software production technologies, which have been commonly used in software development, have shown limitations in improving software development productivity, Unlike conventional methods, component-based software development (CBD) technology, which is a method of developing a component that acts as a component for each function first, and then assembles them, has recently emerged and is rapidly spreading.

In other words, the information systems required by modern management are becoming more complex and larger in size, and as the competition intensifies, time-to-market, flexibility of change and expansion, and reduction of construction costs The need for more became more urgent. The component-based software development methodology emerged as an optimal alternative to this, inheriting the principle of partition conquest and the advantages of object-oriented development, breaking down the unit business functions and related data that make up the system and dividing it into smaller pieces. In order to be able to be reused, the software development has been developed into an assembly concept.

Large enterprise software runs as a distributed system and is developed in the concept of layered design. Typically, large enterprise software is developed in a three-tier or multi-tier structure. It is done. In general, a hierarchical design places the presentation layer at the upper layer, the business logic layer at the middle layer, and the data service layer at the end.

By the way, most components except the components of the end are combined with the component (s) of the lower layer, and basically provide their services to the components of the upper layer based on the services of the lower layer component. At this time, service calls to subcomponents are compiled with static coding and distributed in the form of black box (binary code).

In this case, static coding is also referred to as early binding, which refers to developing a client component based on an interface specification specification (commonly called a signature) defined by a server component. . However, the above-described static coding method component-based software development technology has its technical limitations for the following reasons.

In order to assemble and develop components in binary form (black boxes compiled with hidden source code) that are already developed and placed on the market, reusing them to assemble and develop software that performs the functions the designer wants, The signature must be matched between the component (the component that invokes the service, or 'client') and the lower layer component (the component that provides the service, or 'server'). Here, the signature includes an interface with a component, a class name (ID) and a method name, a parameter type, and an order.

Unlike hardware, software requires many parts (i.e. number of components) and varies (almost infinitely), so it is not possible to predetermine the specification, and to solve the problem of signature matching between components developed independently by different developers. There is a burden of modifying the component source code or manually developing the glue code.

Furthermore, current component technologies do not include client-side information about service invocations provided by subcomponents in metadata provided at deployment, so if the component you want to reuse depends on other components, the system created at the time of development of that component Detailed design information should be obtained and referenced.

Moreover, the component-based development techniques according to the prior art have a high coupling and statically coded message flow between components, so deleting or adding one component of a business process has a great effect on other components in the process. Also, because the flow of messages in other software development through assembly is entirely new, this static coupling significantly reduces the reusability of components.

Moreover, Component Platform technologies currently available to software developers include CORBA, COM +, EJB, and .NET, which are component metadata that are commonly used as contract contracts. Since it provides only a signature of a service provided by itself, it is not possible to assemble a binary component to request a service from a lower component during a processing operation of an invocation of a higher component.

That is, although the independently developed binary components are assembled in the form of a multi-layer dependency structure, the prior art has made it impossible, although the goal of the component-based development methodology is directed.

For this reason, until now, software developers have mainly reused only components for GUI (Graphic User Interface), which provide simple and independent services, and the reuse rate of components in the business logic domain, which is the middle layer, is extremely low. .

That is, simple GUI components such as ActiveX Control and JavaBean, which do not depend on other component services, are mainly reused, and components of the business layer designed and implemented by component-based software development methods are rarely reused.

In order to solve the technical limitations of the above-described component-based software development method according to the prior art, several improvements have been proposed. That is, in order to solve the problems of the prior art, a method of centrally managing message flows between all components has been proposed. A representative example is how to assemble a component using a workflow. Workflow approaches design all components as independent components that do not depend on other components, and use workflows to centrally manage message flow between components.

However, even in the workflow approach, since any component cannot directly call another component, the component's services (methods) must be designed to receive all the information required for the unit of work as a parameter and to produce the result independently. This is not the partitioning conquest and structural method that software engineering has pursued, so it is very unnatural from the design method, resulting in the development of large components that are less general and reusable.

In addition, in the workflow method, all message flows between components are passed through the workflow, which incurs a heavy overhead on the network and system compared to direct invocation between components, and affects the overall system operation when the workflow engine fails. Will be given.

Furthermore, the University of California at Irvine, USA, has limited C2 Style, a method of assembling message-based components, which uses the Mediation Logic in the wrapper code for assembly. In addition, since the flow control logic of the connection components must be hard coded, the assembly process is complicated and flexible changes are difficult.

That is, the C2 style has a structure in which components are connected (assembled) by connecting components by exchanging messages with each other according to communication rules by connecting connectors, and communication between C2 style components is an asynchronous service request. And notification messages. At this time, each message is broadcasted to all components connected to the connector, and it is decided whether to process or ignore the received message according to the message rules defined in each component's dialog.

Furthermore, in the case of the C2 style according to the prior art, the Architecture Description Language (ADL) is defined in order to specify at a higher level of abstraction the components constituting the software system, their interactions, and the composition rules of the components and connectors. There is a hassle that needs to be defined in two notation formats, IDN: Component Interface Definition Notation and Architecture Definition Notation.

First of all, in the case of the C2 style according to the prior art, a white box approach is inevitable to implement a hierarchical dependency relationship between components to be reused, thereby significantly reducing component reusability.

In addition, when reusing and assembling binary layered components compiled by applying the C2 style according to the prior art, since there is no information (Metadata) at which point the component needs a method call of a subcomponent. Implementing a hierarchical dependency structure is fundamentally impossible.

Therefore, to assemble binary components in C2 style, instead of requesting the subcomponent service during the service processing, the components are redesigned so that they receive all the information required for processing the service from the beginning as parameters, and the wrapper code first calls the subcomponent. Therefore, it is necessary to implement flow control logic that receives necessary information and passes it as a parameter when calling the inner component method, and then passes the return value to the upper component.

This approach is an element that makes it inherently impossible to apply the structural design techniques that software engineers are pursuing today. Moreover, when the C2 style is applied, the assembly process is complicated and error-prone. Debugging is difficult and can be very time consuming and expensive.

Moreover, the C2 style of the prior art has the disadvantage of incurring a myriad of unnecessary interrupts and message identification processing, which adds to the system burden because all interactions between components always occur through the process of broadcasting and communication rules through the connector. have.

Accordingly, the present invention has been proposed to solve the above-mentioned problems, and is a combination between components (assembly) by utilizing a client-side metadata generation technique, a technique for mediating component association with glue code, and a technique for automatically generating glue code. By overcoming the syntactic and semantic matching problem of signatures that are strictly required for the system, we can increase the reuse rate of components and flexibly control the message flow between components developed according to the natural component-based development method without modifying the component code. The first purpose is to provide.

In addition to the first object, the second object of the present invention is a glue template code generation technique and a method of implementing a multi-layer structure, which enable assembling components in a familiar sequence diagram form in a top-down manner in software development. To provide.

The third object of the present invention is, in addition to the first and second objects, a component creation and assembly technique with remarkably improved reusability, and a component-based software development device and system that facilitates maintenance according to business logic changes. And providing a method.

A fourth object of the present invention is, in addition to the above objects, a component-based software development device, system and method that enables distributed placement and remote hosting of components and enables integrated testing and monitoring of assembled components. To provide.

In addition to the above objects, the fifth object of the present invention is to provide a component-based software development device, a system and a method which can improve the reusability of a component by fine-graining the size of the component to an appropriate size. It is.

In addition to the above objects, a sixth object of the present invention is to provide a method of assembling binary components in a multi-layered structure, and to provide and develop an assembly method without additional overhead such as broadcasting and conversion into asynchronous messages. It does not require any documentation in the process, and provides a component-based software development device, system, and method for enabling inexpensive and rapid maintenance.

In order to achieve the above object, the present invention in the component implementation and assembly of the component-based development method, processing means for arbitrarily inputting the signature and annotation of the service of the sub-component to be called from the component developer; Processing means for generating a helper function code for dynamically binding and calling a service of a glue component based on the input signature; Processing means for generating a newly created helper function call code in the lower service call part; Processing means for selecting a calling service for later message flow adjustment and assembly and for generating client-side metadata used for automatically generating template code of the glue component; A component implementing method comprising a processing means for independently testing a component function by creating a test temporary glue component, and processing means for selecting components to be assembled using a GUI tool and arranging them in a drawing; Processing means for freely setting a message flow between components by selecting a client component and a server component among the components arranged in the drawing using a GUI tool; Processing means for automatically generating a template code of a glue component and receiving an arbitration code; Comprising the component assembly method characterized in that consisting of the processing means for generating a glue component by compiling the glue codes.

The present invention is characterized in that the interface of the existing concept is called a server-side interface (Server-Side Interface), and the dependency contract (Dependency Contract) for the sub-component is called a client-side interface (Client-Side Interface). In addition, the present invention is characterized in that it is included in the client-side interface by defining the contents (hereinafter referred to as metadata) for the specification required for independent developers to assemble various components on the market.

As such, when metadata is extended to include client-side interface information as well as server-side according to the present invention, the assembly tool dynamically reads metadata of both components to be connected and automatically generates the glue code template. It becomes possible to generate.

The component assembly technique according to the present invention not only enables the assembly of a multi-layered structure of binary components but also mediates the syntactic or semantic inconsistencies present in parameters between heterogeneous components. By inserting logic (Mediation Logic) in the glue code according to the present invention can maximize the component reuse rate.

Conventionally, when developing a middle layer component that completes its service depending on a subcomponent, a development order was required because the identifier and interface specification of the subcomponent were previously known, but the present invention uses the information of the subcomponent. Instead, new identifiers and specifications are arbitrarily generated as client-side interfaces, and the assembly structure reads this metadata to generate glucose with the identifiers and specifications.

As a result, it is possible to develop and test middle-tier components in a non-procedural manner without subcomponents, thereby increasing component development productivity. In the detailed description of the present invention, the metadata extension and assembly technique of the present invention will be referred to as active binding, in contrast to the existing binding scheme that passively depends on the interface of the subcomponent.

The component assembly technology according to the present invention enables a component to be developed independently of other components, extends existing metadata to include all information necessary for flexible component assembly as metadata, and automatically uses the metadata. It creates glue templates and provides component implementation and assembly devices that flexibly control message flow between components by applying glue mechanisms.

The present invention automatically generates a template of a glue component, which is an arbitration component for assembling a component, significantly reducing the time and cost of assembling the component, dramatically improving the reuse rate of components dependent on other components, and providing a component message. Flexibility in flow control and ease of rigor of component-to-component matching greatly facilitates the development and maintenance of new systems.

The above objects, features and advantages will become more apparent from the following detailed description taken in conjunction with the accompanying drawings. Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

Each drawing shows the following contents. 1 is a diagram illustrating a message transfer structure between components devised to apply a component-based software development method according to the present invention.

Referring to FIG. 1, for flexible message flow control between components 310 and 320 compiled into binary code and provided in a black box form, the client component 310 requesting a specific function service includes a subcomponent 320; Metadata 311 that specifies a service having a signature from a server component and metadata 312 corresponding to an interface that is a usage contract for using a service of a server component 320. By assembling the two components (310, 320) by implementing the glue component 330, which is a mediator applying the glue concept using.

By allowing the glue component 330 to dynamically control the message flow with the call information, the client component 310 and the server component 320 can be called and called to each other even if they do not have each other's call information. This dynamic message flow control increases component development and assembly efficiency and enables component team projects.

2A and 2B are diagrams respectively illustrating a joining method for assembling components according to the prior art and a joining method for assembling components according to the present invention. Referring to FIG. 2A (Prior Art), in the existing component-based software development, if the client component A 410 is calling a service of the server component B 420 using an interface called b1 421, the call content is the client. The component A 410 is statically coded, compiled and distributed in binary form.

In other words, the flow of messages through integration between components is highly combined and statically coded, so it takes a lot of load to change and also reduces reusability. In addition, deleting or adding one component service in the whole system has a great effect on other components in the process. This change in load causes the time-to-market to develop new products using components.

On the other hand, the concept of component assembly according to the invention shown in FIG. 2B is such that when client component A 310 needs to invoke a service provided through interface b1 () 322 of server component B 320, client component A Although 310 does not know the user contract with respect to server component B 320, the client component A 310 defines a subcomponent called (component ID = component X, interface ID = x1 (), and operation). By building information about the signatures into the metadata 311 and including it in the component, the metadata 311 is used to satisfy the attributes defined in the metadata (component ID = component X, interface ID = x1). (), Create a glue component with the called operation and signature with the same operation, and check the server component B 320's By calling a face b1 () by having passed the results to the client component A (310), the client services component A (310) of the server component B (320) that may be used in the call.

In the method of assembling components according to the present invention, even if the exact call information of each other is not known, the calling and the called between the components can be made and the message flow between the components becomes very flexible. By using the glue component 330, even components that are not perfectly matched can be customized and connected, and the creation, modification, and deletion of message flows between components can be performed very easily. Significantly reduces

3 is a flowchart illustrating a process of implementing and assembling components for component-based software development according to the present invention, showing an embodiment thereof. Referring to FIG. 3, the method for developing component-based software using the glue component template according to the present invention includes two steps, a component implementation step (step S1) and a component assembly step (step S2). The component implementation step (step S1) is a step of receiving a signature and an annotation of a service that should be provided from a subcomponent in order to implement the component independently of other interacting components (step S11), and a glue component based on the received information. Generating helper function code for dynamically binding and calling a service of the step (step S12), inserting the helper function call code in the subservice call part (step S13), and generating information about the subcomponent call as metadata Step (step S14), we create a temporary glue component for testing and Performing a bit (step S15) and the like consists of five steps:

In addition, the component assembly step (step S2) is a step of selecting the components to be assembled using the GUI Tool to place in the drawing (step S21), setting the message flow between the components arranged in the drawing (step S22), two components Automatically generating a template of the glue component to be connected to insert the arbitration code (step S23), and compile the glue code to generate the glue component (step S24) consists of four steps.

That is, the present invention enables all components to be fundamentally independent from other components (steps S11 to S13) and to test a function (step S15), and to provide a flexible message flow between independent components. It is characterized in that the component is implemented by extending the metadata to include information about a service required by the metadata in the metadata (step S14).

In addition, it flexibly customizes the component message flow in the GUI environment (steps S21 and S22), and automatically creates a template of the glue component that connects the message flow between the two by using metadata of the caller component and the called component when assembling the component. By editing the arbitration code for generating the component and matching the integrity of the component message flow (step S23), and compiling the glue codes to generate the glue component (step S24), it is possible to quickly assemble the component while minimizing component assembly errors.

4 is a process flow diagram illustrating an embodiment of a component implementation method that includes client-side metadata regarding service invocations provided by subcomponents in accordance with the present invention. This process processes the internal parts of the sub-component call internally and implements this information in the form of metadata to alleviate the strong coupling of message flow between components, which is the root cause of the problems of the existing component-based development methodology. This is a step that allows you to develop components independently and to improve their reusability.

Referring to Figure 4, while developing a component to meet the standard according to the present invention (step S111), when the service call of the lower component is required (step S112), independently of the presence or absence of the lower component, the component A user is provided with a signature about a service to be provided for processing internally, namely, an arbitrary name of an operation, parameters to be passed in order to use the service, and return values to be returned, and annotation information describing the same (step S113).

Subsequently, a helper function that is a member function of a component class of a component that satisfies the inputted signature is defined, and code that calls a service of a subcomponent in the helper function by using a dynamic binding method (defining IDs of arbitrary subcomponents and interfaces and Object generation, operation call that satisfies the input signature) is automatically generated (step S12).

On the other hand, through the step of automatically generating a code (step S13) to replace the sub-component call to the operation of the sub-component to the newly generated helper function call to implement the independent dependency of the other components. If you implement a series of processes that process the internal part of the service through the signature and annotation input of the subcomponent service that you want to call as above, you can use the so-called Wizard to implement the error of the subcomponent calling part. It can minimize and process multiple steps more easily.

Referring back to FIG. 4, in the component-based method according to the present invention, information about a service call defined in a component internal helper function for assembly with a lower component is generated as component metadata and included in the component. Is expanded (step S14). This metadata information allows the user to include metadata about the services of the subcomponents that he / she should provide as well as metadata about the services he / she already provides. Provide a specification of whether the service should be provided.

Here, the client-side metadata is generated inside the component using a resource part other than the source code binary or a .Net user attribute part when the source code is compiled. Client-side metadata extends the metadata that the component itself has, making it possible to automatically create a mediator that connects the two components using the glue mechanism (step S23).

In addition, since client-side metadata generated during component implementation is used to create a glue component template as it is, the developer automatically generates identifiers for a number of glue components and corresponding classes or interfaces generated during system assembly. Eliminate the hassle of making.

As a preferred embodiment of the present invention, stub components are temporarily generated to replace the glue component in charge of connection with the server component in order to perform an error test and a functional test on the component under development alone (step S15). .

Using the client-side metadata included in the component for component unit testing, a template of the stub component that satisfies the server component ID, interface ID, operation signature, and the like that is called automatically is generated (step S151), and the developer Edits the return value of the service to be provided from the server component (step S152), compiles it, develops the stub component, and performs the independent error and function test of the developed component (step S153). By using dynamic binding techniques such as stub components and reflection, errors and functional checks of components can be performed, thereby essentially developing all components independently of other components and performing functional tests.

5 shows a preferred embodiment of a method of assembling components in accordance with the present invention. The component assembly process shown in Fig. 5 includes the steps of customizing the component message flow in a graphic environment (steps S21 and S22), automatically generating a glue component template and editing the component arbitration code (step S23), and compiling the glue codes. To generate the glue component (step S24), and repeats this step as necessary to implement the software system.

In a preferred embodiment according to the present invention, each component is treated as a single statement that performs a single function, and the steps of customizing the flow of messages between components prior to creation of the glue component in order to flexibly place the order of execution of the components. . Using the GUI tool using the sequence diagram used in system design, place instances of the components to be assembled in the drawing (step S21), and set the message flow between the components by selecting the client component and the server component to be connected among them. (Step S22). Using the sequential GUI Tool for flexible customization of the component message flow has the great advantage of being able to freely set the component flow and message flow according to time series.

In addition, in the present invention, the glue component template is automatically generated using metadata corresponding to the client side metadata and the interface of the server component side to connect the two components, and the signature and semantic inconsistency between the components are solved. The glue component is generated by inserting the arbitration code (step S23) and compiling the generated and inserted glue codes (step S24).

 By going through this assembly process disclosed by the present invention, it is possible to apply the divisional conquest method without assembling a large-scale system at once, to assemble using several sequential diagrams, test each independently, and then integrate the system as a whole. Ultimately, you treat components as statements that perform a single function, and use flowcharts to flexibly place components in order of execution and to easily implement glue components, enabling you to develop large systems more quickly and quickly.

6 is a flow diagram illustrating an embodiment of an automatic generation method in accordance with the present invention for a glue component that mediates message transfer between components in accordance with the present invention. Referring to FIG. 6, in order to connect feature services between two components, the metadata related to service invocations of subcomponents of the client component are examined (step S2311), and the developer shows and connects a list of services to be called by the client component. The process of selecting the desired service call (step S2312) and the metadata corresponding to the interface of the server component are examined (step S2321) to show a list of services provided by the server component to the developer and to select the service to be called (step S2322). Go through the process.

In addition, the glue component template code is automatically generated using the client-side metadata regarding the selected service, that is, the client component metadata regarding the selected invocation of the client component and the server component providing service (step S233). At this time, the client-side metadata is used to read information such as the identifier of the desired server component class or interface and the signature of the operation, and to automatically determine the glue component, interface, class, and source code defining the operation. Creates a template for the glue component automatically.

Then, the developer inserts simple arbitration code into the automatically generated glue component template code to solve the grammatical matching problem and semantic inconsistency of the signature between components so that the two components can communicate correctly. A guaranteed arbitration code is inserted (step S234). By injecting client and server-side annotations and signatures into the glue component template, it is very easy for developers to write arbitration code. In addition, when creating a glue component template, system integration tests can be performed by automatically inserting code to log message contents and time required for service calls between components and inspecting the logged data.

In addition, as a preferred embodiment of the present invention, by performing all operations related to component assembly and assembly test in a GUI environment and automatically generating a template and some source code of the glue component, it is easy to generate a message flow between components without modifying the source code. It's highly intuitive and simplified to make complex and time-consuming component assembly and testing processes so you can quickly build new systems and easily maintain them.

Hereinafter, an embodiment of a development platform for providing a component-based software development environment according to the present invention will be described in detail with reference to FIGS. 7 and 8. 7 and 8 are described as a preferred embodiment of the .NET (.Net) development platform of Microsoft, but is not necessarily limited to this, it is of course possible to extend to other development platforms.

7A-7E are diagrams sequentially illustrating one embodiment of implementing a component that includes client-side metadata in a GUI provided in accordance with the present invention. Referring to FIG. 7A, when a software developer determines that a subcomponent service is needed while generating code for implementing a component (that is, to call a method provided by a subcomponent), a 'cursor' is applied to a portion of the service required. Position it. Here, the method means a function that allows a lower component to access the upper component. The program developer then clicks on the menu 'SmartBind 712 (Generating client-side code and metadata)' at the top of the development tool.

Then, the development tool according to the present invention displays a dialog window 713 for inputting an ID (ID) and a method signature used to call a subcomponent (actually a glue component).

7B is a diagram illustrating an embodiment of a dialog for generating a glue component provided by a component-based software development tool according to the present invention. Referring to FIG. 7B, the developer inputs a signature of a desired service regardless of the signature of a service provided by a subcomponent to be assembled later. Referring to FIG. 7B, a return type, a method name, a method comment, a qualifier, a parameter type, a name, and the like are input.

Closing the dialog window 713 shown in FIG. 7B, the development tool according to the present invention based on the information input from the developer, the client side for the ID and method signature of the service to be provided by the glue component to be created by the assembly tool at assembly time. Generate the metadata and the code that creates this glue component object and calls the method (reference numeral 715 in FIG. 7C) and functionalizes this code. Referring to FIG. 7C, the development tool according to the present invention generates a code for calling a function generated at 713 of FIG. 7B at the position where the cursor is positioned at 711 of FIG. 7A.

Meanwhile, as illustrated in FIG. 7D, the development tool according to the present invention uses a glue component generation menu button that supports assembly with subcomponents to test whether a component under development can be assembled and operated without errors. 716).

Subsequently, when the developer clicks the menu button 716 of FIG. 7D, the development tool according to the present invention reads the client-side metadata generated at 715 of FIG. 7C to generate a glue component having the same ID and signature. Create the template code and project file you create.

7D is a diagram illustrating a solution search window according to the present invention showing project files for creating a stub component wizard 717 (a temporary glue component created by a development tool for testing).

FIG. 7E illustrates a stub component code template generated by the stub component wizard 717 of FIG. 7D. The developer modifies the code shown in FIG. 7E to develop a component that is dependent on a service provided by a subcomponent. You can develop and test without subcomponents.

The components developed and tested through the processes described with reference to FIGS. 7A to 7E are not only server-side metadata (provided by the original component platform technology) for services (methods) provided to upper components, but also subcomponents arbitrarily determined by developers. Embedding client-side metadata that defines the services that (actually the glue component) should provide.

8A-8E illustrate a development tool window illustrating a process of assembling components in accordance with the present invention. Referring to FIG. 8A, a developer creates a new component assembly project 811 for component assembly. That is, the developer selects the component assembly project 811 in the dialog. Subsequently, when the dialog box of FIG. 8A is closed, the development tool according to the present invention generates files for the assembly project and displays the component assembly edit window 812 in the form of a flowchart.

In FIG. 8B, reference numeral 813 denotes a solution search window that displays files of the generated project. The developer selects a "Component" node in the solution search window 813 (eg, by right clicking) and includes the components to be assembled into the assembly project via a context menu.

FIG. 8C is a diagram illustrating components included in an assembly project in the above-described process of FIGS. 8A and 8B. Referring to FIG. 8D, there is shown an assembly tool window 814, which is provided for drawing a sequence diagram in a development tool, and an object life line 815 is shown.

That is, if the developer moves the mouse cursor to the editor window while releasing the component tool in the assembly tool window 814 and releases the button (drag and drop operation), the development tool displays the object lifeline in the flowchart. Subsequently, as illustrated in FIG. 8E, the developer may select one of the components included in the project and map the object life line using the context menu.

8F illustrates a dialog showing attributes of an object lifeline to which a component is mapped, in which a development tool reads metadata of a component mapped to an object lifeline and displays it in the attribute window 816. That is, the property window 816 shown in Fig. 8F reads the server component side metadata and the client side metadata and displays the signature information of each method.

Fig. 8G shows a picture of a developer completing a flowchart in a graphic editing window according to a preferred embodiment of the present invention. That is, the components are mapped to each object lifeline 815 and the component is connected with a message 817 to indicate that the parent component invokes the method of the child component. In accordance with a preferred embodiment of the present invention, message 817 of FIG. 8G is mapped to a glue component that resolves the identity and signature mismatch between the two components and links the method call.

8h is a diagram showing a dialog box for selecting a message in the developer editor and displaying its properties. The message attribute dialog 822 of Fig. 8H reads the client-side metadata 818 of the parent component connected to this message to display the method called by the parent component, and reads the child component server-side metadata 819 to read the child component. Shows the service methods provided by.

When the developer selects the parent component's invocation method and the child component's called method and closes the dialog, the development tool generates code and a project to create a glue component that connects the method invocation between the two components. In FIG. 8H, a combo box 820 for selecting a method to be processed by a corresponding message (glue component) among methods to be called by a parent component, and a method to be processed and connected by the corresponding glue component among called methods of the child component are selected. A combo box 821 is shown.

Fig. 8i shows a development tool generating a project and a glue code template for making a glue component. When the developer selects a parent component calling method and a child component calling method and closes the dialog box, the development tool is opened. The client component metadata of the parent component is read to create a glue component with the same ID, and the glue code implementing the server method having the same signature as the calling method signature selected by the developer is generated. Subsequently, the development tool also reads the subcomponent server-side metadata and annotates the called method signatures of the developer's choices within the methods of the glue code generated in the above process.

Referring back to FIG. 8I, the development tool reads the metadata of the two components and automatically generates the glue component code having the same ID by reading the ID portion of the client-side metadata of the upper component and the glue code 823. Code 824 is shown. Also shown is a service method 825 of the glue component that has the same signature as the signature of the invocation method selected by the developer in the client-side metadata of the parent component. Also shown in FIG. 8I is a glue component project 826 generated by the development tool.

Referring to FIG. 8J, for example, the developer can see that the glue component projects 829 and 830 have been generated for the two messages 827 and 828 in the edit window to generate the glue component for all the messages shown in the flowchart. have.

Referring to FIG. 8K, the developer can edit the glue code generated by the development tool to resolve the syntactic / semantic inconsistency of the method value signatures of the two components. Figure 831 shows the annotation of the signature of the called method by reading the server-side metadata of the subcomponent to make it easy.

8K also shows an example of arbitration code 832 inserted by the developer to resolve the signature mismatch between the two methods.

8L illustrates a process of creating a glue component by compiling the generated and edited glue codes when the developer clicks the 'build' menu. After the glue component is created through the above-described process, the upper component uses the glue component. The glue component will call the subcomponent.

In this way, developers can independently build and integrate binary (compiled) components that are developed independently, without detailed documentation of source code or subcomponent calls, and whose invocation and called method signatures do not exactly match. It becomes possible.

8m illustrates a development tool compiling glue codes to form glue components and displaying the results. After the glue components are created through this process, the parent component calls the glue component and the glue component calls the child component. Will be called.

In this way, developers can independently build and integrate binary (compiled) components that are developed independently, without detailed documentation of source code or subcomponent calls, and whose invocation and called method signatures do not exactly match. It becomes possible.

The foregoing has outlined rather broadly the features and technical advantages of the present invention in order to better understand the claims of the invention which will be described later. Additional features and advantages that make up the claims of the present invention will be described below. It should be appreciated by those skilled in the art that the conception and specific embodiments of the invention disclosed can be readily used as a basis for designing or modifying other structures for carrying out similar purposes to the invention.

In addition, the inventive concepts and embodiments disclosed herein may be used by those skilled in the art as a basis for modifying or designing other structures for carrying out the same purposes of the present invention. In addition, such modifications or altered equivalent structures by those skilled in the art may be variously changed, substituted, and changed without departing from the spirit or scope of the invention described in the claims.

 As described above, the present invention includes the client-side specification information as well as the server-side interface specification information in metadata in connection and reusing many components having been independently developed by different developers and having different signatures. This enables multi-tiered software development, out of order assembly, and parallel development.

In addition, in the component-based software development method according to the present invention, since each component includes client-side interface metadata, a stub component template can be automatically generated, and an appropriate value can be substituted to test component function. Therefore, even if the developer develops the subcomponent independently in a way that is convenient for the subcomponent, there is no problem of calling the subcomponent, and as a result, the software development productivity is improved.

The component development tool implemented according to the present invention can automatically generate glue code templates for component assembly, and by inserting logic to mediate the grammatical and semantic inconsistency of parameters between the server and client-side heterogeneous components to be assembled. It can greatly increase the reusability of components and semi-automate the component assembly process. Furthermore, the present invention enables the assembly of a multilayer structure between components, unlike the prior art, so that the component assembly process can be performed by naturally applying a component coupling relationship in a design.

In addition, the component-based software developed in accordance with the present invention has the effect of reducing unnecessary system load or network load because the method calls between the components directly connected to the synchronous processing. Moreover, the component development tool implemented according to the present invention provides an intuitive component assembling tool in the form of sequence diagrams used for system requirements analysis and system conceptual design, making it easier and easier to develop components without complicated and cumbersome ADL specification or source code creation. It makes it possible to assemble and maintain inexpensively.

Furthermore, when applying the component-based software development technology according to the present invention to Microsoft's .NET development platform, CustomAttribute, Reflection, CodeDom provided by Microsoft's technology It is easy to apply advanced technologies such as) to extend component metadata and to automatically generate glue code templates very efficiently. In addition, by developing assembly tools in the form of VSIP Package, the Visual Studio user experience is applied, the component structure editing function in the form of sequential, glue code editing with IntelliSense, source level debugging, etc. It is possible to provide its advanced features.

In the current component distribution market, GUI components are mainly distributed, and the component that implements business logic is not only diverse, but also very large particle-grained generality due to the lack of hierarchical assembly technology. While only these falling components exist, the active binding technology in accordance with the present invention provides efficient and independent component development and test functionality, and provides a client-side interface specification that enables multi-layer assembly to match the design, thus providing appropriate generalization. It has the effect of encouraging the development of fine-grained, reusable business logic domain components of generality and creating their distribution markets.

In addition, the active binding technology according to the present invention enables the assembly of binary components into a multi-layered structure, thereby matching design and implementation, distributing components designed to operate locally on a network, and operating remotely. To provide remote hosting capabilities. Therefore, it is possible to purchase binary components made by third parties at a low price in the market and to build a large-scale multi-layer distributed system.

Furthermore, the editor in the form of a sequence diagram provided by the active binding technology according to the present invention visualizes the assembly of components in a method call unit of time series, and takes care of assembling a single method call per glue code. It makes it precise and simple. The combination of Microsoft's Visual Studio with active binding technology also provides Intelli-Sense and source-level debugging capabilities for auto-generated glue code templates, maximizing software development productivity.

The active binding technology according to the present invention is fully integrated with Microsoft's latest integrated development tool, Visual Studio .NET 2003, and the component according to the present invention can be quickly and easily applied by applying the user's visual studio experience as it is. It is also possible to apply development techniques.                     

The active binding technology according to the present invention provides a sufficient level of metadata for assembly and visualization of method-level granular assembly structures, enabling system changes by third parties rather than developers without additional documentation. Thus, the system user can reduce the cost of documentation and the exclusive maintenance contract, unlike the conventional case.

Claims (22)

In the method of developing component-based software, a component that extends the component metadata to include client-side call specification information so that independently developed components can be reused in binary form in the development of new software having a multi-layered structure. Development method (a) when the component under development needs to call a lower (server) component method as a client, the method signature input processing means receives an arbitrary signature and annotation for the method from the developer; (b) a glue component method that mediates the invocation of the server component method when the helper function generation processing means executes the software developed through component assembly in the future based on the method signature input in step (a). Generating helper function code for dynamically calling; (c) inserting code for calling the helper function in a portion where the helper function generation processing means needs to call the server component method of the component under development; (d) the metadata generating processing means generating the client-side metadata based on the method signature input in the step (a) and including it in the component under development; Software development method comprising a. The method of claim 1, wherein step (d) And the metadata generation processing means generates the client-side metadata in the form of user attributes and includes it in a component under development. The method of claim 1, wherein step (d) And the metadata generation processing means arbitrarily generates a glue component identifier (ID), a class identifier, and an interface identifier, and generates client-side metadata along with the method signature input in the step (a). According to claim 1, The component development method, (e) The stub (simple) component generation processing means reads the client-side metadata included in the component under development and generates stub component template code corresponding to the virtual subcomponent. Allowing independent testing of the component under development; Software development method comprising a further. In the method of developing component-based software, the component assembly method for developing a multi-layered software by reusing components independently developed by various developers according to the method of claim 1 (a) causing the component placement processing means to arrange the components to be assembled on the graphical tool screen; (b) a component message flow (call relationship) setting processing means for causing a developer to establish a message flow between components as a client and a server for the components in the graphical tool; (c) the glue component template code generating means automatically generating a glue component template to mediate the message flow set in step (b); (c1) reading the client-side metadata of the client component to show the developer a list of methods that the client component can call and to select one of them; (c2) reading the server-side metadata of the server component to show the developer a method list provided by the server component and to select a method to be called; (c3) a substep of reading an identifier part of the client-side metadata selected in the substep (c1) to generate a glue component, an interface, and a class having the same identifier; (c4) a substep of reading a method signature from among client-side metadata selected in the substep (c1) and generating a method having the same signature in the class generated in the step (c3); (c5) a substep of reading the server-side metadata selected in the substep (c2), generating code for creating an instance of the server component, and inserting the code into the method generated in the substep (c4); (d) the glue component generation processing means generating a glue component by compiling the glue component code generated in the step (c); (e) the means allowing the developer to repeat the component assembly process of steps (a) to (d) as necessary to develop a multi-layered software; Software development method comprising a. The method of claim 5, wherein step (c) comprises: (c6) the glue component template code generation processing means checks the signature of the client-side method selected in the substep (c1) and the signature of the server component-side method selected in the substep (c2), and if they do not coincide with each other, Sub-step of receiving an arbitration code from the glue component template code Software development method further comprising. In the system for developing component-based software, the component development apparatus according to the component development method of claim 1 (a) a module device which receives a developer's arbitrary signature and annotation on the method through a dialog when the component under development needs to call a lower (server) component method as a client; (b) based on the signature input from the module device (a), the helper function code for dynamically calling the glue component method which mediates the call of the server component method when the software developed by the component assembly is executed later A module device for generating and inserting code for calling the helper function in a portion in which the server component method needs to be called; (c) a module device for generating client-side metadata based on the signature input by the module device (a) and including it in a component under development; Software development system comprising a. The method of claim 7, wherein the component development apparatus, (d) A module that reads the client-side metadata of the component under development and generates a test stub component template to independently test whether the component under development can be connected to the subcomponent and operate normally without the actual subcomponent. Device; Software development system further comprising. In the system for developing component-based software, the component assembly apparatus according to the component assembly method of claim 5 (a) a module device for arranging components to be assembled on a graphic screen; (b) a module device for visually establishing a message flow between components as a client and a server in the assembly tool window for the components arranged in the module device (a); (c) a module device for generating a glue component code to mediate the message flow established by said module device (b), and wherein said module device (c) comprises the following sub-module devices (c1) to (c3): Contains.>; (c1) a submodule apparatus that reads client-side metadata of the client component to show a developer a list of methods that the client component can call and select one of them; (c2) a submodule apparatus that reads server-side metadata of a server component to show a list of methods provided by the server component to a developer and select a method to be called; (c3) a submodule apparatus for generating a glue component template code using metadata for the client-side method selected by the submodule apparatus (c1) and the server-side method selected by the submodule apparatus (c2); (d) a module device for compiling glue component codes generated by the module device (c) to complete component assembly; Software development system comprising a. The method according to claim 9, wherein the module device (b), The software development system, characterized in that the component arrangement and the message flow setting between the components can be expressed in the form of a sequence diagram. The method of claim 9, wherein the sub module device (c3), And inserting signatures and annotations for the client-side and server-side methods as annotations into the glue component template code, so that developers can easily write the arbitration code if necessary. The method of claim 9, wherein the sub module device (c3), Generates and logs code to record the parameter values, return values, time required, etc., when the client component invokes a server component method, into the glue component template, thereby recording the record in the functional test of the software under development. A software development system characterized by being made available. The method of claim 9, wherein the module device (c) is (c4) compares the signature of the client-side method selected by the submodule apparatus (c1) with the signature of the server component-side method selected by the submodule apparatus (c2) and inputs an arbitration code from the developer if they do not match with each other; A sub module device to receive and insert the glue component template code; Software development system further comprises. delete delete delete delete delete delete delete delete delete

Images