KR20040097941A - Method and system of developing a software with utilizing metadata of the client-side component under component-based development environment - Google Patents

Abstract

PURPOSE: A method and a system for developing software using metadata under a component based environment are provided to enhance reuse of components and flexibly control a message flow between components without correcting component codes by overcoming syntactic/semantic matching problems of a signature severely needed for combination between components. CONSTITUTION: To flexibly control the message flow, a client component(310) requesting a specified function service combining both components by implementing the metadata(311) describing that a server component(320) uses the service having which signature, and a glue component(330), which is a mediator applying a glue concept using the metadata(312) corresponding to a use contracted interface for using the service of the server component. As the glue component dynamically controls the message flow by having call information, both components call or are called from each other even if both components have the call information of an opposite side.

Description

TECHNICAL AND DEVELOPING A SOFTWARE WITH UTILIZING METADATA OF THE CLIENT-SIDE COMPONENT UNDER COMPONENT-BASED DEVELOPMENT ENVIRONMENT}

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 relates to a method of developing software assembled with each other, a new component metadata format, a development tool for implementing the same, and a development environment system.

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, with the advent of embedded systems and ubiquitous computing, the demand for various softwares has soared and changes are frequently required for 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, exhibit limitations in improving software development productivity, Unlike the method, 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 a 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 technology does not include client-side information about service invocations provided by subcomponents in the metadata provided at the time of deployment, so that if a component to be reused depends on another 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 a GUI (Graphic User Interface) providing a simple and independent service, and the reuse rate of components in the business logic domain, which is a 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 burden on the network and the 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 separately in two notation formats: IDN: Component Interface Definition Notation) and Architecture Definition Notation (ADN).

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 a disadvantage of incurring a lot of unnecessary interrupts and message identification processing, which adds to the system burden because all interactions between components always occur through the broadcasting and checking of 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.

