[원문출처] https://camel.apache.org/components/2.x/aws-s3-component.html

해당 문서의 경우 Apache 재단의 Camel Document 문서 일부를 번역 한 것입니다.  일부 내용의 경우 필요에 따라 삭제된 부분이 있슴
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트  

Amazon S3 스토리지 서비스 컴포넌트

Camel 2.8 이후 지원, Both producer 와 consumer 양쪽 모두 지원.

aws-s3://[bucketName|arn][?options]

from("aws-s3://helloBucket?accessKey=yourAccessKey&secretKey=yourSecretKey&prefix=hello.txt")
  .to("file:/var/downloaded");

aws-s3://bucketNameOrArn

AWSCredentials awsCredentials = new BasicAWSCredentials("myAccessKey", "mySecretKey");

ClientConfiguration clientConfiguration = new ClientConfiguration();
clientConfiguration.setProxyHost("http://myProxyHost");
clientConfiguration.setProxyPort(8080);

AmazonS3 client = new AmazonS3Client(awsCredentials, clientConfiguration);

registry.bind("client", client);

from("aws-s3://MyBucket?amazonS3Client=#client&delay=5000&maxMessagesPerPoll=5")
.to("mock:result");

from("file:tmp/test?fileName=test.txt")
     .setHeader(S3Constants.KEY, constant("testFile"))
     .to("aws-s3://mybucket?amazonS3Client=#client&useAwsKMS=true&awsKMSKeyId=3f0637ad-296a-3dfe-a796-e60654fb128c");

  from("direct:start").process(new Processor() {

      @Override
      public void process(Exchange exchange) throws Exception {
          exchange.getIn().setHeader(S3Constants.BUCKET_DESTINATION_NAME, "camelDestinationBucket");
          exchange.getIn().setHeader(S3Constants.KEY, "camelKey");
          exchange.getIn().setHeader(S3Constants.DESTINATION_KEY, "camelDestinationKey");
      }
  })
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=copyObject")
  .to("mock:result");

  from("direct:start").process(new Processor() {

      @Override
      public void process(Exchange exchange) throws Exception {
          exchange.getIn().setHeader(S3Constants.KEY, "camelKey");
      }
  })
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=deleteObject")
  .to("mock:result");

  from("direct:start")
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=listBuckets")
  .to("mock:result");

  from("direct:start")
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=deleteBucket")
  .to("mock:result");

  from("direct:start").process(new Processor() {

      @Override
      public void process(Exchange exchange) throws Exception {
          exchange.getIn().setHeader(S3Constants.KEY, "camelKey");
      }
  })
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=downloadLink")
  .to("mock:result");

  from("direct:start")
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=listObjects")
  .to("mock:result");

  from("direct:start").process(new Processor() {

      @Override
      public void process(Exchange exchange) throws Exception {
          exchange.getIn().setHeader(S3Constants.KEY, "camelKey");
      }
  })
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=getObject")
  .to("mock:result");

  from("direct:start").process(new Processor() {

      @Override
      public void process(Exchange exchange) throws Exception {
          exchange.getIn().setHeader(S3Constants.KEY, "camelKey");
          exchange.getIn().setHeader(S3Constants.RANGE_START, "0");
          exchange.getIn().setHeader(S3Constants.RANGE_END, "9");
      }
  })
  .to("aws-s3://mycamelbucket?amazonS3Client=#amazonS3Client&operation=getObjectRange")
  .to("mock:result");

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-aws-s3</artifactId>
    <version>${camel-version}</version>
</dependency>

<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-aws-s3-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>

번역 문서 저작권 표시 :
저작자표시-비영리-동일조건 변경 허락 (CC BY-NC-SA)
원문 저작권 표시 :
(Developing a customer text editor for the Eclipse IDE, Lars Vogel (c) 2009 - 2020 vogella GmbHVersion 1.1,09.09.2020
, CC BY-NC-SA )
소스 코드의 경우 Eclipse Public License 2.0 를 따른다.

[원문 출처] www.vogella.com/tutorials/EclipseEditors/article.html

해당 문서의 경우 vogella사의 Eclipse IDE Extensions Document 문서 일부를 번역 한 것입니다. 번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 
번역 작업 시 이클립스 내 고유이름을 가진 값의 경우, 가령 Tab의 명칭 등의 경우 화면에서 표시되는 이름이므로 별도로 번역없이 제공하거나 괄호를 사용하여 동시에 명기한다.
저작자표시-비영리-동일조건 변경 허락 (BY-NC-SA)

www.sogomsoft.co.kr (주) 소곰소프트 

1. 이클립스 에디터

텍스트 에디터는 일반적으로 텍스트 데이타를 변경하는 것을 허용하고, 저장 액션이 발생했을때는 언제나 기본 모델의 변경을 적용한다. 

어떤 파일 확장자 또는 컨텍스트 유형을 위한 기능성 에디터를 제공하기 위해 , 다음과 같이 할 수 있다:

• 일반적인 에디터를 확장한다. 

• 자체 에디터를 구현한다. 

일반적인 에디터를 확장하는 것은 구현을 가속화시키고 단순화 할수 있기 때문에 새 파일을 위한 선호하는 선택이다.

일반적인 에디터에서 새 컨텍스트 유형을 지원을 추가하기 위해 다음을 할 필요가 있다. 

• 컨텍스트 유형을 추가한다. 

• "org.eclipse.ui.genericeditor.presentationReconcilers" 확장점을 통해 에디터에 프리젠테이션조정자(PresentationReconsiler)를 등록한다.

1.1. JFace 텍스트 프레임워크

JFace 텍스트에서, 텍스트 문서는 IDocument로 모델링되어 있다.  컨트롤러로 ITextViewer를 사용하는 IDocument 문서를 보거나 편집하기 위해, 문서를 프리젠테이션 하기 위한 StyledText 위젯을 사용한다.

IDocument 인터페이스는 텍스트를 저장하고 다음을 위한 지원을 제공한다.:

• 라인 정보

• 텍스트 조작

• 문서 변경 리스너

• 맞춤형 위치 관리자

• 검색

• 맞춤형 파티션 관리

• 문서 파티션 변경 리스너

문서들은 문서 파티셔너를 통해 다른 파티션으로 분해 될 수 있다. 즉 그 파티션들은 그 파티션들의 유형에 따라 조작할 수 있고 다른 포그라운트(전경) 색상을 가질 수 있다.

1.2. 프리젠테이션 조정자 소개

사용자가 문서를 변경 할 때마다,  파티션 조정자는 시각적 프리젠테이션이 유효하지 않는 영역과 그 영역을 고칠수 있는 방법을 결정한다.

소스코드의 하이라이팅(강조)은 프리젠테이션 조정자를 사용함으로써 보관될 수 있다.  그런 프리젠테이션 조정자는 "org.eclipse.ui.genericeditor.presentationReconcilers" 확장을 통해서 정의 될 수 있다. 프리젠테이션 조정자는 IPresentationReconciler 인터페이스를 구현할 컨텍스트유형과 클래스의 명세서를 필요로 한다. IPresentationReconciler를 사용할때, 어떤 IRules는 지정된 컨텍스트 유형을 지원할 수 있다. IRule은 문서의 파티셔닝 또는 텍스트의 스타일링의 목적을 위해 텍스트를 스캔하는 것을 사용하여 룰을 정의한다. 

파티션은 문서상에 의미론적인 뷰이다.( 역자주, 파티션은 개념상으로는 뷰이다):

• 각각의 파티션은 컨텍스트 유형을 가진다. 

• 문서의 각각의 문자는 파티션에 속해 있다. 

• 문서는 멀티 파티셔닝을 지원한다. 

• 파티셔닝은 항상 최신 정보이다.

1.3. 에티터로 동작하기 위한 API

현재 활성화 페이지를 통해서 에디터를 열 수 있다. 그렇게 하기 위해 "org.eclipse.ui.editors" 확장점에서 정의된 에디터를 위한 EditorInput 객체와 ID를 필요하다. 

page.openEditor(new YourEditorInput(), ID_OF_THE_EDITOR);

그외 페이지에서 얻기 위해 다음처럼 사용 할 수  있다.:

// 에디터가 뷰 안에 있다면 
getViewSite().getPage(); 

// 에디터가 커멘드 내에 있다면
HandlerUtil.getActiveWorkbenchWindow(event).getActivePage(); 

// 에디터가 다른 어딘가에 있다면 
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();

2. 에디터에 하이버링크 탐지기 추가 하기 

2.1. 소스 에디터에서 하이퍼링크(Hyperlinks)

Java 에디터에서 엘리먼트에 컨트롤 키를 누르고 클릭하면 그곳을 탐색 할 수 있다.

이 기능은 "org.eclipse.ui.workbench.texteditor.hyperlinkDetectors" 확장점(extension point)을 위한 확장을 통해서 제공된다. 지정된 이름은 General > Editors > Text Editors > Hyperlinking에 preferences에서 보인다.  만약 "org.eclipse.ui.genericeditor.GenericEditor" 대상 id를 사용하는 일반적인 에디터를 사용하기 위해 "org.eclipse.ui.DefaultTextEditor"를 사용하는 모든 텍스트 에디터에서 사용하기를 원하면 대상ID(targetId)가 지원하기를 원하는 에디터 유형에 대상 아이디를 지정한다.

IHyperlinkDetector는 IHyperlink 객체의 배열을 반환하는 것을 하기로 되어 있다. IHyperlink 구현체는 하이퍼링크 액션을 수행한다.

2.2. 색상과 폰트 preferences 추가 하기 

이클립스는 General > Appearance > Colors and Fonts에서 사용자에 의해서 색상과 폰트를 사용자 정의 하기 위한 페이지를 제공한다. 

이 페이지를 위한 엔트리를 정의하기 위해, "org.eclipse.ui.themes" 확장점(extension point)을 위한 확장점을 정의할 필요가 있다.

예를 들면, plugin.xml 파일 또는 플러그인에서 다음 엔트리로 카테고리, 폰트와 컬러를 제공할 수 있다.

<extension point="org.eclipse.ui.themes"> 
	
    <themeElementCategory 
    	id="com.vogella.eclipse.preferences.mythemeElementCategory" 
        label="vogella category"> 
    	<description> An example theme category </description> 
    </themeElementCategory> 
    
    <colorDefinition 
    	categoryId="com.vogella.eclipse.preferences.mythemeElementCategory" 
        id="com.vogella.eclipse.preferences.myFirstColorDefinition" 
        label="vogella color" 
        value="COLOR_DARK_BLUE"> 
    	<description> Your description for the color </description> 
    </colorDefinition> 
    
    <fontDefinition 
    	categoryId="com.vogella.eclipse.preferences.mythemeElementCategory" 
        id="com.vogella.eclipse.preferences.myFirstFontDefinition" 
        label="vogella Font" 
        value="Lucida Sans-italic-18"> 
        <description> Your description for the font </description> 
    </fontDefinition> 
    
</extension>

색상을 위한 값은 SWT 클래스에 정의된 COLOR_* 상수가 될수 있다. 또한 255,0,0같은 RGB 값으로 지정할 수 있다. 폰트를 위해 값이 다음 패턴 `fontname-style-height` 값으로 정의되어 있다.

이제 preferences은 사용자나 CSS 엔진을 통해 변경 될 수있다. 현재 값을 얻기 위해, IThemeManager를 사용할 수 있다.

// Eclipse 4 API 
@Inject 
IThemeManager themeManager; 

// Eclipse 3 API
IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager(); 
ITheme currentTheme = themeManager.getCurrentTheme(); 

ColorRegistry colorRegistry = currentTheme.getColorRegistry(); 
Color color = colorRegistry.get("com.vogella.eclipse.preferences.myFirstColorDefinition"); 

FontRegistry fontRegistry = currentTheme.getFontRegistry(); 
Font font = fontRegistry.get("com.vogella.eclipse.preferences.myFirstFontDefinition");

2.3. 사용자 정의 스펠링 엔진

"org.eclipse.ui.workbench.texteditor" 플러그인은 "org.eclipse.ui.workbench.texteditor.spellingEngine" 확장점을 통해 사용자 정의 스펠링 엔진을 등록하기 위한 옵션을 제공한다. 

3. 연습 : 사용자 정의 파일 유형을 위한 일반적인 에디터 사용하기

이 연습에서, 일반적인 텍스트 에디터와 작업확장자로 파일을 연결한다. 파일 내에서 예제처럼 속송 파일을 편집하는 것을 지원하기를 원한다. 

test:Hello 
Helper:stuff

3.1. 새 플러그인 생성

"com.vogella.ide.editor.tasks"로 불리는 간단한 새 플러그인 프로젝트를 생성한다.

3.2. Manifest 위존관계 추가하기

MANIFEST.MF 파일을 위한 에디터를 연다. Add 버튼을 사용하여 의존관계(Dependencies) 탭을 통해서 다음 의존관례를 추가한다.

• org.eclipse.text

• org.eclipse.ui

• org.eclipse.ui.editors

• org.eclipse.ui.genericeditor

• org.eclipse.ui.workbench.texteditor

• org.eclipse.jface.text

• org.eclipse.core.runtime

• org.eclipse.core.resources

3.3. 텍스티로 manifest 파일 리뷰하기

MANIFEST.MF 탭을 선택하면, 일반적인 텍스트(plain text)로 이 파일을 볼 수 있다. 다음 해결방법과 같이야 힌다. (매번 릴리즈로 변경되기 때문에 버전 번호는 제거 되었다.).

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Tasks
Bundle-SymbolicName: com.vogella.ide.editor.tasks
Bundle-Version: 1.0.0.qualifier
Bundle-Vendor: VOGELLA
Automatic-Module-Name: com.vogella.ide.editor.tasks
Bundle-RequiredExecutionEnvironment: JavaSE-11
Require-Bundle: org.eclipse.text,
 org.eclipse.ui,
 org.eclipse.ui.editors,
 org.eclipse.ui.genericeditor,
 org.eclipse.ui.workbench.texteditor,
 org.eclipse.jface.text,
 org.eclipse.core.runtime,
 org.eclipse.core.resources

3.4. 컨텍스트 유형 정의하기

MANIFEST.MF 에디터를 사용하여, 확장(Extensions) 탭을 열고 Add…​ 버튼을 누른다..

"org.eclipse.core.contenttype.contentTypes" 확장점(extension point)을 선택한다.

다이얼로그를 닫고 확장을 추가 하기 위해 Finish을 누른다.

새 엔트리에 오른쪽 마우스 클릭하고 New > content-type을 선택한다.

다음 스크린샷과 유사하게 .tasks 확장자를 사용하는 파일을 위한 컨텍스트 유형을 지정한다. 

plugin.xml 파일에 엔트리를 생성한다..

plugin.xml 파일은 다음 목록과 유사하게 보여야 한다. manifest 편집기의 plugin.xml 탭을 클릭함으로써 그 내용을 볼 수 있다.

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.4"?> 
<plugin> 
	<extension point="org.eclipse.core.contenttype.contentTypes"> 
    	<content-type file-extensions="tasks" id="com.vogella.ide.contenttype.tasks" name="Tasks" priority="high"> 
        </content-type> 
    </extension> 
</plugin>

3.5. 에디터로 컨텐츠 유형 연결하기

컨텐츠 유형은 특정 에디터로 연결 될 수 있다. 이를 위해 "org.eclipse.ui.editors" 확장점이 사용 될 수 있다. 

확장(Extensions) 탭에 Add 버튼을 통해서 "org.eclipse.ui.editors extension"을 추가한다.

컨텍스트 유형을 정의하기 위해 "org.eclipse.ui.editors"애 오른쪽 마우스 클릭하고, New > editorContentTypeBinding를 선택한다.

그 결과 plugin.xml은 이제 다음과 같이 보여야 한다. 

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.4"?> 
<plugin> 

	<extension point="org.eclipse.core.contenttype.contentTypes"> 
		<content-type file-extensions="tasks" id="com.vogella.ide.contenttype.tasks" name="Tasks" priority="high"> 
		</content-type> 
	</extension> 

	<extension point="org.eclipse.ui.editors"> 
		<editorContentTypeBinding contentTypeId="com.vogella.ide.contenttype.tasks" editorId="org.eclipse.ui.genericeditor.GenericEditor"> 
		</editorContentTypeBinding> 
	</extension> 
    
</plugin>

3.6. feature를 통해서 product에 플러그인 추가 하기

IDE feature에 새 플러그인을 추가하라. features를 사용하지 않는 경우, 이 단계를 넘어가라

3.7. 개발 테스트 하기

 features 와 product를 사용한다면 product를 통해 새 이클립스 런타임을 시작하라.

features 와 product를 사용하지 않는다면, 새 플러그인이 시작시에 포함 될 수 있도록 직접 런터 환경 구성을 업데이트하라. 

이클립스 런타임에서 Window > Preferences > General > Content Types에서 컨텐츠 유형이 보이는지 확인하라

새 프로젝트를 생성하라 (General 또는 Java 프로젝트).

새 프로젝트에서 .tasks 확장자로 새 파일을 생성하라. 만약 파일을 연다면, 일반적인 텍스트 데이터에서 열려야 한다.

아이콘은 일번적인 에디터의 아이콘이 되여야 한다. 

4. 연습: 구문 하이라이팅 구현하기

이 연습에서 작업 파일 에디터를 위한 구문 하이라이팅을 구현한다. com.vogella.ide.editor.tasks플러그인 상에서 작업을 계속한다.

4.1. 구문 하이라이팅 구현하기 

IRule을 정의 하기 위한 다음 클래스를 구현한다.

package com.vogella.ide.editor.tasks; 

import org.eclipse.jface.text.rules.ICharacterScanner; 
import org.eclipse.jface.text.rules.IRule; 
import org.eclipse.jface.text.rules.IToken; 
import org.eclipse.jface.text.rules.Token; 

public class PropertyNameRule implements IRule { 

	private final Token token; 
    
    public PropertyNameRule(Token token) { 
    	this.token = token; 
    } 
    
