개발자를 꿈꾼다

Ruby의 내장(전역) 변수들

Sat, 05 May 2012 01:57:33 +0900

정규 표현식 관련
- $` : 패턴에 매치되는 부분의 앞부분이 저장된다. 치환에서는 \`로 사용할 수 있다. MatchData 클래스의 pre_match와 같다.
- $& : 패턴에 매치되는 부분이 저장된다. 치환에서는 \&로 최근 매치 전체로 사용할 수 있다.
- $' : 패턴에 매치되는 뒷부분이 저장된다. 치환에서는 \'로 사용할 수 있다. MatchData 클래스의 post_match와 같다.
- $~ : 패턴 매치에 대해 궁금해할 만한 모든 정보를 담고 있는 MatchData 객체가 저장됨. 스레드 지역 변수로 그 정규 표현식이 사용된 지역 내에서만 사용할 수 있다.
- $1 ~ $9 : ()연산(그룹)의 매치 결과. 스레드 지역 변수로 그 정규 표현식이 사용된 지역 내에서만 사용할 수 있다. 정규 표현식 내에서는 \1 ~ \9로 사용할 수 있다. MatchData 클래스의 [1] ~ [9] 와 같다.
- $+ : 마지막으로 매치된 그룹. 치환에서는 \+로 사용할 수 있다.
현재 컨텍스트 관련
- $_ : 현재 컨텍스트의 임시 변수. 모든 연산에서 명확한 변수를 지정하지 않을 때 사용된다. Ruby에서 사용을 자제하는 추세.
  - gets에서 반환하는 내용
  - 프로그램의 입력 파일( 아닌 듯 )
  - 정규 표현식에서 단순한 정규표현식만 사용할 경우 $_가 사용된다.
- $. : 현재 라인 번호 또는 현재까지 입력 받은 줄 수
- ~ : ~ 연산자는 정규표현식이 $_에 매칭하는지 판단한다.
- $! : 해당 스레드에서 마지막에 발생한 예외
커맨드 관련
- $? : `로 둘러싸인 커맨드의 종료 상태값
명령행 관련
- ARGF : 프로그램의 입력 파일
  - ARGF.each { |line| print line if line =~ /Ruby/ }
  - print ARGF.grep ( /Ruby/ )
- ARGV : 명령행으로 실행시 프로그램 파일 이름 뒤의 매개변수의 배열
  - C와는 달리 ARGV[0]은 프로그램의 이름이 아니라 프로그램의 첫 번째 매개변수이다.
- $0 : 명령행으로 실행시 현재 프로그램의 이름
- EVN : 운영체제 환경 변수에 대한 객체. 해시는 아니지만 ENV#to_hash로 해시로 변환할 수 있다
  - ENV['SHELL'], ENV['HOME'], ENV['USER'], EVN.keys.size, ENV.keys[0, 7], ...
  - 일부 환경 변수의 값은 루비가 처음 실행되기 시작할 때 읽는다. 이러한 변수는 변경 시켜 인터프리터의 동작을 변경 시킬 수 있다.
모듈 관련
- $" : require 표현식으로 로드한 경로를 저장한 배열. require에 넘겨진 이름 그대로를 저장하므로 같은 파일을 다른 경로로 준다면 두 번 저장될 수도 있다.
  - 두 번 저장되는 경우
    - require '/usr/lib/ruby/1.9/English.rb'
    - require '/usr/lib/ruby/1.9/rdoc/../English.rb'
- $: : require 표현식으로 공유 라이브러리(*.so, *.dll)을 로드할 경우 공유 라이브러리를 검색할 디렉토리(로드 경로)를 저장한 배열
  - 다른 표현으로 $LOAD_PATH 가 있다.

2011-12-08

Thu, 08 Dec 2011 00:53:59 +0900

Extending Eclipse - Plug-in Development Tutorial

Lars Vogel

Version 2.0

Copyright © 2007, 2008, 2009, 2010, 2010 Lars Vogel

04.12.2011

Revision History
Revision 0.1    01.04.2008    Lars Vogel
Created
Revision 0.2 - 2.0    14.04.2009 - 04.12.2011    Lars Vogel
bugfixes and enhancements
Eclipse Plug-ins Tutorial

This article describes the creation and deployment of Eclipse plug-ins. The article is based on Eclipse 3.7 (Eclipse Indigo) and Java 1.6.

Table of Contents

1. Eclipse Plugins
2. Prerequisites
3. Hello World Plug-in
4. Contribute to existing UI elements
4.1. Overview
4.2. Contribute to package explorer
4.3. Restrict the extension - Visible When
5. Resources and Marker
5.1. Overview
5.2. Create markers
5.3. More on markers
6. Adapters
6.1. Overview
6.2. Example
7. Deploying a plugin
8. Tutorial: Deploying a plug-in
8.1. Export plug-in and put into dropin folder
8.2. Create a p2 update site
9. Thank you
10. Questions and Discussion
11. Links and Literature
11.1. Source Code
11.2. Eclipse Resources
11.3. vogella Resources
1. Eclipse Plugins

The smallest software component in Eclipse are plug-ins. The Eclipse IDE allows the developer to extend the IDE functionality via plug-ins. For example you can create new menu entreis or new editors via plug-ins. This tutorial gives several examples how to do this.

Eclipse is build upon the OSGi framework. The OSGi framework provides a dynamic modular architecture which is used for running the Eclipse IDE.

2. Prerequisites

This tutorial assumes that you are already familiar with using the Eclipse IDE and have experience in developing Java.

3. Hello World Plug-in

We will create a plug-in which contributes a menu entry to the standard Eclipse menu.

Create a new plug-in project de.vogella.plugin.first via File → New → Project → Plug-in Development → Plug-in Project.

Select the "Hello, World Command!" template and press Finish. This should automatically open the "Plug-in Development perspective".

Select the file MANIFEST.MF, right click it, select Run-As → Eclipse Application

A new workbench starts with a new menu entry. If you select this menu entry a message box will be displayed.

4. Contribute to existing UI elements

4.1. Overview

In this example we will add a new context menu entry to the Package explorer view. The context menu is displayed if the user select a file in the package explorer via a right mouse click. We will offer the option to create a HTML page for a Java source file.

To contribute to an existing menu or toolbar you need to know the corresponding ID. This ID can be found via the "Menu Spy". See Eclipse Source Code Guide for details.

4.2. Contribute to package explorer

Create a new plug-in project de.vogella.plugin.htmlconverter. Do not use a template. Select the tab "Dependencies" of the file plugin.xml. Add the dependencies to org.eclipse.jdt.core and org.eclipse.core.resources.

The following uses Eclipse Commands. See Eclipse Commands Tutorial to learn how to work with commands.

Add a command with the ID de.vogella.plugin.htmlconverter.convert and the default handler de.vogella.plugin.htmlconverter.handler.Convert to your plug-in.

Add this command to the menu via the extension point org.eclipse.ui.menus and use as the "locationURI" popup:org.eclipse.jdt.ui.PackageExplorer. Set the label to "Create HTML" for this contribution.

The resulting file plugin.xml should look like the following.


<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="popup:org.eclipse.jdt.ui.PackageExplorer">
         <command
               commandId="de.vogella.plugin.htmlconverter.convert"
               label="Create HTML"
               style="push">
         </command>
      </menuContribution>
   </extension>
   <extension
         point="org.eclipse.ui.commands">
      <command
            defaultHandler="de.vogella.plugin.htmlconverter.handler.Convert"
            id="de.vogella.plugin.htmlconverter.convert"
            name="Convert">
      </command>
   </extension>

</plugin>


Eclipse allows to save additional information for each file. You can use the IResource interface and the setPersistentProperty() and getPersistentProperty() methods. With these functions you can save Strings on files. We use these functions to save a directory for Java source files which already were exported via HTML.

Create the de.vogella.plugin.htmlconverter.handler.Convert class.


package de.vogella.plugin.htmlconverter.handler;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.ui.handlers.HandlerUtil;

public class Convert extends AbstractHandler {
    private QualifiedName path = new QualifiedName("html", "path");

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {

        IStructuredSelection selection = (IStructuredSelection) HandlerUtil
                .getActiveMenuSelection(event);

        String directory = "";
        Object firstElement = selection.getFirstElement();
        if (firstElement instanceof ICompilationUnit) {
            ICompilationUnit cu = (ICompilationUnit) firstElement;
            IResource res = cu.getResource();
            boolean newDirectory = true;
            directory = getPersistentProperty(res, path);

            if (directory != null && directory.length() > 0) {
                newDirectory = !(MessageDialog.openQuestion(
                        HandlerUtil.getActiveShell(event), "Question",
                        "Use the previous output directory?"));
            }
            if (newDirectory) {
                DirectoryDialog fileDialog = new DirectoryDialog(
                        HandlerUtil.getActiveShell(event));
                directory = fileDialog.open();

            }
            if (directory != null && directory.length() > 0) {
                analyze(cu);
                setPersistentProperty(res, path, directory);
                write(directory, cu);
            }

        } else {
            MessageDialog.openInformation(HandlerUtil.getActiveShell(event),
                    "Information", "Please select a Java source file");
        }
        return null;
    }

    protected String getPersistentProperty(IResource res, QualifiedName qn) {
        try {
            return res.getPersistentProperty(qn);
        } catch (CoreException e) {
            return "";
        }
    }

    // TODO: Include this in the HTML output

    private void analyze(ICompilationUnit cu) {
        // Cool JDT allows you to analyze the code easily
        // I don't see really a use case here but I just wanted to do this here
        // as I consider this as cool and
        // what to have a place where I can store the data
        try {

            IType type = null;
            IType[] allTypes;
            allTypes = cu.getAllTypes();

/**
            * Search the public class
            */

            for (int t = 0; t < allTypes.length; t++) {
                if (Flags.isPublic((allTypes[t].getFlags()))) {
                    type = allTypes[t];
                    break;
                }
            }
            if (type != null) {
                String classname = type.getFullyQualifiedName();
                IMethod[] methods = type.getMethods();
            }

        } catch (JavaModelException e) {
            e.printStackTrace();
        }

    }

    protected void setPersistentProperty(IResource res, QualifiedName qn,
            String value) {
        try {
            res.setPersistentProperty(qn, value);
        } catch (CoreException e) {
            e.printStackTrace();
        }
    }

