KR100884435B1 - A Method for Decoupling Service Components from Application-Specific Business Entities - Google Patents

A Method for Decoupling Service Components from Application-Specific Business Entities Download PDF

Info

Publication number
KR100884435B1
KR100884435B1 KR1020070125847A KR20070125847A KR100884435B1 KR 100884435 B1 KR100884435 B1 KR 100884435B1 KR 1020070125847 A KR1020070125847 A KR 1020070125847A KR 20070125847 A KR20070125847 A KR 20070125847A KR 100884435 B1 KR100884435 B1 KR 100884435B1
Authority
KR
South Korea
Prior art keywords
data type
component
service
business entity
converter
Prior art date
Application number
KR1020070125847A
Other languages
Korean (ko)
Other versions
KR20070121624A (en
Inventor
정안모
Original Assignee
정안모
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 정안모 filed Critical 정안모
Priority to KR1020070125847A priority Critical patent/KR100884435B1/en
Publication of KR20070121624A publication Critical patent/KR20070121624A/en
Priority to PCT/KR2008/007142 priority patent/WO2009072809A2/en
Application granted granted Critical
Publication of KR100884435B1 publication Critical patent/KR100884435B1/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G06F8/36—Software reuse
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/20—Software design
    • G06F8/24—Object-oriented

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Data Mining & Analysis (AREA)
  • Databases & Information Systems (AREA)
  • Mathematical Physics (AREA)
  • Stored Programmes (AREA)

Abstract

본 발명은 소프트웨어 컴포넌트의 재사용 기술에 관한 것으로, 독립적으로 개발된 바이너리 컴포넌트들을 소스 코드 수정 없이 재사용할 수 있도록 특정 애플리케이션의 비즈니스 엔티티(Business Entity)에 대한 서비스 컴포넌트의 종속성을 제거하는 방법을 제시한다. 본 발명은 비즈니스 엔티티를 우선 정의하고 그 명세에 따라 서비스 컴포넌트를 개발하는 종래의 소프트웨어 개발 방법과 달리, 컴포넌트 개발자는 특정 비즈니스 엔티티에 대한 고려 없이 자신이 비즈니스 로직을 구현하는 데 사용할 데이터 타입을 임의로 정의하여 이를 바탕으로 서비스 컴포넌트를 개발하고, 애플리케이션 개발자는 이렇게 개발된 컴포넌트들을 조립할 때 데이터 타입 컨버터를 통해 컴포넌트 개발자가 임의로 정의한 데이터 타입과 애플리케이션에서 실제로 사용할 비즈니스 엔티티의 속성 타입을 정합, 연동하는 방식으로 소프트웨어를 개발할 수 있게 한다. 본 발명은 이처럼 서비스 컴포넌트로부터 특정 비즈니스 엔티티에 대한 종속성을 제거하여 이미 제3자가 개발해 놓은 서비스 컴포넌트들의 획득, 조립을 통해 애플리케이션을 개발할 수 있게 함으로써 컴포넌트 재사용률을 제고하고, 개발 기간을 단축하며, 소프트웨어 생산과 유지 보수를 용이하게 한다.The present invention relates to a technology for reusing a software component, and provides a method of removing a dependency of a service component on a business entity of a specific application so that independently developed binary components can be reused without source code modification. Unlike the conventional software development method of first defining a business entity and developing a service component according to its specification, the component developer arbitrarily defines a data type to be used to implement business logic without considering a specific business entity. Based on this, the service component is developed and the application developer uses the data type converter to match the data type arbitrarily defined by the component developer with the property type of the business entity actually used in the application. Enable development The present invention removes the dependency on a specific business entity from the service component so that the application can be developed by acquiring and assembling service components already developed by a third party, thereby improving component reuse rate, shortening development time, and software. Facilitate production and maintenance.

데이터 타입, 비즈니스 엔티티, 의존성 주입, 컴포넌트 재사용, 컴포넌트 조립, 소프트웨어 생산성 Data types, business entities, dependency injection, component reuse, component assembly, software productivity

Description

객체지향 기반 서비스 컴포넌트의 특정 애플리케이션 비즈니스 엔티티에 대한 종속성 제거 방법 {A Method for Decoupling Service Components from Application-Specific Business Entities}{A Method for Decoupling Service Components from Application-Specific Business Entities}

도 1은 본 발명에 따라 개발된 서비스 컴포넌트가 특정 애플리케이션의 비즈니스 엔티티와 연동하는 구조를 나타낸 개념도.1 is a conceptual diagram illustrating a structure in which a service component developed in accordance with the present invention works with a business entity of a specific application.

도 2는 본 발명에 따라 서비스 컴포넌트를 개발하는 절차를 나타낸 일 흐름도.2 is a flow diagram illustrating a procedure for developing a service component in accordance with the present invention.

도 3은 본 발명에 따라 서비스 컴포넌트를 개발하는 절차 중 컴포넌트 자체 데이터 타입과 데이터 타입 컨버터 인터페이스 타입을 정의하는 단계를 더욱 상세하게 나타낸 일 흐름도.3 is a flowchart illustrating in more detail the steps of defining a component itself data type and a data type converter interface type during a procedure of developing a service component according to the present invention;

도 4는 본 발명에 따라 데이터 타입 컨버터 컴포넌트를 개발하는 절차를 나타낸 일 흐름도.4 is a flow diagram illustrating a procedure for developing a data type converter component in accordance with the present invention.

도 5는 본 발명에 따라 개발된 소프트웨어 실행시 각 구성 요소가 상호작용하면서 클라이언트의 서비스 호출을 처리하는 순서를 나타낸 순차도.5 is a sequence diagram illustrating a sequence of processing a service call of a client while each component interacts when executing software developed according to the present invention.

도 6은 본 발명의 양호한 일 실시 예에서 루트 데이터 타입과 주석용 커스텀 애트리뷰트를 정의해 둔 공용 객체 코드.6 is a public object code defining a root data type and a custom attribute for annotation in a preferred embodiment of the present invention.

도 7은 본 발명의 양호한 일 실시 예에서 애플리케이션이 실제로 사용하는 비즈니스 엔티티 객체 코드.7 is a business entity object code actually used by an application in a preferred embodiment of the present invention.

도 8은 본 발명의 양호한 일 실시 예에서 재사용할 서비스 컴포넌트의 서비스 객체 코드.8 is a service object code of a service component to reuse in one preferred embodiment of the present invention.

도 9는 본 발명의 양호한 일 실시 예에서 재사용할 서비스 컴포넌트의 자체 데이터 타입 코드.9 is a self data type code of a service component to be reused in one preferred embodiment of the present invention.

도 10은 본 발명의 양호한 일 실시 예에서 재사용할 서비스 컴포넌트의 데이터 타입 컨버터 인터페이스 코드.10 is a data type converter interface code of a service component to be reused in one preferred embodiment of the present invention.

도 11은 본 발명의 양호한 일 실시 예에서 애플리케이션 조립시 구현되는 데이터 타입 컨버터 객체 코드.11 is a data type converter object code implemented in the application assembly in a preferred embodiment of the present invention.

도 12는 본 발명의 양호한 일 실시 예에서 애플리케이션 조립시 생성되는 데이터 타입 컨버터 객체와 서비스 컴포넌트 자체 데이터 타입 간의 의존성 주입 정보 파일.12 is a dependency injection information file between a data type converter object and a service component itself data type generated when an application is assembled in a preferred embodiment of the present invention.

본 발명은 객체지향 컴포넌트 기반 소프트웨어 개발 기술에 관한 것으로, 더욱 상세하게는 독립적으로 개발된 바이너리 컴포넌트를 소스 코드 수정 없이 조립을 통해 새로운 소프트웨어를 개발하는 데 재사용할 수 있도록 해주는 기술에 관한 것이며, 더욱 상세하게는 컴포넌트 선 개발, 후 조립 방식에 의한 소프트웨어 개발을 가로막는 서비스 컴포넌트와 비즈니스 엔티티의 단단한 결합을 해소하는 기술에 관한 것이다.The present invention relates to an object-oriented component-based software development technology, and more particularly, to a technology that enables reuse of independently developed binary components to develop new software through assembly without source code modification. For example, the present invention relates to a technology that solves the tight coupling of service components and business entities that prevents component line development and post-assembly software development.

1968년 더글러스 맥킬로이(Douglas McIlroy)가 나토(NATO)의 소프트웨어 공학 컨퍼런스에서 컴포넌트의 대량 생산과 조립을 통한 소프트웨어 생산을 주창한 이래 소프트웨어 모듈의 재사용에 의한 생산성 향상은 소프트웨어 산업계의 오랜 숙원이었다. 이러한 소프트웨어의 재사용 가능한 모듈화에 대한 관심은 1980년대 후반의 객체지향 프로그래밍의 출현을 거쳐 1990년 이후 OMG의 CORBA/CCM과 마이크로소프트의 COM/COM+ 등 컴포넌트 모델들의 출현을 자극했고, 현재는 Java와 C# 같은 객체지향 언어로 EJB와 .NET 같은 컴포넌트 프레임워크 기반에서 소프트웨어를 생산하는 것이 IT 산업계의 대세를 형성하고 있다.Since Douglas McIlroy in 1968 advocated software production through mass production and assembly of components at NATO's software engineering conference, productivity gains from reuse of software modules have long been the industry's ambitions. This interest in the reusable modularization of software has led to the emergence of object-oriented programming in the late 1980s and the emergence of component models such as OMG's CORBA / CCM and Microsoft's COM / COM + since 1990, and now Java and C #. Producing software on the basis of component frameworks such as EJB and .NET in the same object-oriented language forms the trend of the IT industry.

그러나 위와 같은 최신 객체지향 컴포넌트 기술들은 그동안 이루어온 발전에도 불구하고 정작 그것들을 잉태한 화두인 컴포넌트의 재사용을 통한 소프트웨어 개발로부터는 멀어져 왔다. 현존하는 상용 기술들은 바이너리 컴포넌트의 재사용을 지향하기보다는 애플리케이션에 필요한 컴포넌트들을 모두 새로 개발하면서 간편한 모듈 연동과 코드 수준의 재사용 효율을 높이는 방향으로 진보해왔고, 컴파일 단계에서 에러를 조기 검출하기 위하여 엄격한 타입 안정성(Type-Safety)을 요구하는 소프트웨어 개발 방식에 정착하게 되었다. 이 타입 기반 프로그래밍에서는 컴포넌트를 개발할 때 이미 상호작용할 특정 타입(클래스, 인터페이스, 사용자 정의 데이터 타입 등)이 확보되어 그 식별 정보를 코드에 사용할 수 있어야 컴파일이 가능하 므로, 결과적으로 컴포넌트가 특정 타입, 나아가서 다른 특정 컴포넌트와 단단하게 결합될 수 밖에 없다. 이는 재사용 주창자들이 강조하는 느슨한 결합(Loose Coupling)과 정면으로 배치되는 개발 방식이고, 이런 방식으로 개발된 컴포넌트는 소스 코드 수정 없이는 다른 환경에서 재사용될 수 없다. (후술하는 액티브 바인딩 기술의 경우에서 볼 수 있듯이 타입 안정성 준수와 바이너리 컴포넌트의 재사용이 반드시 양립 불가능하지는 않다.)However, the latest object-oriented component technologies, such as the above, have moved away from software development through reuse of components, which are the topic of their conception despite the progress made in the past. Existing commercial technologies have advanced toward simple module integration and code-level reuse efficiency by developing all the components needed for the application rather than reusing binary components, and strict type stability to detect errors early in the compilation phase. It has become a software development method that requires (type-safety). In this type-based programming, when a component is developed, a specific type (class, interface, user-defined data type, etc.) to be interacted with already exists and its identification information must be available to the code to be compiled. Furthermore, it can only be tightly coupled with other specific components. This is the loose coupling emphasized by reuse proponents, and the development method deployed in front, and components developed in this way cannot be reused in other environments without source code modification. (As seen in the case of the active binding technology described below, type safety compliance and binary component reuse are not necessarily incompatible.)

비즈니스 로직을 구현한 서비스 컴포넌트가 하드웨어 부품처럼 다양한 애플리케이션에서 소스 코드 수정 없이 재사용될 수 있으려면 특정 애플리케이션 환경에 종속되지 않아야 한다. 어떤 컴포넌트가 특정 애플리케이션 환경에 종속되지 않으려면 다른 특정 컴포넌트와의 결합이 느슨해야 할 뿐 아니라, 특정 애플리케이션을 구성하는 주요 개념이자 컴포넌트간 데이터 전달을 담당하는 비즈니스 엔티티와의 결합 역시 느슨해야 한다. 이것은 결국 각 서비스 컴포넌트가 플랫폼이나 프레임워크에서 클래스 라이브러리로 제공하는 타입 이외에는 외부에 정의된 특정 타입의 인스턴스를 사용하는 코드를 포함해서는 안 된다는 것을 의미한다.Service components that implement business logic must not be dependent on a specific application environment in order to be reused without modification of source code in various applications, such as hardware components. In order for a component not to be dependent on a particular application environment, not only should it be loosely coupled with other specific components, but also loosely coupled with the business entity that is responsible for the data passing between components and the main concepts that make up a particular application. This means that each service component must not contain code that uses an externally defined instance of a specific type other than the type provided by the platform or framework as a class library.

그러나 종래의 컴포넌트 기술에서는 전술한 대로 서비스 컴포넌트가 다른 서비스 컴포넌트의 인터페이스, 애플리케이션의 비즈니스 엔티티 등 외부에 정의된 타입들을 코드에서 사용하므로 특정 애플리케이션에 종속될 수밖에 없고, 이를 다른 애플리케이션에서 사용하려면 소스 코드를 수정해야만 한다. 소스 코드를 수정하려면 소스 코드가 있어야 하는데 제3자가 개발한 컴포넌트의 소스 코드를 구할 수 있는 가능성은 현실적으로 희박하며, 설사 구한다 해도 제3자가 작성한 소스 코 드를 분석하여 에러 없이 수정하는 것이 필요한 컴포넌트를 처음부터 새로 개발하는 것보다 쉬운 작업도 아니다. 따라서 종래의 상용 컴포넌트 기술 기반으로는 제3자가 독립적으로 개발한 서비스 컴포넌트를 재사용하는 것이 바이너리 차원에서는 원천적으로 불가능하고, 소스 코드 차원에서는 경제적으로 비현실적이라 할 수 있다.However, in the conventional component technology, as described above, the service component uses externally defined types in the code, such as an interface of another service component and a business entity of the application, so that the component is dependent on a specific application. You must fix it. The source code is required to modify the source code, but the possibility of obtaining the source code of a component developed by a third party is practically unlikely, and even if it is obtained, it is necessary to analyze the source code written by the third party and fix the component without error. It's not as easy as developing from scratch. Therefore, reusing service components independently developed by a third party based on the conventional commercial component technology is not possible at the binary level and economically unrealistic at the source code level.

이상에서 살펴본 바와 같이 이미 개발된 서비스 컴포넌트들을 새로운 애플리케이션 개발에 재사용할 수 있으려면 각 컴포넌트가 외부에 정의된 특정 타입에 의존하지 않아야 한다. 타입 안정성을 강제하는 오늘날의 객체지향 컴포넌트 기술 기반에서 이 목표를 이룰 수 있는 현실적 방법은 각 컴포넌트가 자신의 기능을 수행하기 위해 의존해야 하는 인터페이스 타입이나 사용자 정의 데이터 타입을 해당 컴포넌트 자체 내에 정의하여 소스 코드 작성에 사용하고, 이런 방식으로 개발된 서비스 컴포넌트를 차후 애플리케이션 개발에 재사용할 때 메타데이터로 노출되는 타입 정보를 이용하여 실제로 의존할 외부 타입과의 결합을 컴포넌트 밖에서 중재하는 것이다. 이 중재 작업에서는 클라이언트-서버 관계로 조립되는 서비스 컴포넌트 사이의 인터페이스 불일치를 해소해야 하고, 서비스 컴포넌트에서 비즈니스 엔티티 대신 사용한 자체 데이터 타입과 애플리케이션의 실제 비즈니스 엔티티 사이의 타입 불일치를 해소해야 한다.As discussed above, in order to be able to reuse already developed service components for new application development, each component should not depend on a specific type defined externally. In today's object-oriented component technology, which enforces type stability, a realistic way to achieve this goal is to define the interface types or user-defined data types that each component must rely on to perform its function and then define the source by itself. By using the type information exposed in the metadata for use in writing code and reusing service components developed in this way for future application development, you mediate the association outside the component with external types that you actually depend on. This intervention should resolve interface inconsistencies between service components that are assembled in a client-server relationship, and resolve type inconsistencies between their data types used in place of business entities in service components and the actual business entities of the application.

이와 같이 선 컴포넌트 개발, 후 조립 재사용 방식으로 소프트웨어를 개발할 수 있게 하는 기술은 자바, 닷넷 등 종래의 상용 컴포넌트 기술에서는 지원하지 않는다. 아직 상용화되지 않은 기술 중에서는 액티브 바인딩 기술(대한민국 특허 등 록번호 10-0697246: "컴포넌트 기반 환경 하에서 확장된 메타데이터를 이용한 소프트웨어 개발 방법 및 시스템)과 그 업그레이드 버전(대한민국 특허 출원번호 10-2007-0113441: "컴포넌트 재사용과 의존성 주입 기술을 이용한 소프트웨어 개발 및 실행 방법")에서 각 컴포넌트 내에 서비스 요청에 필요한 인터페이스를 정의하여 자족적인 코딩을 가능케 함으로써 서비스 컴포넌트간의 종속성을 제거하고 조립시 글루 컴포넌트를 통해 인터페이스 불일치를 해소하는 방법을 제시하고 있다.As described above, the technology for developing software using pre-component development and post-assembly reuse is not supported by conventional commercial component technologies such as Java and .NET. Among the technologies not yet commercially available, active binding technology (Korean Patent Registration No. 10-0697246: "Software development method and system using extended metadata in a component-based environment) and its upgraded version (Korean Patent Application No. 10-2007-) 0113441: "How to Develop and Run Software Using Component Reuse and Dependency Injection Techniques") defines interfaces for service requests within each component to enable self-sufficient coding to eliminate dependencies between service components and to interface through glue components during assembly. It suggests how to resolve the inconsistency.

