Korea [국가변경]

이 기사 내에서 :
	머리말
	SCA 101
	SCA 프로젝트 구현하기
	결론
	다운로드 하십시오
	참고자료
	필자소개
	기사에 대한 평가

관련 링크:
	WebSphere 기술자료
	웹서비스 기술자료

한국 developerWorks > WebSphere | 웹서비스 >

IBM WebSphere Developer Technical Journal: Service Component Architecture로 SOA 솔루션 구현하기 -- Part 1

새로운 프로그래밍 모델

문서 옵션

JavaScript가 필요한 문서 옵션은 디스플레이되지 않습니다.

샘플 코드

난이도 : 중급

Roland Barcia, Certified IT Specialist, IBM
Jeff Brent, Advisory Software Engineer, IBM

2005 년 10 월 26 일

IBM® WebSphere® Integration Developer와 IBM WebSphere Process Server의 릴리스로 인해 Service Component Architecture 라고 하는 서비스 지향 아키텍처(SOA)를 구현하는 새로운 프로그래밍 패러다임이 생겨났다. 이것은 비즈니스 솔루션을 SOA에서 구현하여 정렬하도록 특별히 고안된 새로운 프로그래밍 모델이며, 서비스의 통합과 구성에 초점이 맞춰져 있다.

IBM WebSphere Developer Technical Journal 발췌.

머리말

여러분은 또 다른 프로그래밍 모델은 없다고 생각할지도 모르겠다. 웹 서비스는 어떤가? Enterprise JavaBeans에 무슨 일이 일어났는가? 글쎄 서비스 컴포넌트 아키텍처(SCA)는 기존 프로그래밍 모델을 대체하거나 필적하기 위한 것은 아니다. 대신 SCA는 기술 중립적인 방식으로 인터페이스, 구현, 레퍼런스를 정의하는 모델을 제공하기 때문에 이러한 엘리먼트들을 어떤 구현 기술과도 연결할 수 있다.

예를 들어, 자바에서 인터페이스를 정의하고 구현은 BPEL 프로세스로서 사용되거나, 나의 인터페이스를 WSDL 문서로서 갖고 있고 구현은 자바 클래스가 될 수 있다. 그림 1은 IBM WebSphere Process Server에서 SCA가 사용되는 방법을 나타내고 있다.

그림 1. WebSphere Process Server의 SCA
Figure 1. SCA in WebSphere Process Server

WebSphere Process Server에서 통합 개발자는 다양한 구현 기술을 사용할 수 있고 자바나 WSDL 같은 오픈 표준을 사용하여 인터페이스를 노출할 수 있다. 게다가 SCA는 클라이언트 프로그래밍 모델을 제공하기 때문에 클라이언트가 서비스 컴포넌트에 액세스 할 수 있다. 개발자들은 자신들에게 익숙한 다양한 기술(Enterprise JavaBeans™(EJB))을 사용하여 개발할 수 있으며 SCA를 사용하여 컴포넌트들을 한데 연결할 수 있다.

SCA의 또 다른 주요 엘리먼트는 컴포넌트들간 의존성을 정의하는 표준 모델을 정의하고 있다. 의존성은 레퍼런스들을 사용하여 SCA 컴포넌트들을 함께 연결함으로서 정의된다.

그림 2. 컴포넌트들간 의존성 정의
Figure 2. Define dependencies between components

마지막으로 SCA는 컴포넌트들을 하나의 서비스 모듈로 패키징하는데 필요한 표준 전개 모델을 정의한다. 종속 관계들과 제휴된 SCA 컴포넌트들은 전개 가능한 단위로 패키징 될 수 있다.

그림 3. 종속 관계와 함께 패키징된 컴포넌트
Figure 3. Components packaged with dependencies

SCA 모듈은 그저 또 하나의 패키지 유형만은 아니다. WebSphere Process Server에서 SCA 서비스 모듈은 J2EE EAR 파일과 같은 것이며, 기타 여러 J2EE 하위 모듈과 같은 것이다. WAR 파일 같은 J2EE 엘리먼트들은 SCA 모듈과 함께 패키징 될 수 있다. 비 SCA 객체들(JSP 등)은 SCA 서비스 모듈과 함께 패키징 될 수 있으며, 독립형 레퍼런스 라고 하는 특별 유형의 레퍼런스를 사용하여 SCA 클라이언트 프로그래밍 모델을 통해 SCA 서비스들을 호출할 수 있다.

그림 4. 비 SCA 객체들을 위한 독립형 레퍼런스
Figure 4. Standalone reference for non-SCA artifacts

SCA는 통합과 긴밀하게 연결되어 있다. 우리는 앞서서 SCA 컴포넌트들간 종속 관계들을 정의하는 방법으로서 레퍼런스들을 설명했다. 예를 들어, 같은 모듈 안에 또 다른 SCA 컴포넌트에 대한 레퍼런스를 정의 할 수 있다. 이 레퍼런스를 사용하여 모듈 내에서 서비스 컴포넌트들을 호출할 때, 데이터는 레퍼런스에 의해 전달된다. SCA는 컴포넌트들이 호출되는 방식을 정의하거나 다른 SCA 모듈에 존재하는 다른 SCA 서비스를 호출하는 방식을 정의한다.

외부 서비스 호출용 모듈을 반입(import)과 반출(export)이라고 한다.

반입과 반출은 모듈의 관점에서 표현된다. 모듈은 독립적인 컴포넌트 번들로서 특정 비즈니스 기능을 수행한다.

모듈이 또 다른 엔터티(외부 서비스나 다른 모듈)가 비즈니스 함수를 호출할 수 있기를 원할 때 모듈은 그 기능을 반출한다. 또한 반출을 통해 다양한 전송 프로토콜들을 통해서 이 서비스들을 사용할 수 있다. 반출은 모듈 내의 특정 컴포넌트와 제휴되어 있다.

