lightbulb_outline Help shape the future of the Google Play Console, Android Studio, and Firebase. Start survey

바인드된 서비스

바인드된 서비스란 클라이언트-서버 인터페이스 안의 서버를 말합니다. 바인드된 서비스를 사용하면 구성 요소(활동 등)를 서비스에 바인드하거나, 요청을 보내고 응답을 수신하며 심지어는 프로세스간 통신(IPC)까지 수행할 수 있게 됩니다. 일반적으로 바인드된 서비스는 다른 애플리케이션 구성 요소를 도울 때까지만 살고 백그라운드에서 무한히 실행되지 않습니다.

이 문서는 다른 애플리케이션 구성 요소로부터 서비스에 바인드하는 방법을 포함하여 바인드된서비스를 만드는 방법을 보여줍니다. 하지만 일반적인 서비스에 관한 정보도 알아두는 것이 좋습니다. 서비스에서 알림을 전달하는 방법이나 서비스를 포그라운드에서 실행되도록 설정하는 방법 등 여러 가지 추가 정보를 알아보려면 서비스 문서를 참조하세요.

기본 사항

바인드된 서비스란 일종의 Service 클래스 구현으로, 이를 통해 다른 애플리케이션이 이 서비스에 바인드하여 상호작용할 수 있습니다. 한 서비스에 대한 바인딩을 제공하려면, onBind() 콜백 메서드를 구현해야 합니다. 이 메서드는 클라이언트가 서비스와 상호작용하는 데 사용하는 프로그래밍 인터페이스를 정의하는 IBinder 객체를 반환합니다.

클라이언트가 서비스에 바인드하려면 bindService()를 호출하면 됩니다. 이 때, 반드시 서비스와의 연결을 모니터링하는 ServiceConnection의 구현을 제공해야 합니다. bindService() 메서드는 값 없이 즉시 반환됩니다. 그러나 Android 시스템이 클라이언트와 서비스 사이의 연결을 생성하는 경우, 시스템은 onServiceConnected()ServiceConnection에서 호출하여 클라이언트가 서비스와 통신하는 데 사용할 수 있도록 IBinder를 전달합니다.

여러 클라이언트가 한 번에 서비스에 연결될 수 있습니다. 그러나, 시스템이 서비스의 onBind() 메서드를 호출하여 IBinder를 검색하는 경우는 첫 번째 클라이언트가 바인드되는 경우뿐입니다. 시스템은 그 후 같은 IBinder를 바인드되는 추가 클라이언트 모두에 전달하며 이때는 onBind()를 다시 호출하지 않습니다.

마지막 클라이언트가 서비스에서 바인딩을 해제하면 시스템은 서비스를 소멸시킵니다(startService()가 서비스를 시작했을 경우 제외).

바인드된 서비스를 구현할 때 가장 중요한 부분은 onBind() 콜백 메서드가 반환하는 인터페이스를 정의하는 것입니다. 서비스의 IBinder 인터페이스를 정의하는 방법에는 몇 가지가 있고, 다음 섹션에서는 각 기법에 관해 논의합니다.

바인드된 서비스 생성

바인딩을 제공하는 서비스를 생성할 때는 클라이언트가 서비스와 상호작용하는 데 사용할 수 있는 프로그래밍 인터페이스를 제공하는 IBinder를 제공해야 합니다. 인터페이스를 정의하는 방법은 세 가지가 있습니다.

바인더 클래스 확장
서비스가 본인의 애플리케이션 전용이며 클라이언트와 동일한 프로세스에서 실행되는 경우(이런 경우가 흔함), Binder 클래스를 확장하고 그 인스턴스를 onBind()에서 반환하는 방식으로 인터페이스를 생성해야 합니다. 클라이언트가 Binder를 받으며, 이를 사용하여 Binder 구현 또는 심지어 Service에서 사용할 수 있는 공개 메서드에 직접 액세스할 수 있습니다.

이것은 서비스가 본인의 애플리케이션을 위해 단순히 백그라운드에서 작동하는 요소에 그치는 경우 선호되는 기법입니다. 인터페이스를 생성할 때 이 방식을 사용하지 않는 유일한 이유는 서비스를 다른 애플리케이션에서나 별도의 프로세스에 걸쳐 사용하고 있는 경우뿐입니다.