액티브 바인딩 기술은 전술한 바와 같이 서비스 컴포넌트간 결합을 완화하고 인터페이스 중재를 통한 컴포넌트 조립 방법을 제시함으로써 독립적으로 개발된 서비스 컴포넌트를 소스 코드 수정 없이 재사용할 수 있게 하는 데 필수불가결한 기반을 제공했다. 그러나 이 기술은 서비스 컴포넌트가 특정 애플리케이션의 비즈니스 엔티티에 종속되는 문제는 다루지 않고 있다. 애플리케이션을 구성하는 주요 개념이자 프리젠테이션 계층, 비즈니스 로직 계층, 데이터 처리 계층의 서비스 컴포넌트들 사이에서 매개변수나 결과 값 형태로 데이터를 전달하는 비즈니스 엔티티는 애플리케이션마다 사용처의 요구사항을 반영하여 고유하게 정의된다. 엄격한 타입 안정성을 지향하는 기존 상용 개발 환경에서는 이러한 애플리케이션 고유의 비즈니스 엔티티 타입과 서비스 컴포넌트의 각 메소드가 다루는 데이터 타입이 일치할 때만 컴파일과 동작이 가능하므로 비즈니스 엔티티를 먼저 정의하고 이를 기반으로 서비스 컴포넌트를 개발한다. 따라서 오늘날의 개발 환경에서는 액티브 바인딩 기술을 통해 서비스 컴포넌트간의 상이한 인터페이스를 중재할 수 있다 해도 서비스 컴포넌트의 데이터 타입과 애플리케이션의 비즈니스 엔티티 타입을 중재하는 방법 이 추가로 마련되지 않으면 현실적으로 제3자에 의해 독립적으로 개발된 서비스 컴포넌트들을 소스 코드 수정 없이 조립하여 새로운 애플리케이션을 개발할 수 있는 가능성이 상당히 줄어든다.As described above, the active binding technology provides an indispensable basis for reusing service components independently developed without source code modification by providing a method of assembling components through interface arbitration and mitigation. However, this technique does not address the problem of service components being dependent on the business entity of a particular application. The business concepts that deliver data in the form of parameters or result values between the key concepts that make up an application and the service components of the presentation layer, business logic layer, and data processing layer are uniquely defined to reflect the needs of each application. do. In the existing commercial development environment with strict type stability, only the business entity is defined first, and then the service component is defined based on the business entity type because it can be compiled and operated only when the data type handled by each method of the service component matches. Develop. Therefore, in today's development environment, even though active binding technology can mediate different interfaces between service components, it is practically independent from third parties unless there is additional means to mediate the data type of the service component and the business entity type of the application. The possibility of developing new applications by assembling service components developed without modification to source code is greatly reduced.

이상과 같은 서비스 컴포넌트 재사용 관련 기술의 현황을 살펴볼 때, 특정 애플리케이션 환경에 종속되지 않는 컴포넌트를 개발, 재사용하여 소프트웨어 생산성을 제고하기 위해서는 서비스 컴포넌트간 결합성 완화 문제를 해결한 액티브 바인딩 기술에 더해 서비스 컴포넌트와 비즈니스 엔티티 사이의 결합성을 완화하는 새로운 기술의 등장이 요구된다.In view of the state of the technology related to service component reuse as described above, in order to improve software productivity by developing and reusing components that are not dependent on a specific application environment, in addition to active binding technology that solves the problem of loosening the coupling between service components, service component The emergence of new technologies to mitigate the linkage between business entities and business entities is required.

본 발명은 독립적으로 개발된 서비스 컴포넌트들을 소스 코드 수정 없이 재사용할 수 있도록 하는 데 있어 전술한 문제점을 해결하기 위한 것으로, 서비스 컴포넌트의 비즈니스 엔티티 타입에 대한 종속성을 제거하기 위하여 서비스 컴포넌트 개발자가 특정 애플리케이션의 비즈니스 엔티티 타입에 의존하는 대신 컴포넌트 자체 데이터 타입을 임의로 정의하고 그 타입 정보를 사용하여 자족적으로 비즈니스 로직을 구현하는 방법을 제공하고자 한다.The present invention has been made to solve the above-mentioned problem in allowing independently developed service components to be reused without source code modification. In order to remove dependency on a business entity type of a service component, a service component developer can Instead of relying on a business entity type, we want to provide a way to arbitrarily define the data type of the component itself and use that type information to self-sufficiently implement business logic.

본 발명은 또한 상기 방식으로 개발된 서비스 컴포넌트들을 조립하여 애플리케이션을 개발할 때 컴포넌트 개발자가 임의로 정의한 컴포넌트 자체 데이터 타입과 애플리케이션에서 실제로 사용될 비즈니스 엔티티 타입을 정합하여 상호작용을 가능케 하기 위한 데이터 타입 컨버터 컴포넌트를 구현하는 방법을 제공하고자 한 다.The present invention also implements a data type converter component for enabling interaction by matching the data type of the component itself arbitrarily defined by the component developer and the business entity type actually used in the application when assembling the service components developed in the above manner. To provide a way to do it.

본 발명은 아울러 상기 방식으로 개발된 애플리케이션의 실행시 프레임워크가 의존성 주입 정보 파일을 참조하여 객체를 생성하고 데이터 타입 컨버터 객체를 서비스 컴포넌트의 자체 데이터 타입에 주입함으로써 제3자가 개발한 서비스 컴포넌트들이 새로운 애플리케이션의 비즈니스 엔티티들을 에러 없이 다룰 수 있게 하는 기술을 제공하고자 한다.The present invention also provides a new service component developed by a third party by creating an object by referring to the dependency injection information file and injecting a data type converter object into its own data type. We want to provide a technology that allows you to handle business entities in your application without errors.