모듈이 또 다른 엔터티(외부 서비스나 모듈)의 기능을 활용하려면, 이 모듈은 그 함수를 반입한다. 반입 역시 다양한 전송 프로토콜들을 통해 서비스 공급자들과 인터랙팅 할 수 있는 기능을 제공한다.

그림 5는 그러한 개념을 표현한 것이다.

그림 5. SCA 반입과 반출
Figure 5. SCA imports and exports

반입과 반출은 추상적인 개념이다. 특정 기술과 연결되어야 한다. WebSphere Process Server V6.0에서 제공하는 바인딩 유형들은 다음과 같다.

SCA(SCA 모듈에 사용됨.)
웹 서비스
JMS
Stateless 세션 빈.

반입과 반출을 통해 SCA 컴포넌트들을 호출할 때, 매개변수들은 값으로 전달된다.

그림 6. SCA 반입과 반출
Figure 6. SCA imports and exports

SCA 컴포넌트들을 하나로 연결하는 와이어는 인프라 레벨의 코드에서 나온다. 예를 들어, 와이어가 동기식 또는 비동기식이 되도록 정의할 수 있고 일방 작동 또는 요청-응답 작동이 되도록 할 수 있으며 컴포넌트들간 트랜잭션을 정의할 수도 있다. SCA는 인프라 상세를 핸들한다.

반입과 반출은 JMS, Enterprise JavaBeans, 웹 서비스 같은 다양한 기술들과 연결될 수 있다. 이로서 웹 서비스 클라이언트가 SCA 모듈을 호출하거나, SCA 모듈이 SCA 프로그래밍 모듈을 사용하여 Enterprise JavaBean을 호출할 수 있는 것이다.

그림 7. 다양한 기술과 연결된 반입과 반출
Figure 7. Imports and exports with other technologies

반입과 반출에 대해서는 후반에 설명하도록 하겠다.

나의 데이터

SCA는 비즈니스 서비스를 정의할 수 있는 범용 모델을 제공한다. 서비스 데이터 객체(SDO)는 데이터를 위한 범용 모델을 표현하는 기술을 제공한다. SCA 컴포넌트들은 합성될 수 있고, SDO를 전달하여 중립적인 방법으로 데이터들을 서로 교환할 수도 있다. SDO 아키텍처의 근본적인 개념은 데이터 객체이다. 이는 프리머티브 유형의 데이터나 다른 데이터 객체들을 보유하고 있는 데이터 구조이다. 이 데이터 객체는 또한 데이터 객체에 포함된 데이터에 대한 정보를 제공하는 메타데이터에 대한 레퍼런스도 보유하고 있다.

SDO 프로그래밍 모델에서, 데이터 객체들은 commonj.sdo.DataObject 자바 인터페이스 정의에 의해 나타난다. 이 인터페이스에는 메소드 정의가 포함되어 있는데, 이로서 클라이언트가 DataObject와 제휴된 속성들을 설정할 수 있도록 한다. SDO 아키텍처에서 또 한 가지 중요한 개념은 데이터 그래프이다. 이것은 데이터 객체 세트를 캡슐화 하는 구조이다. 이 그래프에 포함된 상위 레벨 데이터 객체에서부터, 모든 자식 데이터 객체들은 루트 데이터 객체부터 레퍼런스를 참조하여 접근 할 수 있다. 데이터 그래프에 포함된 또 다른 중요한 기능은 변경 요약이다. 이는 그래프 내의 어떤 데이터 객체와 속성들이 프로세싱 동안 변경되었는지에 대한 정보를 기록하는데 사용된다. (참고자료.)

WebSphere Process Server는 비즈니스 객체를 통해 SDO 스팩을 구현한다. SCA 컴포넌트들은 비즈니스 객체들을 전달하여 데이터를 교환할 수 있다. (그림 8)

그림 8. WebSphere Process Server 비즈니스 객체
Figure 8. WebSphere Process Server business objects

SDO가 DataGraph에서 래핑되는 것과 마찬가지로, 비즈니스 그래프는 상위 레벨 비즈니스 객체를 래핑하고 그래프에 포함된 데이터를 보완하는 추가 정보를 제공하는데 사용된다. 특히 비즈니스 그래프에는 그래프의 데이터에 대한 변경 요약(SDO 변경 요약 정보와 비슷함), 이벤트 요약, 동사 정보(EIS 시스템들간 데이터 동기화에 사용됨)가 포함된다. 비즈니스 그래프는 SDO 아키텍처의 데이터 그래프 개념과 매우 비슷하다. 하지만 이벤트 요약과 향상된 정보의 동사 부분은 SDO 데이터 그래프 개념에는 포함되어 있지 않다.

위로

SCA 101

이제는 샘플을 사용하여 SCA에 대해 본격적으로 논해보자. 샘플을 구현하는 과정에서 IBM WebSphere Integration Developer를 설명할 것이다. 이 툴은 SCA 컴포넌트들을 구현하고 통합하는데 사용된다.

개요

SCA와 비즈니스 객체를 설명하기 위해서는 비즈니스 케이스와 관련된 개념들을 논해야 한다. 모든 개발 노력들과 마찬가지로, 이 사이클은 요구 사항에서 출발한다. 이 시나리오의 요구 사항에는 신용 승인 서비스의 생성이 포함되어 있다. 이는 신청자(CreditApplication)에 대한 정보를 받아서 신용 등급(CreditRating)을 사용하여 응대한다.

SCA의 가장 단순한 엘리먼트는 서비스 컴포넌트이다. 앞서 언급했던 것 처럼, 서비스 컴포넌트는 인터페이스와 구현으로 구성된다. 이러한 객체들을 "코딩" 하는데 사용되는 기술은 다양하다. WebSphere Process Server에서 인터페이스는 자바 또는 WSDL이 될 수 있다. 자바 인터페이스는 아래 보이는 것처럼 평범한 자바 인터페이스(POJI)가 될 수 있다.