메신저 사용
인터페이스가 여러 프로세스에 걸쳐 적용되도록 해야 하는 경우, 서비스에 대한 인터페이스를 Messenger로 생성할 수 있습니다. 이 방식을 사용하면 서비스가 여러 가지 유형의 Message 객체에 응답하는 Handler를 정의합니다. 이 HandlerMessenger의 기초이며, 이를 통해 클라이언트와 IBinder를 공유할 수 있으므로, 클라이언트가 Message 객체를 사용해 서비스에 명령을 보낼 수 있습니다. 이외에도, 클라이언트가 자체적으로 Messenger를 정의하여 서비스가 메시지를 돌려보낼 수 있도록 할 수도 있습니다.

이것이 프로세스간 통신(IPC)을 수행하는 가장 간단한 방법입니다. Messenger가 모든 요청을 단일 스레드로 큐에 저장하여, 서비스를 스레드로부터 안전하게 설계하지 않아도 되기 때문입니다.

AIDL 사용
AIDL(Android Interface Definition Language)은 객체를 운영 체제가 이해할 수 있는 원시 유형으로 해체한 다음 여러 프로세스에 걸쳐 마샬링하여 IPC를 수행합니다. Messenger를 사용하는 이전 기법은 사실상 AIDL을 기본 구조로 하고 있습니다. 위에서 언급한 바와 같이 Messenger는 단일 스레드에 모든 클라이언트 요청 큐를 생성하므로 서비스는 한 번에 하나씩 요청을 수신합니다. 그러나, 서비스가 동시에 여러 요청을 처리하도록 하고 싶은 경우에는 AIDL을 직접 사용해도 됩니다. 이 경우, 서비스가 다중 스레딩을 할 수 있어야 하며 스레드로부터 안전하게 구축되었어야 합니다.

AIDL을 직접 사용하려면 프로그래밍 인터페이스를 정의하는 .aidl 파일을 생성해야 합니다. Android SDK 도구는 이 파일을 사용하여 인터페이스를 구현하고 IPC를 처리하는 추상 클래스를 생성하며, 그러면 개발자가 직접 이것을 서비스 내에서 확장하면 됩니다.

참고: 대부분의 애플리케이션의 경우, 바인드된 서비스를 생성하기 위해 AIDL를 사용해서는 안 됩니다. 그러려면 다중 스레딩 기능이 필요할 수 있고, 따라서 더 복잡한 구현을 초래할 수 있기 때문입니다. 따라서 AIDL은 대부분의 애플리케이션에 적합하지 않으므로 이 문서에서는 여러분의 서비스에 이를 이용하는 방법에 대해 다루지 않습니다. AIDL을 직접 사용해야 한다는 확신이 드는 경우, AIDL 문서를 참조하세요.

바인더 클래스 확장

서비스를 사용하는 것이 로컬 애플리케이션뿐이고 여러 프로세스에 걸쳐 작동할 필요가 없는 경우, 나름의 Binder 클래스를 구현하여 클라이언트로 하여금 서비스 내의 공개 메서드에 직접 액세스할 수 있도록 할 수도 있습니다.

참고: 이것은 클라이언트와 서비스가 같은 애플리케이션 및 프로세스에 있는 경우에만 통하며, 이 경우가 가장 보편적입니다. 이 방식이 잘 통하는 경우를 예로 들면, 음악 애플리케이션에서 자체 서비스에 액티비티를 바인드하여 백그라운드에서 음악을 재생하도록 해야 하는 경우가 있습니다.

이렇게 설정하는 방법은 다음과 같습니다.

  1. 서비스에서 다음 중 한 가지에 해당하는 Binder의 인스턴스를 생성합니다.
    • 클라이언트가 호출할 수 있는 공개 메서드 포함
    • 클라이언트가 호출할 수 있는 공개 메서드가 있는 현재Service 인스턴스를 반환
    • 클라이언트가 호출할 수 있는 공개 메서드가 포함된 서비스가 호스팅하는 다른 클래스의 인스턴스를 반환
  2. Binder의 인스턴스를 onBind() 콜백 메서드에서 반환합니다.
  3. 클라이언트의 경우, BinderonServiceConnected() 콜백 메서드에서 받아, 제공된 메서드를 사용해 바인딩된 서비스를 호출합니다.

참고: 서비스와 클라이언트가 같은 애플리케이션에 있어야 하는 것은 그래야만 클라이언트가 반환된 객체를 캐스팅하여 해당 API를 적절하게 호출할 수 있기 때문입니다. 또한 서비스와 클라이언트는 같은 프로세스에 있어야 하기도 합니다. 이 기법에서는 여러 프로세스에 걸친 집결 작업을 전혀 수행하지 않기 때문입니다.