상기 목적을 달성하기 위하여 본 발명은, 객체지향 컴포넌트 기반 소프트웨어 개발 환경에서 특정 애플리케이션의 비즈니스 엔티티에 종속되지 않도록 비즈니스 엔티티를 대신하는 자체 데이터 타입을 내장한 서비스 컴포넌트를 구현하는 방법; 상기 방식으로 개발된 서비스 컴포넌트들을 애플리케이션 개발에 재사용할 때 상기 서비스 컴포넌트의 자체 데이터 타입을 애플리케이션에서 실제 사용하는 비즈니스 엔티티의 데이터 타입으로 변환하는 데이터 타입 컨버터 컴포넌트 구현 방법; 상기 방식으로 개발된 애플리케이션의 실행시 프레임워크가 의존성 주입 정보 파일을 참조하여 객체를 생성하고 데이터 타입 컨버터 객체를 서비스 컴포넌트의 자체 데이터 타입에 주입함으로써 재사용되는 서비스 컴포넌트들이 새롭게 정의된 비즈니스 엔티티들을 에러 없이 다룰 수 있게 하는 방법을 제시한다.In order to achieve the above object, the present invention provides a method for implementing a service component incorporating its own data type in place of a business entity so as not to be dependent on the business entity of a specific application in an object-oriented component-based software development environment; A data type converter component implementation method for converting the service component developed in the above manner into the data type of a business entity actually used in an application when reusing the service component for application development; When the application developed in this manner is executed, the framework creates an object with reference to the dependency injection information file and injects a data type converter object into the service component's own data type so that service components that are reused can be newly defined without error. Provide ways to handle it.

이하에서는 첨부된 도면을 참조하여 본 발명에 따른 소프트웨어 개발 방법 및 실행 방법을 상세히 설명하기로 한다.Hereinafter, a software development method and an execution method according to the present invention will be described in detail with reference to the accompanying drawings.

도 1은 본 발명에 따라 개발된 서비스 컴포넌트가 특정 애플리케이션의 비즈니스 엔티티와 연동하는 구조를 나타낸 개념도이다. 본 발명에 따른 서비스 컴포넌트(13)는 서비스 객체(131) 외에, 차후 연동하게 될 애플리케이션의 비즈니스 엔티티 대신 코딩에 사용하기 위해 정의된 컴포넌트 자체 데이터 타입(132)과, 차후 비즈니스 엔티티 타입을 컴포넌트 자체 데이터 타입으로 변환하기 위해 구현할 데이터 타입 컨버터 객체의 모태인 데이터 타입 컨버터 인터페이스를 추가로 내장하는 구조를 갖는다.1 is a conceptual diagram illustrating a structure in which a service component developed according to the present invention interworks with a business entity of a specific application. In addition to the service object 131, the service component 13 according to the present invention defines a component own data type 132 defined for use in coding instead of a business entity of an application to be interworked in the future, and a business entity type in the future. It has a structure that additionally embeds a data type converter interface, which is the base of a data type converter object to be implemented to convert to a type.

본 발명에 따라 실제 연동하게 될 애플리케이션의 비즈니스 엔티티가 존재하지 않는 상태에서 서비스 컴포넌트를 개발하는 환경에서는 모든 비즈니스 엔티티 타입이 상속해야 하는 데이터 타입으로서 컴포넌트 개발자와 애플리케이션 개발자가 공용하는 루트 데이터 타입(111)의 존재가 필수적이다. 명칭만 가지는 형식으로 정의된 루트 데이터 타입은 공용 타입 패키지(11) 형태로 본 발명에 따른 개발 방식을 채택한 모든 개발자들에게 제공된다.According to the present invention, in the environment in which a service component is developed in a state where there is no business entity of an application to be interworked, the root data type 111 shared between component developers and application developers is a data type that all business entity types must inherit. The presence of is essential. The root data type defined in the form of a name only is provided to all developers who adopt the development method according to the present invention in the form of a common type package 11.

본 발명에 따라 개발된 서비스 컴포넌트들을 재사용하면서 새로운 애플리케이션을 개발할 때 애플리케이션 개발자는 루트 데이터 타입(111)을 상속하는 비즈니스 엔티티 객체(121)들을 정의한다. 비즈니스 엔티티가 갖추어지면 비즈니스 엔티티 타입을 재사용할 서비스 컴포넌트의 자체 데이터 타입(132)으로 변환하는 데이터 타입 컨버터 객체(141)를 구현한다. 이 컨버터 객체는 서비스 컴포넌트에 정의된 데이터 타입 컨버터 인터페이스(133)의 메소드들을 구현함으로써 완성된다.When developing a new application while reusing service components developed in accordance with the present invention, the application developer defines business entity objects 121 that inherit the root data type 111. Once the business entity is in place, it implements a data type converter object 141 that converts the business entity type into its own data type 132 of the service component to be reused. This converter object is completed by implementing the methods of the data type converter interface 133 defined in the service component.

이상과 같이 개발, 조립된 서비스 컴포넌트(13), 비즈니스 엔티티(12), 데이 터 타입 컨버터 컴포넌트(14)에 대해 상호 의존 관계를 나타낸 파일(16)을 생성하고, 이들을 프레임워크(15)에 배치하여 실행하면, 프레임워크는 상기 의존성 정보 파일에 따라 컴포넌트들의 객체를 생성하고 데이터 타입 컨버터 객체의 레퍼런스를 서비스 컴포넌트 자체 데이터 타입에 주입해준다. 이를 통해 서비스 컴포넌트 객체의 서비스 메소드가 다루는 비즈니스 엔티티 속성은 그에 대응하는 컴포넌트 자체 데이터 타입 속성으로 변환되며, 이 상태에서 서비스 메소드는 필요한 작업을 수행한다.The file 16 showing the interdependencies for the service component 13, the business entity 12, and the data type converter component 14 developed and assembled as described above is generated and placed in the framework 15. When executed, the framework creates an object of components according to the dependency information file and injects a reference of the data type converter object into the service component itself data type. This translates the business entity attributes handled by the service method of the service component object into the corresponding component's own data type attributes, where the service method performs the necessary work.

도 2는 본 발명에 따라 서비스 컴포넌트를 개발하는 절차를 나타낸 일 흐름도이다. 서비스 컴포넌트 개발 순서는 다음과 같다. 서비스 컴포넌트 객체의 서비스 메소드를 개발하다가(S11) 사용자 정의 데이터 타입으로 정의된 비즈니스 엔티티를 매개변수나 반환값으로 사용해야 하는 경우(S12), 특정한 애플리케이션의 비즈니스 엔티티 타입을 사용하는 대신 모든 비즈니스 엔티티 타입들이 상속해야 할 루트 타입을 사용하여 메소드 시그너처를 정의한다(S13). 이어서 서비스 메소드 코드에서 특정 애플리케이션의 비즈니스 엔티티 대신 사용할 컴포넌트 자체 데이터 타입과, 차후 애플리케이션 개발시 만들어질 데이터 타입 컨버터가 구현할 컨버터 인터페이스 타입을 정의한다(S14). 이어서 서비스 메소드의 매개변수로 받은 루트 타입의 변수를 컨버전 오퍼레이터를 이용하여 컴포넌트 자체 데이터 타입으로 변환하는 코드를 서비스 메소드의 첫 명령문(statement)으로 작성한다(S15). 이후 매개변수로 받은 비즈니스 엔티티 객체를 사용하는 대신 컴포넌트 자체 데이터 타입의 변수를 사용하여 개발중인 컴포넌트의 서비스 메소드를 완성한다(S16).2 is a flowchart illustrating a procedure of developing a service component according to the present invention. Service component development sequence is as follows. When developing a service method of a service component object (S11) and using a business entity defined as a user-defined data type as a parameter or return value (S12), instead of using the business entity type of a specific application, all business entity types The method signature is defined using the root type to be inherited (S13). Subsequently, the service method code defines a data type of a component to use instead of a business entity of a specific application and a converter interface type to be implemented by a data type converter to be created in the future application development (S14). Subsequently, the code for converting the variable of the root type received as a parameter of the service method into the component's own data type using the conversion operator is created as the first statement of the service method (S15). After that, instead of using the business entity object received as a parameter, the service method of the component under development is completed by using the variable of the component's own data type (S16).

도 3은 본 발명에 따라 서비스 컴포넌트를 개발하는 절차 중 컴포넌트 자체 데이터 타입과 데이터 타입 컨버터 인터페이스 타입을 정의하는 단계(S14)를 더욱 상세하게 나타낸 일 흐름도이다. 서비스 컴포넌트 자체 데이터 타입과 컨버터 인터페이스 타입을 정의하는 순서는 다음과 같다. 개발중인 컴포넌트 안에 컴포넌트 자체 데이터 타입 클래스를 만들고 비즈니스 엔티티 객체를 수용하기 위한 루트 타입의 필드 변수를 선언한다(S141). 이어서 상기 컴포넌트 자체 데이터 타입 클래스에 루트 타입의 매개변수를 갖는 생성자를 정의하고(S142), 동 클래스에 루트 타입을 상속한 비즈니스 엔티티 타입을 앞서 정의된 생성자를 사용하여 컴포넌트 자체 데이터 타입으로 변환하는 컨버전 오퍼레이터를 구현한다(S143). 이어서 상기 클래스에 개발중인 컴포넌트 객체의 서비스 메소드에서 사용할 속성들의 타입과 이름을 정하고 각 속성별로 Get 액세서(Accessor)와 Set 액세서를 선언한다(S144). 이어서 개발중인 컴포넌트 안에 앞서 선언된 Get 액세서 및 Set 엑세서에서 차후 연동할 실제 비즈니스 엔티티의 속성을 컴포넌트 자체 데이터 타입 속성으로 변환하는 데 사용할 메소드들로 구성된 컨버터 인터페이스 타입을 정의한다(S145). 이어서 런타임시 프레임워크의 의존성 주입 기능을 사용하기 위하여 상기 컴포넌트 자체 데이터 타입 클래스에 차후 구현될 컨버터 객체의 레퍼런스를 수용할 변수로서 컨버터 인터페이스 타입의 필드와 속성을 선언한다(S146). 마지막으로 앞서 선언된 컨버터 객체 레퍼런스 필드의 변수를 사용하여 컴포넌트 자체 데이터 타입의 각 속성별로 Get 액세서와 Set 액세서를 완성하여 컴포넌트 자체 데이터 타입 정의를 완료한다(S147).3 is a flowchart illustrating in more detail a step S14 of defining a component itself data type and a data type converter interface type in a process of developing a service component according to the present invention. The order of defining the service component itself data type and converter interface type is as follows. In the component under development, the component creates its own data type class and declares a field variable of the root type for accommodating the business entity object (S141). Subsequently, a constructor having a parameter of a root type is defined in the component own data type class (S142), and a conversion is performed to convert a business entity type that inherits the root type to the component itself data type using the constructor defined above. Implement the operator (S143). Subsequently, the type and name of the attributes to be used in the service method of the component object being developed in the class are declared, and a Get accessor and a set accessor are declared for each attribute (S144). Subsequently, in the component under development, a converter interface type including a method used to convert an attribute of an actual business entity to be interworked in the get accessor and the set accessor previously declared into a component's own data type attribute is defined (S145). Subsequently, in order to use the dependency injection function of the framework at runtime, a field and a property of a converter interface type are declared as variables to accommodate a reference of a converter object to be implemented later in the component itself data type class (S146). Finally, using the variables of the converter object reference field declared above, the Get accessor and the Set accessor are completed for each property of the component's own data type to complete the definition of the component itself data type (S147).

