我的方法:

类来管理从/到服务/活动的发送和接收消息:

import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

public class MessageManager {

    public interface IOnHandleMessage{
        // Messages
        int MSG_HANDSHAKE = 0x1;

        void onHandleMessage(Message msg);
    }

    private static final String LOGCAT = MessageManager.class.getSimpleName();

    private Messenger mMsgSender;
    private Messenger mMsgReceiver;
    private List<Message> mMessages;

    public MessageManager(IOnHandleMessage callback, IBinder target){
        mMsgReceiver = new Messenger(new MessageHandler(callback, MessageHandler.TYPE_ACTIVITY));
        mMsgSender = new Messenger(target);
        mMessages = new ArrayList<>();
    }

    public MessageManager(IOnHandleMessage callback){
        mMsgReceiver = new Messenger(new MessageHandler(callback, MessageHandler.TYPE_SERVICE));
        mMsgSender = null;
        mMessages = new ArrayList<>();
    }

    /* START Getter & Setter Methods */
    public Messenger getMsgSender() {
        return mMsgSender;
    }

    public void setMsgSender(Messenger sender) {
        this.mMsgSender = sender;
    }

    public Messenger getMsgReceiver() {
        return mMsgReceiver;
    }

    public void setMsgReceiver(Messenger receiver) {
        this.mMsgReceiver = receiver;
    }

    public List<Message> getLastMessages() {
        return mMessages;
    }

    public void addMessage(Message message) {
        this.mMessages.add(message);
    }
    /* END Getter & Setter Methods */

    /* START Public Methods */
    public void sendMessage(int what, int arg1, int arg2, Bundle msgData){
        if(mMsgSender != null && mMsgReceiver != null) {
            try {
                Message msg = Message.obtain(null, what, arg1, arg2);
                msg.replyTo = mMsgReceiver;
                if(msgData != null){
                    msg.setData(msgData);
                }
                mMsgSender.send(msg);
            } catch (RemoteException rE) {
                onException(rE);
            }
        }
    }

    public void sendHandshake(){
        if(mMsgSender != null && mMsgReceiver != null){
            sendMessage(IOnHandleMessage.MSG_HANDSHAKE, 0, 0, null);
        }
    }
    /* END Public Methods */

    /* START Private Methods */
    private void onException(Exception e){
        Log.e(LOGCAT, e.getMessage());
        e.printStackTrace();
    }
    /* END Private Methods */

    /** START Private Classes **/
    private class MessageHandler extends Handler {

        // Types
        final static int TYPE_SERVICE = 0x1;
        final static int TYPE_ACTIVITY = 0x2;

        private IOnHandleMessage mCallback;
        private int mType;

        public MessageHandler(IOnHandleMessage callback, int type){
            mCallback = callback;
            mType = type;
        }

        @Override
        public void handleMessage(Message msg){
            addMessage(msg);
            switch(msg.what){
                case IOnHandleMessage.MSG_HANDSHAKE:
                    switch(mType){
                        case TYPE_SERVICE:
                            setMsgSender(msg.replyTo);
                            sendHandshake();
                            break;
                        case TYPE_ACTIVITY:
                            Log.v(LOGCAT, "HERE");
                            break;
                    }
                    break;
                default:
                    if(mCallback != null){
                        mCallback.onHandleMessage(msg);
                    }
                    break;
            }
        }

    }
    /** END Private Classes **/

}

在活动示例中:

