KR100828302B1 - A Method for Software Development and Operation Based on Component Reuse and Dependency Injection - Google Patents
A Method for Software Development and Operation Based on Component Reuse and Dependency Injection Download PDFInfo
- Publication number
- KR100828302B1 KR100828302B1 KR20070113441A KR20070113441A KR100828302B1 KR 100828302 B1 KR100828302 B1 KR 100828302B1 KR 20070113441 A KR20070113441 A KR 20070113441A KR 20070113441 A KR20070113441 A KR 20070113441A KR 100828302 B1 KR100828302 B1 KR 100828302B1
- Authority
- KR
- South Korea
- Prior art keywords
- component
- components
- interface
- service
- client
- Prior art date
Links
Images
Classifications
-
- 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
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Abstract
본 발명은 컴포넌트 기반의 소프트웨어 개발 기술에 관한 것으로, 독립적으로 개발된 바이너리 컴포넌트들의 조립을 통한 애플리케이션 개발로 소프트웨어 생산성을 높이기 위하여 소프트웨어 부품(컴포넌트)의 개발과 조립을 별도의 공정으로 명확하게 구분한 기존의 액티브 바인딩 기술(ABT: Active Binding Technology)을 더욱 효과적으로 개선하고, 이를 의존성 주입 기능을 갖춘 프레임워크 기술과 결합하여 컴포넌트 재사용성과 애플리케이션의 성능 및 품질을 더욱 향상시키는 기술에 관한 것이다.The present invention relates to a component-based software development technology, to clearly develop and assemble a software component (component) into a separate process in order to increase software productivity by application development through assembly of independently developed binary components. It's about technology that improves Active Binding Technology (ABT) more effectively and combines it with framework technology with dependency injection to further improve component reusability and application performance and quality.
본 발명은 독립적으로 개발된 바이너리 컴포넌트들이 특정 애플리케이션 아키텍처나 특정 컴포넌트와의 결합이 미리 결정되어 있지 않은 온전한 부품으로서 다양한 환경에서 용이하게 조립, 사용될 수 있게 하기 위해 각 컴포넌트가 차후에 의존할 서버 컴포넌트의 서비스를 호출하는 방법에 있어 인터페이스에 대한 명세 정보만을 임의로 정의하고 이를 메타데이터에 포함시켰던 기존의 액티브 바인딩 기술과 달리 서비스 요청 인터페이스 타입 자체를 각 컴포넌트 내에 정의하여 사용하고 그 상세한 정보를 메타데이터로 노출함으로써 개발자들에게 익숙한 직관적이고 간결한 프로그래밍을 가능케 하고, 애플리케이션 실행시 동적 결합(Dynamic Binding)에 따른 성능 부담 가능성을 제거한다.The present invention provides a service of a server component, which each component will later rely on, so that independently developed binary components can be easily assembled and used in various environments as intact components having no predetermined application architecture or combination with a specific component. Unlike the existing active binding technology which arbitrarily defined only the specification information of the interface in the method of calling and including it in the metadata, the service request interface type itself is defined and used in each component, and the detailed information is exposed as metadata. It enables intuitive and concise programming that is familiar to developers, and eliminates the potential performance burden of dynamic binding at application run time.
또한 본 발명은 클라이언트 컴포넌트 객체가 가상의 서버 컴포넌트와의 상호작용 중재를 담당할 글루 컴포넌트의 객체를 직접 생성하는 기존의 액티브 바인 딩 방식과 달리 프레임워크가 글루 컴포넌트 객체를 생성하고 그 참조를 클라이언트 컴포넌트 객체에 의존성 주입 방식으로 할당하도록 함으로써 컴포넌트 개발시 의존 관계에 관한 코딩을 더욱 간결하게 해주며, 클라이언트 컴포넌트와 서버 컴포넌트의 중간에 위치하는 글루 컴포넌트를 통해 트랜잭션, 보안 등 핵심 미들웨어 서비스를 적용하고 애플리케이션 작동 상태를 감시할 수 있게 해줌으로써 애플리케이션의 개발과 관리를 용이하게 하고, 성능과 품질을 향상시킨다. In addition, the present invention is different from the existing active binding scheme in which the client component object directly creates an object of the glue component that is responsible for mediating interaction with the virtual server component, and the framework generates the glue component object and references the client component. Dependency injection makes it easier to code dependencies when developing components. Glue components that are located between client and server components apply core middleware services such as transactions and security, and operate applications. The ability to monitor status facilitates the development and management of applications, improving performance and quality.
컴포넌트 재사용, 컴포넌트 조립, 글루 컴포넌트, 서비스 요청 인터페이스, 인터페이스 중재, 프레임워크, 미들웨어, 의존성 주입, 디펜던시 인젝션, 객체지향 프로그래밍, 액티브 바인딩 Component Reuse, Component Assembly, Glue Component, Service Request Interface, Interface Arbitration, Framework, Middleware, Dependency Injection, Dependency Injection, Object Oriented Programming, Active Binding
Description
도 1a는 종래의 컴포넌트 기술에 따른 프로그램 설계시 컴포넌트 다이어그램에 나타나는 컴포넌트 조립 개념도.1A is a conceptual diagram illustrating component assembly shown in a component diagram in a program design in accordance with a conventional component technology.
도 1b는 종래의 컴포넌트 기술에 따른 실제 컴포넌트 조립 구현도.1B illustrates an actual component assembly implementation in accordance with conventional component technology.
도 2a는 본 발명에 따라 구현된 컴포넌트 구조도.2A is a component structural diagram implemented in accordance with the present invention.
도 2b는 본 발명에 따라 구현된 컴포넌트의 파일 구조도.2B is a file structure diagram of a component implemented in accordance with the present invention.
도 3은 본 발명에 따라 컴포넌트를 구현하는 절차를 나타낸 일 흐름도.3 is a flow diagram illustrating a procedure for implementing a component in accordance with the present invention.
도 4는 본 발명에 따른 컴포넌트 조립 구현도.4 is a component assembly implementation in accordance with the present invention.
도 5는 본 발명에 따라 컴포넌트를 조립하는 절차를 나타낸 일 흐름도.5 is a flow chart illustrating a procedure for assembling components in accordance with the present invention.
도 6은 본 발명에 따라 개발되고 조립된 컴포넌트들에 대한 프레임워크의 의존성 주입 구현도.6 is a dependency injection implementation of the framework for components developed and assembled in accordance with the present invention.
도 7은 본 발명에 따라 개발된 소프트웨어 실행시 프레임워크가 컴포넌트간 의존성을 주입하는 절차를 나타낸 일 흐름도.7 is a flowchart illustrating a procedure of injecting dependencies between components when the framework is executed in accordance with the present invention.
도 8은 본 발명의 양호한 일 실시 예의 컴포넌트 조립 구현도.8 is a component assembly implementation of one preferred embodiment of the present invention.
도 9는 본 발명의 양호한 일 실시 예에서 구현된 클라이언트 컴포넌트 코드.9 is a client component code implemented in one preferred embodiment of the present invention.
도 10은 본 발명의 양호한 일 실시 예에서 구현된 커스텀 애트리뷰트 클래스 코드.10 is a custom attribute class code implemented in one preferred embodiment of the present invention.
도 11은 본 발명의 양호한 일 실시 예에서 구현된 서버 컴포넌트 코드.11 is a server component code implemented in one preferred embodiment of the present invention.
도 12는 본 발명의 양호한 일 실시 예에서 구현된 글루 컴포넌트 코드.12 is a glue component code implemented in a preferred embodiment of the present invention.
도 13은 본 발명의 양호한 일 실시 예에서 작성된 컴포넌트 배치 구성 파일.13 is a component layout configuration file created in one preferred embodiment of the present invention.
본 발명은 컴포넌트 기반 소프트웨어 개발(CBD: Component-Based Development) 기술 및 프레임워크 기술에 관한 것으로, 더욱 상세하게는 제3자가 개발한 바이너리 코드 형태의 컴포넌트를 하드웨어 부품처럼 재사용, 조립하여 새로운 애플리케이션을 개발함으로써 소프트웨어 생산성을 획기적으로 제고하고자 했던 컴포넌트 기반 개발 패러다임의 본래 취지를 실제로 구현하기 위해 컴포넌트의 개발 공정과 조립 공정으로 분리하는 방법과, 이러한 컴포넌트들을 효율적으로 조립하여 애플리케이션을 개발하고 여기에 품질 높은 미들웨어 서비스를 제공하는 방법에 관한 것이다.The present invention relates to component-based software development (CBD) technology and framework technology. More specifically, a new application is developed by reusing and assembling components in a binary code form developed by a third party as hardware components. In order to realize the original intention of the component-based development paradigm, which was intended to drastically increase software productivity, a method of separating components into a development process and an assembly process, as well as efficiently assembling these components to develop applications and high quality middleware It relates to a method of providing a service.
소프트웨어 생산성 제고는 컴퓨터가 출현한 이래 항상 제기되어 온 미완의 숙제이다. 특히 인터넷의 발전과 유비쿼터스 컴퓨팅 시대의 도래로 다양하고 새로 운 소프트웨어 및 기존 소프트웨어 변경에 대한 수요는 나날이 폭증하고 있는 것에 비해 소프트웨어 개발 생산성 향상이 완만하게 진행되고 있는 오늘날 획기적인 돌파구 마련에 대한 요구는 더욱 절실해졌다. 그동안 소프트웨어 개발 현장에서는 구조적 개발 방법, 정보공학 기반 개발 방법, 객체 지향 프로그래밍, 컴포넌트 기반 개발 방법, 모델 주도형 개발 방법(MDD: Model-driven Development), 애스펙트 지향 프로그래밍(AOP: Aspect-oriented Programming), 서비스 지향 아키텍처(SOA: Service-oriented Architecture) 등 수많은 기술과 방법론이 제시되고 실험되고 사용되면서 상당한 생산성 및 품질 향상이 이루어져 온 것이 사실이지만, 그럼에도 각 방법론 자체가 안고 있는 발상의 한계 또는 현실적 구현 가능성 부족 등으로 만성적인 소프트웨어 위기를 타개할 결정적 방안으로 자리 잡은 것은 없다.Improving software productivity is an incomplete assignment that has always been raised since the advent of computers. In particular, with the development of the Internet and the advent of ubiquitous computing, the demand for various new software and existing software changes is increasing day by day, and the demand for breakthrough breakthroughs in today's software development productivity is progressing slowly. Done In the past, in the software development field, structural development methods, information engineering-based development methods, object-oriented programming, component-based development methods, model-driven development (MDD), aspect-oriented programming (AOP), and services While many technologies and methodologies, such as service-oriented architecture (SOA), have been proposed, tested, and used, significant productivity and quality improvements have been made.However, the limitations of ideas and lack of practical implementation that each methodology itself has As a result, there is no definitive way to overcome the chronic software crisis.
소프트웨어 생산성 제고를 위한 제안들의 핵심은 결국 소프트웨어 모듈의 기성 부품화로 수렴된다. 자동차, 컴퓨터 등 하드웨어 분야에서처럼 완제품을 구성하기 위한 표준화된 부품들이 시장에 풍부하게 존재하는 상태에서 부품을 구입, 조립하여 새 제품을 만들자는 것이다. 이런 맥락에서 이미 1960년대 말에 소프트웨어 위기 타개책으로 컴포넌트의 대량 생산과 재사용의 필요성이 제기되었고, 1990년대부터는 CORBA/CCM, COM+, Java/EJB, .NET 등 컴포넌트 기반 개발 플랫폼들이 프로그래밍 환경을 주도하게 되었다. 또 최근에 IT 업계의 화두로 떠오른 SOA 역시 넓은 의미의 컴포넌트인 서비스의 재사용성을 중요한 장점으로 내세우며 주창되었다.The core of the proposals to increase software productivity ultimately converges on off-the-shelf componentization of software modules. With the abundance of standardized parts in the market, such as in the hardware field of automobiles, computers, etc., it is necessary to purchase and assemble parts to make new products. In this context, the need for mass production and reuse of components has already been raised in the late 1960s as a solution to the software crisis.In the 1990s, component-based development platforms such as CORBA / CCM, COM +, Java / EJB, and .NET led the programming environment. It became. In addition, SOA, which has recently emerged as a topic of the IT industry, has been advocated for the reusability of services, a broad component.
여기서 컴포넌트를 재사용한다 함은 곧 이미 개발되어 컴파일된 바이너리 코드 상태의 컴포넌트들을 구하여 새로운 환경에서 소스 코드 수정 없이 조립하여 다 시 쓴다는 것을 의미한다. 기능상 재사용 가능한 컴포넌트라 할지라도 타인이 작성한 소스 코드를 구하여 분석하고 수정해야만 한다면 그러한 작업에 소요되는 고비용으로 인하여 재사용에 의한 개발 생산성 향상 효과가 미미해지기 때문이다. 또 시장에서 거래되는 컴포넌트의 소스 코드를 구하는 것은 현실적으로 불가능에 가까운 일이기도 하다.Reusing components here means obtaining components that have already been developed and compiled binary code, and reassembling them without modifying the source code in the new environment. Even if it is a functionally reusable component, if the source code written by another person has to be obtained, analyzed, and modified, the high productivity cost of such work minimizes the development productivity. It is also practically impossible to get the source code of a component traded on the market.
소프트웨어 컴포넌트가 하드웨어 부품처럼 자유롭게 재사용되려면 특정 대상과의 조립에 관한 사전 고려 없이 개발 생산되어야 하고, 조립은 차후에 별도 공정으로 처리되는 것이 바람직하다. 그러나 종래의 컴포넌트 기반 개발 방법론들은 컴포넌트 개발 과정에 다른 특정 컴포넌트와의 결합이 이미 결정되어 포함되는 소프트웨어 개발 방식을 택하고 있어 독립적으로 개발된 상용(COTS: Commercial Off-the-Shelf) 바이너리 컴포넌트의 소스 코드 수정 없는 재사용/조립이라는 CBD 본연의 이상 실현과는 다른 길을 걷고 있다. 종래의 컴포넌트 기술들이 이처럼 부품 개발과 부품 조립이 단일 공정 내에 혼재된 소프트웨어 개발 방식을 취함으로써 컴포넌트 개발 과정의 단순성, 직관성, 안정성을 기하는 것도 의미가 있지만, 그로 인해 부품 생산 공정과 조립 공정을 명확히 분리함으로써 얻을 수 있는 컴포넌트 재사용성 및 소프트웨어 생산성의 획기적 향상 기회를 스스로 가로막고 있는 것도 사실이다.In order for software components to be freely reused like hardware components, they must be developed and produced without prior consideration for assembly with a particular object, and the assembly is preferably processed in a separate process later. However, the conventional component-based development methodologies adopt a software development method in which a combination with other specific components is already included in the component development process, so that the source of an independently developed commercial off-the-shelf (COTS) binary component is developed. It's a different path from the CBD's natural ideal of reuse / assembly without code modification. Conventional component technologies make it possible to achieve the simplicity, intuition, and stability of the component development process by adopting a software development method in which component development and assembly of components are mixed in a single process. It is also true that they are blocking the opportunity to dramatically increase component reusability and software productivity.
컴포넌트들은 내장된 코드를 은닉한 채 메타데이터로 노출된 인터페이스를 매개로 상호 통신하며 서비스를 주고 받는데, 각 컴포넌트는 자신이 서버로서 클라이언트에 제공하는 서비스에 관한 서비스 제공 인터페이스(Provided Interfaces)와 자신이 클라이언트로서 서버에 의존할 서비스에 관한 서비스 요청 인터페이스(Required Interfaces)를 갖는다. 인터페이스 외에는 별도의 통신 수단이 없으므로 실제 환경에서 서비스를 주고 받는 두 컴포넌트의 경우 클라이언트 컴포넌트의 서비스 요청 인터페이스는 서버 컴포넌트의 서비스 제공 인터페이스와 정확하게 일치해야 한다.The components communicate with each other through the interface exposed as metadata while concealing the embedded code, and each component exchanges and provides services. As a client, it has the Service Request Interfaces for the services that will depend on the server. Since there is no separate communication means other than the interface, for the two components that exchange services in the real environment, the service request interface of the client component must exactly match the service providing interface of the server component.
상기 개념에 따르면 각 컴포넌트는 클라이언트로서나 서버로서나 독립적으로 존재하면서 다른 다양한 컴포넌트들과 상하위 양방향으로 통신할 수 있는 준비가 되어 있는 것처럼 보인다. 그러나 인터페이스를 하나의 타입(Type: 객체지향형 프로그래밍 언어로 작성되는 프로그램의 최상위 구성 단위로서, 클래스, 인터페이스 등이 이에 해당)으로 취급하면서 컴포넌트의 독립성, 재사용성보다는 애플리케이션 단위의 타입 안정성에 중점을 두는 종래의 컴포넌트 기반 개발 방법론 및 기술에서는 특정 타입은 오직 한 곳에만 존재해야 한다는 원칙에 따라 특정 인터페이스 역시 고유한 식별자를 가지면서 어느 한 곳에만 존재하게 된다. 즉 서비스를 주고 받는 두 컴포넌트의 경우 클라이언트 컴포넌트의 서비스 요청 인터페이스와 서버 컴포넌트의 서비스 제공 인터페이스가 정확히 일치해야 하지만 동일한 형태의 인터페이스가 두 곳에 존재할 수는 없으므로, 하나는 다른 하나를 참조하는 정보만 담고 있어야 한다.According to the concept, each component appears to be independent of the client or server and is ready to communicate with the other various components in both up and down directions. However, the interface is treated as a type (a top-level constituent unit of a program written in an object-oriented programming language, such as a class or an interface), which focuses on type stability of an application unit rather than component independence and reusability. In the conventional component-based development methodology and technology, a certain interface must exist only in one place according to the principle that a specific type must exist only in one place. In other words, the two components that send and receive services must exactly match the service request interface of the client component and the service providing interface of the server component, but the same type of interface cannot exist in two places, so one should only contain information that refers to the other. do.
따라서 종래 기술에서는 각 컴포넌트가 자신이 제공하는 서비스에 관한 서비스 제공 인터페이스만을 온전하게 정의하여 포함하고 있으며, 서비스 요청 인터페이스는 별도로 정의하지 않고 자신이 의존하는 서버 컴포넌트에 정의되어 있는 서 비스 제공 인터페이스 타입을 사용하는 코드를 내장하는 구조로 되어 있다. 이로 인해 각 컴포넌트는 자신이 의존하는 서버 컴포넌트와의 조립 정보를 코드에 내장하게 되고, 결국 다계층 구조 내의 컴포넌트들이 정적인 콜 스택(Call Stack) 방식으로 단단히 결합하게 된다. 이것은 하나의 컴포넌트를 원래의 목적 시스템 외의 다른 환경에서 사용하려면 그 소스 코드를 수정해야 한다는 것을 의미하며, 따라서 독립적으로 개발된 바이너리 컴포넌트들을 획득하여 간단하게 조립하는 방식으로 소프트웨어를 개발함으로써 생산성을 끌어올리는 것이 불가능하다는 것을 의미한다.Therefore, in the related art, each component completely defines and includes only a service providing interface related to a service provided by the component, and a service request interface type defined in a server component on which it depends, without defining a service request interface. It is a structure to embed the code to be used. As a result, each component embeds assembly information with the server component it depends on in the code, and finally, components in a multi-tiered structure are tightly coupled in a static call stack. This means that to use a component in an environment other than the original target system, you need to modify its source code, thus boosting your productivity by developing software by simply acquiring independently assembled binary components. It means that it is impossible.
이러한 종래의 컴포넌트 기반 기술의 문제점은 여타의 기존 재사용 방법론에도 그대로 적용되어 영향을 미친다. 먼저 SOA의 경우 비즈니스 관점의 업무 단위를 반영하는 자율적 모듈인 서비스들은 XML 등 표준 메시지 기반으로 통신하므로 용이하게 재사용될 수 있지만, 다른 서비스에 의존하지 않고 자율적으로 기능하기 위해서는 입자가 상당히 커질 수밖에 없다. 그런데 이렇게 상대적으로 큰 입자의 서비스를 통째로 개발하는 것은 설계에서 구현, 유지 보수에 이르기까지 소프트웨어 생명주기 전 과정을 통해 매우 비효율적이다. 따라서 각각의 서비스는 여러 개의 보다 작은 객체 지향 또는 컴포넌트 기반 모듈로 분리하여 구현하고 이들을 결합하는 형태로 개발하는 것이 일반적이다. 이 과정에서 제3자가 개발한 바이너리 컴포넌트들을 서비스의 구성 재료로 재사용할 수 있다면 SOA 서비스 개발 생산성이 크게 향상될 것이다. 그러나 앞서 언급한 바와 같이 현존하는 컴포넌트 기술들은 독립적으로 개발된 바이너리 컴포넌트의 소스 코드 수정 없는 재사용을 지원하지 않기 때문 에 SOA 서비스 개발 생산성 향상에 기여하지 못하며, 이것은 기업 등 대규모 조직들이 급변하는 외부 환경에 신속하게 대응할 수 있게 해줄 최적의 아키텍처로 각광받고 있는 SOA 체제로의 전환에 큰 장애가 된다.This problem of the conventional component-based technology is applied to other existing reuse methodology as it is affecting. First, in the case of SOA, services that are autonomous modules reflecting business units from the business perspective can be easily reused because they communicate based on standard messages such as XML, but the particles must grow considerably to function autonomously without depending on other services. However, the development of such relatively large particle services as a whole is very inefficient throughout the software lifecycle, from design through implementation and maintenance. Therefore, each service is usually developed in a form that is separated into several smaller object-oriented or component-based modules and combined with each other. In this process, if third-party developed binary components can be reused as a service material, SOA service development productivity will be greatly improved. However, as mentioned above, existing component technologies do not support the reuse of independently developed binary components without modification of source code, which does not contribute to the improvement of SOA service development productivity. An optimal architecture that will enable you to respond quickly is a major obstacle to the transition to SOA systems that are in the spotlight.
의존성 주입(Dependency Injection)은 클라이언트 컴포넌트와 서비스 구현체 사이의 의존성을 제거하여 컴포넌트의 재사용성을 향상시키는 디자인 모델로서, 클라이언트 컴포넌트 대신 컨테이너가 서버 컴포넌트를 인스턴스화하고 그 레퍼런스를 클라이언트 컴포넌트 객체에 주입해주는 방식이다. 이 방식을 사용하면 클라이언트 컴포넌트의 클래스가 서버 컴포넌트의 구현 클래스를 컴파일 타임에 알 필요가 없고 서버 컴포넌트의 식별자를 가지고 있을 필요가 없으므로 컴포넌트 조립이 유연해진다. 그러나 이 모델 역시 종래의 컴포넌트 기술에 적용할 경우 특정 인터페이스 타입을 서비스 호출에 사용하는 클라이언트 컴포넌트는 그 인터페이스 타입을 구현한 서버 컴포넌트들과만 조립이 가능하므로 단일 애플리케이션 내의 버전 교체에 유용할 뿐, 독립적으로 개발되어 인터페이스가 상이한 컴포넌트들의 조립은 불가능하므로 실질적인 컴포넌트 재사용 효과가 미미하다.Dependency Injection is a design model that improves the reusability of components by removing the dependencies between client components and service implementations. Instead of client components, containers instantiate server components and inject their references into client component objects. . This approach provides flexibility in component assembly because the client component's class does not need to know the server component's implementation class at compile time and does not have to have an identifier for the server component. However, if this model is applied to the conventional component technology, client components that use a specific interface type for service invocation can be assembled only with server components that implement the interface type. As it is impossible to assemble components with different interfaces, the actual component reuse effect is insignificant.
특정 애플리케이션 도메인별로 공통 기능 요소를 식별하여 미리 구현해 놓고 가변 요소들만 필요에 따라 개발하는 방식으로 개발 생산성을 높이고자 하는 프로덕트 라인(Product Line) 또는 프레임워크 어프로치(Framewwork Approach)도 컴포넌트 재사용 방법론의 한 예이다. 이 모델은 미리 구현된 컴포넌트 세트를 통째로 사용하고 수요처별 혹은 신규 개발 상품에 추가로 필요한 컴포넌트들만 새로 구현하는 개념이므로, 이미 개발된 컴포넌트들의 재사용 측면에서는 종래의 컴포넌트 기술이 가진 한계와 무관하게 높은 효율성을 보인다. 그러나 이 방식은 도메인 엔지니어링에 대규모 선투자가 필요하므로 처리 업무가 고도로 정형화되어 한 번 개발된 컴포넌트들의 재사용 빈도가 매우 높은 군사, 금융 등 일부 특수 영역에서만 효과를 거둘 수 있으며, 광범위한 일반 영역에 적용하기에는 비현실적, 비경제적인 모델이다. 따라서 범용성이 큰 일반 영역의 상용 컴포넌트 베이스는 인터페이스가 다른 컴포넌트들을 조립하여 쓸 수 있는 방안이 마련된 상태에서 무수한 독립 벤더들이 다양하고 유용한 컴포넌트들을 경쟁적으로 개발, 축적하는 방식으로 자연스럽게 구축되는 것이 현실적이고 바람직하다.Another example of a component reuse methodology is the Product Line or Framework Approach, which seeks to increase development productivity by identifying common functional elements in a specific application domain, pre-implementing them, and developing only the variable elements as needed. to be. This model uses a whole set of pre-implemented components and newly implements only components necessary for each customer or new development product. Therefore, in terms of reuse of already developed components, high efficiency is achieved regardless of the limitations of the conventional component technology. Seems. However, this approach requires large upfront investments in domain engineering, so processing is highly formalized and can only be effective in a few special areas, such as military and finance, where the once-developed components are highly reusable and unrealistic to apply to a wide range of general areas. This is an uneconomical model. Therefore, it is realistic and desirable that commercial component base of general area with general versatility is naturally built by countless independent vendors competitively developing and accumulating various useful components with a method for assembling components with different interfaces. Do.
이상에서 살펴 본 바와 같이 바이너리 컴포넌트의 재사용을 가로막는 가장 큰 장애는 종래의 대표적인 컴포넌트 기술들이 컴포넌트간 연동을 구현함에 있어 클라이언트 컴포넌트가 서버 컴포넌트에 정의된 인터페이스에 일방적으로 의존하도록 한 데 있었다. 그 결과 클라이언트 컴포넌트의 소스 코드에 특정 서버 컴포넌트의 특정 서비스 제공 인터페이스의 고유한 식별자 정보가 내장될 수밖에 없고, 그와 같은 코드를 수정하지 않는 한 컴포넌트들을 본래의 개발 환경 외에서는 재사용할 수 없다. 이런 컴포넌트 구조상의 한계를 극복하고자 등장한 것이 액티브 바인딩 기술(대한민국 특허 등록번호 10-0697246: "컴포넌트 기반 환경 하에서 확장된 메타데이터를 이용한 소프트웨어 개발 방법 및 시스템")이다.As described above, the biggest obstacle to the reuse of binary components has been to allow client components to unilaterally rely on interfaces defined in server components in implementing the inter-component interworking. As a result, unique identifier information of a specific service providing interface of a specific server component may be embedded in the source code of the client component, and the component may not be reused outside the original development environment unless such code is modified. An active binding technology (Korean Patent Registration No. 10-0697246: "Software Development Method and System Using Extended Metadata in a Component-Based Environment") has emerged to overcome this limitation in component structure.
액티브 바인딩 기술은 컴포넌트가 특정 애플리케이션에 종속되는 것을 방지하기 위해 클라이언트 컴포넌트가 특정 서버 컴포넌트의 서비스 제공 인터페이스 타입을 사용하는 코드를 내장하는 대신 서비스 요청에 필요한 정보(메소드 이름, 파라미터/리턴값의 이름, 형식 등)를 개발자가 임의로 정의하고, 이를 토대로 서버 컴포넌트 객체를 호출하는 방식을 사용함으로써 실제로 의존할 서버 컴포넌트에 대한 정보 없이도 내부적으로 완결된 코딩을 가능케 하는 컴포넌트 모델을 제시한다. 이렇게 임의로 정의하여 생성되는 서비스 요청 관련 정보는 커스텀 애트리뷰트 등의 기능을 통해 메타데이터에 포함되어 외부로 노출되며, 실제 서버 컴포넌트와의 조립을 중재할 가상의 서버 컴포넌트인 글루 컴포넌트의 템플릿 코드를 자동 생성하는 기반이 된다. 글루 컴포넌트는 컴포넌트 개발과 별도로 실행되는 조립 과정에서 클라이언트 및 서버 컴포넌트의 메타데이터를 읽어들여 생성되며, 양측 인터페이스 사이의 문법적, 의미적 불일치를 정합, 중재하는 데 사용된다. 이처럼 액티브 바인딩 기술은 컴포넌트의 컴포넌트를 특정 애플리케이션에 종속되지 않는 독립된 부품으로 개발할 수 있게 하고, 이런 부품들을 소스 코드 밖에서 중재, 결합할 수 있게 함으로써 제3자에 의해 독립적으로 개발된 바이너리 컴포넌트의 소스 코드 수정 없는 재사용/조립을 통한 소프트웨어 개발을 가능케 한다.In order to prevent a component from being dependent on a particular application, the active binding technology uses the information required for the service request (method name, parameter / return value name, By defining a format arbitrarily and using a method of calling a server component object based on this, a component model that enables internally complete coding without information on the server component to be actually relied on is presented. The service request-related information generated by defining arbitrarily is included in the metadata through functions such as custom attributes and exposed to the outside, and automatically generates the template code of the glue component, a virtual server component to mediate assembly with the actual server component. It is the basis for Glue components are created by reading metadata of client and server components during assembly, which is executed separately from component development. They are used to match and mediate grammatical and semantic inconsistencies between the two interfaces. As such, active binding technology enables the development of components of a component as independent components that are not dependent on a specific application, and by intervening and combining these components outside the source code, the source code of a binary component independently developed by a third party. Enables software development through re-use / assembly without modification.
그러나 상기와 같은 액티브 바인딩 기술에도 몇 가지 비효율 요소가 존재한다. 우선 컴포넌트 개발 과정에서 개발자에게 익숙한 기존의 표준 프로그래밍 기법 대신 새로운 독자 방식을 채택하고 있다. 임의로 정의된 서비스 요청 관련 정보를 컴포넌트에 내장하기 위해 커스텀 애트리뷰트 등을 이용한 독자적인 방식으로 메타데이터를 확장하는 것이다. 액티브 바인딩 기술 발명 특허에서는 이 과정의 상당 부분을 자동 처리해주는 위저드(Wizard) 형태의 도구를 함께 제공하기 때문에 실행이 간편하고 학습 부담이 적긴 하지만, 개발 환경 변화에 민감한 개발자들에게 여 전히 거부감을 일으킬 수 있고, 코드가 낯설고 복잡해지는 단점이 있다. 이와 더불어 비표준 방식으로 구현된 컴포넌트는 새로운 버전의 플랫폼에서 호환성 문제를 일으킬 수도 있다.However, there are some inefficiencies in such active binding techniques. First of all, in the process of developing a component, it adopts a new proprietary method instead of the existing standard programming techniques familiar to developers. In order to embed arbitrarily defined service request-related information in a component, metadata can be extended in its own way using custom attributes. Active Binding Technology The invention patent comes with a wizard-type tool that automatically handles much of this process, making it easy to implement and less expensive to learn. The disadvantage is that the code becomes unfamiliar and complicated. In addition, components implemented in a nonstandard way may cause compatibility issues on newer versions of the platform.
기존의 액티브 바인딩 기술이 비표준 구현 방식을 채택함에 따라 야기되는 더 중요한 문제는 애플리케이션 실행시 발생하는 성능 저하이다. 객체지향 프로그래밍에서는 의존 관계를 표현하는 실행 코드에서 클래스, 인터페이스 등 특정 타입을 명확히 참조해야 하는데, 액티브 바인딩 기술에서는 선 개발, 후 조립 원칙에 따라 미리 개발된 컴포넌트들을 조립할 때 생성되는 글루 컴포넌트 안에 비로소 클라이언트 컴포넌트가 참조할 서비스 요청 인터페이스 타입이 생성된다. 즉 참조할 타입이 존재하지 않는 상태에서 개발되는 액티브 바인딩 컴포넌트 코드는 인터페이스 타입을 사용하여 글루 컴포넌트 객체의 메소드를 호출할 수 없다. 이 경우 클라이언트 컴포넌트의 글루 컴포넌트 객체에 대한 메소드 호출은 런타임에 리플렉션 등의 기능을 통해 동적으로 실현되며, 이와 같은 동적 결합(Dynamic Binding 또는 Late Binding)은 일반적인 객체지향 프로그래밍의 정적 결합(Static Binding 또는 Early Binding)에 비해 프로그램 실행시 훨씬 큰 성능 부담을 초래한다.The more significant problem caused by traditional active binding technologies adopting nonstandard implementations is the performance degradation that occurs when running applications. In object-oriented programming, specific types, such as classes and interfaces, must be clearly referenced in executable code that expresses dependencies. In active-binding technology, clients can only be built into glue components generated when assembling pre-developed components according to pre-development and post-assembly principles. The service request interface type is created for the component to reference. That is, active-binding component code developed without a type to refer to cannot call a method of a glue component object using an interface type. In this case, the method invocation on the glue component object of the client component is realized dynamically at runtime, such as by reflection, and such dynamic binding (Dynamic Binding or Late Binding) is a static binding of general object-oriented programming (Static Binding or Early). Compared to Binding, it causes much bigger performance burden when running the program.
액티브 바인딩 컴포넌트의 비표준 구현 방식으로 인해 야기되는 또 하나의 문제는 버전 교체의 용이성뿐 아니라 성능 향상, 간결한 코딩에도 장점을 가진 의존성 주입 모델을 적용할 수 없다는 점이다. 이 역시 액티브 바인딩 컴포넌트 개발시 참조할 타입이 존재하지 않는다는 점에서 기인하는 것으로, 의존성 주입 모델도 실행 코드 내에 특정 인터페이스 타입에 대한 의존 관계가 명시되어 있어야 사용 가능한 객체지향 프로그래밍 기반 기술이기 때문이다. 의존성 주입 모델에 따라 컴포넌트 객체의 생성과 풀링을 컨테이너에 맡기게 되면 객체 생성 관련 코드를 작성할 필요가 없으므로 코딩이 간결해지고, 생성된 객체의 효율적인 관리에 따라 시스템 자원 사용의 효율성이 향상될 뿐 아니라, 클라이언트 컴포넌트 객체에 필요한 서버 컴포넌트 객체를 컨테이너가 할당해줌에 따라 버전이 다른 서버 컴포넌트와의 조립이 자유로워지기 때문에 동 기술은 자바의 최신 미들웨어 규격인 EJB 3.0에서 표준으로 채택하는 등 크게 각광받고 있다. 컴포넌트 재사용성 측면에서는 인터페이스가 일치하는 서버 컴포넌트의 버전 교체에 그치는 의존성 주입 모델에 비해 독립적으로 개발된 바이너리 컴포넌트의 자유로운 조립을 지원하는 액티브 바인딩 기술의 효용성이 월등하지만, 의존성 주입 모델이 제공하는 간결한 코딩과 성능 향상 효과를 이용할 수 없다는 점은 상당한 제약이라고 할 수 있다.Another problem caused by non-standard implementations of active-binding components is the inability to apply dependency injection models that not only facilitate version replacement, but also improve performance and streamline coding. This is also due to the fact that there is no type to refer to when developing an active binding component, because the dependency injection model is an object-oriented programming-based technology that can be used only when a dependency on a specific interface type is specified in the executable code. According to the dependency injection model, entrusting the creation and pooling of component objects to the container eliminates the need to write code related to object creation, which simplifies coding and improves the efficiency of using system resources through efficient management of the created objects. As the container assigns the server component object required for the component object, assembling with different server components becomes free, the technology is widely adopted as the standard in Java 3.0's latest middleware standard, EJB 3.0. In terms of component reusability, the active binding technology, which supports free assembly of independently developed binary components, is superior to the dependency injection model that only replaces the version of the server component with matching interface, but the simple coding provided by the dependency injection model. The lack of performance gains is a significant limitation.
상기 종래 기술의 현황에서 살펴본 바와 같이 종래의 객체지향 프로그래밍 기반 컴포넌트 기술들은 컴포넌트의 자유로운 조립과 재사용보다는 애플리케이션 단위의 타입 안정성 및 개발 효율에 주안점을 둠으로써 코딩의 간결성, 직관성과 동일 프로젝트 내의 일관성, 효율성은 얻을 수 있지만 컴포넌트의 완전 부품화와 이들의 조립 생산을 통한 소프트웨어 개발 생산성 제고라는 CBD 본연의 이상에서는 멀어져 왔다. 반면 이러한 종래의 컴포넌트 기술들의 결함을 보완하고자 제안된 액티브 바인딩 기술은 컴포넌트의 개발과 조립을 별도의 공정으로 분리해야 한다는 원칙에 입각하여 다른 특정 컴포넌트에 직접 의존하지 않는 완전히 독립된 부품에 가까운 컴포넌트들을 구현하고 이들을 조립, 재사용하는 방법을 제시하고 있지만 비표준 프로그래밍 방식을 채택함으로써 학습, 코딩, 성능, 호환성 면에서 새로운 부담을 야기한다.As described in the state of the art, conventional object-oriented programming-based component technologies focus on type stability and development efficiency of an application unit rather than free assembly and reuse of components, thereby simplifying coding, intuition and consistency and efficiency within the same project. Can be attained, but it is far from the CBD's inherent ideal of improving software development productivity through complete component parts and their assembly production. On the other hand, the active binding technology proposed to compensate for the deficiencies of the conventional component technologies implements components that are completely independent parts that do not directly depend on other specific components, based on the principle that the development and assembly of components must be separated into separate processes. And how to assemble and reuse them, but adopting a nonstandard programming approach creates new burdens on learning, coding, performance, and compatibility.
이에 본 발명에서는 기존의 액티브 바인딩 기술이 추구하는 컴포넌트 재사용성 제고라는 목표와 그 실천 방안으로서 컴포넌트 개발과 조립 공정을 분리하고 컴포넌트를 완전 부품화해야 한다는 대원칙은 거시적 차원에서 소프트웨어 생산성 향상을 위해 올바른 방향이므로 그대로 유지하는 한편, 동 기술이 채택하고 있는 독자적인 컴포넌트 구현 방식으로 인해 야기되는 부정적 효과들을 해소하기 위해 객체지향 프로그래밍 표준 방식인 인터페이스 타입 정의를 이용하여 보완된 액티브 바인딩 컴포넌트를 구현하는 방법을 제공하는 것을 제1 목적으로 삼는다.Therefore, in the present invention, the goal of improving component reusability that the existing active binding technology pursues and the principle of separating the component development and assembly process and fully componentizing it as a practical method are the right directions for improving the software productivity at the macro level. It provides a way to implement complementary active binding components using interface type definitions, an object-oriented programming standard, to eliminate the negative effects caused by the proprietary component implementation adopted by the technology. Make it a primary purpose.
본 발명의 제2 목적은 상기 제1 목적에 부가하여 보완된 액티브 바인딩 컴포넌트 객체들의 조립에 의존성 주입 모델을 적용함으로써 코딩과 조립을 더욱 간편하게 하고, 실행 성능을 향상시키며, 최신 미들웨어들과 호환되면서 그 장점을 최대한 활용할 수 있는 방법을 제공하는 데 있다.The second object of the present invention is to simplify the coding and assembly, improve execution performance, and be compatible with the latest middleware by applying a dependency injection model to the assembly of active binding component objects which is supplemented in addition to the first object. It's about providing a way to make the most of the benefits.
상기 목적을 달성하기 위하여 본 발명은, 객체지향 컴포넌트 기반 소프트웨어 개발에 있어 다른 특정 컴포넌트에 종속되지 않는 완전 부품화된 컴포넌트를 구현하는 방법; 글루 컴포넌트를 이용하여 상기 컴포넌트들을 조립하는 방법; 상기 컴포넌트들의 조립을 통해 작성된 애플리케이션 실행시 프레임워크가 객체 생성과 의존성 주입을 담당케 하는 방법을 제시하고 있다. In order to achieve the above object, the present invention provides a method for implementing a fully componentized component that does not depend on other specific components in object-oriented component-based software development; Assembling the components using glue components; It presents a way for the framework to take care of object creation and dependency injection when executing applications created by assembling the above components.
이 중에서 상기 컴포넌트 구현 방법은 다른 컴포넌트의 서비스가 필요할 때 그 컴포넌트의 서비스 제공 인터페이스에 직접 의존하는 코드를 작성하는 대신 서비스 요청 인터페이스 타입을 정의하는 단계; 개발중인 컴포넌트와 그 서버 컴포넌트의 조립시 생성되어 이들의 인터페이스 불일치를 중재하는 데 사용되는 글루 컴포넌트의 객체 레퍼런스를 수용하기 위한 필드와 이 필드로의 접근 통로인 속성을 선언하고 필드 변수를 사용하는 서비스 호출 코드를 완성하는 단계; 상기 인터페이스 정보를 메타데이터에 내포하는 단계를 포함하는 것을 특징으로 한다.Among these, the component implementation method may further include defining a service request interface type when writing a service that directly depends on a service providing interface of the component when a service of another component is required; A service that uses field variables and declares fields to hold object references of glue components, which are created during assembly of the developing component and its server components, and used to mediate their interface inconsistencies, as well as access paths to these fields. Completing the calling code; And embedding the interface information in the metadata.
상기 컴포넌트 조립 방법은 조립될 컴포넌트들 중에서 클라이언트 컴포넌트에서는 서비스 요청 인터페이스 정보를, 서버 컴포넌트에서는 서비스 제공 인터페이스 정보를 읽어 서로 연결될 호출/피호출 메소드를 식별하는 단계; 상기 컴포넌트들의 인터페이스 불일치를 정합할 글루 컴포넌트의 프로젝트를 생성하고 그 안에 서비스 요청 인터페이스를 구현할 클래스를 생성하는 단계; 상기 클래스 내에 서버 컴포넌트의 객체 레퍼런스를 할당받는데 필요한 필드와 속성을 선언하고 이를 이용하여 피호출 메소드를 호출하는 코드를 작성하는 단계; 상기 호출/피호출 메소드의 시그너처가 구문적 또는 의미론적으로 일치하지 않는 경우 이를 중재하는 코드를 작성하여 상기 클래스 내에 삽입하는 단계; 상기 글루 프로젝트를 컴파일하여 글루 컴포넌트를 생성하는 단계; 상기 클라이언트/서버/글루 컴포넌트간 의존 정보를 의존성 주입 프레임워크 형식에 따라 컴포넌트 배치 구성 파일로 작성하는 단계를 포 함하는 것을 특징으로 한다.The method of assembling the component may include identifying service call interface information in a client component and service call interface information in a server component, and calling / calling methods to be connected to each other among components to be assembled; Creating a project of a glue component to match interface mismatches of the components and creating a class therein to implement a service request interface; Declaring a field and a property required to be assigned an object reference of a server component in the class and using the same, writing code to call a called method; Writing code to intervene if the signature of the call / call method does not syntactically or semantically match and insert into the class; Compiling the glue project to generate a glue component; And writing the dependency information between the client / server / glu components into a component deployment configuration file according to a dependency injection framework format.
상기 의존성 주입 프레임워크를 이용한 소프트웨어 실행 방법은 프레임워크 외부의 클라이언트에서 서비스를 요청하면 프레임워크가 컴포넌트 배치 구성 파일을 읽어 그 서비스 처리에 관여하는 컴포넌트들(글루 컴포넌트 포함)을 식별하는 단계; 상기 식별된 컴포넌트들을 서비스 처리 경로의 최종단에 위치하는 컴포넌트로부터 외부 클라이언트가 요청한 메소드를 제공하는 최상단 컴포넌트에 이르기까지 서버-글루-클라이언트 방향으로 순차적으로 객체를 생성하고 그 레퍼런스를 전달하는 단계; 상기 최상단 컴포넌트의 객체 레퍼런스를 외부 클라이언트에 전달하는 단계를 포함하는 것을 특징으로 한다.The method for executing software using the dependency injection framework may include: when a client requests a service from a framework outside the framework, the framework reads a component configuration file to identify components (including glue components) involved in processing the service; Creating the objects sequentially in the server-glu-client direction from the components located at the end of the service processing path to the top components providing methods requested by an external client and passing a reference thereof; And forwarding an object reference of the uppermost component to an external client.
상기와 같은 본 발명의 소프트웨어 개발 및 실행 방법은 독립적으로 개발된 바이너리 컴포넌트의 재사용을 통한 소프트웨어 개발 생산성 향상이라는 기존의 액티브 바인딩 기술의 기본 사상과 구현 방법을 상당 부분 원용하고 있으나 다음과 같은 중요한 차이를 나타낸다.The software development and execution method of the present invention uses the basic idea and implementation method of the existing active binding technology to improve software development productivity by reusing independently developed binary components. Indicates.
첫째, 컴포넌트 구현에 있어서 서비스 요청 인터페이스(기존 액티브 바인딩 기술에서는 클라이언트측 인터페이스로 부름)의 정의 방법과 그 인터페이스가 존재하는 장소를 변경하였다. 종래의 일반적인 컴포넌트 기술들에서는 각 컴포넌트가 서비스 제공 인터페이스 타입 정의를 내장하고 있을 뿐, 별도로 정의된 서비스 요청 인터페이스 명세 또는 타입 정의 없이 서버 컴포넌트의 서비스 제공 인터페이스 타입을 참조하여 사용하는 코드를 내장하는 방식을 취한다.First, in the component implementation, we changed the definition of the service request interface (called client-side interface in the existing active binding technology) and the location of the interface. In the conventional general component technologies, each component embeds a service providing interface type definition, and a method of embedding code used by referring to the service providing interface type of the server component without a separately defined service request interface specification or type definition. Take it.
이에 비해 기존 액티브 바인딩 기술에서는 각 컴포넌트가 다른 컴포넌트에 요청할 서비스에 대해 개발자가 독자적으로 임의의 시그너처를 정하여 코딩에 사용하고, 이를 커스텀 애트리뷰트 등의 기능을 통해 서비스 요청 인터페이스를 명세화하여 메타데이터에 포함시키는 방식을 취한다. 클라이언트 컴포넌트의 메타데이터에 포함된 서비스 요청 인터페이스의 명세는 글루 컴포넌트 객체로 생성되면서 비로소 호출 가능한 타입이 된다. 따라서 기존 액티브 바인딩 기술 기반의 각 컴포넌트(글루 컴포넌트 제외)는 메타데이터에 서비스 제공 인터페이스의 명세와 서비스 제공 인터페이스 명세를 내장한다.On the other hand, in the existing active binding technology, the developer independently sets a random signature for a service that each component requests from another component and uses it for coding, and specifies the service request interface through metadata such as custom attributes and includes it in the metadata. Take the way. The specification of the service request interface included in the metadata of the client component is created as a glue component object and becomes a callable type. Therefore, each component (except glue component) based on the existing active binding technology embeds the specification of the service providing interface and the specification of the service providing interface in metadata.
반면 본 발명에서는 개발자가 독자적으로 서비스 요청 인터페이스 타입을 정의하여 코드에 내장하고, 그 인터페이스의 메소드를 서비스 호출 코드에 사용하며, 컴파일시 그 명세가 메타데이터에 자동 생성되도록 하는 방식을 취하고 있다. 따라서 본 발명 기반의 각 컴포넌트(글루 컴포넌트 제외)는 코드에 서비스 요청 인터페이스 타입을 내장하고, 메타데이터에 서비스 제공 인터페이스 명세와 서비스 요청 인터페이스 명세를 내장한다.On the other hand, in the present invention, the developer independently defines a service request interface type and embeds it in the code, uses the method of the interface in the service call code, and takes the method of automatically generating the specification in metadata when compiling. Therefore, each component (except glue component) based on the present invention embeds a service request interface type in code and a service provision interface specification and a service request interface specification in metadata.
이와 같이 독자적인 서비스 요청 인터페이스의 보유 여부와 형태가 달라지면 프로그래밍 패턴에도 자연히 큰 변화가 따르는데, 구체적으로는 바이너리 컴포넌트의 재사용, 개발 순서상의 제약, 코딩과 학습 부담, 프레임워크 활용, 실행 성능 등의 측면에 영향을 미치며, 이에 대해서는 발명의 효과에서 상술하기로 한다.Such a change in the type and possession of a unique service request interface naturally changes the programming pattern. Specifically, the reuse of binary components, constraints on development order, coding and learning burden, framework utilization, and execution performance It affects, and will be described in detail in the effect of the invention.
둘째, 컴포넌트 조립 방법에 있어서는 컴포넌트 구현 방법의 변화에 따라 글루 컴포넌트 내에 서비스 요청 인터페이스 타입을 정의하는 단계가 생략되고, 역시 컴포넌트 구현 방법의 차이의 의해 프레임워크의 의존성 주입 기능을 활용할 수 있 게 됨에 따라 이를 수용하기 위하여 컴포넌트 배치 구성 파일을 작성하는 절차가 추가되는 변화가 발생한다. 그러나 글루 컴포넌트를 통해 상이한 인터페이스를 중재하여 클라이언트 컴포넌트와 서버 컴포넌트를 조립하는 근본적 방식은 그대로 유지되며, 절차의 생략과 추가로 인한 조립 부담의 차이는 미미하다고 할 수 있다.Second, in the method of assembling the component, the step of defining the service request interface type in the glue component is omitted according to the change in the method of implementing the component, and the dependency injection function of the framework can be utilized due to the difference in the method of implementing the component. To accommodate this, a change occurs that adds a procedure for creating a component deployment configuration file. However, the basic way of assembling client and server components by mediating different interfaces through glue components remains the same, and the difference in assembly burden due to the omission and addition of procedures is insignificant.
셋째, 소프트웨어 실행 방법에 있어서 기존 액티브 바인딩 기술에서는 고려되지 않았던 프레임워크의 의존성 주입 기능 활용이 추가되었다. 이는 컴포넌트 구현 방법상의 변화에서 언급한 대로 각 컴포넌트 내에 서비스 요청 인터페이스 타입을 정의함으로써 가능해진 변화이며, 이와 같은 최신 미들웨어 기술과의 접목이 초래하는 긍정적 영향도 발명의 효과에서 언급하기로 한다.Third, the use of the dependency injection function of the framework, which was not considered in the existing active binding technology, was added to the software execution method. This is a change made possible by defining a service request interface type in each component, as mentioned in the change in component implementation method, and the positive effect caused by the integration with the latest middleware technology will be mentioned in the effect of the present invention.
이하에서는 첨부된 도면을 참조하여 본 발명에 따른 소프트웨어 개발 방법 및 실행 방법을 상세히 설명하기로 한다.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.
도 1a는 종래의 컴포넌트 기술 기반에서 애플리케이션을 설계할 때 컴포넌트 다이어그램에 나타나는 컴포넌트 조립의 논리 모델로서, 클라이언트 컴포넌트(110)의 서비스 요청 인터페이스(111)와 서버 컴포넌트(120)의 서비스 제공 인터페이스(121)가 맞물려 서비스를 주고 받는 것으로 표시하고 있다.FIG. 1A is a logical model of component assembly shown in a component diagram when designing an application based on a conventional component technology. The
그러나 상용 컴포넌트 기술을 사용하여 실제로 컴포넌트간 의존 관계를 구현할 때는 도 1b의 물리 모델에 나타난 바와 같이 클라이언트 컴포넌트(110)가 독립적으로 서비스 요청 인터페이스를 독립적으로 정의하여 사용하는 것이 아니라 서버 컴포넌트(120)에 내장된 서비스 제공 인터페이스(121) 타입을 사용하여 서버 컴포넌트 객체(122)의 메소드를 호출한다. 실제 프로그래밍 환경에서 컴포넌트간 의존 관계가 도 1b와 같이 구현될 수밖에 없는 이유는, 타입 안정성을 중시하는 기존 상용 컴포넌트 기술들이 인터페이스를 타입으로 간주하여 동일한 식별자(Full Name)를 가진 인터페이스가 물리적으로 한 곳 이상에서 정의되는 것을 허용하지 않고, 특정 인터페이스 구현 객체의 레퍼런스를 다른 식별자를 갖는 인터페이스의 변수에 배정하는 것을 허용하지 않기 때문이다. 따라서 이런 방식으로 구현된 클라이언트 컴포넌트는 외부에 정의되어 있는 인터페이스에 의존하는 코드를 내장하기 때문에 도 1b처럼 서버 컴포넌트와 정적으로 단단히 결합되며, 소스 코드 수정 없이는 다른 환경에서 독립적으로 재사용될 수 없다.However, when using a commercial component technology to actually implement the dependencies between components, as shown in the physical model of FIG. 1B, the
도 2a는 본 발명에 따라 구현된 컴포넌트의 구조를 나타낸다. 이 컴포넌트(210)는 컴포넌트의 개발과 조립을 별개의 공정으로 분리하고, 이미 개발되어 독립된 부품으로 존재하는 컴포넌트들을 획득/조립하여 새로운 소프트웨어를 작성할 수 있으려면 다른 특정 컴포넌트와의 조립에 대한 어떤 가정이나 메타 정보, 코드도 내포하지 않아야 한다는 원칙에 입각하여, 도 2a처럼 서비스 제공 인터페이스 타입(221)뿐 아니라 독자적으로 정의한 서비스 요청 인터페이스 타입(212)도 자체 내에 포함하여 다른 컴포넌트의 서비스가 필요할 때 그 컴포넌트의 서비스 제공 인터페이스에 의존하지 않고 스스로 내장하고 있는 서비스 요청 인터페이스 타입(221)을 사용하여 서비스 호출 코드를 완성하는 것을 특징으로 한다.2A shows the structure of a component implemented in accordance with the present invention. This
도 2b는 현존하는 대표적 객체지향 컴포넌트 플랫폼 중 하나인 닷넷 프레임워크(.NET Framework) 상에서 본 발명에 따라 닷넷 컴포넌트(어셈블리)를 확장한 컴포넌트를 구현했을 때 생성되는 컴포넌트 파일의 구조를 보여준다. 종래의 닷넷 컴포넌트 파일은 개발자 정보, 의존하는 컴포넌트의 식별자, 버전 번호 등을 포함하는 컴포넌트 차원의 메타데이터인 매니페스트(310), 컴포넌트가 구현한 서비스 제공 인터페이스(221)와 클래스 등 타입에 관한 정보(321)를 담고 있는 타입 메타데이터(320), 컴파일된 실행코드(330), 비트맵, 스트링 같은 리소스(340)로 구성되어 있다. 이에 비해 닷넷 컴포넌트를 확장한 본 발명에 따른 컴포넌트는 타입 메타데이터(320)에 서비스 요청 인터페이스 타입(212)의 정보(322)가 더 포함되어 있다.FIG. 2B illustrates the structure of a component file generated when a component that extends a .NET component (assembly) according to the present invention is implemented on the .NET Framework, which is one of the representative object-oriented component platforms. Conventional .NET component files include a
도 3은 상기 본 발명에 따른 컴포넌트를 개발하는 절차(S1)를 나타낸 일 흐름도이다. 그 절차는 다음과 같다. 종래의 객체지향 컴포넌트 기반 기술에 따라 컴포넌트를 개발하는 과정(S11)에서 다른(서버) 컴포넌트의 서비스가 필요하면(S12) 그 서버 컴포넌트에 정의된 서비스 제공 인터페이스에 의존하는 대신 개발중인 컴포넌트 내에 서비스 요청 인터페이스 타입을 정의한다(S13). 이와 함께, 상기 개발중인 컴포넌트와 상기 서버 컴포넌트를 조립할 때 생성되어 두 컴포넌트간의 인터페이스 불일치를 중재하는 데 사용되는 글루 컴포넌트 객체의 레퍼런스를 수용할 필드와 그 필드에 접근하는 통로인 속성을 상기 서비스 호출 코드를 포함하는 클래스 내에 선언하고(S14), 선언된 필드의 변수를 이용하여 상기 서비스 호출 코드를 완성한다(S15). 이러한 과정을 거쳐 작성된 코드를 컴파일하면 서비스 요청 인터페이스 정보(323)가 타입 메타데이터(320)에 포함된 도 2b와 같은 파일 구조의 컴포넌트가 생성된다(S16).3 is a flowchart illustrating a procedure S1 of developing a component according to the present invention. The procedure is as follows. If a service of another (server) component is needed in the process of developing a component according to the conventional object-oriented component-based technology (S11) (S12), instead of relying on the service providing interface defined in the server component, a service request is made in the component under development. An interface type is defined (S13). In addition, the service call code is a property that is generated when assembling the component under development and the server component, and a field for receiving a reference to the glue component object used to mediate an interface mismatch between the two components and a property for accessing the field. Declare in a class containing (S14), and completes the service call code by using the variable of the declared field (S15). Compiling the code created through this process generates a file structure component as shown in FIG. 2B in which the service request interface information 323 is included in the type metadata 320 (S16).
한편 도 3의 절차에 따라 서비스 요청 인터페이스 타입을 정의하는 과 정(S13)에서 타입 정의에 커스텀 애트리뷰트 등의 기능을 이용하여 서비스 요청 인터페이스임을 나타내는 주석을 부가함으로써 메타데이터에 포함되는 서비스 요청 인터페이스와 서비스 제공 인터페이스 정보를 쉽게 구분할 수 있도록 할 수 있다.Meanwhile, in the process of defining the service request interface type according to the procedure of FIG. 3, the service request interface and the service included in the metadata are added to the type definition by adding an annotation indicating that the service request interface is used using a function such as a custom attribute. The interface information provided can be easily distinguished.
또한 도 3의 절차에 따라 서비스 호출 코드를 작성하는 과정(S15)에서 작성중인 코드가 개발중인 컴포넌트의 서비스 제공 인터페이스에 속한 메소드를 구성하는 경우, 해당 메소드가 자신의 서비스를 수행하기 위해 의존하는 서비스 요청 인터페이스에 속한 메소드들의 이름을 커스텀 애트리뷰트 등의 기능을 이용하여 호출 순서대로 동 메소드에 주석으로 부가하여 컴포넌트간 상호작용을 나타내는 프로토콜 정보를 메타데이터에 포함시킴으로써 차후 컴포넌트 조립 작업시 컴포넌트간 상호작용을 에러 없이 구현하는 것을 지원할 수 있다.In addition, in the process of writing the service call code according to the procedure of FIG. 3, when the code being written composes a method belonging to the service providing interface of the component under development, the service that the method depends on to perform its own service. By adding the names of methods belonging to the request interface to the methods in the order of invocation using functions such as custom attributes, the protocol information indicating the interaction between components is included in the metadata so that the interaction between components can be performed in future component assembly work. Can support implementation without errors.
또한 도 3의 절차에 따라 서비스 요청 인터페이스를 정의하는 과정(S13) 및 서비스 호출 코드를 작성하는 과정(S15)에서 커스텀 애트리뷰트 등의 기능을 이용하여 각 인터페이스와 메소드에 불변식(Invariant), 선행조건(Pre-condition), 사후조건(Post-condition)을 기술한 의미론적 행위 주석 및 시그너처 구문 주석을 부가하고 이를 메타데이터에 포함시킴으로써 차후 컴포넌트 조립 작업시 정밀한 조립 대상 메소드 식별과 정확한 중재 코드 작성을 지원할 수 있다.Also, in the process of defining a service request interface according to the procedure of FIG. 3 (S13) and the process of writing a service call code (S15), invariants and preconditions are applied to each interface and method using functions such as custom attributes. (Pre-condition) and post-condition semantic behavior comments and signature syntax comments are added and included in the metadata to support precise assembly target method identification and accurate intervention code writing in future component assembly work. Can be.
도 4는 본 발명에 따라 독립적으로 개발된 두 개의 컴포넌트가 클라이언트와 서버 관계로 조립되는 구조를 나타낸 것이다. 본 발명에서는 컴포넌트 조립은 컴포넌트 소스 코드를 전혀 수정하지 않고 컴포넌트 외부에서 이루어져야 한다는 원칙에 입각하여, 클라이언트 컴포넌트(210)가 내장하고 있는 서비스 요청 인터페이스 타입에 대한 메타데이터(322)와 서버 컴포넌트(220)가 내장하고 있는 서비스 제공 인터페이스 타입에 대한 메타데이터(321)를 이용하여 글루 컴포넌트(230)에 서비스 요청 인터페이스(212)를 구현하는 글루 클래스(231)를 생성하고, 이를 통해 조립되는 컴포넌트들(210, 220) 사이의 메소드 호출/피호출을 중재한다.4 illustrates a structure in which two components independently developed according to the present invention are assembled in a client and server relationship. In the present invention, based on the principle that the component assembly should be done outside the component without modifying the component source code at all, the
도 5는 본 발명에 따라 개발된 컴포넌트들을 조립하는 절차(S2)를 나타낸 일 흐름도이다. 그 절차는 다음과 같다. 조립될 두 컴포넌트 중 클라이언트 컴포넌트의 메타데이터에서는 서비스 요청 인터페이스 정보를, 서버 컴포넌트의 메타데이터에서는 서비스 제공 인터페이스 정보를 읽어내(리플렉션) 상호 연결될 호출 메소드와 피호출 메소드를 식별한다(S21). 이어서 두 컴포넌트의 인터페이스 불일치를 정합할 글루 컴포넌트의 프로젝트를 생성하고(S22), 이 글루 프로젝트 내에 앞에서 식별된 호출 메소드를 포함하고 있는 서비스 요청 인터페이스 타입을 구현하는 클래스를 생성한다(S23). 이어서 생성된 클래스 내에 서버 컴포넌트의 객체 레퍼런스를 수용할 필드와 이 필드의 접근 통로인 속성을 선언한다(S24). 만일 호출 메소드와 피호출 메소드의 시그너처가 구문적 또는 의미론적으로 일치하지 않는 경우 이를 중재하는 코드를 작성하여 상기 클래스 내에 삽입한다(S25). 상기 단계 S24에서 선언된 필드의 변수를 이용하여 서버 컴포넌트의 피호출 메소드를 호출하는 코드를 작성한다(S26). 이상과 같은 과정을 통해 글루 프로젝트가 완성되면 이를 컴파일하여 글루 컴포넌트를 생성한다(S27). 글루 컴포넌트 생성 후 클라이언트, 서버, 글루 컴포넌트간의 의존 정보를 추후 완성된 애플리케이션 실행시 의존성 주입을 실행할 프레임워크가 규정한 형식에 따라 컴포넌트 배치 구성 파일로 작성한다(S28).5 is a flowchart illustrating a procedure S2 of assembling components developed according to the present invention. The procedure is as follows. Among the two components to be assembled, the service component interface information is read in the metadata of the client component and the service provision interface information is read (reflected) in the metadata of the server component to identify the calling method and the called method to be interconnected (S21). Subsequently, a project of the glue component to match the interface mismatch between the two components is generated (S22), and a class that implements the service request interface type including the calling method identified above in the glue project is generated (S23). Subsequently, a field to receive an object reference of the server component and a property that is an access path of the field are declared in the generated class (S24). If the signatures of the calling method and the called method do not match syntactically or semantically, a code for arbitrating them is created and inserted into the class (S25). Using the variable of the field declared in step S24, a code for calling a called method of a server component is created (S26). When the glue project is completed through the above process, the glue component is compiled to generate the glue component (S27). After the glue component is generated, dependency information between the client, server, and glue components is created in a component configuration file according to a format defined by a framework that will execute dependency injection when executing a completed application later (S28).
한편 도 5의 절차에 따라 호출 메소드와 피호출 메소드를 식별하는 과정(S21)에서 호출 메소드가 의존하는 피호출 메소드에 대한 프로토콜 메타데이터가 부가되어 있는 경우 이를 기반으로 서비스 요청 인터페이스에 속한 메소드들을 호출 순서대로 표시해줌으로써 컴포넌트 조립시 컴포넌트간 상호작용을 에러 없이 구현하는 것을 지원할 수 있다.Meanwhile, in the process of identifying the calling method and the called method according to the procedure of FIG. 5, when protocol metadata of the called method on which the calling method depends is added, the methods belonging to the service request interface are called based on this. By displaying them in order, you can support the component-free interaction between components when assembling them.
도 6은 본 발명에 따라 개발되고 조립된 컴포넌트들에 대해 런타임에 프레임워크가 의존성을 주입하는 방식을 나타낸 것이다. 이 모델에서는 프레임워크(410)의 조립 모듈(411)이 서버 컴포넌트(220)의 객체(223), 글루 컴포넌트(230)의 객체(231), 클라이언트 컴포넌트(210)의 객체(213)를 각각 생성하고, 서버 컴포넌트 객체의 레퍼런스를 글루 컴포넌트의 속성에, 글루 컴포넌트 객체의 레퍼런스를 클라이언트 컴포넌트 객체의 속성에 순차적으로 주입함으로써 독립적으로 개발된 컴포넌트들의 상호작용을 가능케 한다.6 illustrates how the framework injects dependencies at run time for components developed and assembled according to the present invention. In this model, the
도 7은 본 발명에 따라 개발된 소프트웨어를 실행할 때 프레임워크가 컴포넌트간 의존성을 주입하는 절차(S3)를 나타낸 일 흐름도이다. 그 절차는 다음과 같다. 사용자 인터페이스 등 프레임워크 밖의 클라이언트가 서비스를 요청하면(S31) 프레임워크가 컴포넌트 배치 구성 파일을 읽어 요청된 서비스 처리에 관여하는 모든 컴포넌트(글루 컴포넌트 포함)를 식별한다(S32). 이어서 식별된 컴포넌트 중 다른 컴포넌트에 의존하지 않는 최종단의 컴포넌트를 서버 컴포넌트로, 그 컴포넌트의 메소드를 호출하는 컴포넌트를 클라이언트 컴포넌트로 설정하고 이들을 중재하는 글루 컴포넌트를 식별한다(S33). 식별된 클라이언트, 서버, 글루 컴포넌트의 객 체를 생성한다(S34). 서버 객체 레퍼런스를 글루 객체의 속성에 전달한다(S35). 글루 객체 레퍼런스를 클라이언트 객체의 속성에 전달한다(S36). 글루 객체 레퍼런스를 전달받은 클라이언트 객체가 외부 클라이언트가 요청한 서비스 메소드를 제공하는 최상단 컴포넌트인지를 검사하여(S37) 아니면 이 컴포넌트를 서버 컴포넌트로 하는 새로운 서버-글루-클라이언트 컴포넌트 관계를 식별하고(S38) 이들 컴포넌트에 대해 객체 레퍼런스 전달 과정(S34~S36)을 반복한다. 이상과 같은 의존성 주입 프로세스가 최상단 컴포넌트에 이르면 최상단 컴포넌트 객체의 레퍼런스를 외부 클라이언트에 전달한다(S39).7 is a flowchart illustrating a procedure S3 of injecting dependency between components when a framework executes software developed according to the present invention. The procedure is as follows. When a client outside the framework, such as a user interface, requests a service (S31), the framework reads a component configuration file to identify all components (including glue components) involved in processing the requested service (S32). Subsequently, a final component that does not depend on other components among the identified components is set as a server component, and a component that calls a method of the component is set as a client component, and a glue component that mediates them is identified (S33). Create an object of the identified client, server, glue component (S34). The server object reference is transmitted to the attribute of the glue object (S35). The glue object reference is transmitted to the property of the client object (S36). Examine whether the client object passed the glue object reference is the highest component that provides the service method requested by the external client (S37) or identify a new server-glu-client component relationship that uses this component as the server component (S38). The object reference passing process (S34 ~ S36) is repeated for the component. When the dependency injection process reaches the uppermost component, the reference of the uppermost component object is transmitted to the external client (S39).
한편 본 발명에서 글루 컴포넌트는 기본적으로 클라이언트 컴포넌트와 서버 컴포넌트간의 인터페이스 불일치를 중재하는 역할을 담당하지만, 컴포넌트 사이의 모든 메소드 호출/피호출이 글루 컴포넌트를 통해서 이루어지므로 글루 컴포넌트가 서버 컴포넌트의 메소드를 호출하기 직전과 직후에 프레임워크의 세팅 정보를 참조하여 보안, 트랜잭션, 모니터링 등 프레임워크가 제공하는 미들웨어 서비스를 수행하도록 할 수 있다. 이 방법은 프로그램 실행시 서버 컴포넌트의 프록시를 동적으로 생성하여 메소드 호출 직전과 직후에 프레임워크를 참조하게 하는 종래의 미들웨어 기술과 달리 이미 정적으로 컴파일된 글루 컴포넌트를 사용하므로 성능 부담을 크게 줄여준다.Meanwhile, in the present invention, the glue component basically plays a role of mediating an interface mismatch between the client component and the server component, but since all method calls / calls between the components are made through the glue component, the glue component calls a method of the server component. Just before and after the following, the setting information of the framework may be referred to to perform the middleware service provided by the framework, such as security, transaction, and monitoring. This method significantly reduces the performance burden by using glue components that are already statically compiled, unlike traditional middleware technology, which dynamically creates a proxy for a server component when the program is executed, to refer to the framework immediately before and after a method call.
이하에서는 본 발명에 따른 소프트웨어 개발 방법과 실행 방법을 현존하는 대표적 개발 플랫폼 중 하나인 마이크로소프트사의 닷넷 프레임워크에 적용한 양호한 일 실시 예를 상술하기로 한다.Hereinafter, a preferred embodiment of applying the software development method and the execution method according to the present invention to the .NET framework of Microsoft Corporation, which is one of the existing representative development platforms, will be described in detail.
상기 양호한 일 실시 예에서는, Cheeseman-Daniel의 저명한 CBD 방법론(UML Components: A Simple Process for Specifying Component - Based Software . Addison-Wesley, 2001)에서 사용된 호텔 예약 시스템을 모델로 하여, 본 발명에 따라 인터페이스가 상이한 클라이언트 컴포넌트와 서버 컴포넌트를 구현하고, 이들의 상이한 인터페이스를 정합하는 글루 컴포넌트를 통하여 조립한 후, 프레임워크에 서버, 글루, 클라이언트 컴포넌트의 객체 생성과 이들 사이의 의존성 주입을 위임하기 위한 컴포넌트 배치 구성 파일을 작성하는 과정을 도면을 참조하여 상술한다.In one preferred embodiment, Cheeseman-Daniel's prominent CBD methodology ( UML Components: A Simple Process for Specifying Component - Based Software . Modeling the hotel reservation system used in Addison-Wesley, 2001), the framework implements client and server components with different interfaces according to the present invention, and assembles them through glue components that match their different interfaces. The process of creating a component configuration file for delegating object creation of server, glue, and client components and dependency injection between them will be described in detail with reference to the accompanying drawings.
도 8은 본 실시 예에 따라 클라이언트 컴포넌트(ReservationSystem), 글루 컴포넌트(GlueComponent), 서버 컴포넌트(HotelMgr)가 구현, 조립되어 상호작용하는 것을 나타낸 논리 모델이다.FIG. 8 is a logical model illustrating implementation, assembly, and interaction of a client component (ReservationSystem), a glue component, and a server component HotelMgr according to the present embodiment.
도 9는 상기 양호한 일 실시 예를 구현하기 위하여 본 발명에 따라 개발된 클라이언트 컴포넌트 ReservationSystem의 코드 일부를 보여준다. 이 코드는 서비스 제공 인터페이스 IMakeReservation(221), 이 서비스 제공 인터페이스를 구현한 클라이언트 객체 ReservationObject(213), 이 객체가 사용하는 서비스 요청 인터페이스 IHotelHandling(212)로 구성되어 있다. 여기에서 클라이언트 객체(213)는 서비스 제공 인터페이스(221)의 멤버 메소드 MakeReservation을 구현(214)하고 있는데, 이 과정에서 다른 컴포넌트의 서비스를 이용해야 할 필요성이 발생함에 따라 개발자가 임의로 서비스 요청 인터페이스 타입(212)을 정의하였고, 이 인터페이스는 차후 조립 작업시 생성되는 글루 컴포넌트가 구현하게 된다. 클라이언트 객체는 글루 컴포넌트가 구현한 서비스 요청 인터페이스의 멤버 메소드를 호출해야 하기 때문에 프레임워크로부터 글루 컴포넌트 객체의 레퍼런스를 전달받을 필드(215)와 이 필드로의 접근 통로인 속성(216)을 선언해야 한다. 이후 필드 변수를 이용하여 글루 컴포넌트에 구현될 피호출 메소드를 호출하는 코드(217)을 작성하게 되는데, 여기에서는 변수 htlHandler를 사용하여 글루 컴포넌트에 구현될 서비스 요청 인터페이스(212)의 메소드 BookRoom을 호출하고 있다. 한편 서비스 요청 인터페이스(212) 상단에는 메타데이터 내에서 서비스 제공 인터페이스 정보와 구별하기 쉽도록 커스텀 애트리뷰트를 이용하여 서비스 요청 인터페이스임을 나타내는 주석(218)을 부가하였다.Figure 9 shows a portion of the code of the client component ReservationSystem developed in accordance with the present invention to implement the preferred embodiment. This code consists of a service
도 10은 상기 도 9의 서비스 요청 인터페이스 주석(218)을 부가하는 데에 사용할 커스텀 애트리뷰트 클래스 InterfaceAttribute의 코드를 나타낸 것이다. 이처럼 System.Attribute 클래스를 상속한 임의의 커스텀 애트리뷰트 클래스를 구현하고 이를 기반으로 주석을 부가하면 컴파일시 그 주석 내용이 메타데이터에 포함된다.FIG. 10 illustrates code of a custom attribute class InterfaceAttribute to be used to add the service
도 11은 본 발명에 따라 구현된 서버 컴포넌트 HotelMgr의 코드 일부를 보여주고 있다. 이 코드는 서비스 제공 인터페이스 IHotelMgr(221)와 이 인터페이스를 구현한 서버 객체 HotelMgrObject(223)로 이루어져 있다. 이 서버 컴포넌트의 서비스 제공 인터페이스(221)에서는 멤버 메소드 RentRoom에 대한 시그너처를 정의하고 있고, 서버 객체(223)에서는 이 메소드를 구현하고 있다.11 shows a part of the code of the server component HotelMgr implemented in accordance with the present invention. This code consists of a service providing
도 12는 본 발명에 따라 각각 독립적으로 구현된 클라이언트 컴포넌트 ReservationSystem과 서버 컴포넌트 HotelMgr의 상이한 인터페이스를 중재하여 조 립하는 글루 컴포넌트 GlueComponent의 코드 일부를 보여준다. 글루 컴포넌트의 클래스는 클라이언트 컴포넌트의 서비스 요청 인터페이스를 구현하는데, 도 11에서는 GlueObject라는 이름의 글루 객체(231)가 이에 해당한다. 이 객체는 다시 크게 프레임워크로부터 서버 컴포넌트 객체의 레퍼런스를 전달받을 필드 선언부(232)와 이 필드에 대한 접근 통로인 속성 선언부(233), 클라이언트 컴포넌트의 서비스 요청 인터페이스에 속한 멤버 메소드를 구현한 메소드 구현부(235)로 이루어진다. 조립자는 이 메소드 구현(235)에서 서버 컴포넌트의 피호출 메소드를 호출하는 코드(236)를 작성하는데, 이 과정에서 호출 메소드와 피호출 메소드의 시그너처가 상이한 경우 이를 중재하는 작업을 해야 한다. 본 실시 예의 경우 호출 메소드 BookRoom과 피호출 메소드 RentRoom의 시그너처가 대부분 일치하지만 호출 메소드의 두 번째 매개변수의 타입이 CustomerDetails인 반면 이에 상응하는 피호출 메소드의 매개변수 타입은 CustId로 서로 다른 상황을 상정하고 있는데(CustomerDetails가 CustId를 포함하는 형태), 메소드 호출 코드(236)에서는 이같은 시그너처 불일치를 해소하기 위해 클라이언트 컴포넌트로부터 받은 cus 대신 서버 컴포넌트가 요구하는 cus.custid를 넘겨주고 있다.FIG. 12 shows a part of code of a glue component GlueComponent that arbitrates and assembles different interfaces of a client component ReservationSystem and a server component HotelMgr each independently implemented according to the present invention. The class of the glue component implements the service request interface of the client component. In FIG. 11, a
도 13은 본 발명에 따라 조립된 컴포넌트들을 실행할 때 프레임워크가 서버, 글루, 클라이언트 컴포넌트 각각의 객체를 생성하고 이들 사이의 의존성을 주입하도록 지시하는 컴포넌트 배치 구성 파일을 보여준다. 프레임워크는 이 파일의 의존 정보에 따라 클라이언트 컴포넌트 객체 ReservationObject, 글루 컴포넌트 객체 GlueObject, 서버 컴포넌트 객체 HotelMgrObject를 생성한 후, 서버 객체 레퍼런스 를 글루 객체의 속성 HotelMgr에 주입하고, 글루 객체 레퍼런스를 클라이언트 객체의 속성 HotelHandling에 주입하는 작업을 수행하게 된다.Figure 13 shows a component deployment configuration file that instructs the framework to create objects of each of the server, glue, and client components and inject dependencies between them when executing components assembled according to the present invention. The framework creates the client component object ReservationObject, the glue component object GlueObject, and the server component object HotelMgrObject according to the dependency information of this file, then injects the server object reference into the glue object's property HotelMgr, and injects the glue object reference into the client object's properties. You will be injecting into HotelHandling.
본 발명은 종래의 컴포넌트 기반 기술들과 달리 독립적으로 개발된 바이너리 컴포넌트의 재사용과 조립을 통한 소프트웨어 생산성 향상을 목표로 제안된 액티브 바인딩 기술을 보완, 그 유용성을 높인 것이다. 따라서 본 발명의 효과는 기존 액티브 바인딩 기술이 제시한 발명의 주요 효과를 대부분 그대로 승계하고 강화하며, 몇 가지 추가적 효과를 지닌다.The present invention, unlike the conventional component-based technologies, complements the proposed active binding technology to improve the software productivity by reusing and assembling independently developed binary components to enhance its usefulness. Therefore, the effects of the present invention inherit and strengthen most of the main effects of the present invention proposed by the existing active binding technology, and have some additional effects.
우선 본 발명이 승계, 강화하는 액티브 바인딩 기술의 발명 효과는 다음과 같다.First, the invention effects of the active binding technology inherited and strengthened by the present invention are as follows.
첫째, 컴포넌트의 개발과 조립을 별도의 공정으로 명확히 구분하고 컴포넌트를 다른 특정 컴포넌트와의 의존 정보를 포함하지 않는 완전한 부품이 되게 함으로써 제3자가 독립적으로 개발하여 인터페이스 시그너처가 상이한 바이너리 컴포넌트들을 소스 코드 수정 없이 조립, 재사용할 수 있게 한다. 이는 신규 개발이 아닌 조립에 의한 개발을 통해 소프트웨어 생산성을 제고하고자 한 CBD 본연의 이상을 실현하는 데 필요한 최우선적 조건이다.First, the development and assembly of components are clearly separated into separate processes, and the third party is developed independently by third-party development by modifying the source code of the binary components with different interface signatures. It can be assembled and reused without This is a top priority for realizing CBD's inherent ideals to increase software productivity through assembly rather than new development.
둘째, 의존할 서버 컴포넌트 없이도 컴포넌트를 개발, 테스트할 수 있으므로 애플리케이션의 비순차적 병렬 개발이 가능해진다. 이는 이미 개발된 컴포넌트들을 획득, 조립하지 않고 애플리케이션을 처음부터 신규 개발하는 경우 개발 인력을 효 율적으로 활용하여 개발 기간을 단축할 수 있게 한다.Second, you can develop and test components without the server components to rely on, allowing for non-sequential parallel development of applications. This makes it possible to use development staff efficiently and to shorten development periods when new applications are developed from the beginning without acquiring and assembling already developed components.
기존의 액티브 바인딩 기술로는 불가능하였으나 본 발명에 의해 달성될 수 있는 효과는 다음과 같다.Although not possible with the existing active binding technology, the effects that can be achieved by the present invention are as follows.
첫째, 상기와 같은 효과를 갖는 컴포넌트를 구현함에 있어 비표준적인 독자 방식을 지양하고 객체지향 프로그래밍 표준에 따르는 인터페이스 정의 방식을 채택함으로써 개발자의 학습 부담을 제거하고, 간결하고 직관적인 코딩을 가능케 한다.First, in implementing the component having the above effects, it avoids the non-standard reader method and adopts the interface definition method according to the object-oriented programming standard, thereby eliminating the learning burden of the developer and enabling simple and intuitive coding.
둘째, 표준적인 컴포넌트 구현 방식을 채택함에 따라 기존의 성숙하고 검증된 최신, 최고 수준의 플랫폼 기술들을 온전하게 활용할 수 있고, 새로운 버전의 플랫폼에서도 호환성 문제를 야기하지 않는다.Second, the adoption of standard component implementations allows full use of existing mature, proven, top-of-the-line platform technologies, and does not cause compatibility issues on newer versions of the platform.
셋째, 컴포넌트 내에 임의로 정의된 서비스 요청 인터페이스를 직접 참조하여 자족적이고 완결된 의존 관계를 정적으로 코딩할 수 있으므로 선 개발, 후 조립 방식에 따르는 불가피한 부담으로 여겨졌던 클라이언트와 서버 컴포넌트 객체의 런타임시 동적 결합에 의한 성능 저하 문제를 제거한다. 이와 같은 본 발명의 가상 정적 결합은 개발과 조립이 동일 공정으로 이루어지는 종래 컴포넌트 기술의 일반적인 실제 정적 결합 방식과 성능면에서 동일한 효과를 거둔다.Third, since the self-contained and completed dependency can be statically coded by directly referencing a randomly defined service request interface within the component, dynamic coupling at runtime between client and server component objects, which was considered an inevitable burden of pre-development and post-assembly. Eliminates performance degradation issues caused by Such virtual static coupling of the present invention has the same effect in terms of performance and performance as the general actual static coupling scheme of the conventional component technology in which development and assembly are performed in the same process.
넷째, 자족적이고 완결된 의존 관계 표현이 가능해짐에 따라 객체의 생성과 관리를 컨테이너에 맡기는 의존성 주입 모델을 활용할 수 있다. 본 발명에 따른 컴포넌트 모델에 최신 미들웨어 기술인 의존성 주입 모델을 적용함으로써 코딩이 더욱 간결해지고, 자원 활용의 효율성과 운영 성능이 더욱 향상된다.Fourth, as a self-contained and complete dependency expression can be expressed, a dependency injection model that delegates the creation and management of objects to containers can be utilized. By applying the dependency injection model, which is the latest middleware technology, to the component model according to the present invention, coding becomes more concise, and resource efficiency and operational performance are further improved.
이상과 같은 효과들이 결합하면 종래의 최신 컴포넌트 기반 기술들의 장점인 간결하고 직관적인 코딩, 타입 안정성, 뛰어난 실행 성능 등을 갖추면서도 바이너리 수준의 자유로운 조립과 재사용이 가능한 컴포넌트를 구현할 수 있으므로 개발에서 유지 보수까지를 아우르는 소프트웨어 생산성이 크게 향상될 것이다. 또한 본 발명에 의해 소프트웨어 생산 패러다임이 바뀌게 되면 중소규모의 컴포넌트 생산 전문 업자들이 생겨나고 컴포넌트 시장이 활성화되면서 소프트웨어 산업의 에코시스템이 건강해지고 경제 전반에도 긍정적인 영향을 미칠 것이다.Combined with these effects, you can build components that can be freely assembled and re-used at the binary level, with the simplicity and intuitive coding, type stability, and outstanding execution performance of the latest component-based technologies. Software productivity will be greatly improved. In addition, if the software production paradigm is changed by the present invention, small and medium-sized component production specialists will be created and the component market will be activated, which will make the ecosystem of the software industry healthy and positively affect the overall economy.
Claims (8)
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR20070113441A KR100828302B1 (en) | 2007-11-07 | 2007-11-07 | A Method for Software Development and Operation Based on Component Reuse and Dependency Injection |
| PCT/KR2008/006566 WO2009061146A2 (en) | 2007-11-07 | 2008-11-07 | A method for software development and operation based on component reuse and dependency injection |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR20070113441A KR100828302B1 (en) | 2007-11-07 | 2007-11-07 | A Method for Software Development and Operation Based on Component Reuse and Dependency Injection |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| KR20070112755A KR20070112755A (en) | 2007-11-27 |
| KR100828302B1 true KR100828302B1 (en) | 2008-05-08 |
Family
ID=39090963
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| KR20070113441A KR100828302B1 (en) | 2007-11-07 | 2007-11-07 | A Method for Software Development and Operation Based on Component Reuse and Dependency Injection |
Country Status (2)
| Country | Link |
|---|---|
| KR (1) | KR100828302B1 (en) |
| WO (1) | WO2009061146A2 (en) |
Families Citing this family (13)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8065714B2 (en) * | 2008-09-12 | 2011-11-22 | Hytrust, Inc. | Methods and systems for securely managing virtualization platform |
| US8166552B2 (en) | 2008-09-12 | 2012-04-24 | Hytrust, Inc. | Adaptive configuration management system |
| KR101101519B1 (en) * | 2009-11-03 | 2012-01-04 | 정안모 | A Software Development System and Method using an Ontology based Component Assembly Technology |
| KR101418390B1 (en) * | 2012-10-18 | 2014-07-11 | 이지케어텍(주) | system for remotely debugging an application programming and controlling method therefor |
| US20170230419A1 (en) | 2016-02-08 | 2017-08-10 | Hytrust, Inc. | Harmonized governance system for heterogeneous agile information technology environments |
| CN105897728B (en) * | 2016-04-27 | 2022-06-17 | 江苏警官学院 | Anti-virus system based on SDN |
| KR102179890B1 (en) * | 2017-12-07 | 2020-11-17 | 최윤진 | Systems for data collection and analysis |
| CN108255495A (en) * | 2018-01-31 | 2018-07-06 | 中国银行股份有限公司 | A kind of modularization method and system based on Mediator |
| US11048485B2 (en) | 2018-12-07 | 2021-06-29 | International Business Machines Corporation | User interface code re-use based upon machine learning of design documents |
| CN110471651A (en) * | 2019-07-31 | 2019-11-19 | 北京速通科技有限公司 | A kind of method and server-side for realizing control reversion based on C++ |
| CN111158698B (en) * | 2019-12-30 | 2024-03-26 | 北京百舸飞驰科技有限公司 | Modularized communication device and method under Android platform |
| CN113031933B (en) * | 2021-03-22 | 2024-01-09 | 北京达佳互联信息技术有限公司 | Data processing method, device, electronic equipment, storage medium and program product |
| CN117349185B (en) * | 2023-12-04 | 2024-02-23 | 杭银消费金融股份有限公司 | System testing method based on interface strength dependence grading |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| 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 |
| US20050005261A1 (en) * | 2003-07-02 | 2005-01-06 | Severin William B. | Component integration engine |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2004099896A2 (en) * | 2003-05-12 | 2004-11-18 | An Mo Jeong | Method and system of developing a software with utilizing extented metadata of component under component-based development environment |
-
2007
- 2007-11-07 KR KR20070113441A patent/KR100828302B1/en not_active IP Right Cessation
-
2008
- 2008-11-07 WO PCT/KR2008/006566 patent/WO2009061146A2/en active Application Filing
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| 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 |
| US20050005261A1 (en) * | 2003-07-02 | 2005-01-06 | Severin William B. | Component integration engine |
Non-Patent Citations (2)
| Title |
|---|
| "독립적으로 개발된 바이너리 컴포넌트들의 조립을 지원하는 컴포넌트 모델", 엄윤선외 2인, 한국정보과학회 2007 한국컴퓨터종합학술대회 논문집제34권제1호(B), pp. 138-142, 2007.6* |
| Concepts and Techniques simpliying the Assembly Process for Component Instances", Scheben,U. et al. Electronic Notes in Theoretical Computer Science 82 No.5, 2003 |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2009061146A2 (en) | 2009-05-14 |
| KR20070112755A (en) | 2007-11-27 |
| WO2009061146A3 (en) | 2009-07-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| KR100828302B1 (en) | A Method for Software Development and Operation Based on Component Reuse and Dependency Injection | |
| Gacek et al. | Implementing product line variabilities | |
| Sullivan et al. | Modular aspect-oriented design with XPIs | |
| US20070028208A1 (en) | Runtime generative programming method and system | |
| Clark et al. | Applied metamodelling: a foundation for language driven development | |
| Plankensteiner et al. | Fine-grain interoperability of scientific workflows in distributed computing infrastructures | |
| Goedicke et al. | Piecemeal legacy migrating with an architectural pattern language: A case study | |
| Luer et al. | Composition environments for deployable software components | |
| Rouvoy et al. | Leveraging component-oriented programming with attribute-oriented programming | |
| KR100884435B1 (en) | A Method for Decoupling Service Components from Application-Specific Business Entities | |
| CN114721647B (en) | Object-oriented programming method based on codeless application development | |
| Rajan et al. | Unifying aspect-and object-oriented design | |
| Yue et al. | SPOT: A DSL for extending fortran programs with metaprogramming | |
| Gschwind | Adaptation and composition techniques for component-based software engineering | |
| Zdun | Language support for dynamic and evolving software architectures | |
| Cepa | Product-line development for mobile device applications with attribute supported containers | |
| WO2008015110A2 (en) | Methods, apparatus and computer programs for modelling computer programs | |
| Lüders | Use of component-based software architectures in industrial control systems | |
| Abdurazik | Suitability of the UML as an Architecture Description Language with Applications to Testing | |
| Spacek | Design and Implementation of a Reflective Component-Oriented Programming and Modeling Language | |
| Cansado et al. | Unifying architectural and behavioural specifications of distributed components | |
| Samuel et al. | Facilitating Connector Evolution With Architecture-Centric Development | |
| Lano et al. | Introduction to Software Architecture Concepts | |
| Di Martino et al. | Recognition of dynamic Data structures to support porting of applications to the Cloud | |
| Saake et al. | Towards Flexible Feature Composition: Static and Dynamic Binding in Software Product Lines |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| A201 | Request for examination | ||
| A302 | Request for accelerated examination | ||
| E902 | Notification of reason for refusal | ||
| E90F | Notification of reason for final refusal | ||
| E701 | Decision to grant or registration | ||
| GRNT | Written decision to grant | ||
| LAPS | Lapse due to unpaid annual fee | ||
| FPAY | Annual fee payment |
Payment date: 20111226 Year of fee payment: 4 |
|
| R401 | Registration of restoration |