도 4는 본 발명에 따라 애플리케이션 실행시 서비스 컴포넌트 자체 데이터 타입 속성을 그에 대응하는 비즈니스 엔티티 속성으로 변환해줄 데이터 타입 컨버터 컴포넌트를 개발하는 절차를 나타낸 일 흐름도이다. 상기 데이터 타입 컨버터 컴포넌트 구현 순서는 다음과 같다. 데이터 타입 컨버터 컴포넌트 개발 프로젝트를 생성하고(S21), 서비스 컴포넌트에 정의된 컨버터 인터페이스 타입을 모두 식별한 후 이 중 컨버터 클래스로 구현되지 않은 인터페이스를 하나를 선택한다(S22). 이후 서비스 컴포넌트에 정의된 자체 데이터 타입 중 앞서 선택된 컨버터 인터페이스와 대응하는 데이터 타입을 식별하고(S23), 데이터 타입 컨버터 컴포넌트 개발 프로젝트에 앞서 선택된 컨버터 인터페이스를 구현하는 클래스를 생성한다(S24). 이어서 특정 애플리케이션의 비즈니스 엔티티 중 앞서 식별된 컴포넌트 자체 데이터 타입과 대응하는 비즈니스 엔티티를 식별하고(S25), 앞서 선택된 컨버터 인터페이스의 메소드 중 구현되지 않은 메소드 하나를 선택한다(S26). 이어서 컴포넌트 자체 데이터 타입의 속성과 비즈니스 엔티티의 속성 중 앞서 선택된 메소드가 변환, 연동해야 하는 속성 쌍을 식별하고(S27), 상기 컨버터 클래스에 앞서 식별된 속성들의 값을 변환하는 코드를 작성하여 앞서 선택된 메소드의 구현을 완성한다(S28). 이어서 선택된 컨버터 인터페이스의 메소드 중 구현되지 않은 메소드가 남아 있는 경우(S29) 모든 메소드가 구현될 때까지 구현되지 않은 메소드 선택(S26)에서 속성 변환 코드 작성(S28)까지의 과정을 반복하여 선택된 컨버터 인터페이스를 구현하는 컨버터 클래스를 완성한다. 이어서 식별된 컨버터 인터페이스 타입 중 컨버터 클래스로 구현되지 않은 인터페이스가 남아 있는 경우(S30) 모든 컨버터 인터페이스가 구현될 때까지 구현되지 않은 인터페이스 선택(S22)에서 인터페이스 메소드 구현(S29)까지의 과정을 반복하여 데이터 타입 컨버터 클래스 구현을 완료한다. 이어서 이상의 과정을 통해 구현된 컨버터 객체와 그에 대응하는 컴포넌트 자체 데이터 타입 사이의 의존성 주입 정보를 파일로 생성하고(S31), 프로젝트를 컴파일하여 데이터 타입 컨버터 컴포넌트를 생성한다(S32).4 is a flowchart illustrating a procedure for developing a data type converter component for converting a service component itself data type attribute into a corresponding business entity attribute when an application is executed according to the present invention. The data type converter component implementation order is as follows. A data type converter component development project is generated (S21), all the converter interface types defined in the service component are identified, and one of the interfaces not implemented as the converter class is selected (S22). Thereafter, among the own data types defined in the service component, a data type corresponding to the previously selected converter interface is identified (S23), and a class for implementing the selected converter interface prior to the data type converter component development project is generated (S24). Subsequently, the business entity of the specific application identifies a business entity corresponding to the previously identified component itself data type (S25), and selects one of the methods of the previously selected converter interface that is not implemented (S26). Subsequently, the property pair of the property of the component itself data type and the property of the business entity identify an attribute pair to be converted and interlocked (S27), and write a code for converting the values of the properties identified before the converter class to select Complete the implementation of the method (S28). Subsequently, if an unimplemented method remains among the methods of the selected converter interface (S29), the process of selecting the unimplemented method (S26) to writing attribute conversion code (S28) is repeated until all the methods are implemented. Complete the converter class that implements Subsequently, when an interface not implemented as a converter class remains among the identified converter interface types (S30), the process from selecting an unimplemented interface (S22) to an interface method implementation (S29) is repeated until all converter interfaces are implemented. Complete the data type converter class implementation. Subsequently, dependency injection information between the converter object implemented through the above process and the corresponding component's own data type is generated as a file (S31), and the data is compiled to generate the data type converter component (S32).

도 5는 본 발명에 따라 개발된 소프트웨어 실행시 각 구성 요소가 클라이언트의 서비스 호출을 처리하는 순서를 나타낸 순차도이다. 의존성 주입 프레임워크에서 객체 생성과 객체간 의존성 주입을 실행하고 클라이언트의 서비스 호출을 처리하는 절차는 다음과 같다. 사용자 인터페이스 등 외부의 클라이언트가 프레임워크에 배치된 서비스 컴포넌트의 객체를 요구하면(S41), 프레임워크가 의존성 주입 정보 파일을 참조하여 해당 컴포넌트의 객체와 그에 연관된 데이터 타입 컨버터 클래스(들)의 객체를 생성하고(S42, S43), 생성된 데이터 타입 컨버터 객체(들)의 레퍼런스를 각 컨버터 객체에 대응하는 컴포넌트 자체 데이터 타입의 의존성 주입용 속성에 주입한(S44) 후, 서비스를 요청한 클라이언트에 해당 컴포넌트 객체를 반환한다(S45). 이어서 클라이언트가 넘겨받은 컴포넌트 객체의 서비스 메소드를 호출하면서 비즈니스 엔티티의 레퍼런스를 매개변수로 넘겨주면(S46), 호출된 서비스 컴포넌트 객체의 메소드가 클라이언트로부터 매개변수로 받은 비즈니스 엔티티 객체를 컴포넌트 자체 데이터 타입 객체로 변환한다(S47). 이어서 호출된 서비스 메소드가 자신의 서비스 수행을 위해 컴포넌트 자체 데이터 타입 객체의 특정 속성을 액세스하면(S48), 액세스된 속성의 액세서가 데이터 타입 컨버터 객체의 해당 속성 과 관련된 타입 변환 메소드를 호출하면서 비즈니스 엔티티 객체의 레퍼런스를 넘겨주고(S49), 호출된 타입 변환 메소드는 비즈니스 엔티티 객체의 속성을 그에 대응하는 컴포넌트 자체 데이터 타입 속성으로 변환한다. 이어서 클라이언트가 호출한 서비스 메소드는 필요한 만큼 컴포넌트 자체 데이터 타입의 특정 속성 액세스(S48)에서 해당 속성 관련 타입 변환 메소드 호출(S49)까지의 과정을 반복하면서 자신의 서비스 수행을 완료하고 클라이언트에 서비스 수행 결과를 반환한다(S51).5 is a flowchart illustrating an order in which each component processes a service call of a client when executing software developed according to the present invention. In the dependency injection framework, the procedure for executing object creation and dependency injection between objects and handling the client's service invocation is as follows. When an external client such as a user interface requests an object of a service component disposed in the framework (S41), the framework refers to the dependency injection information file to determine an object of the component and an object of the data type converter class (s) associated with it. After generating (S42, S43), injecting the reference of the generated data type converter object (s) to the dependency injection property of the component's own data type corresponding to each converter object (S44), the corresponding component to the client requesting the service Return the object (S45). Subsequently, when the client calls the service method of the component object passed in and passes the reference of the business entity as a parameter (S46), the method of the called service component object receives the business entity object as a parameter from the client as the component's own data type object. (S47). Subsequently, if the called service method accesses a specific property of the component's own data type object to perform its service (S48), the accessor of the accessed property calls the type conversion method associated with the corresponding property of the data type converter object while the business entity The reference of the object is passed (S49), and the called type conversion method converts an attribute of the business entity object into a corresponding component's own data type attribute. Subsequently, the service method called by the client completes its service execution by repeating the process from accessing the specific property of the component's own data type (S48) to invoking the corresponding property related type conversion method (S49) as necessary, and performing the service to the client. Return (S51).

이하에서는 본 발명에 따른 소프트웨어 개발 및 실행 방법을 더욱 구체적으로 드러내기 위해 이를 현존하는 대표적 개발 플랫폼 중 하나인 닷넷 프레임워크에 적용하여 수행한 양호한 일 실시 예의 산출물에 대해 상술하기로 한다. 본 발명에 따른 소프트웨어 개발 및 실행 방법은 닷넷 프레임워크뿐 아니라 자바 등 이와 유사한 구조를 가지는 다른 객체지향 컴포넌트 기술 플랫폼들에도 즉시 적용 가능함을 해당 기술 분야 종사자들은 본 산출물을 통해 쉽게 파악할 수 있을 것이다.Hereinafter, the output of a preferred embodiment performed by applying it to the .NET framework, which is one of the existing representative development platforms, will be described in detail to reveal the software development and execution method according to the present invention. Those skilled in the art will readily appreciate that the software development and execution method according to the present invention can be immediately applied to other object-oriented component technology platforms having a similar structure such as Java as well as a .NET framework.

후술하는 산출물은 본 발명에 따라 닷넷 프레임워크에서 C# 프로그래밍 언어로 개발한 간략한 호텔 고객정보 관리시스템의 구성물로서, 고객 정보 관리 기능을 수행하는 서비스 컴포넌트와, 이 컴포넌트의 자체 데이터 타입을 애플리케이션에서 실제로 사용하는 비즈니스 엔티티와 정합하는 데이터 타입 컨버터 컴포넌트, 비즈니스 엔티티, 모든 비즈니스 엔티티가 상속해야 하는 루트 타입 등이 정의된 공용 객체 및 프레임워크에 객체 생성과 의존성 주입을 위임하는 의존성 정보 파일의 작성 예를 보여준다. 이 예에서는 본 발명의 개념을 이해하는 데 직접적으로 관련되는 최소한의 코드만을 나타낸다.The outputs described below are components of a simple hotel customer information management system developed in the C # programming language by the .NET framework according to the present invention, and use a service component that performs customer information management functions and its own data type in an application. The following example shows how to create a dependency information file that delegates object creation and dependency injection to common objects and frameworks that define data type converter components, business entities, and root types that all business entities must inherit. This example shows only minimal code that is directly related to understanding the concept of the invention.

도 6은 본 실시 예에서 본 발명에 따라 개발되는 애플리케이션의 비즈니스 엔티티가 공통으로 상속해야 할 루트 데이터 타입과 주석용 커스텀 애트리뷰트가 정의되어 있는 공용 객체 CommonObjects의 코드를 보여준다. 이와 같은 공용 객체는 본 발명 실시를 위하여 구현되는 개발 도구의 기본 클래스 라이브러리로 제공될 것이다. 본 실시 예의 공용 객체 코드는 EntityRoot라는 이름만을 가진 루트 데이터 타입(111)과, 특정 인터페이스가 데이터 타입 컨버터 인터페이스임을 나타내는 커스텀 애트리뷰트(112), 특정 클래스가 컴포넌트 자체 데이터 타입임을 나타내는 커스텀 애트리뷰트(113), 특정 속성이 그것을 포함하는 타입이 의존하는 객체의 레퍼런스를 주입받는 의존성 주입 통로임을 나타내는 커스텀 애트리뷰트(114)를 포함하고 있다.FIG. 6 shows the code of the common object CommonObjects in which the root data type and custom attributes for annotation are defined that business entities of an application developed according to the present invention commonly inherit in this embodiment are defined. Such a common object will be provided as a base class library of a development tool implemented for the practice of the present invention. The common object code of this embodiment includes a root data type 111 having only the name EntityRoot, a custom attribute 112 indicating that a specific interface is a data type converter interface, a custom attribute 113 indicating that a specific class is a component's own data type, It contains a custom attribute 114 that indicates that a particular property is a dependency injection path that receives a reference to the object it depends on.

도 7은 본 실시 예의 애플리케이션에서 실제로 사용하는 비즈니스 엔티티 객체 HotelCustomer(121)의 코드를 보여준다. 이 코드에는 비즈니스 엔티티 HotelCustomer가 루트 데이터 타입인 EntityRoot(111)를 상속하고 있음이 나타나 있다. 이 비즈니스 엔티티에는 CustId 등 6개의 속성이 선언되어 있다.7 shows the code of the business entity object HotelCustomer 121 actually used in the application of this embodiment. This code shows that the business entity HotelCustomer inherits the root data type EntityRoot (111). This business entity has six attributes declared, including CustId.

