Detaillierte Erläuterung des Aktivitätslebenszyklus und des Lademodus in der Android-Entwicklung

Dieser Artikel führt Sie in den Lebenszyklus von Aktivität ein. Wenn Sie iOS studiert haben, ist der Lebenszyklus von Aktivität dem Lebenszyklus von ViewController in iOS sehr ähnlich. Der Lebenszyklus ist nicht schwer zu verstehen. Der Lebenszyklus eines Menschen besteht aus nichts anderem als Geburt, Alter, Krankheit und Tod, und der Lebenszyklus einer Blume besteht aus dem Blühen und Verblühen. Der Lebenszyklus von Aktivitäten in Android ist nichts anderes als der Prozess von der Aktivitätserstellung bis zum Tod. In diesem Blog werden die verschiedenen Phasen des Aktivitätslebenszyklus vorgestellt und anhand von Beispielen ein Blick auf den Aktivitätslebenszyklus geworfen. Es ist von entscheidender Bedeutung, den Lebenszyklus der Aktivität zu verstehen, denn nur wenn Sie jede Phase jedes Lebenszyklus verstehen, können Sie in verschiedenen Phasen unterschiedliche Dinge tun.

Als nächstes stellen wir den Lebenszyklus der Aktivität anhand eines Beispiels vor. In dieser Demo wird eine MainActivity angezeigt, die erste Aktivität, die nach dem Start der App angezeigt wird. Es gibt eine Schaltfläche auf MainActivity. Durch Klicken auf die Eingabetaste gelangen Sie von SecondActivity zu MainActivity. Durch diese Reihe von Aktivitätswechseln beobachten wir den Aktivitätslebenszyklus, indem wir ein Protokoll drucken.

1. Code schreiben

Tatsächlich ist der Code dieses Blogs sehr einfach. Er besteht darin, die Methoden in verschiedenen Phasen des Aktivitätslebenszyklus neu zu schreiben und dann die Methode auszudrucken um die Phase dieses Lebenszyklus zu markieren. Die Benutzeroberfläche der Demo ist ebenfalls sehr einfach, daher werde ich nicht zu sehr auf die Layoutdatei der Aktivität eingehen. Schauen Sie sich als Nächstes die Schlüsselcodes in den beiden Aktivitäten an.

1. Der folgende Code ist der Schlüsselcode in MainActivity. Er schreibt verschiedene Phasen des Aktivitätslebenszyklus neu und druckt dann das Protokoll, um zu markieren, welche Methode in welcher Aktivität vorliegt. Rufen Sie die Schaltfläche per ID in der onCreate()-Methode ab, binden Sie dann das Klickereignis an die Schaltfläche und springen Sie zu SecondActivity, wenn auf die Schaltfläche geklickt wird. Der spezifische Code lautet wie folgt.

@Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Log.d("lifeCycle", "MainActivity: 我是onCreate方法，我会在Activity第一次被创建是调用");
    Button jumpButton = (Button) findViewById(R.id.jump_second_button);
    jumpButton.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //跳转到SecondActivity
        Intent intent = new Intent(MainActivity.this, SecondActivity.class);
        startActivity(intent);
      }
    });
  }
  //Ctrl + O 选择父类中的方法进行重写
  @Override
  protected void onStart() {
    super.onStart();
    Log.d("lifeCycle", "MainActivity: 我是onStart方法，我会在Activity由不可见变为可见时调用");
  }
  @Override
  protected void onResume() {
    super.onResume();
    Log.d("lifeCycle", "MainActivity: 我是onResume方法，我在Activity处于运行状态时调用");
  }
  @Override
  protected void onPause() {
    super.onPause();
    Log.d("lifeCycle", "MainActivity: 我是onPause方法，我会在Activity暂停时调用");
  }
  @Override
  protected void onStop() {
    super.onStop();
    Log.d("lifeCycle", "MainActivity: 我是onStop方法，我会在Activity停止时调用");
  }
  @Override
  protected void onRestart() {
    super.onRestart();
    Log.d("lifeCycle", "MainActivity: 我是onRestart方法，我会在Activty从停止状态变为运行状态时调用");
  }
  @Override
  protected void onDestroy() {
    super.onDestroy();
    Log.d("lifeCycle", "MainActivity: 我是onDestroy方法，我会在Activty销毁之前调用");
  }

2. Die obige Methode wird auch in SecondActivity umgeschrieben. Der einzige Unterschied besteht darin, die MainActivity im obigen Protokoll zu ändern. Der Code ist ähnlich und wird nicht nach oben eingefügt.

2. Führen Sie das gedruckte Protokoll aus und beobachten Sie es.

Führen Sie unsere App aus, beobachten Sie dann das gedruckte Protokoll und analysieren Sie den Aktivitätslebenszyklus anhand von Beispielen. Die spezifischen Schritte sind wie folgt:

1. Aktivität erstellen und aktivieren

Das beim ersten Öffnen der App gedruckte Protokoll sieht wie folgt aus. MainActivity ist das Erste, was Sie sehen, wenn Sie die App öffnen. Durch das Protokoll können wir leicht erkennen, dass die folgenden drei Methoden aufgerufen werden müssen, wenn MainActivity zum ersten Mal angezeigt wird. Nach den drei folgenden Methoden wird MainActivty erstellt und dann sichtbar , und endlich in einem lauffähigen Zustand.

(1).onCreate()-Methode: Diese Methode wird aufgerufen, wenn die Aktivität zum ersten Mal erstellt wird. In der vorherigen Demo haben wir das Layout und/oder die Steuerelemente der Aktivität und zugehöriger Ereignisse darin geladen Verfahren.

(2).onStar()t-Methode: Dann wird die onStart()-Methode ausgeführt. Diese Methode wird aufgerufen, wenn die Aktivität von unsichtbar zu sichtbar wechselt.