    private void write(String dir, ICompilationUnit cu) {
        try {
            cu.getCorrespondingResource().getName();
            String test = cu.getCorrespondingResource().getName();
            // Need
            String[] name = test.split("\\.");
            System.out.println(test);
            System.out.println(name.length);
            String htmlFile = dir + "\\" + name[0] + ".html";

            System.out.println(htmlFile);
            FileWriter output = new FileWriter(htmlFile);
            BufferedWriter writer = new BufferedWriter(output);
            writer.write("<html>");
            writer.write("<head>");
            writer.write("</head>");
            writer.write("<body>");
            writer.write("<pre>");
            writer.write(cu.getSource());
            writer.write("</pre>");
            writer.write("</body>");
            writer.write("</html>");
            writer.flush();
        } catch (JavaModelException e) {
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}


If you start this plugin you should be able to create HTML output from a Java source file.

4.3. Restrict the extension - Visible When

Currently our context menu is always displayed. We would like to show it only if a source file is selected. For this we will use a "visible-when" definition. To learn the details of visible-when please see Eclipse Advanced Usage of Commands .

Add the dependency "org.eclipse.core.expressions" to your plugin. Select your menu contribution. Using the right mouse add the condition to the command that it should only be visible if a file is selected which represents a "org.eclipse.jdt.core.ICompilationUnit". For this exercise you use the predefined variable "activeMenuSelection" which contains the selection in the menu and iterate over it. If the selection can get adapted to ICompilationUnit then the contribution will be visible.

This will result in the following "plugin.xml".


<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
   <extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="popup:org.eclipse.jdt.ui.PackageExplorer">
         <command
               commandId="de.vogella.plugin.htmlconverter.convert"
               label="Create HTML"
               style="push">
            <visibleWhen
                  checkEnabled="false">
               <with
                     variable="activeMenuSelection">
                  <iterate
                        ifEmpty="false"
                        operator="or">
                     <adapt
                           type="org.eclipse.jdt.core.ICompilationUnit">
                     </adapt>
                  </iterate>
               </with>
            </visibleWhen>
         </command>
      </menuContribution>
   </extension>
   <extension
         point="org.eclipse.ui.commands">
      <command
            defaultHandler="de.vogella.plugin.htmlconverter.handler.Convert"
            id="de.vogella.plugin.htmlconverter.convert"
            name="Convert">
      </command>
   </extension>

</plugin>


If you now start your plugin the menu entry should only be visible if at least one compilation unit has been selected.

5. Resources and Marker

5.1. Overview

Eclipse represents Resources like Projects, Files, Folders, Packages as IResource.

Marker represent additional informations for resources, e.g. an error marker. Every marker can have attributes (key / value combination). Markers can be displayed in the standard view, e.g. the Task, Bookmark or the problems view. To be displayed in these views you have to use predefined attributes.

The following will demonstrate how to create marker for a selected resource.

5.2. Create markers

Create a plug-in project "de.vogella.plugin.markers". Add the dependency to org.eclipse.core.resources", "org.eclipse.jdt.core" and "org.eclipse.jdt.ui". Create the command "de.vogella.plugin.markers.AddMarker" with the default handler "de.vogella.plugin.markers.handler.AddMarker" and add this command to the menu.

Create the following code.


package de.vogella.plugin.markers.handler;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.handlers.HandlerUtil;

public class AddMarker extends AbstractHandler {

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {
        IStructuredSelection selection = (IStructuredSelection) HandlerUtil
                .getActiveSite(event).getSelectionProvider().getSelection();
        if (selection == null) {
            return null;
        }
        Object firstElement = selection.getFirstElement();
        if (firstElement instanceof IJavaProject) {
            IJavaProject type = (IJavaProject) firstElement;
            try {
                IResource resource = type.getUnderlyingResource();
                IMarker marker = resource.createMarker(IMarker.TASK);
                marker.setAttribute(IMarker.MESSAGE, "This a a task");
                marker.setAttribute(IMarker.PRIORITY, IMarker.PRIORITY_HIGH);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        return null;
    }
}


If you run you can create a marker in the TODO list if you select a Java project and click your menu entry.

5.3. More on markers

For more on markers check the following tutorial from IBM developerworks Using markers, annotations, and decorators in Eclipse.

6. Adapters

6.1. Overview

Adapters help to display information about objects in view without having to adjust the existing views. In this example we will create a small view which allows to select objects and use the properties view to display them.

Adapters are used on several places for example you can use an adapter to display your data in the outline view. See Outline View Example for an example how to do this.

6.2. Example

We will simple use an adapter to show our data in the property view. Create a new plugin project "de.vogella.plugin.adapter". Use the "Plug-in with a view" template with the following settings.

Add the dependency "org.eclipse.ui.views" in tab dependencies of plugin.xml.

Create the following data model.


package de.vogella.plugin.adapter.model;

public class Todo {
    private String summary;
    private String description;
    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;
    }

}


Change the code of SampleView.java to the following. After this change you should be able to run your project, open your view and see your todo items.


package de.vogella.plugin.adapter.views;

import org.eclipse.jface.viewers.ArrayContentProvider;
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.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

import de.vogella.plugin.adapter.model.Todo;

public class SampleView extends ViewPart {
    public static final String ID = "de.vogella.plugin.adapter.views.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);
        }
    }


/**
    * This is a callback that will allow us to create the viewer and initialize
    * it.
    */

    public void createPartControl(Composite parent) {
        viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
                | SWT.V_SCROLL);
        viewer.setContentProvider(new ArrayContentProvider());
        viewer.setLabelProvider(new ViewLabelProvider());
        getSite().setSelectionProvider(viewer);
        viewer.setInput(getElements());

    }


/**
    * Passing the focus request to the viewer's control.
    */

    public void setFocus() {
        viewer.getControl().setFocus();
    }

    // Build up a simple data model
    private Todo[] getElements() {
        Todo[] todos = new Todo[2];
        Todo todo = new Todo();
        todo.setSummary("First Todo");
        todo.setDescription("A very good description");
        todos[0] = todo;
        todo = new Todo();
        todo.setSummary("Second Todo");
        todo.setDescription("Second super description");
        todos[1] = todo;
        return todos;
    }
}


To displays its values in the property view, add the extension point "org.eclipse.core.runtime.adapters" to your project. The data of the extension point should be like the following.


<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>


Implement the factory and the new class "TodoPropertySource" which implements "IPropertySource".


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 {

    @Override
    public Object getAdapter(Object adaptableObject, Class adapterType) {
        if (adapterType== IPropertySource.class && adaptableObject instanceof Todo){
            return new TodoPropertySource((Todo) adaptableObject);
        }
        return null;
    }

    @Override
    public Class[] getAdapterList() {
        return new Class[] { IPropertySource.class };
    }

}



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);
        }
    }

}


If you run your workbench and open your View via Windows -> Show View -> Others -> Sample Category -> Sample View and the property view you should be able to view your data.

7. Deploying a plugin

To use your plug-ins in your standard Eclipse installation you can either export it locally as plug-in and place it into your Eclipse installation or you export it as feature and use the Eclipse update manager to install it.

If you export your plug-in locally you can put it into the Eclipse "dropin" folder of your Eclipse installation. After a restart of your Eclipse your plug-in should be available and ready to be used.

If you want to install your plug-in into your running Eclipse IDE, you can also use "Install into host. Repository". In the export wizard dialog select in this case "Install into host. Repository". This will export your plugin into the selected directory (Repository) and install it directly into the running Eclipse.

If you create and export an feature you can use the Eclipse update manager directly if you point to the created "metadata" repository during the export. You can then use the Eclipse update manager to install this feature.

8. Tutorial: Deploying a plug-in

8.1. Export plug-in and put into dropin folder

Select your plugin.xml and select the tab overview. Press the hyperlink "Export Wizard".

Select the plug-in you want to export.

This will create a jar in the selected directory. Copy this jar to the "dropin" directory in your Eclipse installation directory and re-start Eclipse.

After a restart of Eclipse your plug-in should now be available in your Eclipse installation and ready to be used. For example if you contributed a new view you find it under the Windows -> Show View menu entry.

8.2. Create a p2 update site

p2 is the technical component which allows to install, remove and update plugins to your existing Eclipse IDE installation.

To create an update site you require a feature project. Create a feature project for your plugin.

The Eclipse p2 update manager shows per default only features with a category. While the user can deflag this grouping it is often easier to deploy the feature including an category.

In your feature project create file File -> New -> Other -> Plug-in development -> "Category Definition" a new category for your feature.

Press "New Category" and create a category with a name which describes your functionality. Add your feature to this category.

Export your feature via File -> Export -> "Deployable features". Deploy it to a local directory on your machine. Make sure you select on the Option tab your "category.xml". Also make sure to select "Generate metadata repository".

Try if this feature can be installed into your Eclipse IDE. See Using the Eclipse Update Manager for information on how to use the Eclipse update manager. Use the update manager and point to your local directory. Restart the IDE after installation.

After a restart of Eclipse your plug-in should now be available in your Eclipse installation and ready to be used. For example if you contributed a new view you find it under the Windows -> Show View menu entry.

9. Thank you

Please help me to support this article:



10. Questions and Discussion

Before posting questions, please see the vogella FAQ. If you have questions or find an error in this article please use the www.vogella.de Google Group. I have created a short list how to create good questions which might also help you.

11. Links and Literature

11.1. Source Code

Source Code of Examples

11.2. Eclipse Resources

http://wiki.eclipse.org/Eclipse_Plug-in_Development_FAQ Eclipse Plug-in Development FAQ

http://www.eclipse.org/articles/article.php?file=Article-Adapters/index.html Adapters in Eclipse

http://www.eclipse.org/articles/Article-Resource-deltas/resource-deltas.html How to react to Eclipse resource deltas

OSGi Tutorial

Eclipse RCP Tutorial

11.3. vogella Resources

Eclipse RCP Training (German) Eclipse RCP Training with Lars Vogel

Android Tutorial Introduction to Android Programming

GWT Tutorial Program in Java and compile to JavaScript and HTML

Eclipse RCP Tutorial Create native applications in Java

JUnit Tutorial Test your application

Git Tutorial Put everything you have under distributed version control system

[펌] http://wiki.eclipse.org/Platform_Command_Framework

Wed, 16 Nov 2011 15:18:23 +0900

