¿Hay alguna clase en Java similar a android.os.Handler en Android?

Question

El controlador en Android se utiliza para enviar mensajes entre clases. Por ejemplo:

public class Foo 
{ 

    private Handler handler; 

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

     // ... 
    } 

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

} 

principal:

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

     // ... 
    } 
} 

Así, Busco a una técnica similar en Java, o debo aplicar mi propio manejador?

Answer 1

Creo que está buscando algo así como Observer Pattern, que facilita la comunicación de un objeto a otro.

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

>>> También http://www.oodesign.com/observer-pattern.html

espero haber ayudado ...

Answer 2

no hay uno por defecto. Pero puedes hacer tu propia clase personalizada que haga algo similar. hice uno como este:

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

entonces también tendría una clase personalizada mensaje como este:

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

Puede utilizar este controlador para comunicarse desde un subproceso de fondo para el hilo de interfaz de usuario, sin perturbar demasiado el hilo de UI.

Puede utilizar esta clase por completo de la misma manera que lo haría en Android: En primer lugar se crea una instancia de la clase de interfaz de usuario:

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

Entonces suministrar este caso Handler a su subproceso de fondo:

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

Y por último, se envían mensajes por medio de:

mHandler.obtainMessage(0).sendToTarget(); 

Probé este método en un programa de applet de muestra que hice, y parece funcionar perfectamente. Aunque no soy un experto programador de Java, podría haber algunas desventajas en esto, que realmente no conozco. Si es así, me encantaría escuchar una explicación educada de por qué esto no está bien.

Espero que esto ayude a alguien.

NOTA: Las clases de Controlador y Mensaje anteriores (mi código) no proporcionan la funcionalidad completa de Android.Handler y Android.Message.