도 8은 본 실시 예의 애플리케이션에서 재사용하기 위하여 제3자로부터 획득한 서비스 컴포넌트인 ServiceComponent의 코드 중 서비스 컴포넌트 객체 CustomerMgt(131) 부분을 보여준다. 이 서비스 컴포넌트 객체는 애플리케이션의 실제 비즈니스 엔티티 객체와 이메일을 매개변수로 받아 전송하는 메소드 NotifyCustomer(131-1)와, 비즈니스 엔티티 객체와 이메일 주소를 매개변수로 받아 고객의 이메일 주소를 갱신하는 메소드 UpdateEmailAddress(131-2)를 포함한다. 여 기서 두 메소드는 모두 실제 비즈니스 엔티티 객체의 레퍼런스를 매개변수로 받기 위하여 매개변수 타입이 공용 객체에 정의되어 있는 루트 데이터 타입 EntityRoot로 선언되어 있고, 매개변수 이름은 실제 연동할 비즈니스 엔티티 객체의 이름(본 실시 예에서는 HotelCustomer)을 모르는 상태에서 임의로 정한 customer가 사용되고 있다. 이 두 메소드는 모두 매개변수 customer로 받은 비즈니스 엔티티 객체를 컴포넌트 자체 데이터 타입 MyCustomer로 변환하는 코드를 첫 명령문으로 포함하고 있는데, 이 명령문을 작성하기 전에 컴포넌트 자체 데이터 타입과 데이터 타입 컨버터 인터페이스 정의가 선행되어야 한다.8 shows a part of the service component object CustomerMgt 131 in the code of ServiceComponent which is a service component obtained from a third party for reuse in an application of the present embodiment. This service component object takes a method NotifyCustomer (131-1) that takes an application's actual business entity object and an email as a parameter, and a method UpdateEmailAddress () that takes a business entity object and an email address as parameters. 131-2). Here, both methods are declared with the root data type EntityRoot whose parameter type is defined in the public object to receive a reference of the actual business entity object as a parameter, and the parameter name is the name of the business entity object to which the actual business entity object ( In the present embodiment, a customer who is arbitrarily determined without knowing HotelCustomer) is used. Both of these methods contain the first statement that converts the business entity object received as the parameter customer to the component's own data type MyCustomer. Before writing this statement, the component's own data type and data type converter interface definition must precede it. do.

도 9는 본 실시 예의 애플리케이션에서 재사용하기 위하여 제3자로부터 획득한 서비스 컴포넌트인 ServiceComponent의 코드 중 서비스 컴포넌트 자체 데이터 타입 MyCustomer(132) 부분을 보여준다. 이 데이터 타입 상단에는 공용 객체에 정의되어 있는 컴포넌트 자체 데이터 타입임을 나타내는 커스텀 애트리뷰트(132-1)가 부가되어 있다. 이 자체 데이터 타입에는 우선 이 타입과 연동할 실제 비즈니스 엔티티 객체의 레퍼런스를 수용, 유지하기 위한 필드 변수 bizEntity(132-2)와, 런타임시 프레임워크로부터 데이터 타입 컨버터 객체의 레퍼런스를 주입받아 유지할 필드 변수 typeConverter(132-3)을 선언되어 있다. 또 런타임시 프레임워크로부터 데이터 타입 컨버터 객체의 레퍼런스를 전달받는 통로로서 속성 TypeConverter(132-5)가 정의되어 있는데, 그 상단에는 이 속성이 의존성 주입 위치임을 나타내는 커스텀 애트리뷰트(132-4)가 주석으로 부가되어 있다. 이어서 이 자체 데이터 타입 객체가 생성될 때 공용 객체에 정의되어 있는 루트 데이터 타입을 매개변수로 갖도 록 규정하는 생성자(132-6)와, 차후 연동할 비즈니스 엔티티 객체를 컴포넌트 자체 데이터 타입 객체로 변환하는 컨버전 오퍼레이터(132-7)가 정의되어 있다. 또 서비스 컴포넌트 객체의 메소드들에서 사용하는 자체 데이터 타입의 속성들(132-8)이 정의되어 있는데, 본 실시 예에서 연동하게 될 실제 비즈니스 엔티티의 속성들과 갯수, 이름, 타입 등이 상이함을 알 수 있다.9 shows a part of the service component itself data type MyCustomer 132 in the code of ServiceComponent which is a service component obtained from a third party for reuse in an application of this embodiment. On top of this data type, a custom attribute 132-1 is added to indicate that the component itself is a data type defined in the public object. This self data type first contains a field variable bizEntity (132-2) for accepting and maintaining a reference to the actual business entity object to be associated with this type, and a field variable to be maintained by injecting a reference of the data type converter object from the framework at runtime. typeConverter (132-3) is declared. In addition, a property TypeConverter (132-5) is defined as a path through which a reference of a data type converter object is received from the framework at runtime, and a custom attribute (132-4) is annotated at the top thereof to indicate that the property is a dependency injection location. Added. Then, when this self data type object is created, a constructor (132-6) that specifies as parameter the root data type defined in the public object, and then converts the business entity object to be interworked into the component itself data type object. Conversion operator 132-7 is defined. In addition, properties 132-8 of its own data type used in the methods of the service component object are defined, and the number, name, type, etc. of the actual business entity to be linked in this embodiment are different. Able to know.

이상과 같은 서비스 컴포넌트 자체 데이터 타입 코드는 일견 복잡해 보이지만 대부분 일정한 규칙에 따라 작성하도록 되어 있으므로 그러한 규칙들을 구현한 도구를 사용할 경우 최소한의 신규 입력 정보를 기반으로 자동 생성될 수 있다. 본 실시 예의 경우 서비스 컴포넌트 개발자가 상기 도구에 자체 데이터 타입의 이름(MyCustomer)과 서비스 메소드들에서 사용할 자체 데이터 타입 속성들의 타입 및 이름(int CustomerNumber 등)만 정하여 입력하면, 이 입력 정보와 도구가 임의로 정할 수 있는 필드 변수 이름, 이미 정해져 있는 루트 데이터 타입 및 커스텀 애트리뷰트 주석을 사용하는 나머지 코드가 모두 자동으로 생성될 수 있다.Although the data type codes of the service components themselves seem complicated at first glance, most of them are written according to a certain rule, and thus, a tool that implements such rules can be automatically generated based on the minimum new input information. In the present embodiment, if the service component developer inputs only the name of its own data type (MyCustomer) and the type and name of its own data type attributes (int CustomerNumber, etc.) to be used in the service methods, the input information and the tool are randomly inputted. The remaining code using custom field variable names, predefined root data types, and custom attribute annotations can all be automatically generated.

도 10은 본 실시 예의 애플리케이션에서 재사용하기 위하여 제3자로부터 획득한 서비스 컴포넌트인 ServiceComponent의 코드 중 데이터 타입 컨버터 인터페이스 IMyCustomerConverter(133) 부분을 보여준다. 이 인터페이스 상단에는 이것이 데이터 타입 컨버터 인터페이스임을 나타내는 커스텀 애트리뷰트(133-1)가 주석으로 부가되어 있다. 이 컨버터 인터페이스는 서비스 컴포넌트 객체의 서비스 메소드에서 사용하는 컴포넌트 자체 데이터 타입의 각 속성을 그에 대응하는 비즈니스 엔티티 속성으로 변환하는 Get/Set 메소드들로 구성되는데, 이 코드 역시 상기 도 9 의 서비스 컴포넌트 자체 데이터 타입 정의 과정에서 이미 주어진 자체 데이터 타입 속성들의 타입 및 이름을 기반으로 자동 생성될 수 있다.FIG. 10 shows a part of the data type converter interface IMyCustomerConverter 133 of code of ServiceComponent, which is a service component obtained from a third party, for reuse in an application of this embodiment. At the top of this interface is annotated with a custom attribute 133-1 indicating that it is a data type converter interface. This converter interface consists of Get / Set methods that convert each attribute of the component's own data type used in the service method of the service component object to the corresponding business entity attribute. In the type definition process, it can be automatically generated based on the type and name of its own data type attributes.

도 11은 본 실시 예의 서비스 컴포넌트 자체 데이터 타입 MyCustomer와 애플리케이션에서 실제로 사용하는 비즈니스 엔티티 HotelCustomer의 속성들을 변환하는 데이터 타입 컨버터 컴포넌트 객체 MyCustomerConverter(141)의 코드를 보여준다. 이 데이터 타입 컨버터 객체는 서비스 컴포넌트 Service Component에 정의되어 있는 데이터 타입 컨버터 인터페이스 IMyCustomerConverter(133)에 포함된 메소드들을 구현한다. 이 메소드들을 구현할 때 애플리케이션 개발자는 해당 메소드가 다루는 컴포넌트 자체 데이터 타입 속성에 대응하는 실제 비즈니스 엔티티의 속성을 식별하여 타입을 변환하는 코드를 작성한다. 본 실시 예에서는 컴포넌트 자체 데이터 타입 MyCustomer의 속성 CustomerNumber는 int 타입인데 비해 그에 대응하는 비즈니스 엔티티 HotelCustomer의 속성 CustID는 string 타입으로 선언되어 있다. 따라서 이 두 속성을 연동시키기 위해 메소드 GetCustomerNumber에서는 CustID 값을 Convert.ToInt32() 메소드를 사용하여 int 타입으로, 메소드 SetCustomerNumber에서는 newValue 값을 ToString() 메소드를 사용하여 string 타입으로 변환한다.11 shows the code of the data type converter component object MyCustomerConverter 141 for converting the service component itself data type MyCustomer and the attributes of the business entity HotelCustomer actually used in the application. This data type converter object implements the methods contained in the data type converter interface IMyCustomerConverter 133 defined in the service component Service Component. When implementing these methods, the application developer writes code to convert the types by identifying the attributes of the actual business entity that correspond to the component's own data type attributes that the method deals with. In the present embodiment, the property CustomerNumber of the component own data type MyCustomer is an int type, whereas the property CustID of the corresponding business entity HotelCustomer is declared as a string type. Therefore, to link these two properties, the method GetCustomerNumber converts the CustID value to the int type using the Convert.ToInt32 () method and the new Set value from the method SetCustomerNumber to the string type using the ToString () method.

이상과 같은 데이터 타입 컨버터 메소드 구현 코드 역시 규칙 기반으로 작성되므로 해당 규칙을 구현한 자동화 도구를 사용하여 대부분을 자동 생성할 수 있다. 상기 도구가 서비스 컴포넌트의 메타데이터를 읽어 제시하는 데이터 타입 컨버터 인터페이스 목록에서 개발자가 구현할 인터페이스를 선택하면, 도구는 다시 선택된 인터페이스와 대응하는 컴포넌트 자체 데이터 타입 및 해당 데이터 타입에 대 응하는 비즈니스 엔티티의 메타데이터를 읽어 각각의 속성 목록을 제시하고, 개발자가 이 목록에서 상호 연동할 양측의 속성을 선택, 연결하면 데이터 타입 컨버터 객체의 코드가 자동 생성된다. 다만, 상호 대응하는 속성 사이에 의미론적 차이가 있는 경우(예를 들어 한쪽에서는 미터를 사용하고 다른 쪽에서는 야드를 사용) 개발자가 적절한 변환 코드를 삽입하여 의미 불일치를 중재할 수 있다.The data type converter method implementation code as described above is also written based on rules, so most of them can be automatically generated by using an automation tool that implements the rules. When the tool selects an interface to be implemented by the developer from a list of data type converter interfaces that read and present the metadata of the service component, the tool again selects the component's own data type corresponding to the selected interface and the meta data of the business entity corresponding to the data type. By reading the data and presenting a list of each property, the developer selects and links the properties of both sides to interoperate with, and the code of the data type converter object is automatically generated. However, if there is a semantic difference between the corresponding properties (for example, using meters on one side and yards on the other), the developer can mediate the semantic mismatch by inserting the appropriate conversion code.

도 12는 본 실시 예에서 본 발명에 따라 구현된 컴포넌트들을 프레임워크에 배치하여 실행할 때 프레임워크에 서비스 컴포넌트 객체와 데이터 타입 컨버터 객체를 생성하고, 데이터 타입 컨버터 객체의 레퍼런스를 서비스 컴포넌트 자체 데이터 타입의 의존성 주입용 속성에 주입하도록 지시하는 의존성 주입 정보 파일을 보여준다. 이 파일은 데이터 타입 컨버터 객체를 구현하는 과정에서 이미 주어진 정보를 바탕으로 자동 생성되게 할 수 있다.FIG. 12 illustrates the creation of a service component object and a data type converter object in the framework when the components implemented according to the present invention are deployed and executed in the present embodiment. Show the dependency injection information file that instructs the dependency injection attribute to inject. This file can be created automatically based on the information already given in the implementation of the data type converter object.

이하에서는 도 5~12를 다시 참조하여 본 발명에 따라 개발된 애플리케이션을 실행했을 때 구성 요소들이 상호작용하는 양호한 일 실시 예를 더욱 구체적으로 상술하기로 한다.Hereinafter, a preferred embodiment in which components interact with each other when executing an application developed according to the present invention will be described in more detail with reference to FIGS. 5 to 12 again.