Listing 1



public interface CreditRequest
{

	public DataObject calulateCreditScore(DataObject creditApp)
			throws ServiceBusinessException;

}

자바 구현을 사용한다면 간단한 POJO를 만들 수 있다. 아래는 SCA 구현으로서 작동하는 POJO 예제이다.

Listing 2



public class CreditApprovalImpl implements CreditRequest {
	
	public DataObject calulateCreditScore(DataObject creditApp) {
		
		ServiceManager serviceManager = new ServiceManager();

		BOFactory bof = (BOFactory)serviceManager.locateService("com/ibm/websphere/bo/BOFactory");

		DataObject creditRating = bof.create("http://CreditApproval", "CreditRating");

		
		creditRating.setString("customerId", creditApp.getString("customerId"));
		
		creditRating.setInt("creditScore", 750);
		creditRating.setDouble("creditLimit", 10000d);
				
		return creditRating;
	}

}

이 구현 클래스에서, 우리는 CreditApplication 인풋을 사용하여 CreditRating 비즈니스 객체를 만든다. 그리고 이것을 호출자에게 보낸다.

서비스 컴포넌트는 Service Component Definition Language(SCDL) 파일에서 정의된다. SCDL로 만들어진 컴포넌트 파일은 인터페이스, 구현, SCA 컴포넌트의 서비스 요구 사항들을 정의하고 있다는 점에서, EJB 전개 디스크립터와 비슷하다. 위 자바 클래스용 SCDL 파일은 다음과 같다.

Listing 3



<?xml version="1.0" encoding="UTF-8"?>
<scdl:component xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:java="http://www.ibm.com/xmlns/prod/websphere/scdl/java/6.0.0" 
xmlns:ns1="http://CreditApproval/CreditRequest" 
xmlns:scdl="http://www.ibm.com/xmlns/prod/websphere/scdl/6.0.0" 
xmlns:wsdl="http://www.ibm.com/xmlns/prod/websphere/scdl/wsdl/6.0.0" 
displayName="CreditApproval" name="CreditApproval">
  <interfaces>
    <interface xsi:type="java:JavaInterface" interface="CreditRequest " >
      <method name="calulateCreditScore"/>
    </interface>
  </interfaces>
  <implementation xsi:type="java:JavaImplementation" class=" CreditApprovalImpl"/>
</scdl:component>

인터페이스를 구현하기 위해 WSDL을 사용했다면 다음과 같을 것이다.

Listing 4



<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:bons1="http://CreditApproval" 
xmlns:tns="http://CreditApproval/CreditRequest" 
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="CreditRequest" 
targetNamespace="http://CreditApproval/CreditRequest">
  <wsdl:types>
    <xsd:schema targetNamespace="http://CreditApproval/CreditRequest" 
	xmlns:bons1="http://CreditApproval" 
	xmlns:tns="http://CreditApproval/CreditRequest" 
	xmlns:xsd="http://www.w3.org/2001/XMLSchema">
      <xsd:import namespace="http://CreditApproval" 
schemaLocation="xsd-includes/http.CreditApproval.xsd"/>
      <xsd:element name="calulateCreditScore">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="CreditApp" nillable="true" 
type="bons1:CreditApp"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="calulateCreditScoreResponse">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="CreditRating" nillable="true" 
type="bons1:CreditRating"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:schema>
  </wsdl:types>
    <wsdl:message name="calulateCreditScoreRequestMsg">
    <wsdl:part element="tns:calulateCreditScore" 
name="calulateCreditScoreParameters"/>
  </wsdl:message>
    <wsdl:message name="calulateCreditScoreResponseMsg">
    <wsdl:part element="tns:calulateCreditScoreResponse" 
name="calulateCreditScoreResult"/>
  </wsdl:message>
    <wsdl:portType name="CreditRequest">
    <wsdl:operation name="calulateCreditScore">
      <wsdl:input message="tns:calulateCreditScoreRequestMsg" 
name="calulateCreditScoreRequest"/>
      <wsdl:output message="tns:calulateCreditScoreResponseMsg" 
name="calulateCreditScoreResponse"/>
    </wsdl:operation>
  </wsdl:portType>
</wsdl:definitions>

구현 클래스는 같아 보인다. (WSDL로서 정의되기 때문에 자바 인터페이스를 구현하지 않는다는 점을 제외하고는 말이다.)

우리의 SCDL 파일은 인터페이스를 WSDL 문서로 바인딩 한다.

Listing 5



<?xml version="1.0" encoding="UTF-8"?>
<scdl:component xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:java="http://www.ibm.com/xmlns/prod/websphere/scdl/java/6.0.0" 
xmlns:ns1="http://CreditApproval/CreditRequest" 
xmlns:scdl="http://www.ibm.com/xmlns/prod/websphere/scdl/6.0.0" 
xmlns:wsdl="http://www.ibm.com/xmlns/prod/websphere/scdl/wsdl/6.0.0" 
displayName="CreditApproval" name="CreditApproval">
  <interfaces>
    <interface xsi:type="wsdl:WSDLPortType" portType="ns1:CreditRequest">
      <method name="calulateCreditScore"/>
    </interface>
  </interfaces>
  <implementation xsi:type="java:JavaImplementation" class="CreditApprovalImpl"/>
</scdl:component>