public class activity extends AppCompatActivity
      implements     ServiceConnection,
                     MessageManager.IOnHandleMessage { 

    [....]

    private MessageManager mMessenger;

    private void initMyMessenger(IBinder iBinder){
        mMessenger = new MessageManager(this, iBinder);
        mMessenger.sendHandshake();
    }

    private void bindToService(){
        Intent intent = new Intent(this, TagScanService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
        /* START THE SERVICE IF NEEDED */
    }

    private void unbindToService(){
    /* UNBIND when you want (onDestroy, after operation...)
        if(mBound) {
            unbindService(mServiceConnection);
            mBound = false;
        }
    }

    /* START Override MessageManager.IOnHandleMessage Methods */
    @Override
    public void onHandleMessage(Message msg) {
        switch(msg.what){
            case Constants.MSG_SYNC_PROGRESS:
                Bundle data = msg.getData();
                String text = data.getString(Constants.KEY_MSG_TEXT);
                setMessageProgress(text);
                break;
            case Constants.MSG_START_SYNC:
                onStartSync();
                break;
            case Constants.MSG_END_SYNC:
                onEndSync(msg.arg1 == Constants.ARG1_SUCCESS);
                mBound = false;
                break;
        }
    }
    /* END Override MessageManager.IOnHandleMessage Methods */

    /** START Override ServiceConnection Methods **/
    private class BLEScanServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            initMyMessenger(iBinder);
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mMessenger = null;
            mBound = false;
        }
    }
    /** END Override ServiceConnection Methods **/

业务举例:

public class Blablabla extends Service
    implements     MessageManager.IOnHandleMessage {

    [...]

    private MessageManager mMessenger;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        super.onBind(intent);
        initMessageManager();
        return mMessenger.getMsgReceiver().getBinder();
    }

    private void initMessageManager(){
        mMessenger = new MessageManager(this);
    }

    /* START Override IOnHandleMessage Methods */
    @Override
    public void onHandleMessage(Message msg) {
    /* Do what you want when u get a message looking the "what" attribute */
    }
    /* END Override IOnHandleMessage Methods */

从活动/服务发送消息:

mMessenger.sendMessage(what, arg1, arg2, dataBundle);

这是如何工作的:

on the activity you start or bind the service. The service "OnBind" methods return the Binder to his MessageManager, the in the Activity through the "Service Connection" interface methods implementation "OnServiceConnected" you get this IBinder and init you MessageManager using it. After the Activity has init his MessageManager the MessageHandler send and Handshake to the service so it can set his "MessageHandler" sender ( the "private Messenger mMsgSender;" in MessageManager ). Doing this the service know to who send his messages.

你也可以在MessageManager中使用信使的列表/队列“发送者”来实现这一点，这样你就可以向不同的活动/服务发送多个消息，或者你可以在MessageManager中使用信使的列表/队列“接收者”，这样你就可以从不同的活动/服务接收多个消息。

在“MessageManager”实例中，您有一个接收到的所有消息的列表。

正如你所看到的，使用这个“MessageManager”实例的“Activity’s Messenger”和“Service Messenger”之间的连接是自动的，它是通过“onserviceconnconnected”方法和“Handshake”的使用完成的。

希望这对你有帮助:)非常感谢! 再见:D

绑定是另一种通信方式

创建回调

public interface MyCallBack{

   public void getResult(String result);

}

活动方面:

Implement the interface in the Activity Provide the implementation for the method Bind the Activity to Service Register and Unregister Callback when the Service gets bound and unbound with Activity. public class YourActivity extends AppCompatActivity implements MyCallBack{ private Intent notifyMeIntent; private GPSService gpsService; private boolean bound = false; @Override public void onCreate(Bundle sis){ // activity code ... startGPSService(); } @Override public void getResult(String result){ // show in textView textView.setText(result); } @Override protected void onStart() { super.onStart(); bindService(); } @Override protected void onStop() { super.onStop(); unbindService(); } private ServiceConnection serviceConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName className, IBinder service) { GPSService.GPSBinder binder = (GPSService.GPSBinder) service; gpsService= binder.getService(); bound = true; gpsService.registerCallBack(YourActivity.this); // register } @Override public void onServiceDisconnected(ComponentName arg0) { bound = false; } }; private void bindService() { bindService(notifyMeIntent, serviceConnection, Context.BIND_AUTO_CREATE); } private void unbindService(){ if (bound) { gpsService.registerCallBack(null); // unregister unbindService(serviceConnection); bound = false; } } // Call this method somewhere to start Your GPSService private void startGPSService(){ notifyMeIntent = new Intent(this, GPSService.class); startService(myIntent ); } }

服务端:

Initialize callback Invoke the callback method whenever needed public class GPSService extends Service{ private MyCallBack myCallback; private IBinder serviceBinder = new GPSBinder(); public void registerCallBack(MyCallBack myCallback){ this.myCallback= myCallback; } public class GPSBinder extends Binder{ public GPSService getService(){ return GPSService.this; } } @Nullable @Override public IBinder onBind(Intent intent){ return serviceBinder; } }

正如Madhur提到的，您可以使用总线进行通信。

在使用总线的情况下，您有一些选择:

Otto事件总线库(已弃用，支持RxJava)

http://square.github.io/otto/

绿色机器人的EventBus

http://greenrobot.org/eventbus/

NYBus (RxBus，使用RxJava实现。非常类似于EventBus)

https://github.com/MindorksOpenSource/NYBus

使用信使是在服务和活动之间进行通信的另一种简单方法。

在Activity中，创建带有相应Messenger的Handler。这将处理来自服务的消息。

class ResponseHandler extends Handler {
    @Override public void handleMessage(Message message) {
            Toast.makeText(this, "message from service",
                    Toast.LENGTH_SHORT).show();
    }
}
Messenger messenger = new Messenger(new ResponseHandler());

Messenger可以通过将其附加到Message来传递给服务:

Message message = Message.obtain(null, MyService.ADD_RESPONSE_HANDLER);
message.replyTo = messenger;
try {
    myService.send(message);
catch (RemoteException e) {
    e.printStackTrace();
}

在API演示中可以找到完整的示例:MessengerService和MessengerServiceActivity。关于MyService如何工作，请参阅完整的示例。

提问者可能早就跳过了这个，但以防其他人搜索这个…

还有另一种处理方法，我认为可能是最简单的。

为您的活动添加一个BroadcastReceiver。注册它来接收一些自定义意图在onResume和取消注册它在onPause。然后当你想要发送状态更新或其他信息时，从你的服务中发送意图。

确保如果其他应用程序监听了你的意图(有人会做任何恶意的事情吗?)，你不会不高兴，但除此之外，你应该没问题。

代码示例:

在我的工作中，我有这个:

// Do stuff that alters the content of my local SQLite Database
sendBroadcast(new Intent(RefreshTask.REFRESH_DATA_INTENT));

(RefreshTask。REFRESH_DATA_INTENT只是一个常量字符串。)

在我的监听活动中，我定义了BroadcastReceiver:

private class DataUpdateReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(RefreshTask.REFRESH_DATA_INTENT)) {
          // Do stuff - maybe update my view based on the changed DB contents
        }
    }
}

我在类的顶部声明了我的接收者:

private DataUpdateReceiver dataUpdateReceiver;

我覆盖onResume添加这个:

if (dataUpdateReceiver == null) dataUpdateReceiver = new DataUpdateReceiver();
IntentFilter intentFilter = new IntentFilter(RefreshTask.REFRESH_DATA_INTENT);
registerReceiver(dataUpdateReceiver, intentFilter);

我重写onPause添加:

if (dataUpdateReceiver != null) unregisterReceiver(dataUpdateReceiver);

现在我的活动正在监听我的服务说“嘿，去更新你自己。”我可以在Intent中传递数据，而不是更新数据库表，然后返回到我的活动中寻找更改，但由于我希望更改始终存在，因此通过DB传递数据是有意义的。

其他注释中没有提到的另一种方法是使用bindService()从活动绑定到服务，并在ServiceConnection回调中获取服务的实例。如上所述http://developer.android.com/guide/components/bound-services.html