애플리케이션 사용자가 특정 호텔 고객에게 이메일을 전송하기 위하여 이메일 내용을 작성하여 전송 명령을 내리면 도 5에서처럼(S41) 사용자 인터페이스 모듈이 프레임워크에 해당 기능을 수행하는 서비스 컴포넌트 ServiceComponent의 서비스 객체 CustomerMgt(도8, 131)의 인스턴스를 요구한다. 프레임워크는 의존성 주입 정보 파일(도 12)을 참조하여 CustomerMgt 및 그와 연관된 데이터 타입 컨버터 객체 MyCustomerConverter(도 11, 141)의 인스턴스를 생성하고, MyCustomerConverter의 인스턴스 레퍼런스를 컴포넌트 자체 데이터 타입 MyCustomer(도 9, 132)의 의존성 주입용 속성 TypeConverter(도 9, 132-5)에 주입한 후, 사용자 인터페이스에 CustomerMgt의 인스턴스를 반환한다.When the user of the application writes an email content and sends a command to send an email to a specific hotel customer, as shown in FIG. 131). The framework creates an instance of CustomerMgt and its associated data type converter object MyCustomerConverter (FIGS. 11, 141) with reference to the dependency injection information file (FIG. 12), and converts an instance reference of MyCustomerConverter into the component's own data type MyCustomer (FIG. 9, After injecting the dependency injection attribute TypeConverter (FIG. 9, 132-5) of 132, an instance of CustomerMgt is returned to the user interface.

이어서 사용자 인터페이스 모듈이 서비스 객체 CustomerMgt에서 이메일 전송을 처리하는 서비스 메소드 NotifyCustomer(도 8, 131-1)를 호출하면서 이메일을 받을 고객의 비즈니스 엔티티 HotelCustomer(도 7, 121)의 인스턴스 레퍼런스와 이메일 내용을 매개변수로 넘겨주면, 호출된 NotifyCustomer가 매개변수로 받은 HotelCustomer를 컴포넌트 자체 데이터 타입 MyCustomer에 정의된 컨버전 오퍼레이터 'MyCustomer'(도 9, 132-7)를 이용, MyCustomer 객체로 변환하여 변수 cust에 저장한다.The user interface module then invokes the service method NotifyCustomer (FIGS. 8, 131-1), which handles the sending of emails from the service object CustomerMgt, passing in the instance reference and the email content of the customer's business entity HotelCustomer (FIGS. 7, 121) to receive the email. If passed as a variable, the converted NotifyCustomer called HotelCustomer as a parameter is converted into a MyCustomer object using the conversion operator 'MyCustomer' (FIG. 9, 132-7) defined in the component's own data type MyCustomer and stored in the variable cust.

이어서 NotifyCustomer가 컴포넌트 자체 데이터 타입 MyCustomer의 속성 EmailAddress(도 9, 132-8)를 액세스하면, EmailAddress의 Get 액세서가 데이터 타입 컨버터 객체 MyCustomerConverter의 속성 변환 메소드 GetEmailAddress를 호출하면서 비즈니스 엔티티 객체 HotelCustomer의 인스턴스 레퍼런스를 매개변수로 넘겨준다. 호출된 MyCustomerConverter의 메소드 GetEmailAddress는 HotelCustomer의 속성 Email에 저장된 고객의 이메일 주소를 MyCustomer의 속성 EmailAddress의 Get 액세서에 반환한다. 이 과정에서 비즈니스 엔티티 HotelCustomer 타입의 Email 속성 값이 컴포넌트 자체 데이터 타입 MyCustomer의 EmailAddress 속성 값으로 변환되고, 그 결과 서비스 메소드 NotifyCustomer의 로컬 변수 mailAddr에는 매개변수로 넘겨받은 HotelCustomer 인스턴스의 속성 Email에 입력된 고객의 이메일 주소가 저장된다. 이와 같은 데이터 타입 변환과 데이터 전달 과정을 거친 후 NotifyCustomer는 매개변수 message로 받은 이메일 내용을 mailAddr에 저장된 고객의 이메일 주소로 전송한다.Subsequently, NotifyCustomer accesses the property EmailAddress (FIG. 9, 132-8) of the component's own data type MyCustomer, and the Get accessor of the EmailAddress calls an instance reference of the business entity object HotelCustomer, calling the property conversion method GetEmailAddress of the data type converter object MyCustomerConverter. Pass it to a variable. The method GetEmailAddress of the called MyCustomerConverter returns the customer's email address stored in the HotelCustomer's property Email to the Get accessor of the MyCustomer's property EmailAddress. In this process, the value of the Email attribute of the business entity HotelCustomer type is converted to the value of the EmailAddress attribute of the component's own data type MyCustomer. As a result, the local variable mailAddr of the service method NotifyCustomer is passed as a parameter to the customer Email entered in the attribute Email of the HotelCustomer instance. The email address is saved. After this data type conversion and data passing process, NotifyCustomer sends the email contents received as parameter message to the email address of the customer stored in mailAddr.

한편 또 다른 작업 수행의 예로서 애플리케이션 사용자가 특정 호텔 고객의 이메일 주소를 변경하기 위하여 새 이메일 주소를 입력하고 변경 명령을 내리는 경우를 상정하면, 사용자 인터페이스 모듈이 프레임워크에 해당 기능을 수행하는 서비스 컴포넌트 ServiceComponent의 서비스 객체 CustomerMgt의 인스턴스를 요구하고, 프레임워크가 의존성 주입 정보 파일을 참조하여 CustomerMgt 및 그와 연관된 데이터 타입 컨버터 객체 MyCustomerConverter의 인스턴스를 생성하여 MyCustomerConverter의 인스턴스 레퍼런스를 컴포넌트 자체 데이터 타입 MyCustomer의 의존성 주입용 속성 TypeConverter에 주입한 후 사용자 인터페이스 모듈에게 CustomerMgt의 인스턴스를 반환하기까지의 과정은 상기 이메일 전송 작업의 경우와 동일하다.On the other hand, as an example of performing another task, suppose an application user enters a new email address and issues a change command to change the email address of a specific hotel customer. An instance of the ServiceComponent's service object CustomerMgt is required, and the framework consults the dependency injection information file to create an instance of CustomerMgt and its associated data type converter object MyCustomerConverter, which resolves the instance reference of MyCustomerConverter to dependency injection of the component's own data type MyCustomer. The process of injecting the property TypeConverter and returning an instance of CustomerMgt to the user interface module is the same as that of the above-mentioned email sending operation.

이후 사용자 인터페이스가 서비스 객체 CustomerMgt에서 이메일 주소 변경을 처리하는 서비스 메소드 UpdateEmailAddress(도 8, 131-2)를 호출하면서 비즈니스 엔티티 HotelCustomer의 인스턴스 레퍼런스와 새 이메일 주소를 매개변수로 넘겨주면, 호출된 UpdateEmailAddress 역시 매개변수로 받은 HotelCustomer를 컴포넌트 자체 데이터 타입 MyCustomer에 정의된 컨버전 오퍼레이터 'MyCustomer'를 이용, MyCustomer 객체로 변환하여 변수 cust에 저장한다.If the user interface then calls the service method UpdateEmailAddress (FIG. 8, 131-2), which handles the email address change in the service object CustomerMgt, passing the instance reference and new email address of the business entity HotelCustomer as parameters, the called UpdateEmailAddress is also parameterized. The HotelCustomer received as a variable is converted into a MyCustomer object using the conversion operator 'MyCustomer' defined in the component's own data type MyCustomer and stored in the variable cust.

이어서 UpdateEmailAddress가 매개변수로 받은 새로운 이메일 주소 값 newAddress를 cust.EmailAddress에 배정하면, MyCustomer의 속성 EmailAddress의 Set 액세서가 데이터 타입 컨버터 객체 MyCustomerConverter의 타입 변환 메소드 SetEmailAddress를 호출하면서 비즈니스 엔티티 객체 HotelCustomer의 인스턴스 레퍼런스와 새 이메일 주소를 매개변수로 넘겨준다. 호출된 MyCustomerConverter의 메소드 SetEmailAddress는 HotelCustomer의 속성 Email에 매개변수로 받은 새 이메일 주소를 배정한다. 이와 같은 과정을 통하여 컴포넌트 자체 데이터 타입을 사용하는 서비스 메소드 UpdateEmailAdress가 비즈니스 엔티티의 속성 값을 애플리케이션 사용자로부터 입력받은 내용으로 변경할 수 있다. 이어서 UpdateEmailAddress 메소드는 변경된 이메일 주소를 갖는 비즈니스 엔티티 객체의 레퍼런스를 데이터 서비스 계층의 컴포넌트에 매개변수로 넘겨주면서 데이터베이스에 호텔 고객 정보를 변경하는 작업을 위임할 수 있다.Subsequently, when UpdateEmailAddress assigns the new email address value newAddress received as a parameter to cust.EmailAddress, the Set accessor in the property EmailAddress of MyCustomer calls the type conversion method SetEmailAddress of the data type converter object MyCustomerConverter, calling the instance reference of the business entity object HotelCustomer and the new one. Pass the email address as a parameter. The method SetEmailAddress of the called MyCustomerConverter assigns the new email address received as a parameter to the HotelCustomer property Email. Through this process, the service method UpdateEmailAdress using the component's own data type can change the property value of the business entity into the content received from the application user. The UpdateEmailAddress method can then delegate the task of changing hotel customer information to the database, passing a reference to the business entity object with the changed email address as a parameter to a component in the data service layer.

이상의 구체적인 실시 예에서 볼 수 있듯이, 본 발명은 사전에 비즈니스 엔티티 타입과 무관하게 개발된 서비스 컴포넌트가 애플리케이션 개발시 구현되는 데이터 타입 컨버터 컴포넌트를 통하여 애플리케이션에서 실제로 사용하는 비즈니스 엔티티 타입의 값을 차질 없이 다룰 수 있게 한다.As can be seen from the above specific embodiment, the present invention can handle the value of the business entity type actually used in the application through the data type converter component implemented in the application development before the service component developed regardless of the business entity type in advance. To be able.

이상과 같이 본 발명은 서비스 컴포넌트가 특정 애플리케이션 환경에 종속되는 것을 방지하기 위해 임의의 자체 정의 데이터 타입을 내포하는 새로운 객체지향 컴포넌트 구조를 제안하고, 이 구조에 따라 제3자가 이미 개발해 놓은 서비스 컴포 넌트를 재사용하여 애플리케이션을 개발할 때 데이터 타입 컨버터를 통해 서비스 컴포넌트의 자체 데이터 타입과 애플리케이션에서 실제로 사용되는 비즈니스 엔티티의 데이터 타입을 정합하는 방법을 제시한다. 본 발명은 또한 애플리케이션 실행시 객체 생성과 객체간 의존성 주입을 프레임워크에 위임함으로써 특정 애플리케이션의 비즈니스 엔티티와 무관하게 개발된 서비스 컴포넌트가 애플리케이션에서 실제로 사용하는 비즈니스 엔티티를 차질 없이 다룰 수 있게 하는 방법도 제공한다.As described above, the present invention proposes a new object-oriented component structure containing an arbitrary self-defined data type in order to prevent the service component from being dependent on a specific application environment, and a service component already developed by a third party according to this structure. When developing an application by reusing XML, the data type converter shows how to match the data type of a service component with the data type of the business entity actually used in the application. The present invention also provides a method for delegating object creation and inter-object dependency injection to the framework when an application is executed so that service components developed independently of the business entity of a particular application can deal with the business entities actually used by the application. do.

본 발명은 전술한 방법들을 통해 직관적 코딩, 타입 안정성, 효율적인 에러 검출과 같은 기존의 객체지향 프로그래밍의 장점을 그대로 활용하면서도 비즈니스 로직을 처리하는 서비스 컴포넌트가 특정 애플리케이션의 비즈니스 엔티티에 종속될 수밖에 없는 현재의 기술적 제약을 극복한다. 본 발명은 이로써 서비스 컴포넌트간의 결합을 완화한 액티브 바인딩 기술과 시너지를 이루어 제3자에 의해 독립적으로 개발된 서비스 컴포넌트들을 소스 코드 수정 없이 새로운 애플리케이션 개발에 재사용할 수 있게 한다.The present invention utilizes the above-described methods to make use of the advantages of existing object-oriented programming such as intuitive coding, type stability, and efficient error detection while still allowing service components that process business logic to be dependent on the business entity of a particular application. Overcome technical limitations The present invention thereby creates synergy with active binding technology that mitigates the coupling between service components, allowing service components independently developed by third parties to be reused for new application development without source code modification.