SCDL은 모듈, 레퍼런스, 반입, 반출 같은 SCA 엘리먼트들을 기술하는데 사용된다. SCDL 정의는 여러 파일들을 통해 만들어 진다. 예를 들어, CreditApproval.component 파일에 인터페이스와 구현용 SCDL을 저장한다. 레퍼런스는 CreditApproval.component 파일에 저장되거나 Module 루트에 있는 개별 sca.references 파일에 저장된다. 독립형 레퍼런스도 sca.references에 놓이게 된다. 같은 SCA 모듈 내에서 독립형 레퍼런스는 비 SCA 객체(JSP)에 의해서도 사용되어 SCA 컴포넌트를 호출할 수 있다.

Listing 6



<?xml version="1.0" encoding="UTF-8"?>
<scdl:references xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:java="http://www.ibm.com/xmlns/prod/websphere/scdl/java/6.0.0" 
xmlns:scdl="http://www.ibm.com/xmlns/prod/websphere/scdl/6.0.0">
  <reference name="CreditRequestPartner">
    <interface xsi:type="java:JavaInterface" interface="approval.credit.credit.request.CreditRequest">
      <method name="calulateCreditScore"/>
    </interface>
    <wire target="CreditApproval"/>
  </reference>
</scdl:references>

이 예제에서, 우리가 정의할 세 번째 파일은 sca.module 이다. 이 SCDL 파일에는 모듈에 대한 정의가 포함되어 있다.

Listing 7



<?xml version="1.0" encoding="UTF-8"?>
<scdl:module xmlns:scdl="http://www.ibm.com/xmlns/prod/websphere/scdl/6.0.0" name="CreditApproval"/>

컴포넌트에 WSDL 인터페이스를 정의했지만 또 다른 자바 인터페이스를 독립형 레퍼런스에 추가하여 이를 목표 컴포넌트에 연결할 수 있다. 이러한 방식으로, 자바 클라이언트는 간단한 POJI를 사용하여 SCA 컴포넌트를 호출할 수 있다. WebSphere Integration Developer는 자바와 WSDL 인터페이스간 호출을 변환하는 옵션을 제공할 것이다.

SCDL이 서비스 레퍼런스, 반입, 반출 같은 다른 SCA 객체들을 정의하는 방법을 예제를 통해 설명할 것이다. 위 SCDL 파일의 네이밍 규칙은 WebSphere Integration Developer에 의해 사용되고 실제로도 WebSphere Integration Developer에 의해 사용되었다. 이 예제에서는 첫 번째 SCA 컴포넌트를 구현할 때 WebSphere Integration Developer를 사용할 것이다. 하지만 SCA 신청자는 노트패드 프로세스를 사용하여서도 구현될 수 있다.

WebSphere Integration Developer와 WebSphere Process Server

이 글에서, WebSphere Integration Developer와 WebSphere Process Server를 사용하여 SCA 컴포넌트를 구현하여 실행하는 방법을 설명할 것이다.

WebSphere Integration Developer는 WebSphere Process Server V6에서 실행되는 애플리케이션들을 개발하는데 사용된다. Eclipse 3.0 플랫폼에 기반한 WebSphere Integration Developer는 통합 프로젝트에 역할 기반의 개발을 제공한다. WebSphere Integration Developer와 IBM WebSphere Business Modeler V6를 통합 개발 플랫폼으로서 IBM Rational® Application Developer V6나 IBM Rational Software Architect V6와 함께 사용할 수 있다. J2EE 개발자, 비즈니스 분석가, 통합 개발자들은 자신들의 역할에 맞는 툴링을 사용할 수 있다. 따라서 각 개발자들은 자신들의 역할에 맞는 에디터와 툴에만 집중할 수 있고 결국 생산성을 높일 수 있는 것이다.

WebSphere Process Server는 WebSphere Application Server V6에 기반한 포괄적인 통합 플랫폼이다. WebSphere Process Server는 서비스 지향 아키텍처에서 컴포넌트 기반의 비즈니스 통합 애플리케이션을 실행하는데 사용된다. J2EE 1.4 인프라와 WebSphere Application Server에서 제공하는 플랫폼 서비스에 준하고 있기 때문에 WebSphere Process Server에는 비즈니스 프로세스 자동화 같은 기능이 포함된다.

WebSphere Integration Developer와 WebSphere Process Server에 대한 자세한 내용은 참고자료를 참조하기 바란다.

위로

SCA 프로젝트 구현하기

이제 SCA 프로젝트를 구현할 준비가 되었다. 이 예제에서 간단한 신용 승인 컴포넌트를 구현할 것이다. 이 컴포넌트에는 ID와 이름을 가진 데이터 객체가 포함되고 신용 점수와 신용 한도를 포함하고 있는 또 다른 데이터 객체를 리턴한다. zip file을 다운로드 하여 하드 드라이브에 압축을 푼다. 아마 C: 드라이브가 될 것이다.

WebSphere Integration Developer V6.0은 유연한 개발 환경으로서 SCA 애플리케이션을 구현하는데 사용되는 툴과 위자드를 제공한다.

신용 승인 서비스의 생성을 위해 탑다운 개발에 대해 알아보기로 하겠다. 우리의 탑다운 개발 프로세스 과정은 다음과 같다.

SCA 모듈 생성하기.
비즈니스 객체 생성하기.
서비스 인터페이스 정의.
컴포넌트 생성과 구현.
SCA 컴포넌트의 단위 테스트.
독립형 레퍼런스 제공.
JSP 클라이언트를 사용하여 서비스 테스트하기.

SCA 모듈 생성하기

우선 SCA 모듈을 만들어야 한다. 앞서 언급했듯이, SCA 모듈은 SCA 컴포넌트들의 패키지이다.

WebSphere Integration Developer를 연다. (그림 9)

그림 9. WebSphere Integration Developer 열기
Welcome 스크린을 닫는다.
새로운 모듈을 만든다.
1. WebSphere Integration Developer 워크벤치는 Business Integration으로 열려 있어야 한다. Business Integration 뷰를 찾는다.
2. Business Integration 뷰 안에서 오른쪽 클릭을 하여 New => Module을 선택한다. (그림 10)
  
  그림 10. 새로운 모듈 생성