(3).onResume-Methode: Nachdem die Aktivität sichtbar wird, muss die onResume-Methode aufgerufen werden, um sie in den laufenden Zustand zu versetzen.

2. Wechseln zwischen Aktivitäten

Um es klarer zu machen, können wir das Protokoll löschen, bevor wir auf die Schaltfläche „SecondActivity“ klicken links unten Die Eimermarkierung dient zum Löschen zuvor gedruckter Protokolle. Das unten gedruckte Protokoll ist das Protokoll, das gedruckt wird, wenn auf die Sprungschaltfläche geklickt wird. Während dieses Umschaltvorgangs stoppt MianActivty die Ausführung und wird unsichtbar. SecondActivy wird erstellt und befindet sich im Ausführungszustand. Die spezifischen Schritte sind wie folgt.

(1).onPause()-Methode: Wenn auf die Sprungschaltfläche geklickt wird, ruft die laufende MainActivity onPause() auf, um angehalten zu werden, ist aber weiterhin sichtbar.

(2). Dann ruft SecondActivity die Methode onCreate() zum Erstellen, die Methode onStart() zum Anzeigen und die Methode onResume() zum Ausführen auf.

(3).onStop()-Methode: Wenn SecondActivity ausgeführt wird, ist MainActivity vollständig unsichtbar, daher wird die onStop()-Methode aufgerufen, um in einen vollständig unsichtbaren Stoppzustand zu gelangen.

3. Rückkehr von einer anderen Aktivität

Klicken Sie auf die Eingabetaste von SecondActivity, um von SecondActivity zur MainActivity zurückzukehren. Das folgende Protokoll ist das Protokoll, das gedruckt wird, wenn auf die Schaltfläche „Zurück“ geklickt wird.

(1) Methode „onPause()“: Nach dem Klicken auf die Schaltfläche „Zurück“ ruft SecondActivity die Methode „onPause()“ auf und wechselt in den angehaltenen Betriebszustand.

(2)onRestart()-Methode: Dann ruft MainActivity die onRestart()-Methode auf, um vom gestoppten Zustand in den laufenden Zustand zu wechseln. Dann ruft MainActivity die onStart-Methode von unsichtbar nach sichtbar auf und ruft dann die onResume()-Methode auf, um schließlich in den laufenden Zustand zu gelangen.

(3)当返回到MainActivity中并且MainActivity处于运行状态后，SecondActivity会调用onStop方法，停止运行并不可见。因为SecondActivty做的事出栈操作，停止运行后，就会调用onDestory方法进行销毁。下此在进入SecondActivity中时，还是从onCreate方法进行执行。

4.Activity退出并销毁

接着在MainActivity中点击返回按钮就会退出App了，下方是退出App时打印的Log信息。MainActivty先调用onPause()方法变为暂停运行状态，然后再调用onStop()方法停止运行，最后调用onDestroy()方法进行销毁。

三.生命周期流程图

1.上面是用语言通过实例打印出的Log来描述两个Activity切换的生命周期，接下来将用一个流程图来描述这一过程，具体流程图如下。

2.通过上面的实例不难分析出一个Activity的生命周期分为哪些阶段，并且很容易的看出哪些阶段在什么时候执行，所以我们很容易的画出一个Activity的生命周期，下方的流程图是一个Activity的生命周期。

四.Activity的加载模式

Activity的启用模式也较为简单，它会在活动切换时用到。Activity的启动模式分为四种，standard、singleTop、singleTask、singleInstance模式。接下来将为大家详细的介绍一下这几种加载模式。

Activity的加载模式可以在配置文件AndroidManifest.xml中进行配置，配置项为android:launchMode具体如下图所示：

1.standard模式

在Activity的栈中无论该活动有没有加入栈，活动就会被创建。测试方式是把MainActivity的launchMode设置成standard, 在MainActivity中添加一个按钮，点击按钮使用Intent跳转到当前Activity，看onCreate方法中打印的Log。点击按钮的方法如下：

Button launchModelButton = (Button) findViewById(R.id.launch_model_button);
    launchModelButton.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        Intent intent = new Intent(MainActivity.this, MainActivity.class);
        startActivity(intent);
      }
    });

   

standard加载模式的栈如下所示，无论栈中有没有该对象的实例，都会被创建。

2.singleTop模式

只要被创建的活动不位于栈的顶部，该活动就会被创建入栈。如果将要被创建的活动位于栈的顶部，该活动的实例就不会被创建。测试方法，把上面的模式直接改成singleTop模式，MainActivty往自己身上跳转就不会从新创建一个新的实例，会重用之前在栈顶中的实例。如果是MainActivty跳转到SecondActivty, 然后SecondActivity再次跳转到MainActivty, 那么此时的MainActivity将会被创建，因为栈顶是SecondActivity。如下所示：

3.singleTask模式

单任务模式，这个也不难理解，如果从MainActivty跳转到SecondActivity, 如果再从SecondActivty跳转到MainActivity, 在单任务模式下MainActivity已经在栈中，就会把它之前的Activity出栈，使其处于在栈顶活跃的位置。原理如下图所示：

4.singleInstance

可以看成单例模式，这个比较特殊，被设置成singleInstance的Activity将会放入另一个栈中，因为这样为了便于共用。上面3中模式位于同一个栈中。下方ThirdActivity跳转到一个加载模式为singleInstance的Activity中。

Das war's für den heutigen Aktivitätslebenszyklus. Die relevanten Inhalte werden im nächsten Blog aktualisiert.

Ausführlichere Erläuterungen zum Lebenszyklus und Lademodus von Aktivitäten in der Android-Entwicklung finden Sie auf der chinesischen PHP-Website!