Wie reproduzieren AsyncTask von Android in Java reinen Code

Question

Ich versuche, das gleiche logische reproduzieren, dass Androids AsyncTask in Java reinen Code folgt.

Um dies zu tun, habe ich die abstrakte Klasse AsyncTask erstellt, die meine IAsynTask implementiert, die grundsätzlich onPreExecute, doInBackground und onPostExecute aufruft, auch habe ich die Methode erstellt, wo die Magie passiert.

Um das beispielsweise in meinem Login-Prozess zu verwenden, habe ich die LoginTask-Klasse erstellt, die AsyncTask erweitert, aber anders als ich mir die Implementierung von onPreExecute vorgestellt habe, sieht doInBackground und onPostExecute nicht zwingend aus. Was mache ich falsch?

Inteface:

public interface IAsyncTask { 

    public void onPreExecute(); 
    public void doInBackground(); 
    public void onPostExecute(); 

} 

Klasse:

public abstract class AsyncTask implements IAsyncTask{ 

    public void onPreExecute() { 

    } 

    public void doInBackground(){ 

    } 

    public void onPostExecute() { 

    } 

    public void execute() { 

     onPreExecute(); 

     new Thread(new Runnable() { 
      @Override 
      public void run() { 

       doInBackground(); 

       Platform.runLater(new Runnable() { 
        @Override 
        public void run() { 
         onPostExecute(); 
        } 
       }); 
      } 
     }).start(); 
    } 
} 

[EDITED]

Mit meinen Fragen zu javafx Ich habe bemerkt, dass viele neuere Entwickler vor Problem der Verwaltung Threads. Ich möchte gerne mitteilen, was ich getan habe, um mein Leben im Umgang mit Threads auf javafx zu vereinfachen. Ich habe eine AsyncTask-Klasse auf der Basis von AsyncTask von Android erstellt, die das gleiche wie Android auf eine bescheidene, aber effektive Weise tut. Weitere Informationen dazu finden Sie unter Github project

Answer 1

Es tut mir leid, wenn ich nicht erklären konnte, was genau ich wollte, aber nachdem Sie meinen Code sehen, werden Sie verstehen. Ich habe gerade einen Abstrac-Bezeichner in meinen Methoden hinzugefügt und bekommen, was ich wollte. Es könnte wie ein Newbie-Problem erscheinen, aber ich denke, es kann verwendet werden, um einige einfache Operationen zu vereinfachen, ohne Threads direkt zu verwalten.

Was ich ein einfaches AsyncTask mit Java und JavaFX-Code zu reproduzieren tat:

eine abstrakte Klasse erstellen AsyncTask

public abstract class AsyncTask { 

    abstract void onPreExecute(); 

    abstract void doInBackground(); 

    abstract void onPostExecute(); 

    public void execute() { 

     onPreExecute(); 

     new Thread(new Runnable() { 
      @Override 
      public void run() { 

       doInBackground(); 

       //Platform.runLater is a javafx code that executes onPost in Main Thread. 
       Platform.runLater(new Runnable() { 
        @Override 
        public void run() { 
         onPostExecute(); 
        } 
       }); 
      } 
     }).start(); 
    } 
} 

es Extend unserer Arbeiter Klasse

public class LoginTask extends AsyncTask { 

    @Override 
    void onPreExecute() { 

     //Some code to preexecute in Main Thread 
     System.out.println("OnPreExecute - Main Thread: " + Platform.isFxApplicationThread()); 
    } 

    @Override 
    void doInBackground() { 

     //Some code to execute in background thread as internet requests 
     System.out.println("doInBackground - Main Thread: " + Platform.isFxApplicationThread()); 
    } 

    @Override 
    void onPostExecute() { 

     //Some code to execute in Main thread after background process has done, like update a view 
     System.out.println("onPostExecute - Main Thread: " + Platform.isFxApplicationThread());   
    } 

} 

es zu nennen Sie können tun:

LoginTask taskTest = new LoginTask(); 
taskTest.execute(); 

und Ihr Protokoll wird:

OnPreExecute - Main Thread: true 
doInBackground - Main Thread: false 
onPostExecute - Main Thread: true 

Answer 2

AsyncTask ist im Kern ein Thread. Es ist ein Thread, der in einem anderen beliebigen Thread (aber normalerweise dem Haupt) beginnt, seine Aufgabe ausführt und dann eine Post-Aufgabe an den Thread delegiert, der ihn hervorgebracht hat (wie gesagt, normalerweise der Haupt-Thread).

Das Problem, mit dem Sie bei der Arbeit an diesem Projekt konfrontiert werden, ist die Handler-Klasse, die (!) Diese oben erwähnte Threaddelegierungsfunktion behandelt. Handler ist eine Kernfunktion von Android und ermöglicht die Delegierung von Nicht-Hauptthreadaufgaben an den Thread, in dem es erstellt wurde. Damit Sie eine Art von Java-AsyncTask implementieren können, müssen Sie eine Thread-Delegierungs-API hinzufügen, die im Prinzip genauso funktioniert wie Handler .