3. 그림 11은 New Module 위자드 모습이다. 모듈 이름을 CreditApprovalSCAModule로 한다.
  
  그림 11. 새로운 모듈 생성
4. Business Integration 뷰에서 새로운 프로젝트를 디스플레이 해야 한다. SCA 모듈은 SCDL 파일로서 기술된다. Business Integration 뷰는 SCA 모듈의 논리적 뷰를 보여준다. Physical Resource 뷰를 열어서 SCA 모듈에 포함된 물리적 리소스들을 확인한다. SCA 모듈용 SCDL은 sca.module 파일에 포함되어 있다. 텍스트 에디터로 이 파일을 열면 다음 내용을 볼 수 있다.

Listing 8



<?xml version="1.0" encoding="UTF-8"?>
<scdl:module xmlns:scdl="http://www.ibm.com/xmlns/prod/websphere/scdl/6.0.0" name="CreditApprovalSCAModule"/>

비즈니스 객체 생성하기

인터페이스나 비즈니스 객체를 만드는데 정해진 태스크 순서는 없다. 인터페이스를 만들 때 비즈니스 객체들을 쉽게 만들 수 있었다. 여기에서는 Business Integration 뷰에서 비즈니스 객체들을 만들었다.

비즈니스 객체를 만들 때 실제로 XML 스키마를 만든다. 비즈니스 객체들은 표준 XML 스키마로서 저장된다. 애플리케이션은 SDO 프로그래밍 모델과 XPath를 사용하여 데이터에 액세스 한다.

Business Object Editor를 사용하면 신용 승인 서비스에 의해 사용될 비즈니스 객체 정의를 만들 수 있다. 우리 서비스에 필요한 것은 두 개의 비즈니스 객체이다.

CreditApplication: 신용 등급을 매기는데 쓰일 신용 정보가 포함되어 있다. 신용 신청 비즈니스 객체(CreditApplication)는 세 개의 애트리뷰트들로 구성된다.

Customer Id: 사용자의 ID
First Name: 사용자의 이름
Last Name: 사용자의 성

CreditRating: 신용 점수와 신용 한도 같은 신용 등급 정보를 포함하고 있다. 신용 등급 비즈니스 객체(CreditRating)는 세 가지 애트리뷰트들로 구성된다.

Credit Score: 이전의 기록들에 근거한 사용자의 신용 점수.
Credit Limit: 사용자에게 부과되는 총점.

Request 비즈니스 객체를 만드는 것으로 시작한다. 이것은 SCA 컴포넌트에 대한 인풋 매개변수로서 사용될 것이다.
1. CreditApprovalSCAModule이 확장되었는지를 확인한다. Data Types를 오른쪽 클릭하고 New => Business Object를 선택한다. (그림 12)
  
  그림 12. 새로운 비즈니스 객체 만들기
2. 비즈니스 객체 이름을 CreditApplication으로 한다. (그림 13)
  
  그림 13. 비즈니스 객체 정의하기
3. 비즈니스 객체는 Business Object Editor에서 열려야 한다. Data Types 메뉴 밑에 CreditApplication이 있어야 한다. (그림 14)
  
  그림 14. Business Integration 메뉴

CreditApplication 비즈니스 객체의 애트리뷰트를 정의한다.

Add Attribute 아이콘을 선택하여 애트리뷰트를 추가할 수 있다. (그림 15)

그림 15. Add Attribute 아이콘
customerId를 애트리뷰트 이름으로 입력하고 기본 String 유형을 수락한다. (유형을 변경하려면 유형 필드를 선택하여 드롭다운 박스에서 선택하도록 한다.)

그림 16. 애트리뷰트 정의
String 애트리뷰트를 두 개 더 추가하여 각각 이름을 firstName과 lastName으로 한다. 이 두 개 모두 스트링 유형이어야 한다.

그림 17. 애트리뷰트 정의
비즈니스 객체는 표준 XML 스키마 유형을 사용하여 정의된다. XML 에디터를 사용하여 비즈니스 객체를 열어서 확인한다. (텍스트 에디터에서 비즈니스 객체를 열 수 있다. 오른쪽 클릭을 하여 Open with => 과 여러분의 에디터를 선택한다.)
Business Object Editor를 선택한 후 닫는다.

그림 18. 정의가 완료된 비즈니스 객체

XML 스키마는 아래 코드 샘플과 비슷하다.

Listing 9



<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
targetNamespace="http://CreditApprovalSCAModule">
  <xsd:complexType name="CreditApplication">
    <xsd:sequence>
      <xsd:element minOccurs="0" name="customerId" type="xsd:string"/>
      <xsd:element minOccurs="0" name="firstName" type="xsd:string"/>
      <xsd:element minOccurs="0" name="lastName" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:schema>

이제, 응답을 구현할 두 번째 비즈니스 객체를 만든다.
1. 위와 같은 단계를 따라서 또 다른 비즈니스 객체를 만든다. 이 비즈니스 객체에는 세 개의 필드가 있다.
  - customerId: string 유형.
  - creditScore: int 유형.
  - creditLimit: double 유형.
2. 앞서 언급했듯이, 그림 19 처럼 유형 칼럼을 선택하여 유형을 변경할 수 있다.
  
  그림 19. 애트리뷰트 유형 변경하기
3. Business Object Editor를 저장한 후 닫는다.

이제 두 개의 비즈니스 객체가 생성되었다.

서비스 인터페이스 정의

이제 SCA 인터페이스를 생성할 준비가 되었다. 신용 승인 서비스는 요청-응답 서비스로서 신용 요청을 받아서 신용 등급을 동기식으로 리턴한다. 서비스 인터페이스는 서비스 클라이언트와 서비스 공급자간 인터랙션을 정의한다.