따라서 본 발명은 서비스 컴포넌트의 재사용률을 획기적으로 제고하고, 재사용을 통한 애플리케이션 개발 비용 절약 및 개발 기간 단축을 이룰 수 있게 하며, 소프트웨어 생산과 유지 보수를 용이하게 한다. 본 발명의 이러한 기술적 성과는 소프트웨어 컴포넌트를 하드웨어 부품처럼 개발, 축적하고, 시장에서 필요한 컴포넌트들을 구입, 조립하여 애플리케이션을 개발하는 방식으로 소프트웨어 생산성을 높이고자 했던 CBD의 이상을 실현하는 데 필요한 실용적 기초를 제공한다. 나아가서 컴포넌트 거래 시장을 창출하고 활성화함으로써 영세한 소프트웨어 전문 업체들 의 사업 기회를 확대하여 소프트웨어 에코시스템의 건전성 강화에 기여할 수 있다.Therefore, the present invention can significantly increase the reuse rate of service components, reduce application development costs and shorten development periods through reuse, and facilitate software production and maintenance. This technical achievement of the present invention provides a practical basis for realizing the ideal of CBD, which is to develop and accumulate software components as hardware components, and to increase software productivity by purchasing and assembling necessary components in the market and developing applications. to provide. Furthermore, by creating and activating the component trading market, we can expand the business opportunities of small software specialists and contribute to the soundness of the software ecosystem.

Claims (5)

제3자에 의해 독립적으로 개발된 컴포넌트들이 새로운 애플리케이션 개발에 소스 코드 수정 없이 바이너리 형태로 재사용될 수 있게 하기 위하여, 모든 비즈니스 엔티티가 공통으로 상속해야 하는 루트 타입과 컴포넌트 자체 데이터 타입 정의 수단을 갖춘 객체지향 소프트웨어 개발환경에서 특정 애플리케이션의 비즈니스 엔티티에 종속되지 않도록 컴포넌트를 개발하는 방법은In order to allow components developed independently by third parties to be reused in binary form without modification of source code in new application development, objects with root types and means for defining their own data types that all business entities must inherit in common. In a oriented software development environment, developing a component so that it is not dependent on the business entity of a particular application (가) 개발자가 컴포넌트 객체의 서비스 메소드를 정의하면서 매개변수나 반환값의 데이터 타입으로 특정한 비즈니스 엔티티를 사용해야 하는 경우, 그 비즈니스 엔티티 타입 대신 루트 타입을 사용하는 단계;(A) if a developer defines a service method of a component object and needs to use a specific business entity as a parameter or return data type, using the root type instead of the business entity type; (나) 개발자가 소프트웨어 개발환경의 컴포넌트 자체 데이터 타입 정의 수단을 호출하고 동 수단의 안내에 따라 컴포넌트 자체 데이터 타입과 데이터 타입 컨버터 인터페이스를 정의하는 단계(본 단계는 아래 (나1) 내지 (나7)의 하위 단계로 구성됨);(B) the developer calls the component's own data type definition means of the software development environment and defines the component's own data type and data type converter interface according to the guidance of the means (this step is described in (B) to (B) Consisting of sub-steps); (나1) 개발자가 컴포넌트 자체 데이터 타입 정의 수단에 임의의 데이터 타입 이름을 입력하면 상기 수단이 동일 명칭의 컴포넌트 자체 데이터 타입 클래스를 생성하고 그 안에 비즈니스 엔티티 객체를 수용하기 위한 루트 타입의 필드 변수를 선언하는 단계;(B) If a developer enters an arbitrary data type name into the component's own data type definition means, the means creates a component's own data type class with the same name and creates a field variable of the root type to accommodate the business entity object therein. Declaring; (나2) 컴포넌트 자체 데이터 타입 정의 수단이 상기 단계 (나1)에서 입력받은 데이터 타입 이름을 바탕으로 컴포넌트 자체 데이터 타입 클래스 안에 루트 타입의 매개변수를 갖는 생성자 메소드를 정의하는 단계;(B2) defining, by the component's own data type definition means, a constructor method having parameters of the root type in the component's own data type class based on the data type name input in step (b); (나3) 컴포넌트 자체 데이터 타입 정의 수단이 루트 타입을 상속한 비즈니스 엔티티 타입을 상기 단계 (나2)에서 정의된 생성자를 사용하여 컴포넌트 자체 데이터 타입으로 변환하는 컨버전 오퍼레이터 메소드를 컴포넌트 자체 데이터 타입 클래스 안에 구현하는 단계;(B) in the component's own data type class, a conversion operator method for converting the business entity type from which the component's own data type definition means inherits the root type to the component's own data type using the constructor defined in step (b) above; Implementing; (나4) 개발자가 컴포넌트 자체 데이터 타입 정의 수단에 컴포넌트 자체 데이터 타입에 포함될 속성(들)의 타입과 임의의 이름을 입력하면 상기 수단이 컴포넌트 자체 데이터 타입 클래스 안에 각 속성의 Get 액세서(Accessor)와 Set 액세서를 선언하는 단계;(B) If the developer inputs an arbitrary name and the type of the attribute (s) to be included in the component's own data type into the component's own data type definition means, the means is assigned to the Get Accessor of each attribute in the component's own data type class. Declaring a Set accessor; (나5) 컴포넌트 자체 데이터 타입 정의 수단이 상기 단계 (나4)에서 선언된 Get 액세서 및 Set 엑세서가 차후 실제 비즈니스 엔티티의 속성을 컴포넌트 자체 데이터 타입 속성으로 변환하는 데 사용할 메소드들로 구성된 데이터 타입 컨버터 인터페이스를 정의하는 단계;(B) a data type consisting of methods for which the component own data type definition means will use the get accessor and set accessor declared in step (b) above to convert the actual business entity's attributes to the component's own data type attributes. Defining a converter interface; (나6) 컴포넌트 자체 데이터 타입 정의 수단이 차후 구현될 데이터 타입 컨버터 객체의 레퍼런스를 수용할 변수로서 상기 단계 (나5)에서 정의된 인터페이스 타입의 의존성 주입 필드와 속성을 선언하는 단계;(B) declaring the dependency injection fields and properties of the interface type defined in step (b) as variables that the component itself data type definition means will accept a reference of the data type converter object to be subsequently implemented; (나7) 컴포넌트 자체 데이터 타입 정의 수단이 상기 단계 (나6)에서 선언된 필드의 변수를 사용하여 상기 단계 (나4)에서 선언된 각 속성의 Get 액세서와 Set 액세서를 완성하여 컴포넌트 자체 데이터 타입 정의를 완료하는 단계;(B7) The component self data type defining means completes the Get accessor and Set accessor of each attribute declared in step (b4) by using the variable of the field declared in step (b6), and the component itself data type. Completing the definition; (다) 개발자가 상기 단계 (가)에서 서비스 메소드의 매개변수로 사용된 루트 타입의 변수를 상기 단계 (나)에서 정의된 컴포넌트 자체 데이터 타입으로 변환하는 코드를 서비스 메소드의 첫 명령문(statement)으로 작성하는 단계;(C) The code that the developer converts the variable of the root type used as a parameter of the service method in step (a) to the component's own data type defined in step (b) as the first statement of the service method. Creating; (라) 개발자가 서비스 메소드의 나머지 코드를 작성하면서 매개변수로 받은 비즈니스 엔티티 객체를 사용해야 할 때마다 상기 단계 (다)에서 컴포넌트 자체 데이터 타입으로 변환된 변수를 사용하는 단계:(D) Whenever the developer needs to use the business entity object received as a parameter while writing the rest of the service method, using the variable converted to the component's own data type in step (c) above: 를 포함하는 것을 특징으로 하는 소프트웨어 개발 방법.Software development method comprising a. 청구항 1의 방식으로 개발된 서비스 컴포넌트들을 데이터 타입 컨버터 구현 수단을 갖춘 객체지향 소프트웨어 개발환경에서 소스 코드 수정 없이 조립하여 새로운 애플리케이션을 개발하는 방법에 있어서, 서비스 컴포넌트 자체 데이터 타입과 특정 애플리케이션에서 실제로 사용되는 비즈니스 엔티티 타입 사이의 불일치를 정합하는 데 사용될 데이터 타입 컨버터를 구현하는 방법은A method of developing a new application by assembling service components developed in the method of claim 1 without modification of source code in an object-oriented software development environment having a data type converter implementation means, which is actually used in a service component itself and a specific application. How to implement a data type converter that will be used to match discrepancies between business entity types (가) 개발자가 소프트웨어 개발환경에서 데이터 타입 컨버터 구현이 필요한 서비스 컴포넌트를 선택하고 데이터 타입 컨버터 구현 수단을 호출하는 단계;(A) a developer selecting a service component requiring a data type converter implementation in a software development environment and calling data type converter implementation means; (나) 데이터 타입 컨버터 구현 수단이 상기 단계 (가)에서 선택된 서비스 컴포넌트에 정의된 데이터 타입 컨버터 인터페이스를 모두 식별하여 보여주고, 개발자가 이 중 데이터 타입 컨버터 클래스로 구현되지 않은 인터페이스 하나를 선택하는 단계;(B) the data type converter implementing means identifies and shows all data type converter interfaces defined in the service component selected in step (a) above, and the developer selects one of the interfaces not implemented by the data type converter class. ; (다) 데이터 타입 컨버터 구현 수단이 상기 단계 (나)에서 선택된 데이터 타입 컨버터 인터페이스와 상응하는 컴포넌트 자체 데이터 타입을 식별하는 단계;(C) the data type converter implementing means identifying the component itself data type corresponding to the data type converter interface selected in step (b); (라) 데이터 타입 컨버터 구현 수단이 상기 단계 (나)에서 선택된 데이터 타입 컨버터 인터페이스를 구현하는 클래스를 생성하는 단계;(D) generating, by the data type converter implementing means, a class implementing the data type converter interface selected in step (b); (마) 데이터 타입 컨버터 구현 수단이 애플리케이션의 비즈니스 엔티티를 모두 식별하여 보여주고, 개발자가 이 중 상기 단계 (다)에서 선택된 컴포넌트 자체 데이터 타입과 대응하는 비즈니스 엔티티를 선택하는 단계;(E) the data type converter implementing means identifies and shows all the business entities of the application, and the developer selects a business entity corresponding to the component itself data type selected in step (c) above; (바) 데이터 타입 컨버터 구현 수단이 상기 단계 (나)에서 선택된 데이터 타입 컨버터 인터페이스에 포함된 메소드를 모두 식별하여 보여주고, 개발자가 이 중 구현할 메소드 하나를 선택하는 단계;(F) the data type converter implementation means identifying and showing all methods included in the data type converter interface selected in step (b), and the developer selecting one of the methods to be implemented; (사) 데이터 타입 컨버터 구현 수단이 상기 단계 (다)에서 식별된 컴포넌트 자체 데이터 타입의 속성과 상기 단계 (마)에서 식별된 비즈니스 엔티티의 속성을 모두 보여주고, 개발자가 이 중 상기 단계 (바)에서 선택된 메소드가 다루는 속성 쌍(들)을 선택하는 단계;(G) the data type converter implementation means shows both the property of the component itself data type identified in step (c) and the property of the business entity identified in step (e), the developer of which step (f) Selecting an attribute pair (s) to be handled by the selected method; (아) 데이터 타입 컨버터 구현 수단이 상기 단계 (라)에서 생성된 클래스에 상기 단계 (사)에서 선택된 속성들을 연동하는 데이터 타입 컨버터 객체 코드를 생성하고, 속성의 타입이 상호 일치하지 않는 경우에 한하여 개발자가 타입 변환문을 추가하여 상기 단계 (바)에서 선택된 메소드의 구현을 완성하는 단계;(H) only if the data type converter implementation means generates a data type converter object code for linking the attributes selected in step (g) to the class generated in step (d), and the types of the attributes do not coincide with each other. The developer adding the type conversion statement to complete the implementation of the method selected in the step (bar); (자) 데이터 타입 컨버터 구현 수단이 상기 단계 (나)에서 선택된 데이터 타입 컨버터 인터페이스의 메소드 구현 상태를 보여주고, 구현할 메소드가 남아 있는 경우 모든 메소드가 구현될 때까지 개발자가 상기 단계 (바) 내지 (아)를 반복하여 선택된 데이터 타입 컨버터 인터페이스 구현 클래스를 완성하는 단계;(I) The data type converter implementation means shows the method implementation status of the data type converter interface selected in step (b) above, and if there are remaining methods to implement, the developer can perform steps (bar) to (s) until all methods are implemented. Repeating a) to complete the selected data type converter interface implementation class; (차) 데이터 타입 컨버터 구현 수단이 상기 단계 (나)에서 식별된 데이터 타입 컨버터 인터페이스에 대한 클래스 구현 상태를 보여주고, 구현할 인터페이스가 남아 있는 경우 모든 인터페이스가 구현될 때까지 개발자가 상기 단계 (나) 내지 (자)을 반복하는 단계;(D) the data type converter implementation means shows the class implementation status for the data type converter interface identified in step (b), and if there is an interface to be implemented, the developer may proceed to step (b) until all interfaces are implemented. Repeating (i) to (i); (카) 개발자가 데이터 타입 컨버터 구현 수단에서 의존성 주입 정보 파일 생성 명령을 선택하면, 상기 수단이 상기 단계 (나) 내지 (차)를 통해 구현된 데이터 타입 컨버터 객체와 그에 대응하는 컴포넌트 자체 데이터 타입 사이의 의존성 주입 정보를 파일로 생성하는 단계;(K) If the developer selects a dependency injection information file generation command in the data type converter implementation means, the means is provided between the data type converter object implemented through steps (b) to (d) and the corresponding component's own data type. Generating dependency injection information in a file; (타) 개발자가 소프트웨어 개발환경에서 상기 단계 (가) 내지 (카)에 걸쳐 작성된 클래스에 대해 컴파일 명령을 실행하여 데이터 타입 컨버터 컴포넌트를 생성하는 단계;(E) a developer executing a compile command on a class created in steps (a) to (k) in a software development environment to generate a data type converter component; 를 포함하는 것을 특징으로 하는 소프트웨어 개발 방법.Software development method comprising a. 객체지향 소프트웨어 실행환경을 갖춘 컴퓨터상에서 객체지향 컴포넌트 기반 소프트웨어를 실행하는 방법에 있어서, 청구항 1의 방식으로 개발된 서비스 컴포넌트와 청구항 2의 방식으로 개발된 데이터 타입 컨버터 컴포넌트를 사용하여 개발한 애플리케이션을 의존성 주입 기능을 갖춘 프레임워크상에서 실행하는 방법은A method of executing object-oriented component-based software on a computer having an object-oriented software execution environment, comprising: dependence on an application developed using a service component developed in the method of claim 1 and a data type converter component developed in the method of claim 2 How to run on a framework with injection capabilities (가) 프레임워크 외부의 클라이언트 프로세스가 프레임워크에 배치된 특정 서비스 컴포넌트의 객체를 요구하면 프레임워크가 의존성 주입 정보 파일을 참조하여 해당 컴포넌트의 객체와 그에 연관된 데이터 타입 컨버터 클래스(들)의 객체를 생성하는 단계;(A) When a client process outside of the framework requests an object of a particular service component deployed in the framework, the framework consults the dependency injection information file to determine that component's object and its associated data type converter class (s). Generating; (나) 프레임워크가 의존성 주입 정보 파일을 참조하여 상기 단계 (가)에서 생성된 데이터 타입 컨버터 객체(들)의 레퍼런스를 각 컨버터 객체에 대응하는 서비스 컴포넌트 자체 데이터 타입에 주입하는 단계;(B) the framework injecting the reference of the data type converter object (s) created in step (a) into the service component itself data type corresponding to each converter object with reference to the dependency injection information file; (다) 프레임워크가 서비스 컴포넌트 객체를 요청한 클라이언트 프로세스에게 상기 단계 (가)에서 생성되어 상기 단계 (나)의 의존성 주입 과정을 거친 서비스 컴포넌트 객체를 반환하는 단계;(C) returning, by the framework, the service component object generated in step (a) to the client process requesting the service component object and having undergone the dependency injection process of step (b); (라) 클라이언트 프로세스가 상기 단계 (다)에서 넘겨받은 서비스 컴포넌트 객체의 서비스 메소드를 호출하면서 비즈니스 엔티티의 레퍼런스를 매개변수로 넘겨주는 단계;(D) passing the reference of the business entity as a parameter while the client process invokes the service method of the service component object passed in step (c) above; (마) 상기 단계 (라)에서 호출된 서비스 컴포넌트 객체의 메소드가 클라이언트 프로세스로부터 매개변수로 받은 비즈니스 엔티티 객체를 컴포넌트 자체 데이터 타입 객체로 변환하는 단계;(E) converting the business entity object received as a parameter from the client process by the method of the service component object called in step (d) into a component itself data type object; (바) 상기 단계 (라)에서 호출된 서비스 메소드가 컴포넌트 자체 데이터 타입 객체의 특정 속성을 액세스하는 단계;(F) the service method called in step (d) accesses specific properties of the component's own data type object; (사) 상기 단계 (바)에서 액세스된 속성의 액세서가 데이터 타입 컨버터 객체의 상기 속성과 관련된 타입 변환 메소드를 호출하면서 비즈니스 엔티티 객체의 레퍼런스를 넘겨주는 단계;(G) passing the reference of the business entity object while the accessor of the attribute accessed in step (f) invokes a type conversion method associated with the attribute of the data type converter object; (아) 상기 단계 (사)에서 호출된 타입 변환 메소드가 비즈니스 엔티티 객체의 속성을 그에 대응하는 컴포넌트 자체 데이터 타입 속성으로 변환하는 단계;(H) converting an attribute of the business entity object into a corresponding component's own data type attribute by the type conversion method called in step (i); (자) 상기 단계 (라)에서 호출된 서비스 메소드가 필요한 만큼 상기 단계 (바) 내지 (아)를 반복하면서 자신의 서비스 수행을 완료하는 단계;(I) repeating the steps (bar) to (a) as necessary for the service method called in step (d) to complete the performance of its service; 를 포함하는 것을 특징으로 하는 소프트웨어 실행 방법.Software execution method comprising a. 삭제delete 삭제delete
KR1020070125847A 2007-12-05 2007-12-05 A Method for Decoupling Service Components from Application-Specific Business Entities KR100884435B1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
KR1020070125847A KR100884435B1 (en) 2007-12-05 2007-12-05 A Method for Decoupling Service Components from Application-Specific Business Entities
PCT/KR2008/007142 WO2009072809A2 (en) 2007-12-05 2008-12-03 A method for decoupling service components from application-specific business entities

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020070125847A KR100884435B1 (en) 2007-12-05 2007-12-05 A Method for Decoupling Service Components from Application-Specific Business Entities