    @Override 
    public IToken evaluate(ICharacterScanner scanner) { 
   		int c = scanner.read(); 
    	int count = 1; 
    	while (c != ICharacterScanner.EOF) { 
    		if (c == ':') { 
    		return token; 
    		} 
    		if ('\n' == c || '\r' == c) { 
    			break; 
    		} 
    		count++; 
    		c = scanner.read(); 
   		} 
    
    	// 일치 하지 않으면 원본 포지선에 스캐너 다시 넣는다.  
    	for (int i = 0; i < count; i++) { 
    		scanner.unread(); 
    	} 
    
    	return Token.UNDEFINED; 
    } 
    
}

에디터를 위한 조정자로 사용되게 될 다음 클래스를 구현한다. 

package com.vogella.ide.editor.tasks; 

import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.TextAttribute; 
import org.eclipse.jface.text.presentation.PresentationReconciler; 
import org.eclipse.jface.text.rules.DefaultDamagerRepairer; 
import org.eclipse.jface.text.rules.IRule; 
import org.eclipse.jface.text.rules.RuleBasedScanner; 
import org.eclipse.jface.text.rules.Token; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.widgets.Display; 

public class PropertiesReconciler extends PresentationReconciler { 

	private final TextAttribute tagAttribute = new TextAttribute( Display.getCurrent().getSystemColor(SWT.COLOR_DARK_GREEN)); 
	
    public PropertiesReconciler() { 
		RuleBasedScanner scanner = new RuleBasedScanner(); 
		IRule rule = new PropertyNameRule(new Token(tagAttribute)); 
		scanner.setRules(new IRule[] { rule }); 
		
        DefaultDamagerRepairer dr = new DefaultDamagerRepairer(scanner); 
		this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE); 
		this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE); 
	} 
    
}

"com.vogella.ide.editor.tasks" 플러그인의 plugin.xml 파일에 "org.eclipse.ui.genericeditor.presentationReconcilers" 확장점에 확장을 추가한다..

<extension point="org.eclipse.ui.genericeditor.presentationReconcilers"> 
	<presentationReconciler class="com.vogella.ide.editor.tasks.PropertiesReconciler" contentType="com.vogella.ide.contenttype.tasks"> 
    </presentationReconciler> 
</extension>

4.2. 구현체 테스트하기

런타임 이클립스를 재시작한다. 

.tasks 파일을 연다. 다음 예처럼 파일에 몇몇 프로퍼티 값을 넣는다. :

ID: 1 
Summary: Eclipse IDE Training 
Description: 
Done: 
Duedate: 
Dependent:

결과는 다음 처럼 보여야 한다.:

5. 연습: 색상을 사용자정의하기 위한 사용자를 허용한다. 

이전 연습에서, 하드코드 컬러를 사용한 .task. 파일 에디터를 위한 구문 하이라이팅을 구현했다. 사용자가 생상을 커스터마이징하는 것을 방지할 수 있기 때무네 이것은 최적은 아니다.

이 연습에서 이 색상을 사용자정의 하는 것을 사용자를 허용하기 위해 "com.vogella.ide.editor.tasks" 플러그인을 확장한다. 

5.1. 색상 정의하기

"org.eclipse.ui.themes" 확장점(extension point)을 위한 확장을 추가 하기 위해 manifest 에디터의 확장(Extensions) 탭을 사용한다. 생성된 엔트리에 오른쪽 마우스 클릭하고, themeElementCategory를 선택하고 사용하다. :

• id: com.vogella.ide.editor.tasks.settings

• label: Tasks settings

생성된 엔트리에 오른쪽 마우스 클릭하고 colorDefinition를 선택한다.

사용:

• id: com.vogella.ide.editor.tasks.key

• label: Task key color

• value: 255,0,0

• categoryId: com.vogella.ide.editor.tasks.settings

plugin.xml 컨텐츠가 다음과 같이 보여야 한다. :

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.4"?> 
<plugin> 

	<extension point="org.eclipse.core.contenttype.contentTypes"> 
		<content-type 
        	file-extensions="tasks" 
        	id="com.vogella.ide.contenttype.tasks" 
            name="Tasks" 
            priority="high"> 
		</content-type> 
	</extension> 

	<extension point="org.eclipse.ui.editors"> 
		<editorContentTypeBinding 
        	contentTypeId="com.vogella.ide.contenttype.tasks" 
        	editorId="org.eclipse.ui.genericeditor.GenericEditor"> 
		</editorContentTypeBinding> 
	</extension> 

	<extension point="org.eclipse.ui.genericeditor.presentationReconcilers"> 
		<presentationReconciler 
        	class="com.vogella.ide.editor.tasks.PropertiesReconciler" 
    		contentType="com.vogella.ide.contenttype.tasks"> 
		</presentationReconciler> 
	</extension> 

	<extension point="org.eclipse.ui.themes"> 
		<colorDefinition 
        	categoryId="com.vogella.ide.editor.tasks.settings" 
        	id="com.vogella.ide.editor.tasks.key" 
            label="Task key color" 
            value="255,0,0"> 
		</colorDefinition> 
		<themeElementCategory 
        	id="com.vogella.ide.editor.tasks.settings" 
        	label="Tasks settings"> 
		</themeElementCategory> 
	</extension> 
    
</plugin>

5.2. 검증하기

만약 런타임 이클립스를 실행하면, Window > Preferences > General > Appearance > Colors and Fonts 설정에서 카테고리와 컬러를 보는것이 가능해야 한다.

5.3. 구문 하이라이팅을 위한 색상 사용하기

색상 레지스터리에 접근하고 에디터에서 그것을 사용한다. 다음 코드 짧은 발췌는 도움이 될 것이다.

IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager(); 
ITheme currentTheme = themeManager.getCurrentTheme(); 
ColorRegistry colorRegistry = currentTheme.getColorRegistry(); 
Color color = colorRegistry.get("com.vogella.ide.editor.tasks.key");

package com.vogella.ide.editor.tasks;

import org.eclipse.jface.resource.ColorRegistry;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.presentation.PresentationReconciler;
import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.RuleBasedScanner;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.themes.ITheme;
import org.eclipse.ui.themes.IThemeManager;

public class PropertiesReconciler extends PresentationReconciler {

    public PropertiesReconciler() {

        IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager();
        ITheme currentTheme = themeManager.getCurrentTheme();
        ColorRegistry colorRegistry = currentTheme.getColorRegistry();
        Color color = colorRegistry.get("com.vogella.ide.editor.tasks.key");

        TextAttribute tagAttribute = new TextAttribute(color);

        RuleBasedScanner scanner = new RuleBasedScanner();
        IRule rule = new PropertyNameRule(new Token(tagAttribute));
        scanner.setRules(new IRule[] { rule });
        DefaultDamagerRepairer dr = new DefaultDamagerRepairer(scanner);
        this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
        this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
    }
}

5.4. 변경 테스트하기

Window > Preferences > General > Appearance > Colors and Fonts를 연다.  에디터의 색상을 검색하고 변경한다. 

에디터를 닫고 새로 연다. 새 색상이 사용되었는지를 검증한다. 

5.5. 색상을 업데이트 하기 위해 preferences 리스너 사용하기 

preferences은 사용자 세팅이 지속됩니다. preferences 리스터를 통해 노드에서 변경을 등록 하는 것이 가능하다. 

프로퍼티 조정자(` PropertiesReconciler`) 재정의에서 설치 메서드는 색상을 지속하기 위해 사용되는 "org.eclipse.ui.workbench" 노드에서 변경을 리스팅할 수 있다..

public void install(ITextViewer viewer) { 
	super.install(viewer); 
	IEclipsePreferences node = InstanceScope.INSTANCE.getNode("org.eclipse.ui.workbench"); 
	node.addPreferenceChangeListener(event -> { 
		// TODO 새 색상으로 변경된 룰로 룰을 업데이트한다. 
    	viewer.invalidateTextPresentation(); 
    }); 
}

TODO 를 해결하고 색상이 업데이트 되었는지 체크하라 

package com.vogella.ide.editor.tasks;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.jface.resource.ColorRegistry;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.presentation.PresentationReconciler;
import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.RuleBasedScanner;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.swt.graphics.Color;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.themes.ITheme;
import org.eclipse.ui.themes.IThemeManager;

public class PropertiesReconciler extends PresentationReconciler {

    private ColorRegistry colorRegistry;
    private RuleBasedScanner scanner;
    private IRule rule;

    @Override
    public void install(ITextViewer viewer) {
        super.install(viewer);

        IEclipsePreferences node = InstanceScope.INSTANCE.getNode("org.eclipse.ui.workbench");

        node.addPreferenceChangeListener(event -> {
            updateRule();
            viewer.invalidateTextPresentation();
        });
    }

    private void updateRule() {
        Color color = colorRegistry.get("com.vogella.ide.editor.tasks.key");
        TextAttribute tagAttribute = new TextAttribute(color);
        rule = new PropertyNameRule(new Token(tagAttribute));
        scanner.setRules(new IRule[] { rule });

    }

    public PropertiesReconciler() {

        IThemeManager themeManager = PlatformUI.getWorkbench().getThemeManager();
        ITheme currentTheme = themeManager.getCurrentTheme();
        colorRegistry = currentTheme.getColorRegistry();

        scanner = new RuleBasedScanner();
        updateRule();

        DefaultDamagerRepairer dr = new DefaultDamagerRepairer(scanner);
        this.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
        this.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
    }
}

6. 연습: TODO 프로퍼티를 위한 컨텐츠 지원을 구현

이 연습에서 .tasks 파일을 위한 컨텐츠 지원(코드 완성)을 구현한다. 앞서 논의 했듯이, 그 파일들은 컬럼으로 구분된 키와 값의 쌍을 포함 하여야 한다. 속성(Properties)은 커서가 줄의 시작에 위치 하는 경우에 제안되게 될 것이다. 

6.1. 컨텐츠 지원 확장 추가하기

"com.vogella.ide.editor.tasks" 플러그인 manifest 파일에 "org.eclipse.ui.genericeditor.contentAssistProcessors" 확장점(extension point)을 위한 확장을 추가한다. 

<extension point="org.eclipse.ui.genericeditor.contentAssistProcessors"> 
	<contentAssistProcessor class="com.vogella.ide.editor.tasks.TodoPropertiesContentAssistProcessor" contentType="com.vogella.ide.contenttype.tasks"> 
	</contentAssistProcessor> 
</extension>

TodoPropertiesContentAssistProcessor 구현체는 다음 코드와 유사하게 보여야 한다. 

package com.vogella.ide.editor.tasks; import java.util.Arrays; 

import java.util.List; 
import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.contentassist.CompletionProposal; 
import org.eclipse.jface.text.contentassist.ICompletionProposal; 
import org.eclipse.jface.text.contentassist.IContentAssistProcessor; 
import org.eclipse.jface.text.contentassist.IContextInformation; 
import org.eclipse.jface.text.contentassist.IContextInformationValidator; 

public class TodoPropertiesContentAssistProcessor implements IContentAssistProcessor { 

	// public as used later by other code 
	public static final List<String> PROPOSALS = Arrays.asList( "ID:", "Summary:", "Description:", "Done:", "Duedate:", "Dependent:"); 

	@Override 
	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) { 
		
    	IDocument document = viewer.getDocument(); 
		try { 
			int lineOfOffset = document.getLineOfOffset(offset); 
			int lineOffset = document.getLineOffset(lineOfOffset); 

			// 줄의 시작이 아닌 위치의 경우에 어떠한 컨텐츠 지원도 보여주지 않는다. 
			if (offset != lineOffset) { 
				return new ICompletionProposal[0]; 
			} 
		} catch (BadLocationException e) { 
			// 여기서는 무시하고 계속...
		} 

		return PROPOSALS.stream().filter(proposal -> !viewer.getDocument().get().contains(proposal)) 
								.map(proposal -> new CompletionProposal(proposal, offset, 0, proposal.length())) 
								.toArray(ICompletionProposal[]::new); 
	} 

	@Override 
	public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) { 
		return null; 
	} 

	@Override 
	public char[] getCompletionProposalAutoActivationCharacters() { 
		return null; 
	} 

	@Override 
	public char[] getContextInformationAutoActivationCharacters() { 
		return null; 
	} 

	@Override 
    public String getErrorMessage() { 
		return null; 
	} 

	@Override 
	public IContextInformationValidator getContextInformationValidator() { 
		return null; 
	} 
}

6.2. 구현체 테스트하기 

IDE를 시작하고 .tasks 파일을 연다. 그리고 컨테츠 지원 활성화 시키기 위해 CTRL+Space 를 누른다. 그 결과는 다음과 같다:

6.3. 추가적인 연습 - 지연된 컨텐츠 지원 프로세서 구현하기

일반적인 에디터는 기본적으로 비동기적 코드 완성을 사용한다. 즉, 심지어 제안 컴퓨터 중에 하나가 느리더라도 사용자 이터페이스를 막지 않는다. 

코드 완성 프로세스에 지연을 추가 함으로써 이것을 테스트 한다. 심지어 컨텐츠 지원이 촉발되더라도 에디터가 사용 가능하게 남아 있는 것을 확인한다.

이후에 다시 지연을 제거하라 

7. 향상된 코드 완성

7.1. 추가 연습 - 접두사 완성 추가하기

IDocument 클래스는 컨텐츠들을 파싱하고 변경하기 위한 많은 유틸리티들을 제공한다.  TodoPropertiesContentAssistProcessor#computeCompletionProposals 메서드를 확당한다. 그래서 접두사에 일치 시킬수 있다. 

예를 들면, "D"를 입력하면,  D와 일치 하는 모든 제안을 보여야 한다.

public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {

    IDocument document = viewer.getDocument();

    try {
        int lineOfOffset = document.getLineOfOffset(offset);
        int lineOffset = document.getLineOffset(lineOfOffset);

        int lineTextLenght = offset - lineOffset;
        String lineStartToOffsetValue = document.get(lineOffset, lineTextLenght).toLowerCase();

        return PROPOSALS.stream()
                .filter(proposal -> !viewer.getDocument().get().contains(proposal)
                        && proposal.toLowerCase().startsWith(lineStartToOffsetValue))
                .map(proposal -> new CompletionProposal(proposal, lineOffset, lineTextLenght, proposal.length()))
                .toArray(ICompletionProposal[]::new);
    } catch (BadLocationException e) {
        e.printStackTrace();
    }
    return new ICompletionProposal[0];
}

7.2. 추가 연습 - 컨텐츠 지원의 자동 활성화 가능하게 하기

현재 컨텐츠 지원은 단지 사용자가 CTRL+Space를 누를때 제안들을 보여 준다.  사용자를 위해서는 분명하지 않을지 모른다. 

IContentAssistProcessor는 getCompletionProposalAutoActivationCharacters 메서드를 사용하여 이 행위(CTRL+Space를 누르는 행위)를 변경하는 것을 허용한다. .

사용자를 위해 CTRL+Space 를 누른느 것은 분명하지 않을지 모른다. 모든 문자 컨텐츠 지원을 활성화하는 것을 구현한다.

@Override
public char[] getCompletionProposalAutoActivationCharacters() {
    String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    return str.toCharArray();
}

8. 연습 : 다른 정보를 사용하여 컨텐츠 지원을 구현하기 

같은 컨텐츠 유형을 위해 복수로 컨텐츠 지원 프로세스를 등록하는 것이 가능하다. 

이 연습에서 에디터에 다른 컨텐츠 지원을 추가한다. 이 프로세서는 _ property를 위한 값을 설정하는 것을 허용하게 될 것이다. 이것은 다른 작업에 종속적인 작업을 모델링 하는 것을 허용한다. 

8.1. 새 컨텐츠 지원 프로세서 구현과 등록

IContentAssistProcessor 인터페이스를 구현하는 DependentTodoContentAssistProcessor 클래스를 생성한다. 

"org.eclipse.ui.genericeditor.contentAssistProcessors" 확장점(extension point)에 확장으로 plugin.xml 파일을 통해 이 클래스를 등록한다.

<extension
      ​point="org.eclipse.ui.genericeditor.contentAssistProcessors">
   ​<contentAssistProcessor
         ​class="com.vogella.ide.editor.tasks.TodoPropertiesContentAssistProcessor"
         ​contentType="com.vogella.ide.contenttype.tasks">
   ​</contentAssistProcessor>
​</extension>
​<extension
      ​point="org.eclipse.ui.genericeditor.contentAssistProcessors">
   ​<contentAssistProcessor
         ​class="com.vogella.ide.editor.tasks.DependentTodoContentProcessor"
         ​contentType="com.vogella.ide.contenttype.tasks">
   ​</contentAssistProcessor>
​</extension>

활성화 데이터에 접근하기 위해, 다음 유틸 클래스를 생성한다.

package com.vogella.ide.editor.tasks; 

import org.eclipse.ui.IEditorPart; 
import org.eclipse.ui.IWorkbench; 
import org.eclipse.ui.IWorkbenchPage; 
import org.eclipse.ui.IWorkbenchWindow; 
import org.eclipse.ui.PlatformUI; 

public class Util { 

	private Util() { 
		// 단지 핼퍼 클래스
	} 

	public static IEditorPart getActiveEditor() { 
		IWorkbench workbench = PlatformUI.getWorkbench(); 
		IWorkbenchWindow activeWorkbenchWindow = workbench.getActiveWorkbenchWindow(); 
		if (null == activeWorkbenchWindow) { 
			activeWorkbenchWindow = workbench.getWorkbenchWindows()[0]; 
		} 

		IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage(); 
		if (activePage == null) { 
			return null; 
		} 
        
		return activePage.getActiveEditor(); 
	} 
    
}

DependentTodoContentAssistProcessor 구현체는 다음과 같이 보여야 한다. :

package com.vogella.ide.editor.tasks; 