인터페이스를 만드는 방법은 여러 가지가 있다. 자바 인터페이스를 선택했다면 WebSphere Integration Developer에서 자바 Eclipse 툴을 사용할 수 있다. 우리 예제에서는 Business Integration에서 WSDL 인터페이스를 생성할 것이다. Assembly Editor를 사용하거나 Business Integraiton 뷰를 사용할 것이다. (나중에 Assembly Editor를 사용하여 구현할 것이다.)

먼저, Business Integration 뷰 메뉴를 사용하여 인터페이스를 만든다.
1. Interfaces 메뉴 아이템을 오른쪽 클릭하여 New => Interfaces 를 선택한다. (그림 20)
  
  그림 20. 새로운 인터페이스 만들기
2. New Interface 메뉴에서 이름을 CreditApproval로 입력한다. (우리 예제에서는 디폴트 패키지와 폴더를 사용하고 있다는 것을 유념하라. 다른 인터페이스들을 기능별로 묶어놓은 폴더를 선택할 수 있다.
  
  그림 21. 새로운 인터페이스 만들기

CreditApproval Interface는 단순한 WSDL 파일이다. WebSphere Integration Developer에는 간단한 WSDL 에디터가 들어있다. 인터페이스를 구현할 때 사용할 수 있다.

Interface Editor는 Interface를 만들었을 때 열려야 한다. 열려있지 않다면 비즈니스 인티그레이션 뷰에서 인터페이스를 더블 클릭하여 열 수 있다.
먼저 간단한 요청-응답 작동을 만들 것이다. (비동기식 호출로 사용될 수 있는 일방 작동을 만들 수 있지만 지금으로서는 간단한 동기식 요청만 만든다.) Add Request Response Operation 아이콘을 누른다. (그림 22)

그림 22. Add Request Response Operation 아이콘
에디터 상에 작동을 만들 수 있다. 이 작동 이름을 calculateCreditRating으로 한다. (그림 23)

그림 23. 작동 정의
매개변수를 정의한다. 우리는 두 개의 비즈니스 객체를 만들었다. 하나는 인풋용이고, 다른 하나는 아웃풋용이다. 작동을 만들고 Add Input 아이콘을 선택한다. (그림 24)

그림 24. Add Input 아이콘
인풋 이름을 CreditApplication으로 한다.
Type 칼럼을 선택하고 CreditApplication 비즈니스 객체를 찾는다. 비즈니스 객체는 이제 인터페이스를 구현하는데 사용할 수 있는 유효 타입이다. (그림 25) (여기에서 새로운 비즈니스 객체를 만들 수 있다.)

그림 25. 새로운 비즈니스 객체는 이제 유효 타입이다.
Add Output 아이콘을 선택한다. (그림 26)

그림 26. Add Output 아이콘
유형으로 CreditRating을 선택한다.

그림 27. 아웃풋 정의
Interface Editor를 저장한 후 닫는다.

WSDL 파일을 검사하고 싶으면 Physical Resources 뷰에서 CreditApproval.wsdl 파일을 오른쪽 클릭하여 텍스트 에디터를 사용하여 연다. (그림 28)

그림 28. WSDL 파일 보기
Figure 28. View WSDL file

WSDL 파일은 아래 코드 샘플과 비슷하다.

Listing 10



<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:bons1="http://CreditApprovalSCAModule" 
xmlns:tns="http://CreditApprovalSCAModule/CreditApproval" 
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
name="CreditApproval" targetNamespace="http://CreditApprovalSCAModule/CreditApproval">
  <wsdl:types>
    <xsd:schema targetNamespace="http://CreditApprovalSCAModule/CreditApproval" 
xmlns:bons1="http://CreditApprovalSCAModule" 
xmlns:tns="http://CreditApprovalSCAModule/CreditApproval" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
      <xsd:import namespace="http://CreditApprovalSCAModule" 
schemaLocation="xsd-includes/http.CreditApprovalSCAModule.xsd"/>
      <xsd:element name="calculateCreditRating">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="CreditApplication" nillable="true" 
type="bons1:CreditApplication"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="calculateCreditRatingResponse">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="CreditRating" nillable="true" 
type="bons1:CreditRating"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:schema>
  </wsdl:types>
    <wsdl:message name="calculateCreditRatingRequestMsg">
    <wsdl:part element="tns:calculateCreditRating" 
name="calculateCreditRatingParameters"/>
  </wsdl:message>
    <wsdl:message name="calculateCreditRatingResponseMsg">
    <wsdl:part element="tns:calculateCreditRatingResponse" 
name="calculateCreditRatingResult"/>
  </wsdl:message>
    <wsdl:portType name="CreditApproval">
    <wsdl:operation name="calculateCreditRating">
      <wsdl:input message="tns:calculateCreditRatingRequestMsg" 
name="calculateCreditRatingRequest"/>
      <wsdl:output message="tns:calculateCreditRatingResponseMsg" 
name="calculateCreditRatingResponse"/>
    </wsdl:operation>
  </wsdl:portType>
</wsdl:definitions>

컴포넌트 생성과 구현

SCA를 구현할 준비가 되었다. 지금까지 표준 인터페이스와 비즈니스 객체를 만들었다. 이제 SCA 컴포넌트를 정의할 것이다. SCA Assembly Editor를 사용하여 정의한다.

먼저, SCA 컴포넌트를 정의한다.
1. CreditApprovalSCAModule 메뉴 아이템을 더블클릭 하여 SCA Assembly Editor를 연다. (그림 29)
  
  그림 29. SCA Assembly Editor 열기
2. SCA Assembly Editor에는 SCA 객체들을 생성할 때 사용할 수 있는 팔레트가 있다. 다양한 뷰에서 특정 객체들을 드래그(drag) 할 수도 있다. CreditApproval 인터페이스를 어셈블리에디터로 드래그한다. (그림 30) (팔레트에서 자바 컴포넌트를 드래그하여 인터페이스와 연결시킬 수도 있다.)
  
  그림 30. Assembly Editor로 인터페이스 드래그하기
3. 텍스트 박스가 나타난다. Component with No Implementation Type을 선택한다. (그림 31)
  
  그림 31. Component Creation 텍스트 박스
4. Component1이라는 이름의 Assembly Editor 상에 SCA 컴포넌트가 생겼다. (그림 32)
  
  그림 32. SCA 컴포넌트 아이콘
5. 컴포넌트를 선택하고 이름을 입력하여 이름을 변경하거나, Properties Editor를 사용하여 변경할 수도 있다. (그림 33) Display Name을 CreditApproval로 변경한다. Name 필드는 자동으로 바뀐다.
  
  그림 33. 컴포넌트 이름 변경

인터페이스를 가진 SCA 컴포넌트가 생겼다. 이제 Assembly Editor를 사용하여 구현을 만들 것이다.

Assembly Editor에서 컴포넌트를 오른쪽 클릭 하여 Generate Implementation => Java를 선택하여 뼈대 구현을 만든다. (그림 34)

그림 34. 구현 뼈대 만들기

새로운 자바 구현은 자바 에디터에서 열린다. calculateCreditRating이 보인다. 다운로드 파일에 코드표가 있다.(C:\SCA_ArticleSeries\Part1\CodeSnippet1.txt) 메소드는 아래와 같다.

Listing 11



public DataObject calculateCreditRating(DataObject creditApplication) {
//	Create and return a credit rating object.
	System.out.println("********* credit approval service invoked ******");
	ServiceManager serviceManager = new ServiceManager();

	BOFactory bof = (BOFactory)serviceManager.locateService("com/ibm/websphere/bo/BOFactory");

	System.out.println("********* BOFactory created ******");
	DataObject creditRating = bof.create("http://CreditApproval", "CreditRating");

	System.out.println("********* credit rating object created ******");
	creditRating.setString("customerId", creditApplication.getString("customerId"));
		
	creditRating.setInt("creditScore", 750);
	creditRating.setDouble("creditLimit", 10000d);
	System.out.println("********* returning credit rating object ******");
		
	return creditRating;

}

이 코드는 SCA 서비스 매니저를 사용하여 Business Object Factory를 배치한다. 이는 XML 스키마에서 비즈니스 객체들을 만드는데 사용되는 것이다. 우리는 Response Data Object를 만들고 하드 코딩된 데이터를 리턴한다.
컴파일 오류가 생길 수도 있다. 에디터를 오른쪽 클릭하여 Source => Organize Imports를 선택하여 문제를 해결한다. (그림 35)

그림 35. 오류 수정
자바 파일을 저장한 후 닫는다. Assembly Editor는 열어둔다.

SCA 컴포넌트의 단위 테스트

WebSphere Integration Developer에서는 단위 테스트 툴을 사용하여 컴포넌트의 단위 테스트가 가능하다. SCA 구현의 유형에 따라서, J2SE 환경에서 SCA 컴포넌트를 테스트 할 수 있다. 전체 애플리케이션 서버 없이도 컴포넌트를 테스트 할 수 있다. 물론 이는 컴포넌트 유형에 전적으로 의존한다. 자바 구현은 J2SE 환경에서 쉽게 테스트 할 수 있지만 BPEL 플로우에서 만들어진 SCA 컴포넌트는 WebSphere Process Server 같은 BEPL 엔진이 필요하다. 우리 예제에서는 Test Component를 사용하여 SCA 컴포넌트를 테스트 할 것이다.

Test Component를 시작하려면,

SCA Assembly Editor에서 CreditApproval 컴포넌트를 오른쪽 클릭하여 Test Component를 선택한다. (그림 36)

그림 36. Test Component 시작하기
Test Component Editor가 시작되었다. 툴의 오른편에서 테스트 데이터를 입력하고(그림 37) Continue를 누른다.

그림 37. 테스트 데이터 입력
사용 가능한 런타임 리스트가 디스플레이 된다. Eclipse 1.4 JVM을 선택하고, Finish를 누른다. (그림 38)

그림 38. 런타임 전개 위치
테스트를 시작하려면 Return 아이템을 선택한다. Events 윈도우를 통해 흐름을 감시한다.

그림 39. Events 윈도우
오른편에 결과가 나온다. (그림 40)

그림 40. 단위 테스트 결과

SCA 클라이언트 웹 애플리케이션을 만들고 WebSphere Process Server에서 테스트하기

같은 SCA 전개로 패키징 된 비 SCA 컴포넌트에 의해 SCA 컴포넌트가 호출되도록 하려면 독립형 레퍼런스를 만들어야 한다.
1. SCA Assembly Editor에서, 팔레트 상에 Import 아이콘 옆에 있는 화살표를 선택한다. 더 작은 하위메뉴가 나타난다. Standalone references 아이콘을 선택하여 Assembly Editor 상으로 드래그 한다. (그림 41)
  
  그림 41. 독립형 레퍼런스 만들기
2. Stand-alone References 박스 내부를 클릭하고 이를 Credit Approval 컴포넌트로 드래그 한다. (그림 42)
  
  그림 42. 매칭 레퍼런스 구현하기
3. OK 를 눌러 매칭 레퍼런스를 만든다. (그림 43)
  
  그림 43. 매칭 레퍼런스 구현하기
4. 다음 텍스트 박스에서는 자바 인터페이스를 생성할 옵션이 주어진다. 여러분이 WSDL 인터페이스를 만들었다는 것을 명심하라. 하지만 WebSphere Integration Developer는 동등한 자바 인터페이스를 만들어서 자바 클라이언트도 SCA API를 사용하여 인터랙팅 할 수 있도록 한다. Yes를 선택한다. (그림 44)
  
  그림 44. 인터페이스 변환 확인
독립형 레퍼런스를 사용하여 같은 모듈에 있는 비 SCA 컴포넌트에서 SCA 컴포넌트를 호출할 수 있다. SCA 모듈은 EAR 파일에서 구현되기 때문에 추가 J2EE 컴포넌트들을 SCA 모듈에 추가할 수 있다. 우리 예제에서는 JSP 파일을 갖고 있는 기존 WAR 파일을 반입할 것이다. WAR 파일은 기본 EAR 파일의 일부가 될 것이다.
1. File => Import 를 선택하여 Import 위자드를 띄운다. WAR file을 선택하고 Next를 누른다. (그림 45)
  
  그림 45. 비 SCA 컴포넌트에서 SCA 컴포넌트 호출하기
2. C:\SCA_ArticleSeries\Part1\CreditApprovalClient.war를 선택한다. Add module to an EAR Project는 체크를 해제한다.
  
  그림 46. WAR 파일 반입하기
3. Yes를 선택하여 Web perspective로 전환한다. (그림 47)
  
  그림 47. Web perspective로 전환 하기
4. JSP 파일을 열어 코드를 검사한다. Dynamic Web Projects 디렉토리 밑에 있다. (그림 48) JSP는 creditApprovalClient.jsp이다.
  
  그림 48. Dynamic Web Projects 디렉토리
5. 간단한 JSP를 사용하여 인풋을 받고 SCA API를 사용하여 SCA 컴포넌트를 호출한다. (이 JSP 파일은 MVC를 사용하는 최상의 방법을 따르고 있다.)
SCA에서 Dependency Editor를 사용하여 다양한 패키지들을 SCA 모듈에 추가할 수 있다.
1. CreditApprovalSCAModule을 오른쪽 클릭하여 Dependency Editor를 열고 Open Dependency Editor를 선택한다. (그림 49)
  
  그림 49. Open Dependency Editor
2. J2EE 섹션을 확장하여, Add 버튼을 누른다. (그림 50)
  
  그림 50. 의존성 설정
3. CreditApprovalClient 웹 프로젝트를 선택한다. (그림 51)
  
  그림 51. 웹 프로젝트 선택하기
4. On Build Path에 체크가 되지 않았는지를 확인한다. (Build Path는 이 컴포넌트를 SCA 모듈의 클래스 경로에 추가한다. 우리는 SCA 모듈에 근거한 WAR 파일을 만들어야 한다.) Dependency Editor를 저장한다. 이것은 WAR 파일을 EAR 파일의 일부로 만든다.
  
  그림 52. 의존성 설정
5. 웹 프로젝트에서 SCA 자바 인터페이스를 볼 수 있도록 하려면 웹 프로젝트를 오른쪽 클릭하고 Properties를 선택한다.
6. Java JAR Dependencies로 가서 CreditApprovalSCAModuleEJBClient.jar를 선택한다. 이것은 밑에 생성되는 EJB 클라이언트 JAR 파일이다. (그림 53)
  
  그림 53. 의존성 설정
7. 에디터를 닫는다. 이 부분에서 전체 구현을 수행하는 것을 선택할 수 있다. 꼭 그래야 하는 것은 아니지만 전개 전에 전체 구현을 수행하는 것이 좋다. 자동 구현이 있다면 Clean 을 실행한다. (그림 54)
  
  그림 54. 자동 구현용 Clean
이제 WebSphere Process Server 상에 SCA 컴포넌트와 웹 클라이언트를 전개하고 테스트 할 준비가 되었다. 우리의 SCA 모듈은 J2EE 애플리케이션에서 구현된다. J2EE perspective로 변환하여 객체들을 볼 수 있다. (이 글 후반에 설명하겠다.)

그림 55. J2EE perspective
1. Business Integration perspective의 밑에 Servers 뷰로 변환한다. WebSphere Process Server를 오른쪽 클릭하여 Start를 선택한다. (그림 56)
  
  그림 56. WebSphere Process Server 시작하기
2. 서버가 시작되기를 기다린다. 콘솔을 점검하고 메시지를 기다려라. (그림 57)
  
  그림 57. WebSphere Process Server 시작 메시지
3. 서버를 다시 오른쪽 클릭하고 Add and remove projects를 선택한다. (그림 58)
  
  그림 58. 프로젝트 추가와 삭제
4. CreditApprovalSCAModuleAdd를 선택하고 Add를 선택한다. (그림 59) 오른쪽에 Configured projects 박스로 이동될 것이다.
  
  그림 59. 서버에 설정된 프로젝트
5. 우측 하단에서 진행과정을 보면서 애플리케이션이 전개되는 것을 기다린다. (그림 60)
  
  그림 60. 프로젝트 전개 모니터
6. CreditApporvalSCAModuleApp 이 시작되었는지를 콘솔에서 확인한다. (그림 61)
  
  그림 61. 관리 콘솔 메시지
7. Web perspective로 변환한다. JSP를 오른쪽 클릭하고 Run => Run on Server를 선택한다. (그림 62)
  
  그림 62. 애플리케이션 실행
8. 기존 WebSphere Process Server를 선택하고 Set server as project default를 선택한 후, Finish를 누른다. (그림 63)
  
  그림 63. 서버 설정
9. 애플리케이션이 실행되면 애플리케이션 테스트 데이터를 입력한다. (그림 64)
  
  그림 64. SCA 애플리케이션 테스트 데이터 입력하기
10. 결과는 다음과 같다. (그림 65)
  
  그림 65. SCA 애플리케이션 테스트 결과
11. 브라우저를 닫고 서버를 중지한다.