Publications (2)

Publication Number Publication Date
KR20070121624A KR20070121624A (en) 2007-12-27
KR100884435B1 true KR100884435B1 (en) 2009-02-19

Family

ID=39138910

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020070125847A KR100884435B1 (en) 2007-12-05 2007-12-05 A Method for Decoupling Service Components from Application-Specific Business Entities

Country Status (2)

Country Link
KR (1) KR100884435B1 (en)
WO (1) WO2009072809A2 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20210060689A (en) * 2019-11-18 2021-05-27 주식회사 오픈드래프트 Server side data component for support of development and management and method for perform the data component

Families Citing this family (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN106250248A (en) * 2016-07-28 2016-12-21 努比亚技术有限公司 A kind of to returning the method and apparatus that data carry out type conversion
CN110008431B (en) * 2019-04-11 2021-10-08 成都四方伟业软件股份有限公司 Page component construction method and device, page generation equipment and readable storage medium
CN112689169B (en) * 2020-12-21 2022-06-17 湖南快乐阳光互动娱乐传媒有限公司 Service playing method and device

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20030044959A (en) * 2003-05-12 2003-06-09 정안모 A Method for Implementing and Assembling Software Components using Client-Side Metadata and Glue Codes
KR20030056654A (en) * 2001-12-28 2003-07-04 한국전자통신연구원 Method and apparatus for enterprise jababeans components assembly

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6298478B1 (en) * 1998-12-31 2001-10-02 International Business Machines Corporation Technique for managing enterprise JavaBeans (™) which are the target of multiple concurrent and/or nested transactions
JP4146983B2 (en) * 1999-02-26 2008-09-10 インターナショナル・ビジネス・マシーンズ・コーポレーション Process method and data processing system for calling method of server object

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20030056654A (en) * 2001-12-28 2003-07-04 한국전자통신연구원 Method and apparatus for enterprise jababeans components assembly
KR20030044959A (en) * 2003-05-12 2003-06-09 정안모 A Method for Implementing and Assembling Software Components using Client-Side Metadata and Glue Codes
KR20040097941A (en) * 2003-05-12 2004-11-18 정안모 Method and system of developing a software with utilizing metadata of the client-side component under component-based development environment

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
한국정보과학회 2001년도 가을 학술발표논문집, "자바 빈즈 컴포넌트의 내부 종속성 관계를 고려한 XML 기반 명세 기법에 관한 연구", 제28권, 제2호(Ⅰ), pp. 574~576(2001.10)
한국정보과학회 2007 한국컴퓨터종합학술대회 논문집,"독립적으로 개발된 바이너리 컴포넌트들의 조립을 지원하는 컴포넌트 모델",제34권제1호(B), pp.138-142(2007.06).

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20210060689A (en) * 2019-11-18 2021-05-27 주식회사 오픈드래프트 Server side data component for support of development and management and method for perform the data component
KR102258241B1 (en) * 2019-11-18 2021-06-01 주식회사 오픈드래프트 Server side data component for support of development and management and method for perform the data component

Also Published As

Publication number Publication date
KR20070121624A (en) 2007-12-27
WO2009072809A2 (en) 2009-06-11
WO2009072809A3 (en) 2009-09-17

Similar Documents

Publication Publication Date Title
Dig et al. How do APIs evolve? A story of refactoring
Koehler et al. Declarative techniques for model-driven business process integration
García-Domínguez et al. EUnit: a unit testing framework for model management tasks
KR100828302B1 (en) A Method for Software Development and Operation Based on Component Reuse and Dependency Injection
US10083029B2 (en) Detect application defects by correlating contracts in application dependencies
Butting et al. Systematic language extension mechanisms for the MontiArc architecture description language
Guida et al. Supporting reuse of smart contracts through service orientation and assisted development
Philips et al. Towards tierless web development without tierless languages
US20080256509A1 (en) Pattern-based programming system for automatic code generation
Ducasse et al. Meta-environment and executable meta-language using Smalltalk: an experience report
KR100884435B1 (en) A Method for Decoupling Service Components from Application-Specific Business Entities
Tegeler et al. An introduction to graphical modeling of CI/CD workflows with rig
Sanchez et al. Towards a clean architecture for android apps using model transformations
Voinea et al. Typechecking java protocols with [st] mungo
Jansen et al. TypeScript: Modern JavaScript Development
Knoche et al. Continuous api evolution in heterogenous enterprise software systems
Shute Advanced JavaScript: Speed up web development with the powerful features and benefits of JavaScript
Südholt A model of components with non-regular protocols
Couto et al. Towards enabling overture as a platform for formal notation IDEs
Börger et al. Abstract state machine nets: Closing the gap between business process models and their implementation
Clemente et al. Managing crosscutting concerns in component based systems using a model driven development approach
Heckel et al. Model-based development of executable business processes for web services
Elwasif et al. Bocca: A development environment for HPC components
Drey et al. Kermeta language
Wei et al. Discovering behavioural interfaces for overloaded web services

Legal Events

Date Code Title Description
A201 Request for examination
A302 Request for accelerated examination
E902 Notification of reason for refusal
E902 Notification of reason for refusal
E90F Notification of reason for final refusal
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20130801

Year of fee payment: 5

FPAY Annual fee payment

Payment date: 20131125

Year of fee payment: 6

FPAY Annual fee payment

Payment date: 20150211

Year of fee payment: 7

FPAY Annual fee payment

Payment date: 20170213

Year of fee payment: 9

LAPS Lapse due to unpaid annual fee