import static com.vogella.ide.editor.tasks.Util.getActiveEditor; 
import java.util.Arrays; import org.eclipse.core.resources.IContainer; 
import org.eclipse.core.resources.IResource; 
import org.eclipse.core.runtime.CoreException; 
import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.contentassist.CompletionProposal; 
import org.eclipse.jface.text.contentassist.ICompletionProposal; 
import org.eclipse.jface.text.contentassist.IContentAssistProcessor; 
import org.eclipse.jface.text.contentassist.IContextInformation; 
import org.eclipse.jface.text.contentassist.IContextInformationValidator; 
import org.eclipse.ui.IEditorInput; 
import org.eclipse.ui.IEditorPart; 

public class DependentTodoContentAssistProcessor implements IContentAssistProcessor { 

	@Override 
	public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) { 

		IDocument document = viewer.getDocument(); 
		IEditorPart activeEditor = getActiveEditor(); 
        
		if (activeEditor != null) { 
			IEditorInput editorInput = activeEditor.getEditorInput(); 
			IResource adapter = editorInput.getAdapter(IResource.class); 
			IContainer parent = adapter.getParent(); 
            
			try { 
				int lineOfOffset = document.getLineOfOffset(offset); 
				int lineOffset = document.getLineOffset(lineOfOffset); 
				String lineProperty = document.get(lineOffset, offset - lineOffset); 

				// 컨텐츠 지원은 단지 라인에 종속적으로 사용되어야 한다. 
				if (lineProperty.startWith("Dependent:")) { 
					IResource[] members = parent.members(); 
					// Only take resources, which have the "tasks" file extension and skip the current resource itself 
					return Arrays.asList(members).stream().filter( res -> !adapter.getName().equals(res.getName()) && "tasks".equals(res.getFileExtension())) 
                    									.map(res -> new CompletionProposal(res.getName(), offset, 0, res.getName().length())) 
                                                        .toArray(ICompletionProposal[]::new); 
				} 
			} catch (CoreException | BadLocationException e) { 
				// 여기 무시 하고 계속... 
			} 
		} 
        
		return new ICompletionProposal[0]; 
        
	} 

	@Override 
	public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) { 
	return null; 
	} 

	@Override 
	public char[] getCompletionProposalAutoActivationCharacters() { 
		return null; 
	} 

	@Override 
	public char[] getContextInformationAutoActivationCharacters() { 
		return null; 
	} 

	@Override 
	public String getErrorMessage() { 
		return null; 
	} 

	@Override 
	public IContextInformationValidator getContextInformationValidator() { 
		return null; 
	} 
}

8.2. 검증하기

IDE를 시작하고 적어도 2 .tasks 파일들이 가능한지를 확인한다 그 파일 중 하나를 오픈한다. 그리고 컨텐츠 지원을 활성화 하기 위한 프로퍼티에 종속된 이후 바로 CTRL+Space 키를 누른다.  결과는 다음과 같아야 한다:

9. 연습: 문서 변경에 반응하기

IDocumentSetupParticipant는 기능을 촉발하는 문서의 설정과 변경하는 동안 알림을 받는 것을 허용한다. 컨텐츠 유형을 위한 "org.eclipse.core.filebuffers.documentSetup" 확장점(extension point)을 통한 구현체를 등록 할 수 있다. 

예제에서, .tasks 파일에 빠진 키를 위해 문제점(Problems) 뷰에 마커를 추가 하기 위해 사용한다.

9.1. IDocumentSetupParticipant 구현과 등록

TodoMarkerDocumentSetup은 현재 변경된 IResource를 위한 마커를 적용하기 위한 IDocumentListener을 등록한다.

package com.vogella.ide.editor.tasks; 

import static com.vogella.ide.editor.tasks.Util.getActiveEditor; 
import java.util.Arrays; import java.util.List; 
import java.util.Optional; 
import org.eclipse.core.filebuffers.IDocumentSetupParticipant; 
import org.eclipse.core.resources.IMarker; 
import org.eclipse.core.resources.IResource; 
import org.eclipse.core.runtime.CoreException; 
import org.eclipse.core.runtime.ICoreRunnable; 
import org.eclipse.core.runtime.jobs.Job; 
import org.eclipse.jface.text.DocumentEvent; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.IDocumentListener; 
import org.eclipse.ui.IEditorInput; 
import org.eclipse.ui.IEditorPart; 
import org.eclipse.ui.PlatformUI; 

public class TodoMarkerDocumentSetup implements IDocumentSetupParticipant { 

	private static final String TODO_PROPERTY = "todoProperty"; 

	@Override 
	public void setup(IDocument document) { 
    
		document.addDocumentListener(new IDocumentListener() { 
			private Job markerJob; 
        
			@Override 
			public void documentChanged(DocumentEvent event) { 
				IEditorPart activeEditor = getActiveEditor(); 
				if (activeEditor != null) { 
					IEditorInput editorInput = activeEditor.getEditorInput(); 
					IResource adapter = editorInput.getAdapter(IResource.class); 
					if (markerJob != null) { 
						markerJob.cancel(); 
					} 
					markerJob = Job.create("Adding Marker", (ICoreRunnable) monitor -> createMarker(event, adapter));  // --> 1
					markerJob.setUser(false); markerJob.setPriority(Job.DECORATE); 

					// 계속 타이핑을 핸들링하기 위해 사용자 액션에 반응하기 전에 지연 설정 
					markerJob.schedule(500);  // --> 2
				} 
			} 

			@Override 
			public void documentAboutToBeChanged(DocumentEvent event) { 
				// 필요하지 않음
			} 
		}); 
	}

	private void createMarker(DocumentEvent event, IResource adapter) throws CoreException { 
		String docText = event.getDocument().get(); 
		for (String todoProperty : TodoPropertiesContentAssistProcessor.PROPOSALS) { 
			List<IMarker> markers = Arrays .asList(adapter.findMarkers(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE)); 
			Optional<IMarker> findAny = markers.stream().filter(m -> todoProperty.equals(m.getAttribute(TODO_PROPERTY, ""))).findAny(); 
			if (docText.contains(todoProperty) && findAny.isPresent()) { 
				findAny.get().delete(); 
			} else if (!docText.contains(todoProperty) && !findAny.isPresent()) { 
				IMarker marker = adapter.createMarker(IMarker.PROBLEM); 
				marker.setAttribute(IMarker.MESSAGE, todoProperty + " property is not set"); 
				marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO); 
				marker.setAttribute(IMarker.LOCATION, "Missing line"); 
				marker.setAttribute(TODO_PROPERTY, todoProperty); 
			} 
		} 
	} 
}

plugin.xml에 다음 확장을 추가한다..

<extension point="org.eclipse.core.filebuffers.documentSetup"> 
	<participant class="com.vogella.ide.editor.tasks.TodoMarkerDocumentSetup" contentTypeId="com.vogella.ide.contenttype.tasks"> 
    </participant> 
</extension>

9.2. IDocumentSetupParticipant 등록과 구현

그 결과는 다음과 같이 보여야 한다.:

현재 이미지 링크가 깨져 있슴

10. 연습: 작업을 위한 하이라이팅 구현

이클립스는 다른 파일들에 참조 사이에 탐색을 지원한다. 소스 에디터는 전형적으로 열려있는 파일에 참조에 CTRL + left 마우스 클릭을 지원한다.

*.tasks 파일들은 종속(Dependent)을 통해서 가리킬수 있다: 같은 프로젝트 내에 다른 *.task 파일에 프로퍼티 이 연습에서 에디터는 사용자가 종속 작업 파일 사이 탐색하기 위한것을 허용해야한다.

10.1. manifest 위존관계 추가하기

"com.vogella.ide.editor.tasks"에 플러그인 의존관계로 "org.eclipse.ui.ide" 추가한다.

10.2. 종속 task 파일을 위한 하이퍼링크 구현하기

다음 IHyperlink 구현체 생성하기.

import org.eclipse.core.resources.IFile; 
import org.eclipse.jface.text.IRegion; 
import org.eclipse.jface.text.hyperlink.IHyperlink; 
import org.eclipse.ui.IWorkbenchPage; 
import org.eclipse.ui.PartInitException; 
import org.eclipse.ui.PlatformUI; 
import org.eclipse.ui.ide.IDE; 

public class ResourceHyperlink implements IHyperlink { 

	private IRegion region; 
	private String hyperlinkText; 
	private IFile resource; 

	public ResourceHyperlink(IRegion region, String hyperlinkText, IFile resource) { 
		this.region = region; 
		this.hyperlinkText = hyperlinkText; 
		this.resource = resource;
	}

	@Override 
	public IRegion getHyperlinkRegion() { 
		return region; 
	} 

	@Override 
	public String getTypeLabel() { 
		return null; 
	} 

	@Override 
	public String getHyperlinkText() { 
		return hyperlinkText; 
	} 

	@Override 
	public void open() { 
	IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); 
		try { 
			IDE.openEditor(activePage, resource); 
		} catch (PartInitException e) { 
			e.printStackTrace(); 
		} 
	}
    
}

다음 IHyperlinkDetector 구현체를 생성한다.

import java.util.Arrays; 
import org.eclipse.core.resources.IContainer; 
import org.eclipse.core.resources.IFile; 
import org.eclipse.core.resources.IResource; 
import org.eclipse.core.runtime.CoreException; 
import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.IRegion; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.Region; 
import org.eclipse.jface.text.hyperlink.AbstractHyperlinkDetector; 
import org.eclipse.jface.text.hyperlink.IHyperlink; 
import org.eclipse.ui.IEditorInput; 
import org.eclipse.ui.IEditorPart; 
import org.eclipse.ui.IWorkbench; 
import org.eclipse.ui.IWorkbenchPage; 
import org.eclipse.ui.IWorkbenchWindow; 
import org.eclipse.ui.PlatformUI; 

public class DependentTodoHyperlinkDetector extends AbstractHyperlinkDetector { 

	private static final String DEPENDENT_PROPERTY = "Dependent:"; 

	@Override 
	public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) { 
		IDocument document = textViewer.getDocument(); 
		IWorkbench workbench = PlatformUI.getWorkbench(); 
		IWorkbenchWindow activeWorkbenchWindow = workbench.getActiveWorkbenchWindow(); 
		if (null == activeWorkbenchWindow) { 
			activeWorkbenchWindow = workbench.getWorkbenchWindows()[0]; 
		} 

		IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage(); 
		IEditorPart activeEditor = activePage.getActiveEditor();

		if (activeEditor != null) { 
			IEditorInput editorInput = activeEditor.getEditorInput(); 
			IResource adapter = editorInput.getAdapter(IResource.class); 
			IContainer parent = adapter.getParent(); 

			try { 
				int offset = region.getOffset(); 
				IRegion lineInformationOfOffset = document.getLineInformationOfOffset(offset); 
				String lineContent = document.get(lineInformationOfOffset.getOffset(), lineInformationOfOffset.getLength()); 

				// 컨텐츠 지원은 단지 종속 라인에서 사용되어야 한다.  
				if (lineContent.startsWith(DEPENDENT_PROPERTY)) { 
					String dependentResourceName = lineContent.substring(DEPENDENT_PROPERTY.length()).trim(); 
					Region targetRegion = new Region(lineInformationOfOffset.getOffset() + DEPENDENT_PROPERTY.length(), lineInformationOfOffset.getLength() - DEPENDENT_PROPERTY.length()); 
					IResource[] members = parent.members(); 

					// 단지 "todo" 파일 확장자를 가지는 리소스만 취한다 
					// 그리고 현재 자신의 리소스를 넘어간다. 
					return Arrays.asList(members).stream() 
								.filter(res -> res instanceof IFile && dependentResourceName.equals(res.getName())) 
								.map(res -> new ResourceHyperlink(targetRegion, res.getName(), (IFile) res)) 
								.toArray(IHyperlink[]::new); 
				} 
			} catch (CoreException | BadLocationException e) { 
				e.printStackTrace(); 
			} 
		} 

		// 새 IHyperlink[0]를 반환하지 않는다 
    	// 왜냐하면 배열 단지 null일 수 있고 또는 비어 있지 않을 수 있기 때문이다
		return null; 
	} 
}

DependentTodoHyperlinkDetector 클래스는 다음처럼 plugin.xml에 등록될 수 있다.:

<extension point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectors"> 
	<hyperlinkDetector activate="true" 
    		class="com.vogella.ide.editor.tasks.DependentTodoHyperlinkDetector" 
        	id="com.vogella.ide.editor.tasks.hyperlinkDetector" 
       		name="Hyperlink to other tasks files" 
        	targetId="org.eclipse.ui.genericeditor.GenericEditor"> 
    </hyperlinkDetector> 
</extension>

10.3. 검증하기

검증하기 위해 적어도 2개 *.tasks 파일들을 생성하고 그 중에 하나를 가르키기 위한 종속적 속성을 사용한다. 연결된 파일을 탐색하기 위해 CTRL + 왼쪽 마우스 클릭을 사용할수 있는것을 검증한다. 

Dependent:Training2.tasks

11. 예제: 회사명을 위한 하이퍼링크 탐지기를 구현한다.

이 연습에서 일반적 에디터에서 vogella 키워드를 위한 하이퍼링크 탐지기를 생성한다.

11.1. 프로젝트를 생성하고 의존관계를 추가한다. 

"com.vogella.ide.editor.companylink" 이름으로 된 새 플러그인 프로젝트를 생성한다..

의존관계로 다음 플러그인들을 추가한다.:

• org.eclipse.ui

• org.eclipse.jface

• org.eclipse.ui.workbench.texteditor

11.2. 하이퍼링크 탐지기 추가하기

유니크 ID와 기술한 이름으로 "org.eclipse.ui.workbench.texteditor.hyperlinkDetectors" 확장 추가하기.

하이퍼링크를 결정하고 그 하이퍼링크와 상효작용하기 위한 다음 두 클래스를 생성한다. 

package com.vogella.ide.editor.companylink; 

import org.eclipse.jface.text.IRegion; 
import org.eclipse.jface.text.hyperlink.IHyperlink; 
import org.eclipse.swt.program.Program; 

public class VogellaHyperlink implements IHyperlink { 

	private final IRegion fUrlRegion;
    
	public VogellaHyperlink(IRegion urlRegion) { 
		fUrlRegion = urlRegion; 
	} 

	@Override 
	public IRegion getHyperlinkRegion() { 
		return fUrlRegion; 
	} 

	@Override 
	public String getTypeLabel() { 
		return null; 
	} 

	@Override 
	public String getHyperlinkText() { 
		return "Open vogella website"; 
	} 

	@Override 
	public void open() { 
		Program.launch("https://www.vogella.com/"); 
	} 
}

package com.vogella.ide.editor.companylink; 

import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.IRegion; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.Region; 
import org.eclipse.jface.text.hyperlink.AbstractHyperlinkDetector; 
import org.eclipse.jface.text.hyperlink.IHyperlink; 

public class VogellaHyperlinkDetector extends AbstractHyperlinkDetector { 

	public VogellaHyperlinkDetector() { 
	} 

	@Override 
	public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) { 

		IDocument document = textViewer.getDocument(); 
		int offset = region.getOffset(); 

		// 관련 문자 추출한다
		IRegion lineRegion; 
		String candidate; 
		try { 
			lineRegion = document.getLineInformationOfOffset(offset); 
			candidate = document.get(lineRegion.getOffset(), lineRegion.getLength()); 
		} catch (BadLocationException ex) { 
			return null; 
		} 

		// 키워드를 찾는다.
		int index = candidate.indexOf("vogella"); 
		if (index != -1) { 

			// 키워드를 포함하는 영역을 탐색한다. 
			IRegion targetRegion = new Region(lineRegion.getOffset() + index, "vogella".length()); 
			if ((targetRegion.getOffset() <= offset) && ((targetRegion.getOffset() + targetRegion.getLength()) > offset)) {
				// 링크를 생성한다. 
				return new IHyperlink[] { new VogellaHyperlink(targetRegion) };
            }
		} 
        
		return null; 
        
	} 
    
}

11.3. 검증하기

플러그인을 시작하고 텍스트 에디터에 예를 들면, Java 에디터에서 "vogella"를 추가 한다. Ctrl을 누르고 "vogella"를 클릭한다.외부 브라우저에서 https://www.vogella.com/ 웹사이트가 열려야 한다.

12. 연습: task 파일에 코드 마이닝(추출) 정보 추가 하기.

이클립스는 텍스트 에디터에서 그 정보를 향샹 시키기 위해 추가적인 정보를 보여 주는 것을 지원한다. 그 정보는 저장되지 않는다. 그러나 사용자가 더 나은 내용을 이해 하는데 도움을 준다. 또한 코드 마이닝은 행위를 등록하고 텍스트 에디터를 사용한 디렉토리의 행위를 수행할 수 있다. 

이 연습에서 추가적인 정보를 보여주고 사용자가 코드 마이닝을 통해 어떤 행위를 수행하는 것을 허용하기 위해 task 에디터를 위한 코드 마이닝을 향상 시키게 될 것이다. 

12.1. 코드 마이닝 구현과 등록 

라인 헤더 어노테이션을 생성한 다음 클래스를 구현한다. 

package com.vogella.ide.editor.tasks; 

import java.util.concurrent.CompletableFuture; 
import org.eclipse.core.runtime.IProgressMonitor; 
import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.codemining.ICodeMiningProvider; 
import org.eclipse.jface.text.codemining.LineHeaderCodeMining; 

public class TaskCodeMining extends LineHeaderCodeMining { 

	public TaskCodeMining(int beforeLineNumber, IDocument document, ICodeMiningProvider provider) throws BadLocationException { 
		super(beforeLineNumber, document, provider); 
	} 

	@Override 
	protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) { 
		return CompletableFuture.runAsync(() -> { super.setLabel("This is additional information about the tasks"); }); 
	} 
    
}

다음 ICodeMiningProvider의 구현체를 생성한다..

package com.vogella.ide.editor.tasks; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.CompletableFuture; 
import org.eclipse.core.runtime.IProgressMonitor; 
import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.codemining.ICodeMining; 
import org.eclipse.jface.text.codemining.ICodeMiningProvider; 