[출처: http://wiki.eclipse.org/Platform_Command_Framework]

Platform Command Framework

[hide]

Architecture Overview

http://dev.eclipse.org/viewcvs/index.cgi/~checkout~/platform-ui-home/R3_1/contributions-proposal/requestForComments_html_m41374bdb.png

Figure 1: High Level Architecture

Eclipse Commands Tutorial

http://www.vogella.de/articles/EclipseCommands/article.html Tutorial about using Eclipse Commands by Lars Vogel

Other Resources

Commands in Action by Prakash G.R.:

Command Core Expressions

Commands

Commands are managed by the org.eclipse.ui.commands extension point and the ICommandService.

An example of using the extension point to create a command:

<extension
       point="org.eclipse.ui.commands">
    <category
          description="Actions take at lunch time."
          id="z.ex.view.keybindings.category"
          name="Lunch">
    </category>
    <command
          categoryId="z.ex.view.keybindings.category"
          description="Go for the taco."
          id="z.ex.view.keybindings.eatTaco"
          name="Eat That Taco">
    </command>
</extension>

You can programmatically create commands as well. From within a view:

ICommandService cmdService = (ICommandService) getSite().getService(
    ICommandService.class);
Category lunch = cmdService
    .getCategory("z.ex.view.keybindings.category");
if (!lunch.isDefined()) {
  lunch.define("Lunch", "Actions take at lunch time.");
}
Command eatTaco = cmdService
    .getCommand("z.ex.view.keybindings.eatTaco");
if (!eatTaco.isDefined()) {
  eatTaco.define("Eat That Taco", "Go for the taco.", lunch);
}

Note, however, that a plugin that programmatically defines commands is responsible for cleaning them up if the plugin is ever unloaded.

Also, like IAction you can execute a command directly ... but to get the proper environment it's better to execute it through the IHandlerService. See #Handlers.

Executing a command with parameters

When a Command specifies its parameters, it can also specify a parameter type and/or some valid values. For example, the showView command.

<command
      name="%command.showView.name"
      description="%command.showView.description"
      categoryId="org.eclipse.ui.category.views"
      id="org.eclipse.ui.views.showView"
      defaultHandler="org.eclipse.ui.handlers.ShowViewHandler">
    <commandParameter
        id="org.eclipse.ui.views.showView.viewId"
        name="%command.showView.viewIdParameter"
        values="org.eclipse.ui.internal.registry.ViewParameterValues" />
</command>

To execute this command, you need to create a ParameterizedCommand with a Parameterization (an instance of a parameter and its value).

ICommandService commandService = ...;
                IHandlerService handlerService = ...;
                Command showView = commandService
                                .getCommand("org.eclipse.ui.views.showView");
                IParameter viewIdParm = showView
                                .getParameter("org.eclipse.ui.views.showView.viewId");
 
                // the viewId parameter provides a list of valid values ... if you
                // knew the id of the problem view, you could skip this step.
                // This method is supposed to be used in places like the keys
                // preference page, to allow the user to select values
                IParameterValues parmValues = viewIdParm.getValues();
                String viewId = null;
                Iterator i = parmValues.getParameterValues().values().iterator();
                while (i.hasNext()) {
                        String id = (String) i.next();
                        if (id.indexOf("ProblemView") != -1) {
                                viewId = id;
                                break;
                        }
                }
 
                Parameterization parm = new Parameterization(viewIdParm, viewId);
                ParameterizedCommand parmCommand = new ParameterizedCommand(
                                showView, new Parameterization[] { parm });
 
                handlerService.executeCommand(parmCommand, null);

This executes the showView command with the problem view id. This is done for us when declaratively specifying a keybinding.

<key
      sequence="M2+M3+Q X"
      contextId="org.eclipse.ui.contexts.window"
      commandId="org.eclipse.ui.views.showView"
      schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
    <parameter 
        id="org.eclipse.ui.views.showView.viewId"
        value="org.eclipse.ui.views.ProblemView" />
</key>

Using an IActionDelegate to execute a command

In 3.1 and 3.2 there is no declarative support for a menu item to execute a command. But you can write an IActionDelegate (like GenericCommandActionDelegate) that can be used in the standard extension points (org.eclipse.ui.actionSets, org.eclipse.ui.popupMenus, org.eclipse.ui.editorActions, and org.eclipse.ui.viewActions) and use it to execute the command.

We need to do these things to wire our command to a menu item:

Define an action in an extension point using plugin.xml markup
Connect this action to our IActionDelegate instance (also in plugin.xml)
Tell our IActionDelegate which command to execute (also in plugin.xml)
Code the IActionDelegate class to perform the command execution. (see code example below).

For example, in the above section we saw the showView command takes one parameter, the view id. Here is how we create an Action to execute it:

<action
  id="org.eclipse.ui.examples.actions.showOutlineView"
  label="Show View:Outline"
  menubarPath="org.eclipse.ui.examples.actions.showViewMenu/additions"
  style="push">
  <class class="org.eclipse.ui.tests.api.GenericCommandActionDelegate">
     <parameter name="commandId" 
                          value="org.eclipse.ui.views.showView"/>
     <parameter name="org.eclipse.ui.views.showView.viewId" 
                          value="org.eclipse.ui.views.ContentOutline"/>
  </class>
</action>
<action
  id="org.eclipse.ui.examples.actions.showBookmarkView"
  label="Show View:Bookmark"
  menubarPath="org.eclipse.ui.examples.actions.showViewMenu/additions"
  style="push">
  <class class="org.eclipse.ui.tests.api.GenericCommandActionDelegate">
      <parameter name="commandId" 
                          value="org.eclipse.ui.views.showView"/>
      <parameter name="org.eclipse.ui.views.showView.viewId" 
                          value="org.eclipse.ui.views.BookmarkView"/>
  </class>
</action>

Notes:

For commands without parameters, you can use the class attribute short from:

class="org.eclipse.ui.tests.api.GenericCommandActionDelegate:my.commandId"

your action definition looks more like a keybinding definition. You are specifying the command id and any parameters needed for that action.
We specifed the action using the <class/> element instead of the class attribute ... you'll get a couple of warnings, ignore them.

The definitionId that is currently in the <action/> element is for linking up legacy actions to a keybinding through a command. For example, you've had a ShowMyViewActionDelegate since 3.0, and you want to attach a keybinding to it. We don't want to use that.

We have just shown the plugin.xml markup to trigger a command from within an action. Since the action can be inserted into a menu, this approach allows commands to be triggered by menu items. The glue between actions and commands is a single generic IActionDelegate implementation (shown below). All of the specific behavior code is now unified in the command and its handler. We no longer need an action delegate with a specific run() method for every menu item; consequently we don't need to link ActionSets to commands with the definitionId.

Known Issues:

When you start up eclipse you'll get warnings about your actions not having a class attribute. It's not an error, and won't effect the action performance.

You'll also see the actions in the Uncategorized section of the keybindings page. You can bind keys to them but they won't work from the keybinding. That's OK, you should be binding keys to the command not the action.

Generic Command Action Delegate

We'll need a more robust implementation, but in 3.2 your action delegate needs to look something like the class below. I've only tested this with org.eclipse.ui.actionSets, but it should work with the viewActions, editorActions, and popupMenus extension points as well. The latest version of the code lives in HEAD in the org.eclipse.ui.tests plugin: GenericCommandActionDelegate.java

/*******************************************************************************
  * Copyright (c) 2006 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ui.tests.api;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.Map;
 
 import org.eclipse.core.commands.Command;
 import org.eclipse.core.commands.IParameter;
 import org.eclipse.core.commands.Parameterization;
 import org.eclipse.core.commands.ParameterizedCommand;
 import org.eclipse.core.commands.common.NotDefinedException;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IConfigurationElement;
 import org.eclipse.core.runtime.IExecutableExtension;
 import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.ui.IEditorActionDelegate;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IObjectActionDelegate;
 import org.eclipse.ui.IViewActionDelegate;
 import org.eclipse.ui.IViewPart;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.IWorkbenchWindowActionDelegate;
 import org.eclipse.ui.commands.ICommandService;
 import org.eclipse.ui.handlers.IHandlerService;
 
 /**
  * This action delegate can be used to specify a command with or without
  * parameters be called from an &lt;action/&gt; specified in actionSets,
  * editorActions, viewActions, or popupMenus.
  */
 public class GenericCommandActionDelegate implements
         IWorkbenchWindowActionDelegate, IViewActionDelegate,
         IEditorActionDelegate, IObjectActionDelegate, IExecutableExtension {
 
     private static final String PARM_COMMAND_ID = "commandId";
 
     private String commandId = null;
 
     private Map parameterMap = null;
 
     private ParameterizedCommand parameterizedCommand = null;
 
     private IHandlerService handlerService = null;
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
      */
     public void dispose() {
         handlerService = null;
         parameterizedCommand = null;
         parameterMap = null;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
      */
     public void run(IAction action) {
         if (handlerService == null) {
             // what, no handler service ... no problem
             return;
         }
         try {
             if (commandId != null) {
                 handlerService.executeCommand(commandId, null);
             } else if (parameterizedCommand != null) {
                 handlerService.executeCommand(parameterizedCommand, null);
             }
             // else there is no command for this delegate
         } catch (Exception e) {
             // exceptions reduced for brevity
             // and we won't just do a print out :-)
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction,
      *      org.eclipse.jface.viewers.ISelection)
      */
     public void selectionChanged(IAction action, ISelection selection) {
         // we don't care, handlers get their selection from the
         // ExecutionEvent application context
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
      *      java.lang.String, java.lang.Object)
      */
     public void setInitializationData(IConfigurationElement config,
             String propertyName, Object data) throws CoreException {
         String id = config.getAttribute(IWorkbenchRegistryConstants.ATT_ID);
         // save the data until our init(*) call, where we can get
         // the services.
         if (data instanceof String) {
             commandId = (String) data;
         } else if (data instanceof Map) {
             parameterMap = (Map) data;
             if (parameterMap.get(PARM_COMMAND_ID) == null) {
                 Status status = new Status(IStatus.ERROR,
                         "org.eclipse.ui.tests", "The '" + id
                                 + "' action won't work without a commandId");
                 throw new CoreException(status);
             }
         } else {
             Status status = new Status(
                     IStatus.ERROR,
                     "org.eclipse.ui.tests",
                     "The '"
                             + id
                             + "' action won't work without some initialization parameters");
             throw new CoreException(status);
         }
     }
 
     /**
      * Build a command from the executable extension information.
      * 
      * @param commandService
      *            to get the Command object
      */
     private void createCommand(ICommandService commandService) {
         String id = (String) parameterMap.get(PARM_COMMAND_ID);
         if (id == null) {
             return;
         }
         if (parameterMap.size() == 1) {
             commandId = id;
             return;
         }
         try {
             Command cmd = commandService.getCommand(id);
             if (!cmd.isDefined()) {
                 // command not defined? no problem ...
                 return;
             }
             ArrayList parameters = new ArrayList();
             Iterator i = parameterMap.entrySet().iterator();
             while (i.hasNext()) {
                 Map.Entry entry = (Map.Entry) i.next();
                 String parmName = (String) entry.getKey();
                 if (PARM_COMMAND_ID.equals(parmName)) {
                     continue;
                 }
                 IParameter parm = cmd.getParameter(parmName);
                 if (parm == null) {
                     // asking for a bogus parameter? No problem
                     return;
                 }
                 parameters.add(new Parameterization(parm, (String) entry.getValue()));
             }
             parameterizedCommand = new ParameterizedCommand(cmd,
                     (Parameterization[]) parameters
                             .toArray(new Parameterization[parameters.size()]));
         } catch (NotDefinedException e) {
             // command is bogus? No problem, we'll do nothing.
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
      */
     public void init(IWorkbenchWindow window) {
         if (handlerService != null) {
             // already initialized
             return;
         }
 
         handlerService = (IHandlerService) window
                 .getService(IHandlerService.class);
         if (parameterMap != null) {
             ICommandService commandService = (ICommandService) window
                     .getService(ICommandService.class);
             createCommand(commandService);
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IViewActionDelegate#init(org.eclipse.ui.IViewPart)
      */
     public void init(IViewPart view) {
         init(view.getSite().getWorkbenchWindow());
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IEditorActionDelegate#setActiveEditor(org.eclipse.jface.action.IAction,
      *      org.eclipse.ui.IEditorPart)
      */
     public void setActiveEditor(IAction action, IEditorPart targetEditor) {
         // we don't actually care about the active editor, since that
         // information is in the ExecutionEvent application context
         // but we need to make sure we're initialized.
         if (targetEditor != null) {
             init(targetEditor.getSite().getWorkbenchWindow());
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction,
      *      org.eclipse.ui.IWorkbenchPart)
      */
     public void setActivePart(IAction action, IWorkbenchPart targetPart) {
         // we don't actually care about the active part, since that
         // information is in the ExecutionEvent application context
         // but we need to make sure we're initialized.
         if (targetPart != null) {
             init(targetPart.getSite().getWorkbenchWindow());
         }
     }
 }

Handlers

Handlers are managed by the org.eclipse.ui.handlers extension point and the IHandlerService. Many Handlers can register for a command. At any give time, either 0 or 1 handlers will be active for the command. A handler's active state and enabled state can be controlled declaratively. See Command Core Expressions for a more complex description of the declarative expressions. Handlers are responsible for interpreting any optional command parameters using the ExecutionEvent parameter.

<extension
       point="org.eclipse.ui.handlers">
    <handler
          class="z.ex.view.keybindings.handlers.TacoHandler"
          commandId="z.ex.view.keybindings.eatTaco">
       <activeWhen>
          <with variable="activeContexts">
             <iterate operator="or">
                <equals value="z.ex.view.keybindings.contexts.taco"/>
             </iterate>
          </with>
       </activeWhen>
    </handler>
</extension>

Here the handler is checking the activeContexts variable (See org.eclipse.ui.ISources) and if the "taco" context is active, the handler is active.

The handler itself, TacoHandler, must implement IHandler but would usually be derived from the abstract base class org.eclipse.core.commands.AbstractHandler.

You can create and activate a handler programmatically:

IHandlerService handlerService = (IHandlerService) getSite()
    .getService(IHandlerService.class);
IHandler handler = new AbstractHandler() {
  public Object execute(ExecutionEvent event)
          throws ExecutionException {
    System.out.println("Eat that Taco");
    return null;
  }
};
handlerService
    .activateHandler("z.ex.view.keybindings.eatTaco", handler);

As of 3.2 (and later releases) we should be calling the IHandlerService to run commands. We should not call the Command object execute method itself.

handlerService.executeCommand("z.ex.view.keybindings.eatTaco", null);

In 3.1 it is still necessary to call the Command object directly since the IHandlerService didn't support executeCommand(*). But you can provide almost the same execution environment.

Command eatTaco = cmdService
   .getCommand("z.ex.view.keybindings.eatTaco");
eatTaco.execute(new ExecutionEvent(Collections.EMPTY_MAP, null, handlerService.getCurrentState()));

If you want the handler to evaluate an enablement expression you can do that using the expression parameter of the activateHandler() method. Here is how you need to setup your expression in order to properly work tracking selection changes:

Expression expr = new Expression() {
    public final EvaluationResult evaluate(final IEvaluationContext context) {
        Object sel = context.getVariable(ISources.ACTIVE_CURRENT_SELECTION_NAME);
        (return EvaluationResult.TRUE/FALSE depending on how much you like the selection)
    }
    public void collectExpressionInfo(final ExpressionInfo info) {
         // You need this to cause the expr to be evaluated on selection events
         info.markDefaultVariableAccessed();
    }
};

KeyBindings

KeyBindings are managed by the org.eclipse.ui.bindings extension point and the IBindingService. Keybindings cannot be updated programmatically.

<extension
       point="org.eclipse.ui.bindings">
    <key
          commandId="z.ex.view.keybindings.eatTaco"
          contextId="z.ex.view.keybindings.contexts.taco"
          schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
          sequence="CTRL+3">
    </key>
</extension>

A key binding is active when the context is active. A keybinding is associated with a command (with optional parameters specified by parameter id and value). If a command has a handler while the keybinding is invoked, the handler extracts the command parameters specified by the keybinding from the ExecutionEvent and invokes the appropriate action.

Contexts

Contexts are managed by the org.eclipse.ui.contexts extension point and the IContextService.

Most contexts are created by the extension point, and activated programmatically when appropriate. But you can create contexts programmatically as well. The active contexts usually form a tree, although in the case of keybindings this tree is narrowed down to a branch.

<extension
       point="org.eclipse.ui.contexts">
    <context
          description="To allow the consumption of Tacos"
          id="z.ex.view.keybindings.contexts.taco"
          name="Mexican Food"
          parentId="org.eclipse.ui.contexts.window">
    </context>
</extension>

For a context that was attached to a view, it would normally be activated in the view's createPartControl(*) method.

IContextService contextService = (IContextService) getSite()
  .getService(IContextService.class);
IContextActivation contextActivation = contextService.activateContext("z.ex.view.keybindings.contexts.taco");

You can only de-activate a context that you are responsible for activating.

Programmatically, you can create contexts:

Context tacos = contextService
    .getContext("z.ex.view.keybindings.contexts.taco");
if (!tacos.isDefined()) {
  tacos.define("Mexican Food", "To allow the consumption of Tacos",
      "org.eclipse.ui.contexts.window");
}

Note, however, that a plugin that programmatically defines contexts is responsible for cleaning them up if the plugin is ever unloaded.

Menu Contributions

See Menu Contributions

Tracing Option

There are a couple of reasons why keybindings and commands might not work.

Keybindings are in a context that is not active
There is a keybinding conflict
No handler is currently active for the command
There is a handler conflict

To help track down the problem, you can run with debug tracing options. For example:

org.eclipse.ui/debug=true
org.eclipse.ui/trace/keyBindings=true
org.eclipse.ui/trace/keyBindings.verbose=true
org.eclipse.ui/trace/sources=true
org.eclipse.ui/trace/handlers=true
org.eclipse.ui/trace/handlers.verbose=true
#org.eclipse.ui/trace/handlers.verbose.commandId=org.eclipse.ui.edit.copy
org.eclipse.ui/trace/handlers.verbose.commandId=org.eclipse.jdt.ui.navigate.open.type
org.eclipse.ui/trace/contexts=true
org.eclipse.ui/trace/contexts.verbose=true

I put these options in a debug.options file and run eclipse using:

bash$ eclipse -debug debug.options -data /opt/local/pw_workspace >debug.log 2>&1

This logs the debug output to the debug.log file. This works on windows as well:

C:\development> eclipse33\eclipsec.exe -debug debug.options -data workspaces\pw_workspace >debug.log 2>&1

handlers.verbose.commandId allows you to track the information about a specific command that isn't working. org.eclipse.jdt.ui.navigate.open.type is the open type dialog (normally CTRL+SHIFT+T) and org.eclipse.ui.edit.copy (commented out) is COPY (normally CTRL+C)

Category: Eclipse Project

[펌] Eclipse Commands Tutorial

Wed, 16 Nov 2011 10:24:51 +0900

[출처 : http://www.vogella.de/articles/EclipseCommands/article.html]

Eclipse Commands Tutorial

Lars Vogel

Version 2.0

28.03.2011

Revision History
Revision 0.1	30.03.2009	Lars Vogel
Created
Revision 0.2 - 2.0	11.04.2009 - 28.03.2011	Lars Vogel
bugfixes and improvements

Eclipse Commands

This article describes the usage of Eclipse commands. It describes how to create commands, handlers, add commands into the menu, pop-ups, views and editors and the usage of expressions to restrict UI contributions.

This article is based on Eclipse Helios (3.6).

1. Eclipse Commands - Overview

1.1. Overview

A command in Eclipse is a declarative description of a component and is independent from the implementation details. Commands are defined via the extension point "org.eclipse.ui.commands". A command can be categorized, assigned to the user interface and a key binding can be defined for the command. The behavior of a command can be defined via a handler.

To use a command in your User Interface you need:

Command - Declarative description of the component
Handler - Defines the behavior
UI Assignment - Where and how should the command be included in the UI

1.2. Location URI - User interface

Commands can be used in menus, toolbars and / or context menus. Where and how these commands are displayed is defined via a location URI.

Table 1. Location URI's

Contribution to	Description	Uri
Application menu	Displays the command in the menu of the application	"menu:org.eclipse.ui.main.menu"
Application toolbar	displays the command in the toolbar of the application	"toolbar:org.eclipse.ui.main.toolbar"
View toolbar	displays the command in the toolbar of the view	"toolbar:viewId". For example to display a menu to view with the Id "View1" use "toolbar:View1".
Context menu / pop-up	Command is displayed in a content menu, e.g. right mouse click on an object	n.a.

You can define the relative position of a command in this location URI by using the pattern ?before=id or ?after=id. The id can be an existing separator name, menu ID, or item ID. The command will then be placed before or after the element with the corresponding id. For example if you want to add a command to an existing menu with the id "fileMenu" behind the menu entry with the id "oneEntry" use the locationURI of "menu:fileMenu?after=oneEntry".

1.3. Command Handler

The behavior of a command is defined via handlers. The handler is the class which will be executed once the command is called and must implement the interface "org.eclipse.core.commands.IHandler". "org.eclipse.core.commands.AbstractHandler" provides a default implementation for the IHandler interface.

IHandler defines the following important methods which can be implemented:

isEnabled: Called during instantiation, defines if this handler is enabled
isHandled: Defines if the handler can be called or not
execute: Coding which performs the action
fireHandlerChanged: needs to be called if isEnabled is changed

In the execute method you get access to frequently used values and services via the "HandlerUtil" class.

Handler can be defined with conditions (activeWhen) under which define the conditions under which the handlers are valid for a command. You can define several handlers for a command but only handler can be valid for a command at a certain point otherwise the Eclipse runtime cannot decide which one should be used and the command will not be enabled.

2. Pre-requisite

This article assumes what you have basic understanding of development for the Eclipse platform. Please seeEclipse RCP Tutorialor Eclipse Plugin Tutorial.

3. Commands and menus

3.1. Defining commands

We will create a command which will exit the application. Create a new RCP project"de.vogella.rcp.commands.first" using the "Hello RCP" template. Click on the plugin.xml and select the Extensions tab. Press the "Add" button.

Search for the extension "org.eclipse.ui.commands". Select it and press finish.

Create a new command by right-clicking on your extension point and by selecting New -> command.

Tip

If you only see an "Generic" entry you most likely have not downloaded "Eclipse for RCP/Plug-in Developers". Please see Eclipse Installation .

Set the ID to "de.vogella.rcp.commands.first.commands.Exit" and the name to "Exit". Enter the class "de.vogella.rcp.commands.first.commands.ExitHandler" as defaultHandler.

Press the hyperlink "defaultHandler" to create the class which should extend "org.eclipse.core.commands.AbstractHandler".

                      
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;
        }

}

3.2. Using commands in menus

The command which we defined should be used in a menu. Add the extension point "org.eclipse.ui.menus" to your application similar to adding the extension "org.eclipse.ui.commands". Right click on the extension point and select new -> menuContribution.

Create a new menu contribution with the location URI "menu:org.eclipse.ui.main.menu". Make sure this URL is correct otherwise your menu will not be shown.

Right click your menucontribution and select New -> Menu. Add a menu with the label "File" and the id "fileMenu".

Select your menu, right-click on it, select New-> Command. Maintain your commandID. Set the label to "Exit" and the tooltip to "Exits the application".

Your work should result in a plugin.xml file which looks like the following.

                      
<?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>

Run the example. You should see menu with the file and if you select the "Exit" entry you application should exit.

4. Commands and toolbars

4.1. Overview

You can add commands to the application toolbar and to a view toolbar.

4.2. Application toolbar (coolbar)

Create a new project "de.vogella.rcp.intro.commands.toolbar". Use the "RCP application with a view" as a template. Create a command "de.vogella.rcp.intro.commands.toolbar.Hello" with the default handler "de.vogella.rcp.intro.commands.toolbar.handler.Hello". This handler will open a JFace Dialog.

                              
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;
        }

}

Add a menucontribution to the "org.eclipse.ui.menus extension" point. Set the location URI to "toolbar:org.eclipse.ui.main.toolbar". Add a toolbar to your menu contribution.

Add the command "de.vogella.rcp.intro.commands.toolbar.Hello" to the toolbar. Assign a label and an icon to it.

Activate the application toolbar via ApplicationWorkbenchWindowAdvisor.java and set the 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");
        }
}

The result should look like the following. If you select the element in the toolbar an information dialog should open.

4.3. Contribution to the View Toolbar

You can also add a command directly to a view toolbar. For this we will extend the previous example. Change the class "Perspective" to the following (a standalone view does not have a own toolbar).

                              
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);
        }

}