In addition to the above objects, a fourth object of the present invention is to provide a component-based software development device, system and method which 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.

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

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 lower 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 making a temporary glue component for test, and processing means for selecting and arranging components to be assembled using a GUI tool 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 can automatically generate a template of a glue component, which is an arbitration component for assembling a component, thereby 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 the subcomponent to call (component ID = component X, interface ID = x1 (), and the operation signature). Field information by constructing metadata 311 and including it in a component so that the metadata 311 is used to satisfy an attribute defined in the metadata (component ID = component X, interface ID = x1 ( ), Create a glue component with the called operation and the signature with the same operation, and check in the server component B 320 within the glue component. 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 annotation of a service that should be provided from a lower component 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), create a temporary glue component for testing and test the independent component function It consists of five steps such as the step of performing a test (step S15).

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. The client-side metadata makes it possible to automatically create a mediator connecting two components using the glue mechanism (step S23) by extending the metadata owned by the component itself.

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 metadata and code to create this glue component object and call a method (reference numeral 715 in FIG. 7C) and to function 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 the upper components, but also subcomponents arbitrarily determined by the developer. 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 is a diagram showing a development tool compiling glue codes to make glue components and displaying the results. After creating glue components 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 by synchronously processing method calls directly between components. 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 according to the present invention provides efficient and independent component development and testing capabilities, and provides a client-side interface specification that enables multi-layer assembly to match the design, thus providing adequate generality. It has the effect of encouraging the development of fine-grained, reusable business logic domain components with 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 software by assembling a plurality of components manufactured on a component development platform in a relationship between a client and a server, each of the components independently includes its own unique ID and its own operation signature without restriction. And the metadata in its own arbitrary format. The metadata includes not only the interface called information as a server but also the interface call information as a client. Generating a glue component template for matching the calling specifications of the client component calling the server component with each other to assemble a plurality of components independently having an arbitrary ID and signature. Software that allows manufacturing method. The method of claim 1, wherein the creating a glue component template (a) extracting client side metadata from the client component; (b) generating an interface and a glue component class having the same ID by reading an ID portion of the metadata of step (a); (c) reading a method signature from the metadata of step (a) and generating a method having the same signature in the class generated in step (b); (d) extracting server side metadata from the server side component; And (e) generating and inserting code for creating an instance of the server component in the method generated in step (c) Software production method comprising a. 3. The method of claim 2, further comprising reading a method signature portion from the metadata obtained in step (d) and inserting it as a comment in the code created in step (e). 3. The method of claim 2, wherein generating the glue component template further comprises generating mediation code by comparing metadata of the server with metadata of the client. The component of claim 1, wherein the component including the client-side metadata includes: (a) receiving a signature and an annotation of a service (operation or method) to request from the server (child) component; (b) generating a helper function code for dynamically binding and calling a glue component service that mediates the server component service call based on the signature received in step (a); (c) inputting a helper function call code of step (b) to a portion to which the server component service is to be called; And (d) thereafter generating and incorporating the client-side metadata required to generate the glue component template when assembling the component to a component or component resource Software production method characterized in that it is generated in a step comprising a. 6. The method of claim 5, wherein step (a) is performed using a wizard. 6. The method of claim 5, wherein step (d) includes client-side metadata in a binary component using a custom attribute. 6. The method of claim 5, wherein step (d) includes client-side metadata in a resource included in or distributed with the component. The method of claim 5, wherein the step (d) arbitrarily generates a glue component identifier and a class or interface identifier, and generates the client-side metadata along with the input operation signature. The method of claim 1, wherein the test simple component template code corresponding to the virtual subcomponent is generated using the client-side metadata included in the component, and then the stub component is created by editing and compiling. A software production method characterized by performing independent functional tests of the software being produced. In assembling a component that provides a component-based software development environment, (a) a process of placing selected components on the graphical tool screen using a graphical tool; (b) establishing a call relationship between components by selecting and connecting a client component and a server component using the graphical tool; (c) a process of generating a glue component by generating a glue component template and generating arbitration code for matching a service signature called by the client component with a service signature provided by the server component when the service signature is different or semantically inconsistent; (d) repeating steps (a) to (c) to create as many glue components as needed; And a software development environment for arranging a plurality of glue components generated in the process (d) and the client and server components to implement component-based assembly software. 12. The software development tool of claim 11, wherein process (a) and process (b) provide for establishing component placement and message flow in time series according to a sequence diagram. The software development method according to claim 11 or 12, wherein the process (a) and the process (b) are provided to be independently tested by assembling using a plurality of sequence diagrams. tool. 12. The process of claim 11, wherein said process (c) (c1) the process of showing the developer a list of services to be called by the client component and selecting one of them; (c2) a process of showing a developer a list of services provided by a server component and selecting a service to be called; (c3) generating template code for making a glue component using metadata for the selected client and server side services; And (c4) The process of resolving signature matching problems and semantic inconsistencies between parameters by the developer inserting simple arbitration code into the generated glue component template code. Software development tools that include. 15. The software development tool of claim 14, further comprising a process of inspecting client-side metadata included in the component and presenting the developer a list of signatures and annotations of the service that component is to invoke. 15. The software development tool of claim 14, wherein the process (c3) inserts client and server side annotations and signatures into the glue component template to facilitate the developer to write the arbitration code. 15. The software of claim 14, wherein the process (c3) inserts a code that records parameter values, returned values, and time required to call a service, and uses the recorded data for testing. Development tools. In a component-based software development tool that provides an environment for any program developer to develop new components on a de facto De-Facto Standard component platform, the development tool (a) a process in which the program developer receives a subcomponent service and inputs an ID and a method signature that the development tool will use to call the subcomponent, instead of creating code that calls the method; (b) creating a client-side metadata for the glue component ID and method signature and a glue component object based on the information input in the process (a), and generating a code for calling a method to functionalize the code; And (c) a process of generating template code and a project file by reading the client-side metadata to generate a glue component having the same ID and signature; Component-based software development system comprising a. 19. The component-based software development system of claim 18, wherein the process (c) includes a process of generating a test stub component template for testing whether a component under development can be assembled and operated without error with a subcomponent. . 19. The method of claim 18, wherein the components developed in the processes (a) to (c) are server-side metadata for services provided to the upper component and client-side metadata defining services provided by the lower component arbitrarily determined by the developer. Component-based software development system comprising a. In a component-based software development tool that provides an environment for any program developer to develop new components operating on a de facto De-Facto Standard component platform, the development tool (a) a process of creating a component assembly project for the program developer to assemble the component, generating a file for the assembly project and providing an assembly editing window in a sequential form; (b) a process of recognizing the signature of each method by reading metadata of the mapped component when an object lifeline is generated in the assembly edit window and mapped to a component participating in an assembly project; and (c) a process in which the components are connected by a message, a method is called and a glue component is generated Component-based software development system comprising a. 23. The developer of claim 22 wherein the developer generates the mediation code of the developer if the developer edits the glue code generated by the development tool to resolve syntactic / semantic inconsistencies in the method value signatures of the two components. Component-based software development system further comprising a process.