public class TaskCodeMiningProvider implements ICodeMiningProvider { 

	public TaskCodeMiningProvider() { 
	} 

	@Override 
	public CompletableFuture<List<? extends ICodeMining>> provideCodeMinings(ITextViewer viewer, IProgressMonitor monitor) { 

		return CompletableFuture.supplyAsync(() -> { 
			List<ICodeMining> minings = new ArrayList<>(); 
			IDocument document = viewer.getDocument(); 
			try { 
				minings.add(new TaskCodeMining(0, document, this)); 
			} catch (BadLocationException e) { 
				e.printStackTrace(); 
			} 
            return minings; 
		}); 
	} 

	@Override 
	public void dispose() { 
	} 

}

"org.eclipse.ui.genericeditor.reconcilers" 확장을 통해 컨텐츠 유형을 위한 기본 CodeMiningReconciler를 등록한다..

<extension point="org.eclipse.ui.genericeditor.reconcilers"> 
	<reconciler class="org.eclipse.jface.text.codemining.CodeMiningReconciler" 
			contentType="com.vogella.ide.contenttype.tasks"> 
	</reconciler> 
</extension>

이제 plugin.xml에 다음 확장을 추가한다..

<extension point="org.eclipse.ui.workbench.texteditor.codeMiningProviders"> 
	<codeMiningProvider class="com.vogella.ide.editor.tasks.TaskCodeMiningProvider" 
			id="com.vogella.ide.editor.tasks.codeMiningProvider" 
			label="Show additional task info"> 
		<enabledWhen> 
			<with variable="editorInput"> 
				<adapt type="org.eclipse.core.resources.IFile"> 
					<test property="org.eclipse.core.resources.contentTypeId" 
							value="com.vogella.ide.contenttype.tasks" /> 
				</adapt> 
			</with>
		</enabledWhen> 
	</codeMiningProvider> 
</extension>

12.2. Validate

에디터가 헤더에 추가 정보를 보여주는지 확인하라.

13. 추가 연습 - 코드 마이닝에 액션 추가하기

사용자가 몇몇 액션을 촉발하는 것을 허용하기 위해  TaskCodeMining에 getAction을 재정의 한다. 

package com.vogella.ide.editor.tasks; 

import java.util.concurrent.CompletableFuture; 
import java.util.function.Consumer; 
import org.eclipse.core.runtime.IProgressMonitor; 
import org.eclipse.jface.dialogs.MessageDialog; 
import org.eclipse.jface.text.BadLocationException; 
import org.eclipse.jface.text.IDocument; 
import org.eclipse.jface.text.ITextViewer; 
import org.eclipse.jface.text.codemining.ICodeMiningProvider; 
import org.eclipse.jface.text.codemining.LineHeaderCodeMining; 
import org.eclipse.swt.events.MouseEvent; 

public class TaskCodeMining extends LineHeaderCodeMining { 

	private ITextViewer viewer; 
    
	public TaskCodeMining(int beforeLineNumber, IDocument document, ICodeMiningProvider provider, boolean isValid) throws BadLocationException { 
		super(beforeLineNumber, document, provider); 
	} 

	@Override 
	protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) { 
		this.viewer = viewer; 
		return CompletableFuture.runAsync(() -> { super.setLabel("This is additional information about the tasks"); }); 
	} 

	@Override 
	public Consumer<MouseEvent> getAction() { 
    	return r->showMessageDialog(); 
    } 

	private void showMessageDialog() { 
		MessageDialog.openInformation(viewer.getTextWidget().getShell(), "Clicked", "You clicked on the code mining annotation"); 
	} 
}

14. Optional exercise - Extend your code mining

Clone the Git repository located at https://github.com/angelozerr/EclipseConFrance2018. Import the included project and test them.

Use the information to extend your code mining, e.g., add code minings to each line in your editor.

15. 추가 연습 - JDT 코드 마이닝 리뷰하기

https://github.com/angelozerr/jdt-codemining 위치한 Git 저장소를 복제한다.

코드를 복제하고 프로젝트를 import 한다. 런타임 이클립스에 해당소스를 포함시킨다. 코드를 리뷰한다.

16. 연습: 사용자 정의 에디터 구현하기

새로운것을 저으이 하는 데신에 일반 에디터를재 사용하는 것을 권장하기 때문에, 이것은 여전히 지원된다. 이 장은 어떻게 할 수 있는지 설명을 제공한다. 

16.1. IEditorPart 와 EditorPart

이클립스 IDE를 위한 새 에디터를 정의 하기 위해, 전형적으로, * IEditorInput 클래스를 생성한다. * "org.eclipse.ui.editors" 확장점(extension point)을 위한 확장을 정의한다. * IEditorPart를 확장한 클래스를 구현한다.

IEditorInput는 에디터를 위한 모델로 서비스한다. 이클립스는 IEditorInput 객체 버퍼를 제공하게 될 것이고 그러므로   그 객체는 상대적으로 작아야 한다.

그것은 모델의 경령화 표현을 제공되게 되도록 되어 있다. 예를들면 이클립스 IDE 완전한 파일로 핸들링 하지 않고 파일을 식별하는 IEditorInput 객체를 사용한다. 

IEditorInput의 equals()은 에디터의 본질을 정의한다. 즉, 만약 에디터가 이미 열려 있는지 아닌지 결정하는데 사용된다.

에디터는  init() 메서드에서 IEditorSite 와IEditorInput 를 받는다. setInput() 메서드를 통한 input 과 setSite() 메서드를 통한 side를 설정해야 한다. .

createPartControl() (사용자 인터페이스를 생성하는 ) 이전에 init()이 호출된다. 그러므로 UI 생성하는 동안 input을 사용할 수 있다. 

자체 퍼스펙티브를 정의 한다면, 퍼스펙티브 구현체에 다음 코드를 통해서 에디터 영역을 가능하게 할 수 있다. 

import org.eclipse.ui.IPageLayout; 

public class Perspective implements IPerspectiveFactory { 

	public void createInitialLayout(IPageLayout layout) { 
		//layout.setEditorAreaVisible(false); 
        layout.setFixed(true); 
	} 
    
}

16.2. 에디터 제목과 툴팁을 설정하기 

기본적으로, 에디터는 IEditorInput으로 부터 툴팁과 제목을 사용하게될 것이다.  그러므로 에디터에 타이틀과 툴팁을 변경하는 것을 원할지 모른다. 에디터의 제목을 설정하기 위해 setPartName()와 툴닙을 설정하기 위해 getTitleToolTip()을 사용한다. 툴팁에 대한 자세한 것은 버그 https://bugs.eclipse.org/bugs/show_bug.cgi?id=107772 를 보라.

16.3. 에디터 내용 저장하기 

isDirty()메서드는 에디터가 변경된 데이타를 포함하는지를 결정하다. 이 더티 상태에 벼경에 대한 워크벤치 정보를 위해, 이벤트를 시작한다.

firePropertyChange(IEditorPart.PROP.DIRTY);

17. 링크와 참고 문헌

Adding Colors and Font preferences blog post

https://www.eclipse.org/eclipse/platform-text/eclipseCon/talk.pdf

https://flylib.com/books/en/1.70.1/creating_a_text_editor_with_jface_text.html

https://www.eclipse.org/articles/Article-Folding-in-Eclipse-Text-Editors/folding.html

https://wiki.eclipse.org/FAQ_How_do_I_use_the_text_document_model%3F

18. vogella 트레이닝과 컨설팅 지원

온라인 트레이닝

fitness_center

사이트 트레이닝

group

컨설팅

Appendix A: 저작권, 라이선스와 소스코드

Copyright © 2012-2019 vogella GmbH. Free use of the software examples is granted under the terms of the Eclipse Public License 2.0. This tutorial is published under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Germany license.

Licence

Source code

Sponsor our Open Source development activities and our free content to help us make development easier for everyone

번역 문서 저작권 표시 :
저작자표시-비영리-동일조건 변경 허락 (CC BY-NC-SA)
원문 저작권 표시 :
(ExtensionsAdding menus, toolbar and popup menus to the Eclipse IDE, by Lars Vogel, (c) 2009 - 2020 vogella GmbH Version 3.2, 29.08.2016
, CC BY-NC-SA )
소스 코드의 경우 Eclipse Public License 2.0 를 따른다.

[원문 출처] www.vogella.com/tutorials/EclipseCommands/article.html

해당 문서의 경우 vogella사의 Eclipse IDE Extensions Document 문서 일부를 번역 한 것입니다. 번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 
번역 작업 시 이클립스 내 고유이름을 가진 값의 경우, 가령 Tab의 명칭 등의 경우 화면에서 표시되는 이름이므로 별도로 번역없이 제공하거나 괄호를 사용하여 동시에 명기한다.
저작자표시-비영리-동일조건 변경 허락 (BY-NC-SA)

www.sogomsoft.co.kr (주) 소곰소프트 

1. 커멘드 소개

이클립스 프레임워크는 사용자 인터페이스에 액션을 기여하기 위해 커멘트 프레임워크를 사용한다. 

이클립스에서 커멘드는 컴포넌트의 선언적 기술이며 구현 상세로 부터 독립적이다. 

커멘드는 카테고리화 될 수 있고 사용자 인터페이스에 할당 될 수 있고 키 바인딩은 커멘드를 위해 정의 될 수 있다. 핸들러를 통해 커멘드의 동작이 정의 된다. 

1.1. 이클립스 3.x API로 커멘트 정의하기

이클립스3.x API는 커멘드를 정의하기 위해 확장점(extension points)을 사용한다. 3 확장점이 여기서 역할을 수행한다. 다음 확장점(extension points)은 이클립스 플러그인을 위해 메뉴 또는 툴바 컨트리뷰션을 정의 하는데 관련 있다. 

표 1. 확장점 설명

2.2. 메뉴 확장점의 위치 정의 하기

커멘드의 위치를 정의 할 수있다. 예를들면, 저장(Save) 메뉴 엔트리 다음에 전체 저장(Save All) 메뉴 엔트리가 위치해야 한다. "?before=ID" 또는 "?after=ID" 같은 패턴을 사용함으로써 이 로케이션URL(locationURI)에 커멘드의 상대적 위치를 정의 할 수 있다. .

ID는 menu ID, 또는 item ID 같은 존재 하는 구별자 이름이 될 수 있다. 커멘드는 상응하는 ID로 에리먼트의 앞과 뒤에 놓일 수 있다.

예를 들면, oneEntry 메뉴 엔트리 앞에 fileMenu 메뉴에서 커멘드를 놓기 위해, menu:fileMenu?after=oneEntry 로케이션URI(locationURI)를 사용한다.

3. 핸들러(Handler)

3.1. 커멘드 핸들러

org.eclipse.ui.handlers 확장점(extension point)은 커멘드가 실행될때 한번 호출 되는 어떤 클래스에 커멘드를 연결한다.

커멘드의 동작은 핸들러를 통해서 정의된다. 핸들러(handler)는 커멘드가 호출 될때 한번 실행되는 클래스이다. org.eclipse.core.commands 패키지로 부터 IHandler 인터페이스를 구현 해야 한다. .

IHandler 인터페이스 기본 구현체로 제공되는 org.eclipse.core.commands.AbstractHandler 클래스를 확장 할 수 있다.

핸들러가 실행되면 execute() 메서드가 호출된다. 

execute() 메서드에서 HandlerUtil 클래스를 통해서 시스템 값에 접근 할 수있다. 

3.2. 핸들러의 효력

핸들러는 핸들러가 커멘트에 유효한지에 따라 정의된 조건하에서 조건(activeWhen)으로 정의 될 수 있다. 커멘트들 위해 여러 핸들러들이 정의 될 수 있다. 단지 하나의 핸들러가 어떤 조건의 커멘드를 위해 유효 할 수 있고, 만약 여러개 핸들러가 유효하다면, 이클립스 런타임은 그 커멘드를 비활성화 한다. (역자주, 여러개의 핸들러와 매핑될 수 있지만 하나의 핸들러만 유효해야 하고 여러 핸들러가 유효한 상태이면 그 커멘드가 비활성화 된다.)

4. 튜토리얼의 전제조건

이 튜토리얼은 이클립스 플랫폼 개발의 기본적 이해를 가지고 있다는 것을 가정한다. 만약 기본 정보를 필요로 하면 Eclipse RCP Tutorial 또는 Eclipse Plug-in Tutorial 을 보라.

5. 튜토리얼: 커멘드(Commands )와 메뉴(menus) 

5.1. 연습: 커멘드 정의하기

이 연습에서 어플르케이션을 빠져나오기 위해 허용하는 커멘드를 생성한다. 새 RCP project 를  "Hello RCP" 템플릿을 사용하여 "de.vogella.rcp.commands.first" 생성하라. plugin.xml을 열고 확장(Extensions) 탭을 선택하라. Add…​ 버튼을 눌러라.

확장 "org.eclipse.ui.commands"를 검색하고, 해당 확장을 선택하고 finish버튼을 누른다.

확장(extension)을 오른쪽 마우스 클릭하고 New → command를 선택함으로써 새 커멘드를 생성한다.

"de.vogella.rcp.commands.first.commands.Exit"를 id*인 ID 항목에 "Exit"를 name*인 이름 항목에 설정한다. defaultHandler인 기본핸들러 항목에 "de.vogella.rcp.commands.first.commands.ExitHandler" 클래스를 넣는다..

"org.eclipse.core.commands.AbstractHandler"를 확장해야 하는 클래스를 생성해야 하기 위해 "defaultHandler" 하이퍼 링크를 누른다.

package de.vogella.rcp.commands.first.commands; 

import org.eclipse.core.commands.AbstractHandler; 
import org.eclipse.core.commands.ExecutionEvent; 
import org.eclipse.core.commands.ExecutionException; 
import org.eclipse.ui.handlers.HandlerUtil; 

public class ExitHandler extends AbstractHandler { 
	
    @Override 
    public Object execute(ExecutionEvent event) throws ExecutionException { 
    	HandlerUtil.getActiveWorkbenchWindow(event).close(); 
        return null; 
    } 
}

5.2. 메뉴에서 커멘드 사용하기 

정의된 커멘드는메뉴에서 사용되어야 한다. org.eclipse.ui.menus 확장점(extension point)에 확장(extension)을 추가한다. 확장점(extension point)에 오른쪽 마우스 클릭하고 New > menuContribution.을 선택한다. 

"menu:org.eclipse.ui.main.menu" 로케이션URI(locationURI)로 새 메뉴 컨트리 뷰션을 생성한다. URL이 정확한 스펠링으로 되어 있는지 확인하라 아니면 그 메뉴가 보여지지 않게 될 것이다. 

메뉴컨트리뷰션(menucontribution)에 오른쪽 클릭하고 New > Menu를 선택하라. label*인 라벨 항목에 "File" 과 id 인 ID 항목에 "fileMenu"로 메뉴를 추가 하라.

 메류를 선택하고, 그 메뉴에 오른쪽 마우스 클릭하고, New→ Command를 선택한다. commandID를 지정하라. "Exit"를 라벨 항목에 "Exits the application"를 툴팁 항목에 설정하라..

plugin.xml 파일에 다음과 예제와 같이 보이는 결과가 만들어져야 한다. 

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.4"?> 
<plugin> 
   	<extension id="application" point="org.eclipse.core.runtime.applications"> 
       	<application> 
           	<run class="de.vogella.rcp.commands.first.Application"> 
               </run> 
           </application> 
    </extension> 
	<extension point="org.eclipse.ui.perspectives"> 
       	<perspective name="RCP Perspective" 
           			class="de.vogella.rcp.commands.first.Perspective" 
                    id="de.vogella.rcp.commands.first.perspective"> 
        </perspective> 
    </extension> 
    <extension point="org.eclipse.ui.commands"> 
      	<command defaultHandler="de.vogella.rcp.commands.first.commands.ExitHandler" 
           		id="de.vogella.rcp.commands.first.commands.Exit" 
                name="Exit"> 
        </command> 
    </extension> 
    <extension point="org.eclipse.ui.menus"> 
       	<menuContribution locationURI="menu:org.eclipse.ui.main.menu"> 
           	<menu id="fileMenu" label="File"> 
               	<command commandId="de.vogella.rcp.commands.first.commands.Exit" 
                   		label="Exit" style="push" 
                        tooltip="Exit the application"> 
                </command> 
            </menu> 
         </menuContribution> 
    </extension> 
 </plugin>

예제를 실행하면. 파일 메뉴가 보여야 하고 "Exit" 엔트리를 선택하면 어플리케이션이 종료된다.

6. Tutorial: 커멘드(Commands) 와 툴바(toolbars)

6.1. 개요

어플리케이션 툴바와 뷰 툴바에 커멘드를 추가 할 수 있다. 

6.2. 어플리케이션 툴바 (coolbar)

"de.vogella.rcp.intro.commands.toolbar" 이름의 새 프로젝트를 생성한다. 탬플릿 "RCP application with a view" 을 사용한다. "de.vogella.rcp.intro.commands.toolbar.handler.Hello"을 기본 핸들러로  "de.vogella.rcp.intro.commands.toolbar.Hello" 커멘드를 생성한다. 이 핸들러가 JFace 다이얼로그를 연다.

package de.vogella.rcp.intro.commands.toolbar.handler; 

import org.eclipse.core.commands.AbstractHandler; 
import org.eclipse.core.commands.ExecutionEvent; 
import org.eclipse.core.commands.ExecutionException; 
import org.eclipse.jface.dialogs.MessageDialog; 
import org.eclipse.ui.handlers.HandlerUtil; 

public class Hello extends AbstractHandler { 

	@Override 
    public Object execute(ExecutionEvent event) throws ExecutionException { 
    	MessageDialog.openInformation(HandlerUtil.getActiveWorkbenchWindow( event).getShell(), "Info", "Info for you"); 
        return null; 
    } 
}

