Android语言基础教程（242）Android创建Bound Service实例之使用Messenger类绑定服务显示时间：告别单相思！Messenger让Android服务与界面甜蜜对话

你的Android应用后台服务与前台界面，只差一个Messenger的距离。

还记得那些年我们写过的Android服务吗？有时候像个单相思的暗恋者，界面点了按钮，服务在后台默默工作，却苦于无法把结果实时传递回来。今天，我们就来解锁让服务与界面双向沟通的神技能——Messenger绑定服务。

Messenger就像是Android世界里的专属邮差，在服务和界面之间建立一条通信频道，让它们可以互相发送消息，彻底告别单相思时代！

理解Bound Service：你的应用有个“后台搭档”

在Android应用开发中，我们常常需要让前台界面与后台服务进行通信，比如获取实时数据、执行长时间运行的任务等。

与Started Service（启动式服务）不同，Bound Service更注重组件与服务之间的交互。当一个应用组件通过bindService()方法绑定到服务后，系统会建立一条通信渠道，组件可以直接调用服务中的公共方法。

想象一下，你的Android应用有一个忠实的后台小伙伴，它可以默默地执行任务，只在需要时才与前台界面交流。这就是Bound Service的基本概念。

为什么选择Messenger而不是直接使用AIDL？

看到这里你可能要问：Android进程间通信不是有AIDL吗？为什么还要用Messenger？

简单才是王道！ Messenger本质上是对AIDL的高级封装，它省去了编写AIDL文件的繁琐过程，大大简化了代码结构。使用Messenger，你不需要处理多线程同步问题，因为它会将所有调用自动排队，一次只处理一个请求。

与 AIDL 比较：

当您需要执行 IPC 时，为您的接口使用 Messenger 要比使用 AIDL 实现更加简单，因为 Messenger 会将所有服务调用排入队列，而纯粹的 AIDL 接口会同时向服务发送多个请求，服务随后必须应对多线程处理。

对于大多数应用，服务不需要执行多线程处理，因此使用 Messenger 可让服务一次处理一个调用。如果您的服务必须执行多线程处理，则应使用 AIDL 来定义接口。

一句话总结： 除非你需要服务同时处理多个请求，否则Messenger都是更优选择！

Messenger的工作原理：Android世界的小邮差

Messenger的工作机制就像现实生活中的邮政系统：

Handler = 信件的处理者（收信后决定怎么做）Messenger = 邮差（负责送信）Message = 信件本身（包含具体内容）

查看Messenger源码可以发现，Messenger包含一个IMessenger的成员变量mTarget，通过mTarget可以向Handler传递Message消息。

两个进程间传递的对象为Messenger对象中的mTarget变量，通过mTarget对象可以跨进程发送Message给Handler：

// Messenger.java
public void send(Message message) throws RemoteException {
    mTarget.send(message);
}

实战演练：创建显示时间的Messenger绑定服务

接下来，我们一步步创建一个使用Messenger显示当前时间的Bound Service。这个例子虽然简单，但包含了实现Messenger通信的所有核心概念。

1. 创建服务端（Service）

首先创建我们的服务类，它负责处理获取时间的请求：

public class CurrentTimeService extends Service {
    
    public static final int CURRENT_TIME = 0;
    
    // 创建Handler处理来自客户端的消息
    private class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == CURRENT_TIME) {
                // 创建Time对象并设置为当前时间
                Time time = new Time();
                time.setToNow();
                // 设置时间格式
                String currentTime = time.format("%Y-%m-%d %H:%M:%S");
                
                // 显示Toast提示
                Toast.makeText(CurrentTimeService.this, currentTime, Toast.LENGTH_SHORT).show();
                
                // 如果有回复的Messenger，将时间发送回去
                Messenger clientMessenger = msg.replyTo;
                if (clientMessenger != null) {
                    try {
                        Message replyMsg = Message.obtain(null, CURRENT_TIME);
                        Bundle data = new Bundle();
                        data.putString("time", currentTime);
                        replyMsg.setData(data);
                        clientMessenger.send(replyMsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                super.handleMessage(msg);
            }
        }
    }
    
    // 创建Messenger对象
    private Messenger messenger = new Messenger(new IncomingHandler());
    
    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }
}

这段代码的关键点：

定义了一个消息类型 CURRENT_TIME，用于标识获取时间的请求 IncomingHandler类处理客户端发来的消息在 handleMessage中检查消息类型，如果是 CURRENT_TIME就获取当前时间通过 msg.replyTo获取客户端的Messenger，实现双向通信 onBind方法返回Messenger的Binder对象

2. 创建客户端（Activity）

接下来创建客户端Activity，它负责绑定服务并发送消息：

public class MainActivity extends Activity {
    
    Messenger serviceMessenger;
    boolean bound;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    
    @Override
    protected void onStart() {
        super.onStart();
        
        Button button = (Button) findViewById(R.id.current_time);
        button.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                // 绑定服务
                Intent intent = new Intent(MainActivity.this, CurrentTimeService.class);
                bindService(intent, connection, BIND_AUTO_CREATE);
                
                // 发送获取时间的消息
                if (bound) {
                    Message message = Message.obtain(null, CurrentTimeService.CURRENT_TIME, 0, 0);
                    // 设置回复的Messenger，实现双向通信
                    message.replyTo = clientMessenger;
                    try {
                        serviceMessenger.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }
    
    @Override
    protected void onStop() {
        super.onStop();
        if (bound) {
            bound = false;
            unbindService(connection);
        }
    }
    
    // 创建客户端的Handler和Messenger接收服务端回复
    private Handler clientHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == CurrentTimeService.CURRENT_TIME) {
                String time = msg.getData().getString("time");
                TextView timeTextView = findViewById(R.id.time_textview);
                timeTextView.setText("当前时间：" + time);
            }
        }
    };
    
    private Messenger clientMessenger = new Messenger(clientHandler);
    
    // 服务连接对象
    private ServiceConnection connection = new ServiceConnection() {
        public void onServiceConnected(ComponentName name, IBinder service) {
            serviceMessenger = new Messenger(service);
            bound = true;
        }
        
        public void onServiceDisconnected(ComponentName name) {
            serviceMessenger = null;
            bound = false;
        }
    };
}

客户端代码的关键点：

使用 bindService()方法绑定到服务 ServiceConnection对象处理连接成功和断开的状态连接成功后，通过服务端的Messenger发送消息创建客户端的Messenger并通过 replyTo字段传递给服务端，实现双向通信在客户端Handler中处理服务端返回的消息

3. 布局文件

简单的布局文件，包含一个按钮和一个显示时间的TextView：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical"
    android:padding="16dp">
 
    <Button
        android:id="@+id/current_time"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="获取当前时间"
        android:textSize="18sp" />
 
    <TextView
        android:id="@+id/time_textview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="时间将显示在这里"
        android:textSize="18sp" />
 
</LinearLayout>

4. 在AndroidManifest.xml中声明服务

最后，别忘了在清单文件中声明我们的服务：

<service android:name=".CurrentTimeService" />

如果服务需要被其他应用组件启动，可以添加intent-filter：

<service android:name=".CurrentTimeService">
    <intent-filter>
        <action android:name="com.example.service.CurrentTimeService"/>
        <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
</service>

进阶技巧：实现真正的双向通信

上面的例子展示了基本的双向通信，但在实际开发中，你可能需要更稳定的通信机制。以下是一些进阶技巧：

1. 处理连接状态

在发送消息前，始终检查服务是否已绑定：

private void sendMessageToService() {
    if (!bound || serviceMessenger == null) {
        Toast.makeText(this, "服务未连接", Toast.LENGTH_SHORT).show();
        return;
    }
    
    try {
        Message message = Message.obtain(null, CurrentTimeService.CURRENT_TIME);
        message.replyTo = clientMessenger;
        serviceMessenger.send(message);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}

2. 添加重连机制

当连接意外断开时，尝试重新连接：

private ServiceConnection connection = new ServiceConnection() {
    public void onServiceConnected(ComponentName name, IBinder service) {
        serviceMessenger = new Messenger(service);
        bound = true;
    }
    
    public void onServiceDisconnected(ComponentName name) {
        serviceMessenger = null;
        bound = false;
        // 可以在这里添加重连逻辑
        attemptReconnect();
    }
};
 
private void attemptReconnect() {
    Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            if (!bound) {
                Intent intent = new Intent(MainActivity.this, CurrentTimeService.class);
                bindService(intent, connection, BIND_AUTO_CREATE);
            }
        }
    }, 3000); // 3秒后尝试重连
}

Messenger与其它通信方式对比

Android提供了多种组件间通信的方式，每种都有其适用场景：

1. Intent通信

最简单的通信方式，适合单向数据传输：

// 在Activity中启动Service，并传递数据
Intent intent = new Intent(this, TimerService.class);
intent.putExtra("start_time", System.currentTimeMillis());
startService(intent);
 
// 在Service中获取传递的数据
long startTime = getIntent().getLongExtra("start_time", 0);

优点：简单直接
缺点：只能单向通信，不能频繁通信

2. 广播通信

适合一对多的通信场景：

// 在Activity中发送广播
Intent intent = new Intent("com.example.timer.broadcast");
intent.putExtra("current_time", currentTime);
sendBroadcast(intent);
 
// 在Service中注册广播接收器
private BroadcastReceiver receiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        long currentTime = intent.getLongExtra("current_time", 0);
        // 处理接收到的数据
    }
};

优点：支持一对多通信，组件间解耦
缺点：效率较低，数据量小

3. 共享数据源

通过数据库或文件共享数据：

优点：数据持久化，适合大量数据
缺点：实时性差，需要自己处理同步问题

4. 继承Binder类

适合同一进程内的通信：

优点：性能高，直接调用服务方法
缺点：不能跨进程通信

5. Messenger通信（本文介绍的方法）

优点：可以跨进程，自动处理线程排队，使用相对简单
缺点：数据必须通过Message传递，不能直接调用方法

避坑指南：实际开发中的注意事项

内存泄漏：在Activity销毁时务必解绑服务，否则会导致内存泄漏线程安全：虽然Messenger自动处理了消息排队，但如果在Handler中执行耗时操作，仍然需要自己创建工作者线程跨进程限制：Messenger只能传递支持Parcelable的数据类型，自定义对象需要实现Parcelable接口错误处理：远程调用可能失败，务必添加RemoteException处理生命周期管理：合理处理配置变更（如屏幕旋转）时的服务连接

总结：何时选择Messenger

通过上面的学习，我们可以总结出Messenger的适用场景：

选择Messenger当你的应用需要：

简单的跨进程通信自动的消息排队，避免多线程复杂性双向通信能力相对简单的数据传递

考虑其他方案当你的应用需要：

高性能的同一进程通信（选择Binder）复杂的跨进程接口（选择AIDL）一对多的消息广播（选择Broadcast）简单的单向通信（选择Intent）

Messenger就像是服务和界面间的专属邮差，它可能不是最快的，但绝对是最省心的通信方式之一。通过本文的示例和讲解，相信你已经掌握了使用Messenger实现绑定服务的方法，快去让你的Android应用服务与界面来一场甜蜜对话吧！