예컨대, 어떤 서비스가 클라이언트에게 Binder 구현을 통해 서비스 내의 메서드에 액세스할 수 있도록 한다고 합시다.

public class LocalService extends Service {
    // Binder given to clients
    private final IBinder mBinder = new LocalBinder();
    // Random number generator
    private final Random mGenerator = new Random();

    /**
     * Class used for the client Binder.  Because we know this service always
     * runs in the same process as its clients, we don't need to deal with IPC.
     */
    public class LocalBinder extends Binder {
        LocalService getService() {
            // Return this instance of LocalService so clients can call public methods
            return LocalService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    /** method for clients */
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}

LocalBinderLocalService의 현재 인스턴스를 검색하기 위한 getService() 메서드를 클라이언트에 제공합니다. 이렇게 하면 클라이언트가 서비스 내의 공개 메서드를 호출할 수 있습니다. 예를 들어, 클라이언트는 서비스에서 getRandomNumber()를 호출할 수 있습니다.

다음은 버튼을 클릭했을 때 LocalService에 바인드되며 getRandomNumber()를 호출하는 액티비티를 나타냅니다.

public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to LocalService
        Intent intent = new Intent(this, LocalService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    /** Called when a button is clicked (the button in the layout file attaches to
      * this method with the android:onClick attribute) */
    public void onButtonClick(View v) {
        if (mBound) {
            // Call a method from the LocalService.
            // However, if this call were something that might hang, then this request should
            // occur in a separate thread to avoid slowing down the activity performance.
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

    /** Defines callbacks for service binding, passed to bindService() */
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };
}

위 예시는 클라이언트가 ServiceConnection 구현과 onServiceConnected() 콜백을 사용하여 서비스에 바인드하는 방법을 보여줍니다. 다음 섹션에서는 이러한 서비스로의 바인딩 과정에 대해 좀 더 자세한 정보를 제공합니다.

참고: 위의 예시에서, onStop() 메서드는 서비스에서 클라이언트를 바인딩 해제합니다. 적절한 타이밍에 서비스에서 클라이언트를 바인딩 해제해야 합니다(추가 참고 사항 참조).

추가 샘플 코드는 ApiDemosLocalService.java 클래스와 LocalServiceActivities.java 클래스를 참조하세요.

메신저 사용

서비스가 원격 프로세스와 통신해야 한다면 서비스에 인터페이스를 제공하는 데 Messenger를 사용하면 됩니다. 이 기법을 사용하면 AIDL을 쓰지 않고도 프로세스간 통신(IPC)을 수행할 수 있게 해줍니다.

다음은 Messenger 사용 방법을 간략하게 요약한 것입니다.

  • 서비스가 클라이언트로부터 각 호출에 대해 콜백을 받는 Handler를 구현합니다.
  • Handler를 사용하여 Messenger 객체를 생성합니다 (이것은 Handler에 대한 참조입니다).
  • MessengerIBinder를 생성하여 서비스가 onBind()로부터 클라이언트에게 반환하도록 합니다.
  • 클라이언트는 IBinder를 사용하여 Messenger (서비스의 Handler를 참조)를 인스턴스화하고, 이를 이용하여 Message 객체를 서비스에 전송합니다.
  • 서비스가 각 MessageHandler로 수신합니다. 구체적으로는 handleMessage() 메서드를 사용합니다.

이렇게 하면, 클라이언트가 서비스에서 호출할 "메서드"가 없습니다. 대신 클라이언트는 "메시지"(Message 객체)를 전달하여 서비스가 Handler로 받을 수 있도록 합니다.

다음은 Messenger 인터페이스를 사용하는 서비스의 간단한 예시입니다.

public class MessengerService extends Service {
    /** Command to the service to display a message */
    static final int MSG_SAY_HELLO = 1;

    /**
     * Handler of incoming messages from clients.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

HandlerhandleMessage() 메서드에서 서비스가 수신되는 Message를 받고 what 멤버에 기초하여 무엇을 할지 결정한다는 점을 눈여겨 보세요.

클라이언트는 서비스가 반환한 IBinder에 기초하여 Messenger를 생성하고 send()로 메시지를 전송하기만 하면 됩니다. 예를 들어, 다음은 서비스에 바인드하여 MSG_SAY_HELLO 메시지를 서비스에 전달하는 간단한 액티비티입니다.

public class ActivityMessenger extends Activity {
    /** Messenger for communicating with the service. */
    Messenger mService = null;

    /** Flag indicating whether we have called bind on the service. */
    boolean mBound;

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // This is called when the connection with the service has been
            // established, giving us the object we can use to
            // interact with the service.  We are communicating with the
            // service using a Messenger, so here we get a client-side
            // representation of that from the raw IBinder object.
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        // Create and send a message to the service, using a supported 'what' value
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to the service
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

이 예시에는 서비스가 클라이언트에 응답하는 방식이 나타나 있지 않다는 것을 유념하세요. 서비스가 응답하게 하려면 클라이언트에도 Messenger를 생성해야 합니다. 클라이언트가 onServiceConnected() 콜백을 받으면 send()메서드의 replyTo 매개변수에서 클라이언트의 Messenger를 포함하는 Message를 서비스에 전송합니다.

양방향 메시지를 제공하는 방법의 예시는 MessengerService.java(서비스) 및 MessengerServiceActivities.java(클라이언트) 샘플을 참조하세요.

서비스에 바인딩

애플리케이션 구성 요소(클라이언트)를 서비스에 바인드하려면 bindService()를 호출하면 됩니다. 그러면 Android 시스템이 서비스의 onBind() 메서드를 호출하고, 이는 서비스와의 상호작용을 위해 IBinder를 반환합니다.

바인딩은 비동기식입니다. bindService()는 즉시 반환하고 클라이언트에게 IBinder를 반환하지 않습니다. IBinder를 수신하려면 클라이언트는 ServiceConnection의 인스턴스를 생성하여 이를 bindService()에 전달해야 합니다. ServiceConnection에는 IBinder를 전달하기 위해 시스템이 호출하는 콜백 메서드가 포함됩니다.

참고: 서비스에 바인드할 수 있는 것은 액티비티, 서비스 및 콘텐츠 제공자뿐입니다. 브로드캐스트 수신기로부터는 서비스에 바인드할 수 없습니다.

따라서, 클라이언트로부터 서비스에 바인드하려면 다음과 같이 해야 합니다.

  1. ServiceConnection을 구현합니다.

    이 구현으로 두 가지 콜백 메서드를 재정의해야 합니다.

    onServiceConnected()
    시스템이 이것을 호출하여 서비스의 onBind() 메서드가 반환한 IBinder를 전달합니다.
    onServiceDisconnected()
    Android 시스템이 이것을 호출하는 경우는 서비스로의 연결이 예기치 못하게 끊어졌을 때, 즉 서비스가 충돌했거나 중단되었을 때 등입니다. 클라이언트가 바인딩을 해제한다고 이것이 호출되지는 않습니다.
  2. bindService()를 호출하고, ServiceConnection 구현을 전달합니다.
  3. 시스템이 onServiceConnected() 콜백 메서드를 호출하면, 인터페이스가 정의한 메서드를 사용하여 서비스에 호출을 시작해도 됩니다.
  4. 서비스로부터 연결을 해제하려면 unbindService()를 호출합니다.

    앱이 클라이언트를 소멸시킬 때 클라이언트가 서비스에 여전히 바인딩된 경우, 이 소멸로 인해 클라이언트가 바인딩 해제됩니다. 더 나은 방법은 서비스와의 상호작용이 완료되자마자 클라이언트를 바인딩 해제하는 것입니다. 이렇게 하여 유휴 서비스를 종료할 수 있습니다. 바인딩 및 바인딩 해제의 적절한 타이밍에 대한 자세한 내용은 추가 참고 사항을 참조하세요.

예를 들어, 다음 스니펫은 위와 같이 바인더 클래스를 확장해서 생성한 서비스와 클라이언트를 연결합니다. 그러므로 이 스니펫이 해야 하는 일은 반환된 IBinderLocalService 클래스로 형변환하고 LocalService 인스턴스를 요청하는 것뿐입니다.

LocalService mService;
private ServiceConnection mConnection = new ServiceConnection() {
    // Called when the connection with the service is established
    public void onServiceConnected(ComponentName className, IBinder service) {
        // Because we have bound to an explicit
        // service that is running in our own process, we can
        // cast its IBinder to a concrete class and directly access it.
        LocalBinder binder = (LocalBinder) service;
        mService = binder.getService();
        mBound = true;
    }

    // Called when the connection with the service disconnects unexpectedly
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "onServiceDisconnected");
        mBound = false;
    }
};

ServiceConnection이 있으면 클라이언트는 이것을 bindService()에 전달하여 서비스에 바인드할 수 있습니다. 예:

Intent intent = new Intent(this, LocalService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
  • bindService()의 첫 번째 매개변수는 바인드할 서비스를 명시적으로 명명하는 Intent입니다(인텐트는 암시적일 수 있음).
  • 두 번째 매개변수는 ServiceConnection 객체입니다.
  • 세 번째 매개변수는 바인딩 옵션을 나타내는 플래그입니다. 서비스를 생성하기 위해 보통은 BIND_AUTO_CREATE를 사용합니다(이미 살아 있는 상태가 아닌 경우). 가능한 기타 값은 BIND_DEBUG_UNBINDBIND_NOT_FOREGROUND이며, 값이 없는 경우 0입니다.

추가 참고 사항

다음은 서비스로의 바인딩에 관한 몇 가지 중요한 참고 사항입니다.

  • 항상 DeadObjectException 예외를 트랩해야 합니다. 이 예외는 연결이 끊어지면 발생합니다. 원격 메서드에 의해 발생하는 예외는 이것뿐입니다.
  • 객체는 여러 프로세스에 걸쳐 카운트되는 참조입니다.
  • 일반적으로, 클라이언트의 수명 주기를 결합하고 분해하는 순간을 일치시키면서 바인딩과 바인딩 해제를 짝지어야 합니다. 예:
    • 액티비티가 눈에 보이는 동안에만 서비스와 상호작용해야 한다면 onStart()에는 바인드하고 onStop()에는 바인딩을 해제해야 합니다.
    • 백그라운드에서 중단되었을 때도 액티비티가 응답을 받게 하고 싶다면 onCreate()에는 바인드하고 onDestroy() 중에는 바인딩을 해제합니다. 이때, 사용자의 액티비티가 서비스가 실행되는 시간 전체에서(백그라운드에서라도) 서비스를 사용한다는 것을 유념해야 합니다. 서비스가 다른 프로세스에 있을 경우, 사용자가 프로세스의 가중치를 높이면 시스템이 이를 중단할 가능성이 높아집니다.

    참고: 일반적으로는, 액티비티의 onResume()onPause()에는 바인드하거나 바인딩을 해제하지 말아야 합니다. 이러한 콜백은 모든 수명 주기 전환에서 발생하고 이런 전환에서 발생하는 처리는 최소한으로 유지해야 하기 때문입니다. 또한, 사용자 애플리케이션의 여러 액티비티가 동일한 서비스에 바인드되었고 두 액티비티 사이에 전환이 있을 경우, 현재 액티비티의 바인딩이 해제된 후(일시중지 중) 다음 액티비티가 바인드하기 전(재개 중)에 서비스가 제거되었다가 다시 생성될 수 있습니다 (수명 주기를 조절하기 위한 이러한 액티비티 전환은 액티비티 문서에 설명되어 있습니다).

더 많은 샘플 코드를 보려면 ApiDemosRemoteService.java 클래스를 참조하세요.

바인드된 서비스 수명 주기 관리

서비스가 모든 클라이언트로부터의 바인딩이 해제되면, Android 시스템이 이를 소멸시킵니다(다만 onStartCommand()와도 함께 시작된 경우는 예외). 따라서, 서비스가 순전히 바인드된 서비스일 경우에는 해당 서비스의 수명 주기를 관리하지 않아도 됩니다. 클라이언트에 바인드되었는지를 근거로 Android 시스템이 대신 관리해주기 때문입니다.

그러나 onStartCommand() 콜백 메서드를 구현으로 선택하는 경우라면 서비스를 확실히 중지해야 합니다. 서비스가 현재 시작된 것으로 간주되기 때문입니다. 이 경우 서비스가 클라이언트에 바인드되어 있는지 여부에 상관없이, stopSelf()를 통해 서비스가 스스로 중지되거나 다른 구성 요소가 stopService()를 호출할 때까지 서비스가 실행됩니다.

또한, 서비스가 시작되고 바인딩을 허용할 경우, 다음에 클라이언트가 서비스에 바인드할 때 onRebind()에 대한 호출을 받고 싶다면 시스템이 onUnbind() 메서드를 호출할 때 선택적으로 true를 반환할 수 있습니다. onRebind()는 void를 반환하지만, 클라이언트는 여전히 onServiceConnected() 콜백에서 IBinder를 수신합니다. 아래 그림 1은 이러한 수명 주기의 논리를 나타냅니다.

그림 1. 시작되었으며 바인딩도 허용하는 서비스의 수명 주기입니다.

시작된 서비스의 수명 주기에 관한 자세한 정보는 서비스 문서를 참조하세요.