"org.eclipse.ui.menus extension" 확장에 메뉴컨트리뷰션(menucontribution)을 추가한 후 "toolbar:org.eclipse.ui.main.toolbar"에 로케이션 URI(location URI)을 설정한다.  앞서 생성한 메뉴 컨트리뷰션에 자식 엘리먼트로 툴바를 추가한다.

툴바에 "de.vogella.rcp.intro.commands.toolbar.Hello" 커멘드를 추가한다. 그 커멘트에 라벨과 아이콘을 작성한다.

ApplicationWorkbenchWindowAdvisor 의 configurer.setShowCoolBar(true); 메서드 호출을 통해 어플리케이션 툴바를 활성화 시킨다.

package de.vogella.rcp.intro.commands.toolbar; 

import org.eclipse.swt.graphics.Point; 
import org.eclipse.ui.application.ActionBarAdvisor; 
import org.eclipse.ui.application.IActionBarConfigurer; 
import org.eclipse.ui.application.IWorkbenchWindowConfigurer; 
import org.eclipse.ui.application.WorkbenchWindowAdvisor; 

public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor { 

	public ApplicationWorkbenchWindowAdvisor( 
    	IWorkbenchWindowConfigurer configurer) { 
        	super(configurer); 
        } 
   	
    public ActionBarAdvisor createActionBarAdvisor( IActionBarConfigurer configurer) { 
    	return new ApplicationActionBarAdvisor(configurer); 
    } 
    
    public void preWindowOpen() { 
    	IWorkbenchWindowConfigurer configurer = getWindowConfigurer(); 
        configurer.setInitialSize(new Point(400, 300)); 
        configurer.setShowStatusLine(false); 
        configurer.setShowCoolBar(true); 
        configurer.setTitle("RCP Application"); 
    } 
}

결과는 다음처럼 보이게 된다. 만약 툴바에 엘리먼트를 선택하면 정보 대화창이 열려야 한다.

6.3. 뷰툴바에 기여

뷰 툴바에 직접적으로 커멘드를 추가할 수 있다. 그 것을 위해 이전 예제를 확장한다.  다음에  IPerspectiveFactory를 상속 받은 퍼스펙티브("Perspective") 클래스를 변경하라 (단독 실행(스탠드-얼론, stand-alone) 뷰는 자신의 툴바를 가지지 않는다.).

package de.vogella.rcp.intro.commands.toolbar; 

import org.eclipse.ui.IPageLayout; 
import org.eclipse.ui.IPerspectiveFactory; 

public class Perspective implements IPerspectiveFactory { 

	public void createInitialLayout(IPageLayout layout) { 
    	String editorArea = layout.getEditorArea(); 
        layout.setEditorAreaVisible(false); 
        layout.setFixed(true); layout.addView(View.ID, IPageLayout.LEFT, 1.0f, editorArea); 
    }
}

"toolbar:de.vogella.rcp.intro.commands.toolbar.view" 값을 locationURI: 항목에 로케이션 URI를 사용하는 "org.eclipse.ui.menus" 확장점에 새 메뉴컨트리뷰션을 생성한다.  여기에 toolbar: 접두사는 툴바에 방금 생성한 메뉴컨트리뷰션 추가하기 위해 시스템을 말하고 두번째 인수는 그 뷰의 ID이다. 

이 메뉴컨트리뷰션을 위해 새 커멘드를 생성하고 "de.vogella.rcp.intro.commands.toolbar.Hello"로 커멘드 ID를 설정한다. 그 커멘드의 라벨에 "Say Hello"를 입력한다.

새 뷰 컨트리뷰션을 보기위해 어플리케이션을 실행하라.

6.4. 드롭다운 목록

다음은 어플리케이션 쿨바에 드롭다운 목록을 추가한다. 

이 드롭다운 목록 결과물은 약간 낮설다. 나중에 다른 (실제) 커멘드가 할당되게 될 드롭다운 커멘드 핼퍼(도우미)를 생성한다.

따라서 "referenceToMenuId" 값을 ID로 커멘드를 생성하고 기본 핸들러를 관리 한다. 예를 들면,  "de.vogella.rcp.intro.commands.toolbar.handler.Hello"를 재사용할 수 있다.

"org.eclipse.ui.menus" 확장점에 새 메뉴컨트리뷰션을 추가하고, 그 컨트리뷰션에 "toolbar:org.eclipse.ui.main.toolbar"를 로케이션 URI(location URI)를 설정한다. 새 확장에 툴바와 그 툴바에 새 커멘드를 추가한다. 그 커멘드에 ID는 referenceToMenuId를 사용하는 ID에 라벨과 아이컨을 부여하고  "pulldown"로 스타일을 변경한다.

As the id use referenceToMenuId give it a label and an icon and change the style to "pulldown".

새 메뉴컨트리뷰션을 생성하고 "menu:referenceToMenuId"을 로케이션 URI(locationURI)로 설정한다.

이 풀다운 메뉴에 존재하는 커멘드 "de.vogella.rcp.intro.commands.toolbar.Hello"를 각각 다른 라벨을 사용하여 2번 추가한다. 

어플리케이션을 실행하면, 이제 어플리케이션 툴바에 드롭다운 메뉴를 가지게 된다. 

7. 튜토리얼: 커멘드와 컨텍스트 메뉴

이 예제에서 SWT 테이블 위젯에 컨텍스트 메뉴를 추가한다. "RCP application with a view" 샘플을 기반으로 de.vogella.rcp.intro.commands.popup 이름의 새 프로젝트를 생성한다.

"de.vogella.rcp.intro.commands.popup.showSelected" ID 와 "Show" 라는 이름으로 새 커멘드를 생성한다.

이 예제에서 기본 핸들러를 사용하지 않게 될 것이다.  따라서 plugin.xml 파일에 "org.eclipse.ui.handlers" 확장점을 추가 하고 핸들러를 추가한다. 첫번째 파리미터는 커멘드ID(commandId)이고 두번째 파라미터는 핸들러를 위한 클래스이다. 클래스 이름으로 de.vogella.rcp.intro.commands.popup.handler.ShowSelected를 사용한다.

이제 핸들러에 이 소스를 구현한다. 이 소스는 단지 콘솔에 선택된 엘리먼트를 출력한다. 

package de.vogella.rcp.intro.commands.popup.handler; 

import java.util.Iterator; 
import org.eclipse.core.commands.AbstractHandler; 
import org.eclipse.core.commands.ExecutionEvent; 
import org.eclipse.core.commands.ExecutionException; 
import org.eclipse.jface.viewers.ISelection; 
import org.eclipse.jface.viewers.IStructuredSelection; 
import org.eclipse.ui.handlers.HandlerUtil; 

public class ShowSelected extends AbstractHandler { 
	
    @SuppressWarnings("unchecked") 
    @Override 
    public Object execute(ExecutionEvent event) throws ExecutionException { 
    
    	ISelection selection = HandlerUtil.getActiveWorkbenchWindow(event) .getActivePage().getSelection(); 
        
        if (selection != null & selection instanceof IStructuredSelection) { 
        	IStructuredSelection strucSelection = (IStructuredSelection) selection; 
            for (Iterator<Object> iterator = strucSelection.iterator(); iterator.hasNext();) { 
            	Object element = iterator.next(); 
            	System.out.println(element.toString()); 
            } 
        } 
        
        return null; 
    } 
    
}

자동적으로 생성되게 될 뷰의 ID가 "de.vogella.rcp.intro.commands.popup.view" 인 곳에  "popup:de.vogella.rcp.intro.commands.popup.view" 로 로케이션 URI를 설정한 새 메뉴컨트리뷰션을 추가한다.

새 메뉴컨트리뷰션을 오른쪽 마우스 클릭하고 New → Command를 선택한다. Assign your command to the field "commandId" 필드에 커멘드를 지정하고. 라벨 필드에  "One Item selected" 을 입력한다.

이제 뷰에 메뉴관리자(MenuManager)를 추가했다. 뷰 클래스를 선택하고 다음처럼 변경한다. 

package de.vogella.rcp.intro.commands.popup; 

import java.util.ArrayList; 
import java.util.List; 
import org.eclipse.jface.action.MenuManager; 
import org.eclipse.jface.viewers.ArrayContentProvider; 
import org.eclipse.jface.viewers.LabelProvider; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.graphics.Image; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.swt.widgets.Menu; 
import org.eclipse.ui.ISharedImages; 
import org.eclipse.ui.PlatformUI; 
import org.eclipse.ui.part.ViewPart; 

public class View extends ViewPart { 

	private TableViewer viewer; 
    
    class ViewLabelProvider extends LabelProvider { 
    
        @Override 
        public Image getImage(Object obj) { 
        	return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); 
        } 
        
    } 
    
    @Override 
    public void createPartControl(Composite parent) { 
    
    	viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
        viewer.setContentProvider(ArrayContentProvider.getInstance()); 
        viewer.setLabelProvider(new ViewLabelProvider()); 
        viewer.setInput(getData()); 
        
        // 메뉴 관리자를 생성하고 컨텍스트 메뉴를 생성한다. 
        MenuManager menuManager = new MenuManager(); 
        Menu menu = menuManager.createContextMenu(viewer.getTable()); 
        
        // SWT 위젯에 메뉴를 설정한다. 
        viewer.getTable().setMenu(menu); 
        
        // 프레임워크에 메뉴를 등록한다.  
        getSite().registerContextMenu(menuManager, viewer); 
        
        // 선택 가능한 뷰어를 만든다.
        getSite().setSelectionProvider(viewer); 
	
    } 
        
    /** 
      * 뷰어의 컨트롤에 포커스 요청을 전달한다.  
      */
    @Override 
    public void setFocus() { 
      	viewer.getControl().setFocus(); 
    } 
        
    private List<String> getData() { 
       	List<String> list = new ArrayList<String>(); 
        list.add("One"); 
        list.add("Two"); 
        list.add("Three"); 
            
        return list; 
    } 
    
}

어플리케이션을 실행하라. 테이블에 오른쪽 마우스 클랙을 수행하면, 메뉴가 볼수 있게 되어야 한다. 마약 그 메뉴를 선택하면,  선택된 아이템의 이름이 콘솔에 기록되어야 한다.

8. 링크와 참고문헌

8.1. 이클립스 커멘드 리소스

Eclipse Commands Advanced

Key bindings for Commands

http://wiki.eclipse.org/Platform_Command_Framework Command Framework wiki

http://wiki.eclipse.org/Command_Core_Expressions Commands Core Expressions

번역 문서 저작권 표시 :
저작자표시-비영리-동일조건 변경 허락 (CC BY-NC-SA)
원문 저작권 표시 :
(Eclipse IDE Plug-in Development: Plug-ins, Features, Update Sites and IDE Extensions, by Lars Vogel (c) 2009 - 2020 vogella GmbHVersion 5.5,31.08.2018, CC BY-NC-SA )
소스 코드의 경우 Eclipse Public License 2.0 를 따른다.

[원문 출처] www.vogella.com/tutorials/EclipsePlugin/article.html

해당 문서의 경우 vogella사의 Eclipse IDE Extensions Document 문서 일부를 번역 한 것입니다. 번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 
번역 작업 시 이클립스 내 고유이름을 가진 값의 경우, 가령 Tab의 명칭 등의 경우 화면에서 표시되는 이름이므로 별도로 번역없이 제공하거나 괄호를 사용하여 동시에 명기한다.
저작자표시-비영리-동일조건 변경 허락 (BY-NC-SA)

www.sogomsoft.co.kr (주) 소곰소프트 

이클립스 IDE 플러그인 개발: Plug-ins, Features, Update Sites 와 IDE Extensions

Lars Vogel (c) 2009 - 2020 vogella GmbHVersion 5.5,31.08.2018

이 튜토리얼은 사용자 정의 플러그인으로 이클립스 IDE를 확장 하기 위한 방법을 기술한다. 

1. 이클립스 IDE 확장하기

이클립스 플랫폼과 이클립스 IDE는 기능을 추가, 제거, 또는 존재하는 기능을 사용자 정의 하는 것을 가능하게 하는 확장 가능한 프레임워크이다. 

이클립스 IDE의 모든 다운로드는 소프트웨어 개발을 지원하는 것에 맞춰진 특별한 이클립스 어플리캐이션을 볼수 있다. 이클립스 어플리케이션은 플러그인으로 불리는 개별 소프트웨어 컴포너트로 구성되어 있다. 예를 들면, 이클립스 IDE는 JDT 플러그인들을 통해 Java 어플리케션을 개발 하기 위한 기능을 제공한다.

이클립스가 확장가능한 프레임워크로 만들어 졌기 때문에, 플러그인을 사용할 수 있고 다른 플러그인을 확장 할 수 있다. 

개발 하는 동안, 플러그인을 테스트 하고 디버깅하기 위해 이클립스 IDE의 새 인스턴스를 시작할 수 있다. 새 인스턴스는 때때로 런타임 이클립스 내부 인스턴스로 불린다.

플러그인 또는 MANIFEST 파일의 컨텍스트 메뉴에서 Run As  Eclipse Application 을 선택하는 것이 런타임 이클립스를 시작하는 가장 시윈 방법이다. 기본적으로, 이 명령어는 워크스페이스와 대상 환경으로 부터 모든 플러그인을 얻고, 그 플러그인들로 부터 런타임 이클립스를 시작한다. 그 워크스페이스에서 하나가 사용된다.

런타임 이클립스를 디버깅 할 수 있다. 인스펙션 하기를 원하는 소스코드에 브레이크포인트를 넣고, 플러그인을 오른쪽 클릭하고 Debug As  Eclipse Application를 선택한다.

실행 흐름이 프레이크 포인트로 표시된 구문에 도달 했을 때, 실행이 멈추고, 관련된 구문을 디버깅하는 것과 현재 데이타를 검사하는 것을 할 수 있다. 이 투토리얼은 이클립스 IDE를 사용하는 것과 기본적인 자바 개발에 익숙한 것을 가정한다.

2. 이클립스 SDK 다운로드

이클립스 플랫폼에 기능들을 추가 할 계획이라면 마지막 릴리즈 버전을 다운로드 해야 한다. 공식 릴리즈가 안정적 API가 있습니다, 따라서 플러그인과 features를 추가하기 위한 가장 좋은 기초가 됩니다.

 이클립스 IDE는 다른 멋을 지니고 제공됩니다. 어떤 이클립스 패키지에서 필요한 툴들을 설치 할수 있다면, 일반적으로 플러그인 개발을 위한 모든 필요 툴을 포함하는 이클립스 표준 배포판을 다운로드 하는 것이 쉽습니다. 더 만은 툴을 포함한다른 패키지들은 플러그인 개발에 필요하지 않습니다.

이클립스 IDE 다운로드 사이트를 열고 이클립스 Committers패키지를 위한 이클립스 IDE를 다운로드 한다.  .

3. 싱행 환경구성

3.1. 실행 환경 구성이 무엇인가?

런타임 이클립스는 플러그인의 세트의 선택에 기반한다. 그 플러그인들은 런타임 환경 구성을 통해서 선택된다. 이 런타임 환경 구성은 다음처럼 정의 될수 있다:

• 플러그인 또는 features 등의 세트

• 실행환경을 생성하고 업데이트 하는데 사용되는 제품(product)

실행 환경구성은 일번적인 런처를 실행하는 것을 사용하게 될 환경구성을 정의한다. 예를 들면, Java 가상머신 (VM), 플러그인 (classpath) 종속성(dependencies), 등등 에 인수들을 정의 한다. .

실행 환경 구성을 다시 보거나 편집하기 위해서는 이클립스 메뉴로 부터 Run  Run Configurations…​ 를 선택하라.

여기에서 Main 탭에 Location에서, 런타임 이클립스가 생성되기 위한 환경 구성 파일이 있는 곳을 지정한다.

3.2. 인수 정의하기

실행환경은 인수(Arguments) 탭에 어프리케이션의 추가적 시작 인수를 추가하는 것을 허용한다. 기본적으로, 이클립스는 이미 몇몇 인수들을 포함한다. 예를 들면, 어플리케이션을 실행하는 아키텍처를 지정하기 위해 -os, -ws 그리고 -arch 같은 파라미터이다.

다음 테이블에 유효한 런처 인수들을 목록화 한다. 

테이블 1. 런처 파라미터 

3.3. 런처 환경 구성과 이클립스 제품

만약 이클립스 RCP 어플리케이션을 개발 하는 중이라면, 제품 환경 구성 파일에 기반해서 런처 환경 구성을 생성한다. 런처 환경 구성이 제품을 통해 어플리케이션을 시작할때 매번 업데이트 된다. 

어플리케이션을 다시 시작하기 위해 직접 생성된 실행 환경 구성을 사용 한다. 제품에서 변경된 경우에 환경 구성 파일이 고려되지 않는다.

3.4. 일반적인 런처 문제를 위한 체크리스트

이클립스 RCP 어플리케이션의 실행 환경 구성에서 에러들은 문제의 원인이 된다. 이 장은 RCP 어플리케이션을 시작과 관련된 일반적인 문제들이 기술된다. 어플리케이션을 시작하는 동안 직면한 문제의 경우에 참조로 사용 될 수 있다. 

가장 일반적인 문제는 제품에서 필요한 플러그인들이 빠져 있는 것이다. 만약 제품 환경 구성에 기반이 되는 feature들를 사용한다면 MANIFEST.MF파일에서 참조될 모든 플러그인을 권장할 필요가 있고 또한 feature들에 포함된다. 이 오류는 콘솔 뷰에 보고되고, 전형적으로 첫번째 오류 메시지중에 하나이고 스크롤을 올려서 볼 필요가 있다. 

다음 목록은 전형적인 이 메시지를 어떻게 할것인지 다음과 같이 나열되어 있다. (텍스트에 맞게 서식 변경).

org.osgi.framework.BundleException: Could not resolve module: com.vogella.tasks.services [9] Unresolved requirement: Require-Bundle: com.vogella.tasks.events; bundle-version="1.0.0"

