Esiste una classe in Java simile a android.os.Handler in Android?

Question

Il gestore di Android viene utilizzato per inviare messaggi tra classi. Per esempio:

public class Foo 
{ 

    private Handler handler; 

    public Foo(Handler handler) 
    { 
     this.handler = handler; 

     // ... 
    } 

    public void fooMethod() 
    { 
     // ... 
     handler.obtainMessage("blah blah").sendToTarget(); 
    } 

} 

principale:

public class Main 
{ 
    private Handler handler; 

    public Main() 
    { 
     handler = new Handler() 
     { 
      @Override 
      public void handleMessage(Message msg) 
      { 
       // handle the message that is sent from Foo 
      } 
     }; 

     Foo f = new Foo(handler); 

     // ... 
    } 
} 

Quindi, sto cercando una tecnica simile a Java, o dovrei realizzare il mio proprio gestore?

Answer 1

Credo che tu stia cercando qualcosa come Observer Pattern, che faciliti la comunicazione di un oggetto a un altro.

Vedi >>>http://www.javaworld.com/javaqa/2001-05/04-qa-0525-observer.html

>>> anche http://www.oodesign.com/observer-pattern.html

Spero ho aiutato ...

Answer 2

non ce n'è uno per impostazione predefinita. Ma puoi creare una tua classe personalizzata che faccia una cosa simile. Ho fatto uno come questo:

import java.util.ArrayList; 

public class Handler extends Object{ 

ArrayList<Message> messages; 

public Handler(){ 
    messages = new ArrayList<>(); 
} 

public final Message obtainMessage(int what, Object obj){ 
    Message message = new Message(what, obj, this); 
    messages.add(message); 
    return message; 
} 

public final Message obtainMessage(int what){ 
    Message message = new Message(what, this); 
    messages.add(message); 
    return message; 
} 

public void handleMessage(Message msg){ 
    messages.remove(msg); 
} 

public final boolean hasMessages(){ 
    return !messages.isEmpty(); 
} 
} 

si sarebbe poi anche bisogno di una classe personalizzata messaggio come questo:

public class Message extends Object{ 

int mWhat; 
Object mObj; 
Handler mTarget; 

public Message(int what, Object obj){ 
    mWhat = what; 
    mObj = obj; 
} 

public Message(int what, Object obj, Handler target){ 
    mWhat = what; 
    mObj = obj; 
    mTarget = target; 
} 

public Message(int what, Handler target){ 
    mWhat = what; 
    mTarget = target; 
} 

public Message(int what){ 
    mWhat = what; 
} 

public void sendToTarget(){ 
    mTarget.handleMessage(this); 
} 
} 

È possibile utilizzare questo gestore per comunicare da un thread in background al thread UI, senza disturbare troppo il thread dell'interfaccia utente.

È possibile utilizzare questa classe in tutto allo stesso modo come si farebbe in Android: Per prima cosa è creare un'istanza nella classe UI:

final int MESSAGE_RECEIVED = 0; 
Handler handler = new Handler(){ 
    @Override 
    public void handleMessage(Message msg) { 
     super.handleMessage(msg); 
     switch (msg.mWhat){ 
      case MESSAGE_RECEIVED: 
       System.out.println("Message received."); 
       updateStatus("Message received."); 
       break; 
     } 
    } 
}; 

Poi si forniscono questa istanza Handler al tuo thread in background:

Thread thread = new T1(handler); 
thread.start(); 

E per ultimo, si inviano messaggi attraverso i mezzi di:

mHandler.obtainMessage(0).sendToTarget(); 

Ho testato questo metodo su un programma di applet di esempio che ho fatto, e sembra funzionare perfettamente. Anche se non sono un programmatore java esperto, quindi potrebbero esserci alcuni aspetti negativi di questo, di cui non sono realmente a conoscenza. Se è così, mi piacerebbe sentire una spiegazione colta del perché questo non è ok.

Spero che questo aiuti qualcuno.

NOTA: le precedenti classi Handler e Message (il mio codice) non forniscono tutte le funzionalità di Android.Handler e Android.Message.