Create a new menu contribution to the extension point "org.eclipse.ui.menus" with the locationURI: "toolbar:de.vogella.rcp.intro.commands.toolbar.view". ""toolbar:"" tells the system to add it to the toolbar while the second argument is the id of your view.

Create then a new command for this menucontribution and set the command id to "de.vogella.rcp.intro.commands.toolbar.Hello". Assign the label "Say Hello" to it.

Run the application to see your new view contribution.

4.4. Drop down list

The following adds a dropdown list to the application coolbar.

This creation is a bit strange. You create a helper drop-down command to which later the other (real) commands will be assigned to.

Therefore create a command with the id "referenceToMenuId". Maintain also the default handler. For example you could re-use "de.vogella.rcp.intro.commands.toolbar.handler.Hello".

Add a new menucontribution to the "org.eclipse.ui.menus" extension point. Set the location URI to "toolbar:org.eclipse.ui.main.toolbar". Add a toolbar to this extension and a new command to this new toolbar. As the id use "referenceToMenuId" give it a label and an icon and change the style to "pulldown".

Create a new menucontribution and set the locationURI to: "menu:referenceToMenuId"

Tip

referenceToMenuId is the ID we used earlier in the command.

Add your exiting command "de.vogella.rcp.intro.commands.toolbar.Hello" two times to this menu. Use different labels.

Run your application, it should now have a drop-down list in the application toolbar.

Tip

Add the command "referenceToMenuId" to your exiting view toolbar contribution to get the drop-down menu also in your view.

5. Commands and context menus

Now lets add a ContextMenu to a table. Create a new project "de.vogella.rcp.intro.commands.popup" based on the "RCP application with a view" example.

Create a new command with the ID "de.vogella.rcp.intro.commands.popup.showSelected" and the name "Show".

In this example we will not use the default handler. Therefore add the extension point "org.eclipse.ui.handlers" to your plugin.xml and add a handler. The first parameter is the commandId and the second the class for the handler. We will use class "de.vogella.rcp.intro.commands.popup.handler.ShowSelected".

Implement now the coding for your handler. I just print the selected elements to the console.

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;
        }

}

Add a new menuContribution with the locationURI "popup:de.vogella.rcp.intro.commands.popup.view", where "de.vogella.rcp.intro.commands.popup.view" is the ID of your view which has been automatically created for you.

Right click your new menuContribution and select New -> Command. Assign your command to the field "commandId". Label it "One Item selected".

Now you have add a MenuManager to your view. Select View.java and in the method createPartControl add the following:

                              
        public void createPartControl(Composite parent) {
                viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
                                | SWT.V_SCROLL);
                viewer.setContentProvider(new ViewContentProvider());
                viewer.setLabelProvider(new ViewLabelProvider());
                viewer.setInput(getViewSite());
                // This is new code
                // First we create a menu Manager
                MenuManager menuManager = new MenuManager();
                Menu menu = menuManager.createContextMenu(viewer.getTable());
                // Set the MenuManager
                viewer.getTable().setMenu(menu);
                getSite().registerContextMenu(menuManager, viewer);
                // Make the selection available
                getSite().setSelectionProvider(viewer);
        }

Run your application. On right mouse click the menu should be visible. If you select it menu then the names of the selected items should be written to the console.

6. Advanced Commands

For more advanced usages of Eclipse Commands please see Eclipse Commands Advanced.

7. Thank you

Please help me to support this article:

8. Questions and Discussion

Before posting questions, please see the vogella FAQ . If you have questions or find an error in this article please use the www.vogella.de Google Group . I have created a short list how to create good questionswhich might also help you.

[펌] Eclpse Commands Advanced Tutorial

Wed, 16 Nov 2011 00:51:54 +0900

[출처: http://www.vogella.de/articles/EclipseCommandsAdvanced/article.html]

Eclipse Commands Advanced - Tutorial

Lars Vogel

Version 2.1

24.09.2011

Revision History
Revision 0.1	30.03.2009	Lars Vogel
Created
Revision 0.2 - 2.1	11.04.2009 - 24.09.2011	Lars Vogel
bugfixes and improvements

Eclipse Advanced Commands

This article describes use cases for Eclipse commands which go beyond the simple one for adding commands to menus, toolbars, etc.

This article is based on Eclipse Indigo (3.7).

Table of Contents

1. Eclipse Commands

2. Enabled when (visible when)

3. Eclipse standard commands

3.1. Overview
3.2. Example

4. Calling commands directly via code

5. Providing your own expression

6. Using parameters in commands

7. Defining commands at runtime

8. Thank you

9. Questions and Discussion

10. Links and Literature

10.1. Source Code
10.2. Eclipse Commands Resources
10.3. vogella Resources

1. Eclipse Commands

For an introduction into Eclipse Commands please see Eclipse Commands Tutorial.

2. Enabled when (visible when)

The command framework allows to restrict the availability and visibility of commands, handlers and ui contributions via the core expressions.

In this example we want the command only be enabled if one item from a list of items is selected.

Create a new project "de.vogella.rcp.commands.enable" based on the "RCP application with a view" example.

Add a command with the ID "de.vogella.rcp.commands.enable.command". Add this command to the menu and the toolbar and create the following default handler.

                      
package de.vogella.rcp.commands.enable.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 Command extends AbstractHandler {

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

                return null;
        }

}

Select plugin.xml and add "org.eclipse.core.expressions" as a dependency. Select then the Extensions tab and add the extensions org.eclipse.core.expressions.definitions.

Using right mouse click add a definition "oneElementSelected". Add a "with" variable "selection".

Tip

"selection" is a predefined variable which will be calculated automatically by Eclipse. See core expressionsfor additional variables you can use. For example for a popup menu "activeMenuSelection" provides the selection.

On the "activeMenuSelection" right mouse click and add a count with the value "1". The result should look like

On your handler, right mouse click and select enabledWhen. Right mouse click and add a "reference" to it with the value "oneElementSelected". The result should look like.

The expression were are using is based on "selection". Therefore the list must register itself as selection provider to inform the workbench in case something is selected. Therefore add "getSite().setSelectionProvider(viewer);" in createPartControl of View.java.

                      
public void createPartControl(Composite parent) {
                viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
                                | SWT.V_SCROLL);
                viewer.setContentProvider(new ViewContentProvider());
                viewer.setLabelProvider(new ViewLabelProvider());
                viewer.setInput(getViewSite());
                // Makes the selection available to the workbench
                getSite().setSelectionProvider(viewer);
        }

If you now run the application your command should only be enabled if one element in the list is selected.

Tip

You can also only display the menu if one item is selected. The approach is the same but you only define the restriction on the menu contribution directly (visible when on the command in the menu). For a command in the toolbar the definition would look like:

3. Eclipse standard commands

3.1. Overview

Eclipse provides lots of standard commands which you can re-use. Just press on the "Browse button" while defining your commandId to see the available standard commands. For example the screenshot shows the usage of the standard about dialog command.

The advantage of using standard commands is that you get the keybinding, icons, etc for free.

Tip

Standard commands sometimes map to actions which are contributed via ActionFactory in the class ApplicationActionBarAdvisor. If the ActionFactory returns an IAction you need to register this action. If not these commands are inactive in your menu. For example the following made the reset perspective and welcome command active.

                              
// Method belongs to class ApplicationActionBarAdvisor
        @Override
        protected void makeActions(IWorkbenchWindow window)
        {
                IWorkbenchAction quickStartAction = ActionFactory.INTRO.create(window);
                register(quickStartAction);
                IWorkbenchAction resetView = ActionFactory.RESET_PERSPECTIVE
                                .create(window);
                register(resetView);
        }

3.2. Example

You can also use standard command and define a new handler for this command, e.g. you can use the standard Eclipse delete command (org.eclipse.ui.edit.delete).

Tip

To find the id of existing commands you can you the Eclipse Plugin Spy.

You can use the extension point "org.eclipse.ui.handlers" to define new handlers for the standard commands.

Tip

Eclipse requires you to have only one active handler at the time therefore you have to use the "activeWhen" restriction on the handler to make it more special then the standard binding. To use for example delete in several views with different handlers use "activeWhen" with the variable "activePartId" and as the value your view id.

Create a new RCP application "de.vogella.rcp.commands.standardcommands" with the template "Hello RCP".

Create a handler for the command "org.eclipse.ui.edit.delete" which display a message box. Add the command "org.eclipse.ui.edit.delete" to the menu.

The result should look like the following.

4. Calling commands directly via code

You can call a command directly. For example if you have a command "add.command" defined you can call it via the following coding.

                      

// From a view you get the site which allow to get the service
IHandlerService handlerService = (IHandlerService) getSite().getService(IHandlerService.class);
try {
        handlerService.executeCommand("add.command", null);
        } catch (Exception ex) {
                throw new RuntimeException("add.command not found");
                // Give message
                }
}

This coding above is called within a view which provides access to the site and to services. You can also get the service via the WorkbenchWindow.

5. Providing your own expression

You can write your own Java class which can be used define a variable which can then be used to define if a certain UI element shall be active or not. For example you can read the authorization of the user from your own class and then return the value which is assign to the user. This return value can then be used in a visible / enabled statement. This is similar to the usage of the core expressions we have seen earlier.

Create a RCP application "de.vogella.rcp.commands.sourceprovider" with the template "Hello RCP".

We will create a source provider. This source provider can provide variables which can be used in defining the visibility of commands. Add the extension point "org.eclipse.ui.services" to your plugin and create a new service provider.

This defines a service which provides the variable "de.vogella.rcp.commands.sourceprovider.active" to the workbench. This class must implement ISourceProvider. This value can then be used similar to a core expression. Maintain the following code.

                      
package de.vogella.rcp.commands.sourceprovider;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.ui.AbstractSourceProvider;
import org.eclipse.ui.ISources;

public class CommandState extends AbstractSourceProvider {
        public final static String MY_STATE = "de.vogella.rcp.commands.sourceprovider.active";
        public final static String ENABLED = "ENABLED";
        public final static String DISENABLED = "DISENABLED";
        private boolean enabled = true;


        @Override
        public void dispose() {
        }

        // We could return several values but for this example one value is sufficient
        @Override
        public String[] getProvidedSourceNames() {
                return new String[] { MY_STATE };
        }
        
        // You cannot return NULL
        @SuppressWarnings("unchecked")
        @Override
        public Map getCurrentState() {
                Map map = new HashMap(1);
                String value = enabled ? ENABLED : DISENABLED;
                map.put(MY_STATE, value);
                return map;
        }

        

        // This method can be used from other commands to change the state
        // Most likely you would use a setter to define directly the state and not use this toogle method
        // But hey, this works well for my example
        public void toogleEnabled() {
                enabled = !enabled ;
                String value = enabled ? ENABLED : DISENABLED;
                fireSourceChanged(ISources.WORKBENCH, MY_STATE, value);
        }

}

Create two commands "de.vogella.rcp.commands.sourceprovider.command1" and "de.vogella.rcp.commands.sourceprovider.command2". Create any handler you want for the first command. Command2 will be used to change the state in our ISourceProvider. Maintain the following code for the handler.

                      
package de.vogella.rcp.commands.sourceprovider.handler;

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

import de.vogella.rcp.commands.sourceprovider.CommandState;

public class Command2 extends AbstractHandler {

        @Override
        public Object execute(ExecutionEvent event) throws ExecutionException {
                // Get the source provider service
                ISourceProviderService sourceProviderService = (ISourceProviderService) HandlerUtil
                                .getActiveWorkbenchWindow(event).getService(
                                                ISourceProviderService.class);
                // Now get my service
                CommandState commandStateService = (CommandState) sourceProviderService
                                .getSourceProvider(CommandState.MY_STATE);
                commandStateService.toogleEnabled();
                return null;
        }

}

Add both commands to the menu.

Now use the state provided by your ISourceProvider in your declaration of your menu.

This looks in plugin.xml like the following.

                      
<extension
         point="org.eclipse.ui.menus">
      <menuContribution
            locationURI="menu:org.eclipse.ui.main.menu">
         <command
               commandId="de.vogella.rcp.commands.sourceprovider.command1"
               label="Command1"
               style="push">
            <visibleWhen
                  checkEnabled="false">
               <with
                     variable="de.vogella.rcp.commands.sourceprovider.active">
                  <equals
                        value="ENABLED">
                  </equals>
               </with>
            </visibleWhen>
         </command>
         <command
               commandId="de.vogella.rcp.commands.sourceprovider.command2"
               label="Command2"
               style="push">
         </command>
      </menuContribution>
</extension>

If you now start your application can select the second command the first command will not be available anymore. If you press it again the first command will be displayed again.

6. Using parameters in commands

You can also define parameters in commands. Create project "de.vogella.rcp.commands.parameterfirst" using the "Hello RCP" template.

Create a command with the id "de.vogella.rcp.commands.parameterfirst.helloName" and a default handler "de.vogella.rcp.commands.parameterfirst.handler.HelloName".

Right click on your command, select New -> commandParameter

Use the following id for the parameter "de.vogella.rcp.commands.parameterfirst.commandParameter1"

In the handler you have to evaluate the parameter.

                      
package de.vogella.rcp.commands.parameterfirst.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 HelloName extends AbstractHandler {

        @Override
        public Object execute(ExecutionEvent event) throws ExecutionException {
                String name = event
                                .getParameter("de.vogella.rcp.commands.parameterfirst.commandParameter1");
                MessageDialog.openInformation(HandlerUtil.getActiveShell(event),
                                "Hello", "Hello " + name);
                return null;
        }
}

Add this command to the menu. On the command, right click and select New -> Parameter

As name maintain the name of the parameter, pass as value the value you want to use in your handler.

Add the same command again to the menu and pass another parameter.

If you run your application and select the menu entry the value should be used in the message box.

7. Defining commands at runtime

You can create commands at runtime. Create project "de.vogella.rcp.commands.runtimecommands" using the "Hello RCP" template.

Define a menu contribution. Maintain the class "de.vogella.rcp.commands.runtimecommands.DefineCommands" in this menu contribution.

Create the following class.

                      
package de.vogella.rcp.commands.runtimecommands;

import org.eclipse.swt.SWT;
import org.eclipse.ui.menus.CommandContributionItem;
import org.eclipse.ui.menus.CommandContributionItemParameter;
import org.eclipse.ui.menus.ExtensionContributionFactory;
import org.eclipse.ui.menus.IContributionRoot;
import org.eclipse.ui.services.IServiceLocator;

public class DefineCommands extends ExtensionContributionFactory {

        @Override
        public void createContributionItems(IServiceLocator serviceLocator,
                        IContributionRoot additions) {
                CommandContributionItemParameter p = new CommandContributionItemParameter(
                                serviceLocator, "",
                                "org.eclipse.ui.file.exit",
                                SWT.PUSH);
                p.label = "Exit the application";
                p.icon = Activator.getImageDescriptor("icons/alt_window_16.gif");

                CommandContributionItem item = new CommandContributionItem(p);
                item.setVisible(true);
                additions.addContributionItem(item, null);
        }

}

Run the example, your application should have the Exit command in the menu.

8. Thank you

Please help me to support this article:

SWT / JFace

Tue, 26 Jul 2011 13:41:44 +0900

CommonNavigator 와 ContentProvider에서 서로 참조 얻는 방법

Fri, 20 May 2011 14:40:01 +0900

CommonNavigator에서 ContentProvider의 참조 얻는 법
- IContentProvider.inputChanged를 활용
  1. public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  2. CommonViewer commonViewer = (CommonViewer) viewer;
  3. CommonNavigator commonNavigator = commonViewer.getCommonNavigator();
  4. }
ContentProvider에서 CommonNavigator의 참조 얻는 법

eclipse

Fri, 20 May 2011 14:33:29 +0900

Toad

Mon, 21 Mar 2011 10:56:16 +0900

Linux find 명령어 완전 정복 가이드

Sun, 05 Sep 2010 05:19:28 +0900

[출처] Linux find 명령어 완전 정복 가이드|작성자 녹차우유

저자 - Sheryl Calish

가장 강력하면서도 한편으로는 혼란스러운 유비쿼터스 명령어인 find 명령어에 대한 개요.

게시일 : 2008년 7월

Linux find 명령어는 모든 Linux 명령어 가운데 가장 유용하면서도 혼란스러운 명령어 가운데 하나입니다. 다른 Linux 명령어의 표준 구문과 다른 구문을 가지고 있다는 점에서 어렵습니다. 하지만, 파일명, 파일 유형, 사용자, 더 나아가 타임 스탬프 별로 파일을 찾을 수 있다는 점에서 강력한 명령어이기도 합니다. find 명령어를 사용하면 이러한 속성을 자유롭게 조합해 파일의 위치를 찾을 수 있을 뿐만 아니라, 찾은 파일에 대해 연산을 수행할 수 있습니다.

본 글의 목적은 find 명령어와 그 잠재적 이점을 개략적으로 설명함으로써 find 명령어를 손쉽게 학습 및 사용할 수 있도록 돕는 것입니다. 동시에, find 명령어의 특성 중 가장 강력하면서도 한편으로는 혼란스러운 측면에 대한 개요 및 참조를 제공할 것입니다.

[주: 여기에서 사용된 find 명령어는 GNU 버전이기 때문에 일부 세부 내용은 다른 버전의 find 명령어와 다를 수 있습니다.]

기본 형식

먼저, find 명령어의 기본 구조부터 살펴보겠습니다:

find start_directory test options criteria_to_match action_to_perform_on_results

아래 명령어에서 find는 이름에 “java” 확장자를 가지고 있는 모든 파일을 대상으로 “.”가 표시된 현재 디렉토리를 찾기 시작할 것입니다:

```
find . -name "*.java"
```

아래에는 검색 결과에 대한 간단한 목록이 나열되어 있습니다:

find . -name "*.java" 

./REGEXPvalidate/src/oracle/otnsamples/plsql/ConnectionManager.java 

./REGEXPvalidate/src/oracle/otnsamples/plsql/DBManager.java ..

[주: 본 글에서 잘라 붙이기를 해 find 명령어를 실행하는 경우에는 자체 키보드를 사용해 큰따옴표(“”)를 바꿔야 올바른 결과를 얻을 수 있습니다.]

아래 명령어 역시 동일한 연산을 수행할 것입니다. 어떤 경우든, find 명령어에 전달되도록 escape 문을 통해 와일드카드 문자를 일반 문자로 처리해야 하며 쉘에 의해 해석되지 않아야 합니다. 따라서, 검색 문자열에 큰타옴표를 붙이거나 그 앞에 역슬래시(\)를 붙이십시오:

```
find . -name \*.java
```

find에 대한 인수는 옵션이기는 하지만, 검색 시작 위치를 지정하지 않은 경우에는 현재 디렉토리에서 기본적으로 검색이 시작됩니다. 옵션 사항이기는 하지만 테스트 조건을 지정하지 않은 경우에는 불완전하거나 선별되지 않은 결과값이 출력됩니다.

아래 3개의 find 명령어를 실행하면 똑같이 현재 디렉토리와 숨겨진 파일을 포함하는 모든 서브디렉토리의 모든 파일 목록이 검색됩니다:

```
find 

find . 

find . -print
```

이는 –la 옵션을 가진 ls 명령어를 실행하는 것과 비슷합니다. 백업을 위해 위 명령어의 출력물에 전체 경로 이름이 포함되기를 원하는 경우라면 시작 디렉토리에 대한 전체 경로를 지정해야 합니다:

find /home/bluher -name \*.java 

/home/bluher/plsql/REGEXPvalidate/src/oracle/otnsamples/plsql/ConnectionManager.java 

/home/bluher/plsql/REGEXPvalidate/src/oracle/otnsamples/plsql/DBManager.java/ ...

또한, 검색 문자열에 1개 이상의 시작 디렉토리를 지정할 수도 있습니다. 적정 권한을 가진 사용자로서 실행되는 경우, 아래 명령어는 모든 jar 파일을 찾기 위해 /usr, /home 및 /tmp 디렉토리 순서로 내려갈 것입니다:

```
find /usr /home /tmp -name "*.jar"
```

적정 권한이 없는 사용자라면 많은 시스템 디렉토리를 검색하기 시작할 때 다음과 같은 오류 메시지가 나올 수 있습니다:

find: /tmp/orbit-root: Permission denied

다음과 같이 검색 문자열을 추가함으로써 불명확한 결과가 나오는 것을 피할 수 있습니다:

find /usr /home /tmp -name "*.jar" 2>/dev/null

이렇게 하면 모든 오류 메시지가 널(null) 파일로 전송되기 때문에 보다 정제된 출력물이 제공됩니다.

기본적으로 find 명령어는 대/소문자를 구별합니다. 대/소문자가 구별되는 find에서는 -name 테스트를 대신해 -iname 테스트를 사용하십시오.

find downloads -iname "*.gif" 

downloads/.xvpics/Calendar05_enlarged.gif 

downloads/lcmgcfexsmall.GIF

또한, 파일명 외에도 유형에 따라 파일을 검색할 수 있습니다. 예를 들어, 아래 명령어를 통해 디렉토리의 모든 서브디렉토리를 찾을 수 있습니다:

```
find . -type d
```

아래 명령어를 사용하면 /usr 디렉토리의 모든 심볼릭 링크(symbolic link)를 찾을 수 있습니다:

```
find /usr -type l
```

위 명령어를 실행하면 3,000개 이상의 링크 목록이 나타날 것입니다. 슈퍼유저(root) 권한을 통해 아래 명령어 가운데 하나를 실행하면 /usr 디렉토리의 링크 목록과 이것이 가리키는 파일이 나타납니다:

# find /usr/bin -type l -name "z*" -exec ls -l {} \; 

lrwxrwxrwx 1 root root 8 Dec 12 23:17 /usr/bin/zsh -> /bin/zsh 

lrwxrwxrwx 1 root root 5 Dec 12 23:17 /usr/bin/zless -> zmore 

lrwxrwxrwx 1 root root 9 Dec 12 23:17 /usr/bin/zcat -> /bin/zcat

```
find /usr/bin -type l -name "z*" -ls
```

하지만, 보다 짧은 두 번째 명령어를 실행하면 디렉토리와 inode 정보를 가진 긴 파일 목록이 나올 것입니다. -exec 및 –ls 실행에 대해서는 후반부에서 다룰 것입니다

find가 찾을 수 있는 다른 파일 유형으로는 다음과 같은 것들이 있습니다

• b - block (buffered) special
• c - character (unbuffered) special
• p - named pipe (FIFO)
• s - socket

find 명령어의 시작점으로 루트를 사용하면 시스템 속도가 크게 느려질 수 있습니다. 반드시 명령어를 실행해야 하는 경우에는 사용량이 적은 시간대나 야간에 실행하는 것이 좋습니다. 아래 구문을 사용해 출력물을 파일로 보낼 수 있습니다.:

```
find / -print > masterfilelist.out
```

원치 않는 출력물을 대량 생산하는 find 명령어를 실수로 입력한 경우에는 CTRL-C를 누르기만 하면 가장 최근에 실행된 명령어가 중단됩니다.

여러 파일 시스템을 갖춘 엔터프라이즈 네트워크에서는 특히 find 명령어가 검색한 파일을 제한하는 것이 좋습니다. 필요한 수 만큼 옵션 및 테스트를 사용함으로써 시스템 상의 로드를 줄일 수 있습니다. 이를 위해 가장 유용하게 사용할 수 있는 옵션은 –xdev와 -mount입니다. 이들 옵션은 find 명령어가 MS-DOS, CD-ROM 또는 AFS와 같은 다른 파일 시스템 상의 디렉토리로 내려가지 않도록 함으로써 검색 범위를 좁혀줍니다. 따라서, 시작 디렉토리와 동일한 유형의 파일 시스템으로 검색을 제한할 수 있습니다.

듀얼 부팅 시스템 사용자는 mount 명령어가 실행되는 경우에 이러한 옵션을 사용할 수 있습니다. Windows 파티션이 관련되어 있다고 가정하면, 아래와 같은 명령어를 통해 마운팅 할 수 있습니다.:

```
mount -t vfat /dev/sda1 /mnt/msdos
```

여러분이 사용하는 실제 명령어는 시스템 설정 방법에 따라 달라집니다. df를 실행하거나 아래 명령어를 수행함으로써 파티션 마운팅 여부를 확인할 수 있습니다:

find /mnt/msdos -name "*.txt" 2> /dev/null

MS Windows 파티션에서는 파일 목록이 길 수 밖에 없습니다. 이제부터는 -mount 또는 -xdev 옵션을 통해 아래 명령어를 실행하십시오:

find / -name "*.txt" -mount 2> /dev/null

또는

find / -name "*.txt" -xdev 2> /dev/null

아래 예에서와 같이 -fstype 테스트를 사용해 find 명령어에 찾고자 하는 파일 시스템을 명확하게 알려줄 수도 있습니다:

find / -name "*.txt" -fstype vfat 2> /dev/null

시간 찾기

find 명령어는 시스템의 타임 스탬프를 토대로 파일 검색에 사용할 수 있는 여러 개의 옵션을 가지고 있습니다. 이러한 타임 스탬프로는 다음이 포함됩니다

• mtime—파일 내용이 마지막으로 수정된 시간
• atime—파일을 읽기 또는 액세스한 시간
• ctime—파일 상태가 변경된 시간

mtime 및 atime의 의미는 그 자체로 쉽게 알 수 있지만, ctime는 좀 더 설명이 필요합니다. inode는 각 파일에 메타 데이터를 가지고 있기 때문에 파일에 연결된 메타 데이터가 변경되면 inode 데이터도 변경됩니다. 파일에 대한 심볼릭 링크 생성, 파일에 대한 권한 변경, 파일 이동 등과 같은 다양한 작업으로 인해 이러한 메타 데이터 변경이 야기될 수 있습니다. 이러한 경우, 파일 내용에 대한 읽기나 수정은 수행되지 않기 때문에 themtime 및 atime은 변하지 않지만 ctime은 변합니다.

이러한 시간 옵션은 각기 -n, n 또는 +n로 지정된 n 값을 함께 사용해야 합니다.

• -n은 n 이하를 반환
• +n은 n 이상을 반환
• n은 정확히 n에 해당되는 값을 반환

보다 명확한 설명을 위해 몇 가지 예를 살펴 보겠습니다. 아래 명령어는 최근 1시간 동안 수정된 모든 파일을 찾아줍니다:

find . -mtime -1 

./plsql/FORALLSample 

./plsql/RegExpDNASample 

/plsql/RegExpSample

-1 대신 1을 가진 동일 명령어를 실행하면 정확하게 1시간 전에 수정된 모든 파일을 찾을 수 있습니다:

```
find . -mtime 1
```

위 명령어는 정확하게 일치하는 값을 요청하기 때문에 모든 결과값이 나오지는 않습니다. 아래 명령어는 1시간 이전에 수정된 파일을 찾아줍니다:

```
find . -mtime +1
```

기본적으로 -mtime, -atime 및 –ctime는 최근 24 시간에 대한 타임 스탬프입니다. 하지만, 뒤에 daystart 옵션을 붙이면 오늘을 시작으로 24시간 주기가 시작됩니다. 또한, mmin, amin 및 cmin을 사용하면 분 단위로 변경된 타임 스탬프를 찾을 수 있습니다.

여러분의 계정으로 로그인한 후 즉시 아래 명령어를 실행하면 최근 1분 내에 읽은 모든 파일을 찾을 수 있습니다:

find . -amin -1 

./.bashrc 

/.bash_history 

./.xauthj5FCx1

find 명령어만으로 파일의 위치를 찾으면 메타 데이터의 일부인 파일의 액세스 시간이 변경된다는 사실에 유의하십시오.

-newer, -anewer 및 –cnewer 옵션을 사용하면 특정 파일과 비교해 수정 또는 액세스된 파일을 찾을 수도 있습니다. 이는 -mtime, -atime 및 –ctime과 비슷합니다.

• -newer : 보다 최근에 내용이 수정된 파일
• -anewer : 보다 최근에 읽기가 수행된 파일
• -cnewer : 보다 최근에 상태가 변경된 파일

마지막 tar 파일 이후로 어떤 방법으로든지 수정된 홈 디렉토리의 파일을 모두 찾으려면 아래 명령어를 사용하십시오:

```
find . -newer backup.tar.gz
```

크기에 따른 파일 찾기

-size 옵션은 지정된 크기 기준에 부합하는 파일을 찾아줍니다. 크기가 5MB 이상인 모든 파일을 찾으려면 아래와 같이 하십시오

find / -size +5000000c 2> /dev/null /var/log/lastlog /var/log/cups/access_log.4 /var/spool/mail/bluher

마지막에 “c”를 붙이면 결과가 바이트 단위로 보고됩니다. 기본적으로 find 명령어는 512 바이트 블록의 수로 크기를 보고합니다. 또한, “c”를 “k”로 교체하는 경우에는 킬로바이트 수로, “w”를 사용하는 경우에는 2바이트 워드의 수로 결과를 표시할 수 있습니다.

-size 옵션은 모든 제로 바이트 파일을 찾거나 이들 파일을 /tmp/zerobyte 폴더로 이동하기 위해 자주 사용됩니다. 아래 명령어가 바로 이러한 연산을 수행합니다.

find test -type f -size 0 -exec mv {} /tmp/zerobyte \;

-exec 옵션은 find 명령어가 만나게 되는 파일의 모든 쉘 명령어를 수행할 수 있도록 해줍니다. 후반부에서 이 옵션의 보다 다양한 사용 예를 확인할 수 있습니다. 중괄호를 사용하면 빈 파일 각각을 이동시킬 수 있습니다

또한, -empty 옵션을 사용하면 빈 파일을 찾을 수 있습니다.

```
find test -empty test/foo test/test
```

권한 및 소유권에 따른 파일 찾기

find 명령어는 시스템 보안 모니터링을 위해 없어서는 안될 명령어입니다. 아래와 같이 기호법이나 8진법을 통해 사용 권한이 널리 열려있는 파일을 찾을 수 있습니다.

find . -type f -perm a=rwx -exec ls -l {} \;

또는

find . -type f -perm 777 -exec ls -l {} \; 

-rwxrwxrwx 1 bluher users 0 May 24 14:14 ./test.txt

위의 명령어나 아래 명령어의 경우 -exec ls –l을 수행하고 있기 때문에, 반환된 파일의 실제 사용 권한을 확인할 수 있습니다. 이 명령어는 “기타 사용자” 및 그룹이 모두 쓰기를 수행할 수 있는 파일을 찾아줍니다.

find plsql -type f -perm -ug=rw -exec ls -l {} \; 2>/dev/null

또는

find plsql -type f -perm -220 -exec ls -l {} \; 2>/dev/null 

-rw-rw-rw- 1 bluher users 4303 Jun 7 2004 plsql/FORALLSample/doc/otn_new.css 

-rw-rw-rw- 1 bluher users 10286 Jan 12 2005 plsql/FORALLSample/doc/readme.html 

-rw-rw-rw- 1 bluher users 22647 Jan 12 2005 plsql/FORALLSample/src/config.sql ..

아래 명령어들을 실행하면 사용자, 그룹 또는 둘 모두가 쓰기 작업을 할 수 있는 파일을 찾을 수 있습니다

find plsql -type f -perm /ug=rw -exec ls -l {} \; 2>/dev/null, or, find plsql -type f -perm /220 -exec ls -l {} \; 2>/dev/null 

-rw-r--r-- 1 bluher users 21473 May 3 16:02 plsql/regexpvalidate.zip 

-rw-rw-rw- 1 bluher users 4303 Jun 7 2004 plsql/FORALLSample/doc/otn_new.css 

-rw-rw-rw- 1 bluher users 10286 Jan 12 2005 plsql/FORALLSample/doc/readme.html 

-rw-rw-rw- 1 bluher users 22647 Jan 12 2005 plsql/FORALLSample/src/config.sql

웹이나 기존 매뉴얼에는 아래 명령어로 나와 있을 것입니다.

find . -perm +220 -exec ls -l {} \; 2> /dev/null

+ 기호는 / 기호와 동일한 역할을 하지만, 새로운 버전의 GNU findutils에서는 권장되지 않고 있습니다.

시스템에서 쓰기 가능한 모든 파일을 찾으려면 아래 명령어를 사용하십시오

find / -wholename '/proc' -prune -o -type f -perm -0002 -exec ls -l {} \; 

-rw-rw-rw- 1 bluher users 4303 Jun 7 2004/home/bluher/plsql/FORALLSample/doc/otn_new.css 

-rw-rw-rw- 1 bluher users 10286 Jan 12 2005 /home/bluher/plsql/FORALLSample/doc/readme.html ...

4번째 사용 권한에 대해 앞으로 조금 더 다루겠지만, 마지막 필드의 “2”는 쓰기 비트로도 알려져 있는 파일 사용 권한의 “기타 사용자”에 해당됩니다. 우리는 설정된 다른 사용 권한이 무엇이든 관계 없이 기타 사용자를 위해 설정된 쓰기 권한을 가진 파일을 보고 싶다는 표시로 0002라는 사용 권한 모드 앞에 대시를 사용했습니다.

위의 명령어에서는 3가지 새로운 개념이 도입되었습니다. 패턴이 발견된 경우, – prune은 파일 패턴 “/proc”에서 -wholename 테스트를 사용함으로써 find 명령어가 이 디렉토리로 내려오지 않도록 막아줍니다. 불린 연산자 “-o”를 통해 find 명령어는 다른 디렉토리에서 명령어의 나머지 부분을 처리할 수 있습니다. 각 표현식 간에 가정된 암시적 and 연산자(-a)가 있기 때문에 좌측 표현식이 거짓(false)으로 평가된 경우 and 뒤에 나오는 표현식은 평가되지 않습니다. 따라서, -o 연산자가 필요합니다. 강제 우선 순위 적용을 위해 괄호를 사용하는 것처럼 find 명령어는 불린 연산자 -not, !,도 지원합니다.

시스템 관리자는 자주 find 명령어를 통해 해당 사용자나 그룹의 이름 또는 ID를 사용해 특정 사용자나 그룹의 정규 파일을 검색하고 있습니다:

[root] $ find / -type f -user bluher -exec ls -ls {} \;

여기, 이러한 명령어의 출력에 대한 간단한 예제가 나와 있습니다:

4 -rw-r--r-- 1 bluher users 48 May 1 03:09 /home/bluher/public_html/.directory 

4 -rw-r--r-- 1 bluher users 925 May 1 03:09 /home/bluher/.profile

또한, find 명령어를 사용해 그룹 별로 파일을 검색할 수도 있습니다:

```
[root] $ find / -type f -group users
```
```
find / -type d -gid 100
```

이 명령어를 실행하면 그룹 ID 100이 소유하고 있는 디렉토리 목록이 나옵니다. 해당되는 uid 또는 gid를 찾기 위해 /etc/passwd 또는 /etc/group 파일에서 more 또는 cat 명령어를 실행할 수 있습니다

이 명령어는 알려진 특정 사용자 및 그룹에 관한 파일을 찾는 것 외에도 사용자나 그룹이 지정되지 않은 파일을 찾는 데도 유용합니다. 아래 명령어는 /etc/passwd 또는 /etc/group 파일에서 리스트를 가지고 있지 않은 파일을 식별합니다.

```
find / -nouser -o -nogroup
```

위 명령어는 실제로 시스템 상에 결과를 제공하는 것은 아니지만, 파일을 이동한 후에 사용자나 그룹이 지정되지 않은 파일을 식별하는 데 사용할 수 있습니다

이제, 본 섹션 초반부에 언급한 별도의 높은 사용 권한 문제를 해결할 수 있게 되었습니다.

SGID 및 SUID는 UNIX 기반 운영 체제 상의 파일 및 디렉토리에 할당할 수 있는 특별 액세스 권한 플래그입니다. 컴퓨터 시스템 액세스에 있어 일반 권한을 가진 사용자가 일시적으로 높아진 권한을 가지고 바이너리 실행 파일을 수행할 수 있습니다.

find / \( -perm -2000 -o -perm -4000 \) -ls 

167901 12 -rwsr-xr-x 1 root root 9340 Jun 16 2006 /usr/bin/rsh 

167334 12 -rwxr-sr-x 1 root tty 10532 May 4 2007 /usr/bin/wall

위 명령어에서 괄호가 escape 처리된 것을 볼 수 있습니다. 또한, 권한 간의 차이점을 확인할 수 있습니다. 첫 번째 파일에는 SGID 권한이 설정되어 있으며 두 번째 파일에는 SUID 권한이 설정되어 있습니다. 위 명령어의 마지막 연산은 -exec ls -dils 연산의 find 명령어와 유사합니다

find 명령어 제어

Linux의 많은 명령어와 달리, find 명령어는 -r 또는 -R 옵션이 없이도 서브디렉토리로 내려가지 않습니다. 이는 기본적으로 지원됩니다. 하지만, 때에 따라 이를 제한하고 싶을 수 있습니다. 이럴 경우, -depth, -maxdepth 및 –mindepth 옵션과 –prune 연산이 유용합니다

-prune이 얼마나 유용한지는 이미 확인했기 때문에 이제는 -depth, -maxdepth 및 -mindepth 옵션에 대해 살펴보겠습니다.

-maxdepth 및 -mindepth 옵션을 사용하면 find 명령어를 통해 검색하고자 하는 디렉토리 트리의 수준을 지정할 수 있습니다. find 명령어가 단 한 수준의 디렉토리를 찾도록 하고 싶은 경우에는 maxdepth 옵션을 사용할 수 있습니다.

아래 명령어를 실행해 디렉토리 트리의 상위 3개 수준의 로그 파일을 검색하면 –maxdepth의 효과를 확인할 수 있습니다. 이렇게 하면 –maxdepth 없이 실행할 때 보다는 훨씬 적은 출력 결과가 나옵니다

```
find / -maxdepth 3 -name "*log"
```

또한, find 명령어에게 디렉토리 트리에서 최소 3개 수준까지 디렉토리를 검색할 것을 지시할 수 있습니다.

```
find / -mindepth 3 -name "*log"
```

-depth 옵션은 내용 평가에 앞서 디렉토리를 평가할 수 있도록 해줍니다. 아래 명령어는 한 예입니다.:

find -name "*test*" -depth ./test/test ./test ./localbin/test ./localbin/test_shell_var ./localbin/test.txt ./test2/test/test ./test2/test ./test2

find 명령어의 세계

지금까지 find 명령어의 유용하지만 다소 혼란스러운 일부 기능에 대해 알아보았지만, find 명령어가 수행할 수 있는 추가 작업이 있습니다. 예를 들어, find 명령어가 기존 버전의 UNIX 및 기타 운영 체제와 호환 가능하도록 하고 여러 파일로 출력을 인쇄하도록 하는 등 연산을 수행할 수 있도록 하는 옵션이 있습니다. 본 자료를 읽은 다음에는 find 명령어에 대한 맨페이지(man page)를 이해할 수 있는 배경 지식을 갖추었을 것으로 생각하기 때문에 이 강력하면서도 유용한 툴을 직접 경험해 볼 것을 권합니다

필자가 자주 사용하는 find 명령 형식

1. 특정 파일을 찾을 때

find . -name '*.cpp'

find를 실행하는 경로에서 시작해서 모든 하위 경로에서 파일의 확장자가 cpp 인 파일 이름을 출력한다.

2. 특정 파일을 찾되, 지정된 깊이까지만 하위 경로를 검색할 때

find . -maxdepth 2 -name '*.cpp'

3. 파일 이름에 GSE3838 이 들어가는 파일 이름을 검색할 때

find . -name '*GSE3838*'

4. 파일 내부에 get_rank 라는 문자열이 들어 있는 파일을 찾아서 파일 이름을 출력할 때

find . -name '*.cpp' -exec egrep -H get_rank {} \;

이 명령구문은 두 가지 일을 하고 있는데, 우선 find option 에 적절한 파일 이름을 검색한다. 그 후 찾아진 파일 이름을 입력으로 하여 -exec 뒤의 구문을 실행한다. 위의 경우, *.cpp 파일을 찾은 후, 각 파일 이름에 대하여 egrep -H get_rank %찾아진 파일 이름% 형태의 명령을 하게 된다. 여기서 grep 을 설명하진 않는데, 위의 명령 구문은, 따라서, get_rank 가 포함된 cpp 파일을 찾아서 그 파일 이름을 출력하고 있다. 이 기능이 은근히 유용한데, 만약 파일 이름을 입력으로 받는 프로그램을 작성했고, 특정 경로 (와 하위 경로)에 포함된 파일들 각각에 대하여 그 프로그램을 실행시켜야 할 때 이와 같이 할 수 있는 것이다.

IMEI, IMSI

Mon, 30 Aug 2010 13:02:40 +0900

IMEI(International Mobile Equipment Identity, 국제 모바일 단말기 인증번호)는 3G 방식에서 단말기가 어느 제조사의 어느 모델인지를 알아볼 수 있는 고유 번호이며, IMSI(International Mobile Subscriber Identity : 국제 모바일 가입자 인증번호)는 USIM에 내장돼 통신사가 가입자 개인을 식별하는데 사용하는 번호로 국제 표준으로 사용되고 있다.

2G 시절에는 ESN(Electronic Serial Number : 전자식 고유 번호)이 이와 유사한 역할을 했다. 그런데 ESN이 유출돼 수많은 브릿지폰(도·감청의 목적으로 제작되는 복제 전화기)이 등장하면서 3G부터는 IMEI와 IMSI를 통해 단말기 정보와 사용자 정보를 분리해서 사용하고 있는 것이다.