빠져있는 플러그인을 식별하고 제품에(만약 제품이 플러그인을 기본으로 하면) 또는 feature들(만약 제품이 feature을 기본으로 하면)에 추가 한다. 

제품 환경 구성 파일에 기반하여 실행 환경이 생성되고 업데이트 되기 때문에 실행 환경에서 의존관계 문제를 수정하는 것을 피해야 한다. 그래서 항상 파생된 정보를 변경하는 대신에 제품 파일이 정확하게 환경 구성하는 것을 권장한다. 그 환경 구성은 제품의 내보내기를 사용되고, 그런 이유로 제품 의존관계에서 오류는 시작 될 수 없는 내보내기로 만들어진 어플리케이션에서 생긴다. 

다음 테이블 목록은 잠재적인 문제와 해결 방법을 나열한다. 

테이블 2. 실행 환경 구성 

4. 연습: 첫번째 플러그인을 생성하고 사용하기

이 연습에서, 마법사를 사용하여 IDE에 확장(extension)을 생성한다. 

4.1. 새 플러그인 프로젝트를 생성한다.

새 플러그인을 생성하기 위해 File > New > Other > Plug-in Development > Plug-in Project 를 선택한다.

프로젝트 이름에 com.vogella.ide.first 를 입력한다..

Next 버튼을 누른다. 다음 페이지에서 아래 스크린샷에 입력된 값을 등록한다. Next 버튼을 누른다.

다음 페이지에서 템플릿 체크박스 중에 하나를 사용하여 플러그인을 생성한다. 4.x API 템플릿을 사용하는 컨트리뷰션 뷰(View contribution using 4.x API )를 선택한다. .

그 후에, Next 버튼 또는 Finish 버튼을 누른다.

만약 Next, 버튼을 눌렀다면 다음과 같이 입력하고, 반면 Finish를 눌렀다면 다음 페이지는 보여지지 않는다.

이 마법사는 선택된 템플릿을 사용하여 새 플러그인을 바로 생성한다. 생성된 파일들을 보기 위해서 프로젝트 탐색기(Project Explorer)를 사용한다.

4.2. 새 플러그인으로 런타임 이클립스 시작하기 

이제 생성된 플러그인으로 런타임 이클립스를 시작해 보자.

현재 IDE의 그 새 플러그인과 모든 대상으로 부터 모든 플러그인으로 런타임 이클립스를 시작한다. 그러기 해 , 그 플러그인 프로젝트에서 오른쪽 마우스를 클릭해서 Run As  Eclipse Application.을 선택한다.

새 예제 뷰를 포함하는 런타임 이클립스를 시작한다..

4.3. 결과 검증

런타임 IDE에 메쥬에서 Window > Show View > Others…​ 를 통해서 샘플 뷰(Sample View) 뷰를 열수 있어야 한다.

5. 사용자 정의 IDE를 정의하기 위해 features 와 products 사용하기

이 예제에서 런타임 이클립스에서 선택된 플러그인들을 환경 구성하고 선택하기 위한 features 와 products를 생성하는 방법을 배우게 된다. 

5.1. 생성하기

File > New > Other…​ > Plug-in Development > Feature Project를 사용해서 com.vogella.ide.feature로 불리는 새 feature 프로젝트를 생성한다. 

마법사의 두번째 페이지에서, feature에 추가하기를 원하는 플러그인을 선택한다. 

그 뒤에 Finish 버튼을 누른다.

5.2. feature 내용 검증하기

feature.xml 파일을 열고 이 에디터에서 포함된 플러그인들(Included Plug-ins) 탭을 선택하고 작업 공간에서 원하는 플러그인들이 이 feature에 포함 되어 있는 것을 확인해라.

5.3. 제품 환경 구성 파일을 포함할 프로젝트 생성하기

File > New > Other…​ > General  Project. 를 사용해서 com.vogella.ide.product 이름으로 새 프로젝트를 생성한다.

프로젝트 이름을 생성한다.

Finish.버튼을 누른다.

5.4. 환경 구성 파일 생성하기

위에서 생성한 프로젝트에서 오른쪽 마우스를 클릭하고 File > New > Other…​ > Plug-in Development > Product Configuration를 선택한다.

com.vogella.ide.product 인 project 폴더 내부에 ide.product 이름의 product 환경 구성 파일을 생성한다. .

Finish 버튼을 누른다..

새 product 파일이 생성되고 에디터에서 열리게 된다.

5.5. product 환경 구성하기

새 파일을 위한 product 에디터가 열려 있는지 확인하라. product 에디터의 개요(Overview) New…​ 버튼을 누른다.

플러그인 정의 하기(Defining Plug-in)에 com.vogella.ide.first 을 입력한다. 어플리케이션(application)에 org.eclipse.ui.ide.workbench를 사용한다. 다음 스크린샷과 유사하게 이름과 ID를 넣는다.

5.6. 버전 번호를 입력한다. 

product에 버전 1.0.0을 입력한다. 

5.7. features를 포함하는 것으로 입력한다.

product는 features에 기반으로 해야 한다. 이를 위해 개요(Overview) 탭에서 features 옵션을 선택한다.

내용(Contents) 탭을 선택하고 Add…​ 버튼을 통해 다음 features를 추가한다..

• com.vogella.ide.feature

• org.eclipse.platform

다음으로 Add Required 버튼을 누른다..

Ctrl + S를 눌러 ide.product 파일을 저장한다.

5.8. 런타임 이클립스를 시작으로 설정을 검증하기

product 파일을 선택하고 Run 버튼을 통해서 이클립스 IDE를 시작한다. .

결과로 런타임 이클립스 IDE가 시작되여야 한다. product에 추가 되여야 하는 그 feature들만을 포함해야 한다. 예를 들면, 현재는 새 Java 프로젝트를 생성할 수 없어야 한다.

5.9. 개발중인 IDE에 Java 툴을 추가 하기

대상 플랫폼에 org.eclipse.jdt.feature.group 을 추가한다. 대상 플랫폼은 다음 목록에 유사하게 해야 한다. 

역자주) 해당 투토리얼에서 Target Profile 파일을 생성 하지 않아서 내용(Contents) 탭에서 Add… 버튼으로 추가 후 테스트 했으며, 별도의 Tartget Profile XML 파일을 생성 후 아래 내용을 입력하거나  File > New > Other…​ > Plug-in Development >  Target Definition으로  생성 후 편집할 수 있다.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?pde version="3.8"?>
<target name="target-platform">
  <locations>
    <location includeAllPlatforms="false" includeConfigurePhase="true" includeMode="planner" includeSource="true" type="InstallableUnit">
      <repository location="http://download.eclipse.org/releases/latest"/>
      <unit id="org.eclipse.equinox.sdk.feature.group" version="0.0.0"/>
      <unit id="org.eclipse.platform.sdk" version="0.0.0"/>
      <unit id="org.eclipse.jdt.feature.group" version="0.0.0"/>
    </location>
  </locations>
</target>

그 다음에, product에 org.eclipse.jdt feature을 추가하고, product 런타임 IDE를 시작한다. 이제 Java 툴이 설치되었다. 예로들면, 새 마법사를 통해 Java 프로젝트를 생성 할수 있는지를 체크 하라.

6. 연습: 3.x 기반 어플리케이션에 e4 part descriptors 추가 하기

이 연습으로 이클립스 3.x RCP 어플리케이션에 모델 기반 파트 컨트리뷰션을 추가 할 수 있다..

6.1. 파트 디스크립터(part descriptor) 추가하기

com.vogella.plugin.partdescriptor 이름으로 간단한 플러그인을 생성한다.

manifest 파일에 다음 의존 관계를 추가한다..

• org.eclipse.core.runtime,

• org.eclipse.jface,

• org.eclipse.e4.ui.model.workbench,

• org.eclipse.e4.ui.di

다음 클래스를 생성한다.

package com.vogella.ide.ui; 

import javax.annotation.PostConstruct; 
import org.eclipse.e4.ui.di.Focus; 
import org.eclipse.jface.viewers.ArrayContentProvider; 
import org.eclipse.jface.viewers.LabelProvider; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.widgets.Composite; 

public class PartEclipse4x { 
  private TableViewer viewer; 
  
  @PostConstruct 
  public void createPartControl(Composite parent) { 
    viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
    viewer.setContentProvider(ArrayContentProvider.getInstance()); 
    viewer.setLabelProvider(new LabelProvider()); 
    viewer.setInput(new String[] {"One", "Two", "Three"}); 
  } 
  
  @Focus public void setFocus() { 
    viewer.getControl().setFocus(); 
  }
}

File > New > Other…​ > Eclipse 4 > Model > New Model Fragment를 사용하여 이 플러그인에 새 모델 fragment 를 추가한다. 

6.2. 검증

이클립스 IDE 인스턴스를 시작하고 빠른 접근 박스(단축키 CTRL+3)를 사용하여 파트를 열수 있는지를 검증한다. .

Window > Show View 메뉴 입장을 통해 이 파트를 열수 있다. 

7. 3.x API로 부터 IEclipseContext에 접근하기

이클립스 IDE IDE에 대해서 중앙 정보를 저장하기 위해 IEclipseContext 데이타 스트럭처를 사용한다. 이클립스 3.x API 를 통해서 또한 이 정보에 접근 할수 있다. .

예를 들면, 이클립스 3.x API 뷰로 부터 내용에 접근하게 하기 위해, 다음 소스 일부를 사용한다. 

// part의 내용 취득
IEclipseContext partContext = getViewSite().getService(IEclipseContext.class); 

// 그 키를 기반으로 내용에서 직접 값에 접근
EModelService service = getViewSite().getService(EModelService.class);

이 소스 일부는 이클립스 3.x API 핸들러를 통한 접근을 보여준다.

// 다음 핸들러가 있다는 것을 가정한다.  
// 활성화 윈도우로 부터 내용 취득
IEclipseContext windowCtx = HandlerUtil.getActiveWorkbenchWindow(event).getService(IEclipseContext.class); 

// 활성화 된 영역으로 부터 내용 취득
IEclipseContext ctx = HandlerUtil.getActivePart(event).getSite().getService(IEclipseContext.class);

8. 이클립스 IDE 또는 3.x RCP 어플리케이션에 모델 엘리먼트 기여하기

8.1. org.eclipse.ui.views 확장포인트(extension point)를 사용해서 Adding 이클립스 3.x 어플리케이션에 이클립스 4.x 파트 추가 하기.

org.eclipse.ui.views 확장점(extension point)를 확장 extension (탭, 테그)에서 e4 파트를 사용 할 수 있다. 이를 보관하기 위해 extension의 내용 메누에 e4view 엔트리를 사용한다. 그 결과 객체는 의존관계 주입(dependency injection)을 통해서 생성된다. 

8.2. e4 메뉴 엔트리들 추가하기

메뉴(Menus), 핸들러(handlers) 그리고 커멘드(commands) 모델 fragments을 통해서 이클립스 어플리케이션에 기여(제공)될 수 있다.

역자주) 어플리케이션에 기여한다는 의미는 이클립스 어플리케이션으로 별도의 기능으로 삽입되어 기능등이 개선 또는 추가 될 수 있는 것을 의미 한다. 즉, 기존 이클립스에 일부로 개발되어 포함 제공 될 수 있다는 의미이다

일치하는 ID로 상응하는 어플리케이션 모델 엘리먼트에 기여하는 모델 fragment를 생성 할 수 있다. 다음 스크린샷은 이클립스 IDE의 menuContributions feature에 기여(제공)하는 방법을 보여준다. 

메뉴를 기여(제공)할 수 있는 MenuContribution 항목을 추가 한 후에 . 그 부모-ID는 메뉴가 기여(제공)될 메뉴의 ID 여야 한다.

모델 fragment는 org.eclipse.e4.workbench.model 확장점(extension poin)을 통해서 다음 목록에서 표시되는 것처럼 plugin.xml 파일에 등록되어 있어야 한다.

<?xml version="1.0" encoding="utf-8"?>
<plugin>
  <extension id="id1" point="org.eclipse.e4.workbench.model">
    <fragment apply="notexists" uri="fragment.e4xmi"> </fragment>
  </extension>
</plugin>

8.3. 오류 분석

문제가 발생했을 경우에, plugin.xml의 소스 코드를 확인하고 모델 fragment가 포함 되었는지를 검증하라. 참조된 모델 fragment의 이름을 검증하고, 모든 정의된 ID가 실행중인 환경 구성에서 사용가능한지를 확인하라.

8.4. 어플리케이션 윈도우에 e4 툴바 엔트리 추가하기

툴바 컨트리뷰션을 기여할 메뉴와 유사하다. 

8.5. 이클립스 IDE 에 파트 디스크립터를 지원하기

이클립스 IDE는 fragments와 프로세서를 통해 파트 디스크립터 모델의 기여를 지원한다. 

만약 파트 디스크립터를 기여하기 위해 the org.eclipse.e4.legacy.ide.application ID를 사용한다면, Window > Show View > Other…​ 다이얼로그 또는 바로가기를 통해서 뷰가 오픈 될 수 있다.  파트 디스크립터같은 뷰 테그를 필요로 한다. 

8.6. 모델 snippet을 통해서 이클립스 IDE에 퍼스펙티브 추가하기

모델 fragment 또는 processor는 snippet을 통해 포스펙티브를 추가 기 위해 이클립스 4.x IDE에 퍼스펙티브를 기여 할 수 있다. 이 확장 엘리먼트 id는 xpath:/ 로 일반화 둘수 있고 feature 명이 snippets 이다.

이 접근은 이클립스 4.x 런타임에 실행하는 RCP 어플리케이션 기반 이클립스 3.x API에 퍼스펙티브를 기여하는데 사용 될 수 있다. .

9. 연습: 이클립스 IDE에 새 퍼스펙티브 추가하기

I이 연습에서, 이클립스 IDE에 새 퍼스펙티브를 기여(제공)한다..

9.1. 모델 엘리먼트를 생성하기

com.vogella.contribute.parts 플러그인에서, 다음 모델 fragment를 생성한다..

퍼스펙티브에 적어도 하나의 파트를 추가한다. 

9.2. 검증

이클립스 IDE를 시작하고 퍼스펙티브 스위쳐 다이얼로그를 통해서 새 퍼스펙티브를 열수 있는지를 검증한다. 

10. 추가 연습: 확장점(extension points) 통해서 POJO 뷰 추가 하기 

이 연습에서, org.eclipse.ui.views 확장점(extension point)의 e4view 엘리먼트를 사용하기 대문에 별도의 플러그인을 통해 e4 기반 뷰 확장을 생성한다.

이 확장(extension) 이클립스 IDE에 기여(제공)될 수 있다. (또는 다른 이클립스  3.x API 기반 RCP 어플리케이션).

10.1. 플러그인 생성하기

com.vogella.ide.e4view 이름의 플러그인을 생성한다.  File > New > Other…​ > Plug-in Project을 사용한다.

com.vogella.ide.e4view 프로젝트를 호출하고 다음 스크린샷에 유사하게 옵션을 선택한다. 

10.2. 플러그인 의존관계 조정하기

새 플러그인의 manifest 파일에 의존관계로 org.eclipse.e4.ui.di 를 추가 하라.

10.3. e4 뷰 생성하기

 다음 생성된 SampleE4View를 조정하라.

package com.vogella.ide.e4view.views; 

import javax.annotation.PostConstruct; 
import javax.inject.Inject; 
import org.eclipse.e4.ui.di.Focus; 
import org.eclipse.jface.action.Action; 
import org.eclipse.jface.action.IMenuListener; 
import org.eclipse.jface.action.IMenuManager; 
import org.eclipse.jface.action.MenuManager; 
import org.eclipse.jface.action.Separator; 
import org.eclipse.jface.dialogs.MessageDialog; 
import org.eclipse.jface.viewers.ArrayContentProvider; 
import org.eclipse.jface.viewers.DoubleClickEvent; 
import org.eclipse.jface.viewers.IDoubleClickListener; 
import org.eclipse.jface.viewers.IStructuredSelection; 
import org.eclipse.jface.viewers.ITableLabelProvider; 
import org.eclipse.jface.viewers.LabelProvider; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.graphics.Image; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.swt.widgets.Menu; 
import org.eclipse.ui.ISharedImages; 
import org.eclipse.ui.IWorkbench; 
import org.eclipse.ui.IWorkbenchActionConstants; 

public class SampleE4View { 
	/**
     * 확장에 의해 지정된 뷰의 ID. 
     */ 
    public static final String ID = "com.vogella.ide.e4view.views.SampleE4View"; 
    
    @Inject IWorkbench workbench; 
    
    private TableViewer viewer; 
    
    private Action action1; 
    
    private Action action2; 
    
    private Action doubleClickAction; 
    
    class ViewLabelProvider extends LabelProvider implements ITableLabelProvider { 
    	
        @Override 
        public String getColumnText(Object obj, int index) { 
        	return getText(obj); 
        } 
        
        @Override 
        public Image getColumnImage(Object obj, int index) { 
        	return getImage(obj); 
        } 
        
        @Override 
        public Image getImage(Object obj) { 
        	return workbench.getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); 
        } 
    } 
    
    @PostConstruct 
    public void createPartControl(Composite parent) { 
    	viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
        viewer.setContentProvider(ArrayContentProvider.getInstance()); 
        viewer.setInput(new String[] { "One", "Two", "Three" }); 
        viewer.setLabelProvider(new ViewLabelProvider()); 
        
        // 뷰의 컨트롤을 위한 헬프 컨텍스트 ID를 생성한다. 
        workbench.getHelpSystem().setHelp(viewer.getControl(), "com.vogella.ide.e4view.viewer"); 
        makeActions(); 
        hookContextMenu(); 
        hookDoubleClickAction(); 
    } 
    
    private void hookContextMenu() { 
    	MenuManager menuMgr = new MenuManager("#PopupMenu"); 
        menuMgr.setRemoveAllWhenShown(true); 
        menuMgr.addMenuListener(new IMenuListener() { 
        	
            @Override 
            public void menuAboutToShow(IMenuManager manager) { 
            	SampleE4View.this.fillContextMenu(manager); 
            }
            
       	}); 
        Menu menu = menuMgr.createContextMenu(viewer.getControl()); 
        viewer.getControl().setMenu(menu); 
    } 
    
    private void fillContextMenu(IMenuManager manager) { 
    	manager.add(action1); 
        manager.add(action2); 
        // 다른 플러그인이 여기에 액션을 기여(제공) 할 수 있다.
        // (역자주, 내부에 생성된 action1, action2 이외에 기존 다른 플러그인 액션을 사용 할 수 있다)
        manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); 
    } 
    
    private void makeActions() { 
    	action1 = new Action() { 
        	@Override 
            public void run() { 
            	showMessage("Action 1 executed"); 
            } 
         }; 
         
         action1.setText("Action 1"); 
         action1.setToolTipText("Action 1 tooltip"); 
         action1.setImageDescriptor(workbench.getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); 
         
         action2 = new Action() { 
         	@Override 
            public void run() { 
            	showMessage("Action 2 executed"); 
            } 
         }; 
         
         action2.setText("Action 2"); 
         action2.setToolTipText("Action 2 tooltip"); 
         action2.setImageDescriptor(workbench.getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); 
         
         doubleClickAction = new Action() { 
         	@Override 
            public void run() { 
            	IStructuredSelection selection = viewer.getStructuredSelection(); 
                Object obj = selection.getFirstElement(); 
                showMessage("Double-click detected on " + obj.toString()); 
            } 
         }; 
         
    } 
    
    private void hookDoubleClickAction() { 
    	viewer.addDoubleClickListener(new IDoubleClickListener() { 
        	@Override 
            public void doubleClick(DoubleClickEvent event) { 
            	doubleClickAction.run(); 
            } 
        });
    } 
    
    private void showMessage(String message) { 
    	MessageDialog.openInformation(viewer.getControl().getShell(), "e4view View", message); 
    } 
    
    @Focus 
    public void setFocus() { 
    	viewer.getControl().setFocus(); 
    } 
}

10.4. 확장점(extension point)에서 엔트리 조정하기

org.eclipse.ui.views 확장점(extension point)을 위해 e4view 속성으로 뷰 속성을 교체한다..

plugin.xml 에디터의 확장(Extensions)탭을 사용하라

plugin.xml 파일에서 org.eclipse.ui.views 확장을 위한 마지막 관련 소스는 다음과 유사하게 보여야 한다.:

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.4"?> 
<plugin> 
   	<extension point="org.eclipse.ui.views"> 
       	<category name="Sample Category" id="com.vogella.ide.e4view"> 
        </category> 
        <e4view category="com.vogella.ide.e4view" 
           		class="com.vogella.ide.e4view.views.SampleE4View" 
                icon="icons/sample.png" 
                id="com.vogella.ide.e4view.e4view1" 
                name="e4view View" restorable="true"> 
        </e4view> 
	</extension> 
        
    <!-- MORE ENTRIES, LEFT OUT FOR BREVITY --> 
</plugin>

10.5. Validate the usage of the e4 뷰의 사용 검증하기

이클립 IDE에서 플러그인을 시작하라 그리고Windows > Show View 메뉴 엔트리를 통해서 뷰를 열수 있는지를 검증하라. 이 뮤는 다음과 유사하게 보일 것이가 항목들상에 컨텍스트 메뉴가 제공되어야 한다. 

10.6. 퍼스펙티브 확장에 뷰를 추가 하기

퍼스펙트브에 뷰를 추가 하기 위해, 다음 스크린샷에서 표시되는 것처럼 존재하는 org.eclipse.ui.perspectiveExtensions 엔트리를 조정한다. 

10.7. 추가 연습: e4 뷰에 툴바 추가하기

현재 확장점(extension point) 처리는 일반 뷰 확장을 제외하고 e4view 확장이 아니다. e4view 에 툴바를 추가 하기 위해, 스스로 관련 정보를 처리 해야 한다. 예를 들면, 주입된 EModelService를 얻을 수 있고,  확장 레지스터 또는 모델 snippet에 기반으로 툴바를 추가한다. 시연의 목적으로 다음처럼 하나의 툴바 엔트리를 간단하게 생성한다.

@PostConstruct 
public void createPartControl(Composite parent, MPart part, EModelService modelService) { 
	viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
    viewer.setUseHashlookup(true); 
    
    // 데이타 모델의 빠른 해시 참조를 사용한다. 
    viewer.setContentProvider(ArrayContentProvider.getInstance()); 
    viewer.setInput(new String[] { "One", "Two", "Three" }); 
    viewer.setLabelProvider(new ViewLabelProvider()); 
    
    // 뷰어의 컨트를을 위한 도움말 컨텍스트 ID를 생성한다. 
    workbench.getHelpSystem().setHelp(viewer.getControl(), "com.vogella.ide.e4view.viewer"); 
    makeActions(); 
    hookContextMenu(); 
    hookDoubleClickAction(); 
    
    MToolBar toolbar = modelService.createModelElement(MToolBar.class); 
    MHandledToolItem toolitem = modelService.createModelElement(MHandledToolItem.class); 
    toolitem.setLabel("View Tool Item"); 
    
    // TODO 툴바 아이템을 위한 관련 아이콘과 커멘트를 설정한다. 
    toolbar.getChildren().add(toolitem); part.setToolbar(toolbar); 
}

11. 연습: 이클립 IDE에 e4 메뉴 추가하기

이 연습에서 com.vogella.tasks.ui 플러그인을 통해 IDE에 메뉴와 툴바 컨트리뷰션을 추가 하게 될 것이다..

11.1. 플러그인 의존관계 추가하기

com.vogella.tasks.ui의 manifest 파일에 다음 의존관계가 있는지 확인하라..

• org.eclipse.e4.core.di,

• org.eclipse.jface

11.2. 핸들러 클래스 생성하기

생성된 핸들러 클래스에 기반해서 다음 클래스를 생성한다.

package com.vogella.tasks.ui.handlers; 

import org.eclipse.e4.core.di.annotations.Execute; 
import org.eclipse.jface.dialogs.MessageDialog; 
import org.eclipse.swt.widgets.Shell; 

public class TestHandler { 
	
    @Execute 
    public void execute(Shell shell) { 
    	MessageDialog.openInformation(shell, "First", "Hello, e4 API world"); 
    } 
}

11.3. 컨트리뷰션을 위한 모델 fragment를 생성한다.

플러그인 프로넥트의 컨텍스트 메뉴로 부터 New > Other…​ > Eclipse 4  Model > New Model Fragment 를 통해 새 모델 fragment를 생성한다.

이 파일 명은 commands.e4xmi을 입력한다.

Finish 버튼을 누른다..

새 fragment가 plugin.xml에 확장으로 정확하게 등록되었다는 것을 확인 하라.

11.4. 커멘트 컨트리뷰션을 정의하라

xpath:/ 엘리먼트 ID를 사용하여 최상위 레벨 엘리먼트의 커멘트에 커멘트들 기여(제공)하기 위한 모델 fragment 를 생성한다. 

새 컨트리뷰션을 정의 학 ㅣ위해 다음 스크린샷을 사용한다.

persistState 플래그를 false로 설정하는 것을 확인하라. 만약 플러그인이 설치 되지 않았다면 그 엘리먼트가 가능하지 않다.

11.5. 핸들러 컨트리뷰션 정의하기

정의된 커멘트로 핸들러를 추가 하고, 이행으로 TestHandler를 사용한다. 

persistState 플래그를 false로 설정하는 것을 확인하라. 만약 플러그인이 설치 되지 않았다면 그 엘리먼트가 가능하지 않다.

11.6. menuContributions 컨트리뷰션을 정의하기

persistState 플래그를 false로 설정하는 것을 확인하라. 만약 플러그인이 설치 되지 않았다면 그 엘리먼트가 가능하지 않다.

메뉴에 적어도 하나의 메뉴를 추가하고 반면 표시되지는 않을 것이다. 

11.7. 메뉴의 존재 검증하기

이클립스 IDE의 새 인스턴스를 시작하고 메뉴가 보이고 동작하는지를 검증한다. 만약 보이지 않는다면, 잠재적 이슈를 위한 모델 스파이를 통해서 체크하라 

12. 연습: 이클립스 IDE에 트림바(trimbar )를 추가 하기

12.1. trimbar 컨트리뷰션 추가하기

또한 같은 커멘트를 위한 trimbar 컨트리뷰션을 추가 할 수 있다.

persistState 플래그를 false로 설정하는 것을 확인하라. 만약 플러그인이 설치 되지 않았다면 그 엘리먼트가 가능하지 않다.

trimbar를 툴바에 추가하기

컨트리뷰션에 처리된 툴 항목을 추가한다.

12.2. 툴바 컨트리뷰션의 존재를 검증하기 

이클립스 IDE의 새 인스턴스를 시작하고, 새 툴바가 가능한지를 검증한다. 만약 윈도우에 보이지 않는다면, 잠재적이슈를 위해서 모델 spy를 통해서 체크한다.

13. 추가 연습: 툴바 엔트리에 아이콘 추가하기

아이콘 폴더를 생성한다.  새 프로젝트에 아이콘을 저장하기 위해 플러그인 이미지 브라우져(Plug-in Image Browser)를 사용한다.

툴바 엔트리에 이 아이콘을 할당한다. 

14. 리소스와 마커

이클립스는 IResource로 프로젝트, 파일, 폴더, 패키지 같은 리소스를 나타낸다. 

마커(Marker)는 추가적으로 리소스를 위한 정보를 나타낸다. 즉, 에러 마커이다. 이 정보는 리소스(파일) 내 저장이 아니라 워크스페이스 메타데이타에 추가 정보로 저장된다. 

모든 마커는 속성을 가질 수 있다. (key / value 조합). 마커는 표준 뷰에서 표시 될 수 있다. 즉, 테스크(Task), 북마크(Bookmark) 또는 문제점 (Problems) 뷰이다. 그 뷰에서 표시되게 되기 위해, 사전에 정의된 속성을 사용해야 한다.

15. 연습: 리소스를 위한 마커를 생성하기

e4 핸들러 템플릿에 기반한 com.vogella.plugin.markers 플러그인 프로젝트를 생성한다.

이 템플릿은 선택된 리소스 위한 IMarker를 생성하기 위해 사용되어야 하는 AddMarkerHandler 핸들러를 생성하게 될 것이다.

다음 의존 관례를 추가 한다.:

• org.eclipse.jface

• org.eclipse.e4.ui.services

• org.eclipse.e4.core.di.annotations

• org.eclipse.core.resources

• org.eclipse.core.runtime

• org.eclipse.e4.core.services

다음에 AddMarkerHandler 코르를 변경한다.:

package de.vogella.plugin.markers.handler; 

import javax.inject.Named; 
import org.eclipse.core.resources.IMarker; 
import org.eclipse.core.resources.IResource; 
import org.eclipse.e4.core.di.annotations.Execute; 
import org.eclipse.e4.core.services.adapter.Adapter; 
import org.eclipse.e4.ui.services.IServiceConstants; 
import org.eclipse.jface.viewers.IStructuredSelection; 

public class AddMarkerHandler { 
	
    @Execute 
    public void execute(@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection, Adapter adapter) { 
    	if (selection == null || selection.isEmpty()) { 
        	return; 
        } 
        
        Object firstElement = selection.getFirstElement(); 
        IResource resource = adapter.adapt(firstElement, IResource.class); 
        
        if (resource != null) { 
        	writeMarkers(resource); 
        } 
	} 
   
	private void writeMarkers(IResource resource) { 
    	try { 
        	IMarker marker = resource.createMarker(IMarker.TASK); 
            marker.setAttribute(IMarker.MESSAGE, "This is a task"); 
            marker.setAttribute(IMarker.PRIORITY, IMarker.PRIORITY_HIGH); 
        } catch (Exception e) { 
        	e.printStackTrace(); 
        } 
    }
}

fragment.e4xmi 파일에 커멘트의 명이 "Hello World" 에서 "Add Task Marker"로 변경되어야 한다.

만약 실행하고 Java 프로젝트나 다른 IResource를 선택하면 메뉴 엔트리를 클릭한다면 테스트 뷰(Tasks View) 에서 마커를 생성할 수 있다. 

16. 어댑터(Adaptors)

어댑터는 존재하는 뷰를 조정해야 하는 것 없이 이 뷰에서 객체에 대한 정보를 표시하는 것을 돕는다. 

어댑터는 몇몇 장소에서 사용된다. 예를 들면, 아웃라인 뷰에서 데이타가 표시하기 위해 사용 될 수 있다. 예제로 FAQ 언어 에디터를 위한 아웃라인 뷰를 어떻게 생성하는가 를 보라.

17. 연습- 프로퍼티 뷰를 위한 어댑터(Adaptors)

프로퍼티 뷰에 데이타를 보여주기 위해 간단하게 어댑터를 사용하게 될 것이다. 

de.vogella.plugin.adapter 이름의 새 플러그인 프로젝트를 생성한다..

MANIFEST.MF 파일의 의존관계(dependencies) 탭에 다음 의존 관계를 추가한다.:

• org.eclipse.core.runtime

• org.eclipse.e4.ui.model.workbench

• org.eclipse.e4.ui.services

• org.eclipse.e4.ui.workbench

• org.eclipse.ui

• org.eclipse.ui.views

데이타 모델로 다음 Todo 클래스를 생성한다.

package de.vogella.plugin.adapter.model; 

public class Todo { 
	
    private String summary; 
    private String description; 
    private boolean done; 
    
    public String getSummary() { 
    	return summary; 
    } 
    
    public void setSummary(String summary) { 
    	this.summary = summary; 
    } 
    
    public String getDescription() { 
    	return description; 
    } 
    
    public void setDescription(String description) { 
    	this.description = description; 
    } 
    
    public boolean isDone() { 
    	return done; 
    } 
    
    public void setDone(boolean done) { 
    	this.done = done; 
    } 
}

모델 fragment (fragment.e4xmi)를 생성하고 샘플뷰로 불리는 PartDescriptor를 추가한다.

PartDescriptor 구현체를 위한 파트로서 SampleView.java를 생성한다.

package de.vogella.plugin.adapter.views; 

import java.util.ArrayList; 
import java.util.List; 
import javax.annotation.PostConstruct; 
import org.eclipse.e4.ui.workbench.modeling.ESelectionService; 
import org.eclipse.jface.viewers.ArrayContentProvider; 
import org.eclipse.jface.viewers.ISelectionChangedListener; 
import org.eclipse.jface.viewers.ITableLabelProvider; 
import org.eclipse.jface.viewers.LabelProvider; 
import org.eclipse.jface.viewers.SelectionChangedEvent; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.graphics.Image; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.ui.ISharedImages; 
import org.eclipse.ui.PlatformUI; 
import de.vogella.plugin.adapter.model.Todo; 

public class SampleView { 
	
    private TableViewer viewer; 
    
    class ViewLabelProvider extends LabelProvider implements ITableLabelProvider { 
    	
        public String getColumnText(Object obj, int index) { 
        	Todo todo = (Todo) obj; 
            return todo.getSummary(); 
        } 
        
        public Image getColumnImage(Object obj, int index) { 
        	return getImage(obj); 
        } 
        
        public Image getImage(Object obj) { 
        	return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); 
        } 
    } 
    
    /**
     * 뷰를 생성하고 초기화 하기 위해 허용되게 될 콜백이다. 
     */ 
    @PostConstruct 
    public void createPartControl(Composite parent, ESelectionService selectionService) { 
    	
        viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
        viewer.setContentProvider(new ArrayContentProvider()); 
        viewer.setLabelProvider(new ViewLabelProvider()); 
        
        viewer.addSelectionChangedListener(new ISelectionChangedListener() { 
        	@Override 
            public void selectionChanged(SelectionChangedEvent event) { 
            	selectionService.setSelection(event.getSelection()); 
            } 
        }); 
        viewer.setInput(getElements()); 
    } 
    
    // 단순한 데이타 모델을 구축한다. 
    private List<Todo> getElements() { 
    	List<Todo> todos = new ArrayList<>(); 
        
        Todo todo = new Todo(); 
        todo.setSummary("First Todo"); 
        todo.setDescription("A very good description"); 
        todo.setDone(true); 
        todos.add(todo); 
        
        todo = new Todo(); 
        todo.setSummary("Second Todo"); 
        todo.setDescription("Second super description"); 
        todos.add(todo); 
       	return todos; 
    } 
}

이렇게 변경한 뒤에, 프로젝트를 실행할 수 있고 뷰을 열고 to-do 항목을 볼수 있어야 한다. 

프로퍼티 뷰에 Todo 값을 표시하기 위해, 프로젝트에 org.eclipse.core.runtime.adapters 확장점(extension point)울 추가 한다.

확장점(extension point)의 데이타는 다음과 같아야 한다.:

<extension point="org.eclipse.core.runtime.adapters"> 
	<factory adaptableType="de.vogella.plugin.adapter.model.Todo" 
    		class="de.vogella.plugin.adapter.TodoAdapterFactory"> 
    	<adapter type="org.eclipse.ui.views.properties.IPropertySource"> 
        </adapter> 
    </factory>
</extension>

프로퍼티 뷰에 확장점을 제공하기 위해 IPropertySource 인터페이스 구현한다.

package de.vogella.plugin.adapter; 

import org.eclipse.ui.views.properties.IPropertyDescriptor; 
import org.eclipse.ui.views.properties.IPropertySource; 
import org.eclipse.ui.views.properties.TextPropertyDescriptor; 
import de.vogella.plugin.adapter.model.Todo; 

public class TodoPropertySource implements IPropertySource { 
	
    private final Todo todo; 
    
    public TodoPropertySource(Todo todo) { 
    	this.todo = todo; 
    } 
    
    @Override 
    public boolean isPropertySet(Object id) { 
    	return false; 
    } 
    
    @Override 
    public Object getEditableValue() { 
    	return this; 
    } 
    
    @Override 
    public IPropertyDescriptor[] getPropertyDescriptors() { 
    	return new IPropertyDescriptor[] { 
        	new TextPropertyDescriptor("summary", "Summary")
            , new TextPropertyDescriptor("description", "Description") 
        };
    } 
    
    @Override 
    public Object getPropertyValue(Object id) { 
    	if (id.equals("summary")) { 
        	return todo.getSummary(); 
        } 
        
        if (id.equals("description")) { 
        	return todo.getDescription(); 
        } 
        
      	return null; 
    } 
    
    @Override 
    public void resetPropertyValue(Object id) { 
    
    } 
    
    @Override 
    public void setPropertyValue(Object id, Object value) { 
        String s = (String) value; 
        if (id.equals("summary")) { 
        	todo.setSummary(s); 
        } 
        
        if (id.equals("description")) { 
        	todo.setDescription(s); 
        } 
    } 
}

IPropertySource 구현체로 팩토리와 새 TodoPropertySource 클래스를 구현한다..

package de.vogella.plugin.adapter; 

import org.eclipse.core.runtime.IAdapterFactory; 
import org.eclipse.ui.views.properties.IPropertySource; 
import de.vogella.plugin.adapter.model.Todo; 

public class TodoAdapterFactory implements IAdapterFactory { 

	// static final 필드를 사용한다 그래서adapterList는 단지 한번 실행된다. 
    private static final Class<?>[] adapterList = new Class<?>[] { IPropertySource.class }; 
    
    @Override 
    public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) { 
    	if (adapterType== IPropertySource.class && adaptableObject instanceof Todo){ 
        	return adapterType.cast(new TodoPropertySource((Todo) adaptableObject)); 
        } 
        
        return null; 
    } 
    
    @Override 
    public Class<?>[] getAdapterList() { 
    	return adapterList; 
    } 
}

만약 워크벤치를 실행하고 Windows > Show > View > Others > Sample Category > Sample View 를 통해 뷰를 열고 그리고 뷰어에 데이타 엘리먼트를 선택할때 프로퍼티 뷰에 데이타를 볼 수 있어야 한다. 

18. 연습 - 어댑터와 워크벤치라벨프로바이더(WorkbenchLabelProvider)

연습 - 프로퍼티 뷰를 위한 어댑터(Adapters)에서 de.vogella.plugin.adapter 플러그인은 이 연습을 위해 재 사용되어야 한다. 

WorkbenchAdapter Sample로 이름이 지어진 또 Sample Category 라는 카테고리를 가지고 있는 다른 파트디스크립터(PartDescriptor)를 생성하다.

파트디스크립터(PartDescriptor) 구현체를 위한 파트로 SampleWorkbenchAdapterView.java 를 생성한다. 이전 SampleView와 차이점은 단지 IStyledLabelProvider 구현체로 WorkbenchLabelProvider를 가지는 DelegatingStyledCellLabelProvider가 LabelProvider로 사용된다는 것이다.

package de.vogella.plugin.adapter.views; 

import java.util.ArrayList; 
import java.util.List; 
import javax.annotation.PostConstruct; 
import org.eclipse.e4.ui.workbench.modeling.ESelectionService; 
import org.eclipse.jface.viewers.ArrayContentProvider; 
import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider; 
import org.eclipse.jface.viewers.ISelectionChangedListener; 
import org.eclipse.jface.viewers.SelectionChangedEvent; 
import org.eclipse.jface.viewers.TableViewer; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.ui.model.WorkbenchLabelProvider; 
import de.vogella.plugin.adapter.model.Todo; 

public class SampleWorkbenchAdapterView { 
	
    private TableViewer viewer; 
    
    /**
     * 뷰어를 생성하고 초기화하는 것을 허용하게될 콜백이다.
     */ 
    @PostConstruct 
    public void createPartControl(Composite parent, ESelectionService selectionService) { 
    	viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); 
        viewer.setContentProvider(new ArrayContentProvider()); 
        
        // IStyledLabelProvider 구현체로 WorkbenchLabelProvider로 DelegatingStyledCellLabelProvider의 활용한다. 
        viewer.setLabelProvider(new DelegatingStyledCellLabelProvider(new WorkbenchLabelProvider())); 
        viewer.addSelectionChangedListener(new ISelectionChangedListener() { 
        	@Override 
            public void selectionChanged(SelectionChangedEvent event) { 
            	selectionService.setSelection(event.getSelection()); 
            } 
        }); 
        viewer.setInput(getElements()); 
    } 
    
    // 단순 데이타 모델을 구축한다.
    private List<Todo> getElements() { 
    	List<Todo> todos = new ArrayList<>(); 
        
        Todo todo = new Todo(); 
        todo.setSummary("First Todo"); 
        todo.setDescription("A very good description"); 
        todo.setDone(true); 
        todos.add(todo); 
        
        todo = new Todo(); 
        todo.setSummary("Second Todo"); 
        todo.setDescription("Second super description"); 
        todos.add(todo); 
        
        return todos; 
    } 
}

WorkbenchLabelProvider를 사용할 때, 뷰어에서 보여질 수있도록 지원되는 객체는 IWorkbenchAdapter, IWorkbenchAdapter2 와 IWorkbenchAdapter3 인터페이스를 위한 어댑터 적어도IWorkbenchAdapter를 위한 어뎁터는 제공해야 한다. 3가지 인터페이스는 객체들이 보여져야 하는 방법을 결정하기위해 WorkbenchLabelProvider에 의해서 사용될 수 있다. 

WorkbenchLabelProvider를 사용해서 위해 3개의 어댑터를 제공하기 위해, TodoWorkbenchAdapter가 생성된다. TodoWorkbenchAdapter는 모든 3개의 인터페이스를 구현한 추상 클래스인 WorkbenchAdapter로 부터 얻는다.

package de.vogella.plugin.adapter; 

import org.eclipse.jface.resource.ImageDescriptor; 
import org.eclipse.jface.viewers.StyledString; 
import org.eclipse.jface.viewers.StyledString.Styler; 
import org.eclipse.swt.SWT; 
import org.eclipse.swt.graphics.TextStyle; 
import org.eclipse.swt.widgets.Display; 
import org.eclipse.ui.ISharedImages; 
import org.eclipse.ui.PlatformUI; 
import org.eclipse.ui.model.WorkbenchAdapter; 
import de.vogella.plugin.adapter.model.Todo; 

public class TodoWorkbenchAdapter extends WorkbenchAdapter { 
	
    @Override 
    public ImageDescriptor getImageDescriptor(Object object) { 
    	return PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJ_ELEMENT); 
    } 
    
    @Override 
    public StyledString getStyledText(Object object) { 
    	if (object instanceof Todo) { 
        	Todo todo = (Todo) object; 
            StyledString styledString = new StyledString(todo.getSummary()); 
            
            if (todo.isDone()) { 
            	Styler styler = new Styler() { 
            		@Override 
                	public void applyStyles(TextStyle textStyle) { 
                    	// 완료된 Todo는 녹색 배경을 가져야 한다.
                   	 textStyle.background = Display.getCurrent().getSystemColor(SWT.COLOR_GREEN); 
                 	} 
               	}; 
                
                styledString.setStyle(0, todo.getSummary().length(), styler); 
            } 
            
            return styledString; 
    	} 
    
    	return super.getStyledText(object); 
    } 
}

이제 TodoAdapterFactory 또 TodoWorkbenchAdapter를 제공하기 위해 확장되어야 한다. 

package de.vogella.plugin.adapter; 

import org.eclipse.core.runtime.IAdapterFactory; 
import org.eclipse.ui.model.WorkbenchAdapter; 
import org.eclipse.ui.views.properties.IPropertySource; 
import de.vogella.plugin.adapter.model.Todo; 

public class TodoAdapterFactory implements IAdapterFactory { 

	// static final 필드를 사용한다 그래서 adapterList는 단지 한번만 실행된다. 
    private static final Class<?>[] adapterList = new Class<?>[] { 
    	IPropertySource.class, WorkbenchAdapter.class 
    }; 
    
    @Override 
    public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) { 
    	
        if (adapterType== IPropertySource.class && adaptableObject instanceof Todo){ 
        	return adapterType.cast(new TodoPropertySource((Todo) adaptableObject)); 
        } else if (adapterType.isAssignableFrom(WorkbenchAdapter.class) && adaptableObject instanceof Todo) { 
        	return adapterType.cast(new TodoWorkbenchAdapter()); 
        } 
        
        return null; 
    } 
    
    @Override 
    public Class<?>[] getAdapterList() { 
    	return adapterList; 
    } 
}

이제 TodoAdapterFactory는 WorkbenchAdapter 객체들을 반환해야 하고, 또 org.eclipse.core.runtime.adapters 확장점(extension point)에 지정되여야 한다.

그 결과는 이것과 유사하게 보여야 한다.:

19. 이클립스 리소스(Resources)

이클립스 리소스에 IResourceChangeListener를 등록 할 수 있다. 예를 들면, 만약 프로젝트를 가지고 있다면, 그 프로젝트에 또는 그 프로젝트로 부터 리소스 리스너를 추가 하더나 제거 할 수 있다. 

// 리스너 추가하기 
project.getWorkspace().addResourceChangeListener(listener); 

// 리스너 제거하기 
project.getWorkspace().removeResourceChangeListener(listener); 

// 리소스 리스너 예제
private IResourceChangeListener listener = new IResourceChangeListener() { 
	public void resourceChanged(IResourceChangeEvent event) { 
    	if (event.getType() == IResourceChangeEvent.PRE_CLOSE || event.getType() == IResourceChangeEvent.PRE_DELETE) {
        	if (event.getResource().equals(project)) { 
            	// 프로젝트 삭제됨 또는 종료됨 
                // 추가 작업 구현
                
           	} 
            return; 
        } 
        
        if (resource == null) 
        	return; 
            
        IResourceDelta delta = event.getDelta().findMember(new Path(resource.getURI().toPlatformString(false))); 
        
        if (delta == null) { 
        	return; 
        } 
        
        if (delta.getKind() == IResourceDelta.REMOVED) { 
        	// 리소스 삭제
            // 추가 작업 구현 
        } 
	} 
};

20. 연습: 플러그인읠 위한 feature 생성하기

20.1. feature 프로젝트 생성하기

플러그인을 위한 feature 프로젝트를 생성하고 그 feature에 플러그인을 추가 할 수 있다. File > New > Other…​ > Plug-in Development > Feature Project를 통해서 feature 프로젝트를 생성한다.

다음 스크린샷을 따라 feature 프로젝트를 생성한다. 

20.2. 카테고리 정의(Category Definition) 생성하기 

feature 프로젝트 내에 File > New > Other…​ > Plug-in development > Category Definition를 메뉴 엔트리를 통해 새 카테고리 정의를 생성할 수 있다.  

New Category 버튼을 누르고 기능을 설명할 이름으로 카테고리를 생성하다. 이 카테고리에 feature를 추가한다.

21. 연습: 플러그인의 업데이트 사이트 생성하기

21.1. 업데이트 사이트 생성하기

장비에 로컬 디렉토리에 feature를 위한 업데이트 사이트를 생성 할 수 있다. 그러기 위해, File > Export > Deployable features를 선택한다.

카테고리를 사용하기 위해, 옵션(Options) 탭으로 변경하고 저장소 분류(Categorize repository) 옵션에 category.xml 파일의 경로를 선택한다. 

21.2. 이클립스 업데이트 관리자를 통해서 feature 설치하기

이클립스 IDE에 이 새 feature를 설치 하기 위해 Help > Install New Software…​ 를 통해 이클립스 업데이트 관리자를 사용하라.

로컬 디렉렉토리를 지정해서 업데이트 관리자를 사용하라. 그리고 feature를 선택하고 설치 하라.  feature를 볼수 없을 경우에, 카테고리 플래그로 항목( Group items by category)을 선택 취소를 시도하라. 이렇게 하면, 내보내기 하는 동안 카테고리를 설정하는 것을 잃어버리게 된다.

21.3. 설치 검증하기

설치 후에 이클립스 IDE를 재시작하라. 플러그인이 이클립스 설치에서 가능한지 그리고 사용할 수 있는지 확인하라. 

22. 이클립스 플러그인 개발 리소스

이클립스 플러그인 개발 FAQ

컬러와 폰트 환경 구성 추가하기 blog post

이클립스 기사, 튜토리얼, 시연, 책들에 목록을 가진 Wiki

이클립스 튜토리얼

이클립스에 어뎁터들

이클립스 리소스 델타 튜토리얼

이클립스에서 마커, 어노테이션, 그리고 데코레이션 사용하기 (IBM)

[원문 출처] swagger.io/docs/specification/about/

해당 문서의 경우 SMARTBEAR 사의 Swagger Specirication Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트

OpenAPI란 무엇인가?

OpenAPI 규격서 (이전에 Swagger 규격서로 알려진) 는 REST API을 위한 API 설명 서식이다. OpenAPI 파일은 아래를 포함해서 전체 API를 설명하기 위하는 것을 가능하게 한다 :

• 가능한 엔드포인트 (/users 등등) 와 각각의 엔드포인트에서 동작( GET /users, POST /users 등등)
• 각각의 작업을 위한 입력과 출력 작업 파라미터들
• 인증 방법
• 연락처 정보, 라이선스, 사용 약관과 기타 정보.

API 규격서는 YAML 또는 JSON으로 작성 될 수 있고. 이 서식은 쉽게 배울수 있고 개발자와 컴퓨터 양쪽이 읽을 수 있다. 완전한 OpenAPI 규격서는 GitHub에서 볼 수 있다. : OpenAPI 3.0 규격서

Swagger는 무엇인가?

Swagger는  REST API들을 설계하고 빌드하고 문서화하고 소비하는데 도움을 줄 수 있는 OpenAPI 규격서을 중심으로 빌드된 오픈소스 툴 세트이다. 주요 Swagger 툴은 아래를 포함한다. :

• Swagger 편집기 – OpenAPI 규격을 작성 할 수 있는 브라우저 기반의 편집기.
• Swagger 사용자인터페이스 – API 문서와 상호작용함으로써 OpenAPI 규격을 만들어 주는 사용자 인터페이스.
• Swagger 코드생성기 – OpenAPI 규격으로 서버 Stub 또는 클라이언트 라이블러리를 생성기

왜 OpenAPI를 사용하는가?

API 자체의 구조를 기술하는 API들의 능력은 OpenAPI에서 매우 엄청난 것의 뿌리가 된다. 일단 작성되면, OpenAPI 규격서와 Swagger 툴은 다양한 방법에서 더 나은 API 개발 하게 만들 수 있다. :

• 설계-우선 사용자들: 개발 할 API의 서버 Stub을 생성하기 위해 Swagger 코드생성기를 사용한다. 단지 서버 로직을 구현 하는것만 남겨저 있고 이미 사용할 준비가 되어 있다.
• 40개 다른 개발 언어에서 사용할 클라이언트 라이블러리를 생성하기 위해 Swagger 코드생성기를 사용한다.
• 사용자가 브라우저에서 직접 개발한 API 호출을 시도 할 수 있게 하기 위해 API문서와 상호작용을 생성하는 Swagger 사용자인터페이스를 사용한다. 
• 개발된 API에 API 관련 툴을 접속하기 위한 규격으로 사용한다. 예를들면, API에 자동화된 테스트 생성을 위해 SoapUI에 규격을 불러들인다. 
• 그리고 추가로! Swgger와 통합된 open-source 와 commercial tools 을 확인해 보라.

[원문 출처] http://activemq.apache.org/slow-consumer-handling.html

해당 문서의 경우 Apache 재단의 ActiveMQ Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트

[원문 출처] http://activemq.apache.org/vm-transport-reference.html

해당 문서의 경우 Apache 재단의 ActiveMQ Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트

VM 전송

VM 전송은 클라이언크가 네트워크 커넥터의 오버헤드 없이 VM 내부에 다른 곳에 접속 하는 것을 허용한다. 이 커넥션은 소켓 커넥션이 사용되지 않는다. 그러나 고성능의 내장된 메시징 시스템을 사용 가능하게 직접 메서드 호출을 사용한다. .

VM 커넥션을 사용하기 위한 첫번째 클라이언트는 내장된 브로커를 구동하게 된다.  그 뒤의 클라이언트 커넥션은 같은 브로커에 접속한다. 일단 브로커에 접속하기 위한 모든 VM 커넥션이 모두 닫히게 되면, 내장된 브로커는 자동적으로 셧다운 된다.

심플 브로커 환경 구성 구문

VM 커넥션을 위한 일반적인 구문인 simple 이고, 단지 제한된 내장된 브로커의 환경 구성을 제공한다. 

vm://brokerName?transportOptions

만약 이미 인스턴스화된 브로커에 접속을 원하면, 내장된 브로커(예를 들면. Apache ServiceMix 같은 경우에 ) brokerName에  이미 실행중인 브로커의 brokerName 과 일치하는 것이 사용 된 vm://brokerName URI를 사용하는 것을  보장한다. 

전송 옵션

예제 URI

vm://broker1?marshal=false&broker.persistent=false

어드벤스드 브로커 환경 구성 구문

VM 커넥션을 위한 어드벤스드 구문이다. Broker 브로커 환경  구성 URI를 사용하여 좀더 광범위하게 브로커를 환경 구성하는 것을 허용한다. 

vm:(broker:(tcp://localhost)?brokerOptions)?transportOptions

또는 
vm:broker:(tcp://localhost)?brokerOptions

전송 옵션 

VM 전송을 사용을 최적화 하는 더 많은 옵션이 있다.

예제 URI

vm:(broker:(tcp://localhost:6000)?persistent=false)?marshal=false

외부 환경 구성 파일을 사용하여 내장된 브로커 환경 구성하기 

 VM 전송과 외부 환경 구성 파일을 사용하여 (i.e. activemq.xml) 내장된 브로커를 시작하기 위해, 다음 URI를 사용하라: