Messenger:使用消息的跨进程通信

最新推荐文章于 2024-04-08 03:18:46 发布
最新推荐文章于 2024-04-08 03:18:46 发布
阅读量1k 收藏 2
点赞数
分类专栏： Android 文章标签： service import binding android random null

转载自：http://xwangly.iteye.com/blog/1109424

这篇文章题目其实做好叫：Activity和Service通过Messenger通讯。

 

 

Messenger:信使

官方文档解释：它引用了一个Handler对象，以便others能够向它发送消息(使用mMessenger.send(Message msg)方法)。该类允许跨进程间基于Message的通信(即两个进程间可以通过Message进行通信)，在服务端使用Handler创建一个Messenger，客户端持有这个Messenger就可以与服务端通信了。

以前我们使用Handler+Message的方式进行通信，都是在同一个进程中，从线程持有一个主线程的Handler对象，并向主线程发送消息。

而Android既然可以使用bindler机制进行跨进行通信，所以我们当然可以将Handler与bindler结合起来进行跨进程发送消息。

查看API就可以发现，Messenger就是这种方式的实现。

一般使用方法如下：

１。远程通过

Java代码 
  1. mMessenger = new Messenger(mHandler)  
mMessenger = new Messenger(mHandler)

创建一个信使对象

２。客户端使用bindlerService请求连接远程

３。远程onBind方法返回一个bindler

Java代码 
  1. return mMessenger.getBinder();  
return mMessenger.getBinder();

4.客户端使用远程返回的bindler得到一个信使（即得到远程信使）

Java代码 
  1. public void onServiceConnected(ComponentName name, IBinder service) { 
  2.     rMessenger = new Messenger(service); 
  3. 　　　　　...... 
  4. }  
			public void onServiceConnected(ComponentName name, IBinder service) {
				rMessenger = new Messenger(service);
　　　　　　　　......
			}

这里虽然是new了一个Messenger，但我们查看它的实现

Java代码 
  1. /**
  2. * Create a Messenger from a raw IBinder, which had previously been
  3. * retrieved with {@link #getBinder}.
  4. *
  5. * @param target The IBinder this Messenger should communicate with.
  6. */ 
  7. public Messenger(IBinder target) { 
  8.     mTarget = IMessenger.Stub.asInterface(target); 
  9. }  
    /**
     * Create a Messenger from a raw IBinder, which had previously been
     * retrieved with {@link #getBinder}.
     * 
     * @param target The IBinder this Messenger should communicate with.
     */
    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }

发现它的mTarget是通过Aidl得到的，实际上就是远程创建的那个。

５。客户端可以使用这个远程信使对象向远程发送消息：rMessenger.send(msg);

这样远程服务端的Handler对象就能收到消息了，然后可以在其handlerMessage(Message msg)方法中进行处理。（该Handler对象就是第一步服务端创建Messenger时使用的参数mHandler）.

经过这５个步骤貌似只有客户端向服务端发送消息，这样的消息传递是单向的，那么如何实现双向传递呢？

首先需要在第５步稍加修改，在send(msg)前通过msm.replyTo = mMessenger将自己的信使设置到消息中，这样服务端接收到消息时同时也得到了客户端的信使对象了，然后服务端可以通过

Java代码 
  1. //得到客户端的信使对象，并向它发送消息 
  2. cMessenger = msg.replyTo; 
  3. cMessenger.send(message);  
//得到客户端的信使对象，并向它发送消息
cMessenger = msg.replyTo;
cMessenger.send(message);

即完成了从服务端向客户端发送消息的功能，这样客服端可以在自己的Handler对象的handlerMessage方法中接收服务端发送来的message进行处理。

双向通信宣告完成。

下面改写ApiDemos工程实现Messenger通信

MessengerService.java

Java代码 
  1. package com.xwangly.apidemo.app; 
  2.  
  3. import java.util.Random; 
  4.  
  5. import android.app.Service; 
  6. import android.content.Intent; 
  7. import android.os.Handler; 
  8. import android.os.IBinder; 
  9. import android.os.Message; 
  10. import android.os.Messenger; 
  11. import android.os.RemoteException; 
  12. import android.util.Log; 
  13.  
  14. public class MessengerService extends Service { 
  15.     private String TAG = "MessengerService"; 
  16.  
  17.     @Override 
  18.     public void onDestroy() { 
  19.         // TODO Auto-generated method stub 
  20.         Log.i(TAG, "onDestroy"); 
  21.         cMessenger = null; 
  22.         super.onDestroy(); 
  23.     } 
  24.  
  25.     @Override 
  26.     public boolean onUnbind(Intent intent) { 
  27.         // TODO Auto-generated method stub 
  28.         Log.i(TAG, "onUnbind"); 
  29.         return super.onUnbind(intent); 
  30.     } 
  31.  
  32.     static final int MSG_REGISTER_CLIENT = 1; 
  33.     static final int MSG_UNREGISTER_CLIENT = 2; 
  34.     static final int MSG_SET_VALUE = 3; 
  35.  
  36.     private Random random = new Random(); 
  37.  
  38.     private Handler mHandler = new Handler() { 
  39.  
  40.         @Override 
  41.         public void handleMessage(Message msg) { 
  42.             // TODO Auto-generated method stub 
  43.             Log.i(TAG, "handleMessage"); 
  44.             switch (msg.what) { 
  45.             case MSG_SET_VALUE: 
  46.                 try { 
  47.                     Message message = Message.obtain(null, 
  48.                             MessengerService.MSG_SET_VALUE); 
  49.                     message.arg1 = random.nextInt(100); 
  50.                      
  51.                     //得到客户端的信使对象，并向它发送消息 
  52.                     cMessenger = msg.replyTo; 
  53.                     cMessenger.send(message); 
  54.                 } catch (RemoteException e) { 
  55.                     // TODO Auto-generated catch block 
  56.                     e.printStackTrace(); 
  57.                 } 
  58.                 break; 
  59.             default: 
  60.                 super.handleMessage(msg); 
  61.             } 
  62.  
  63.         } 
  64.     }; 
  65.  
  66.     /**
  67.      * 自己的信使对象
  68.      */ 
  69.     private Messenger mMessenger = new Messenger(mHandler); 
  70.  
  71.     /**
  72.      * 客户的信使
  73.      */ 
  74.     private Messenger cMessenger; 
  75.  
  76.     @Override 
  77.     public IBinder onBind(Intent intent) { 
  78.         // TODO Auto-generated method stub 
  79.         Log.i(TAG, "onBind"); 
  80.         //返回自己信使的bindler,以供客户端通过这个bindler得到服务端的信使对象（通过new Messenger(bindler)） 
  81.         return mMessenger.getBinder(); 
  82.     } 
  83.  
  84.     @Override 
  85.     public void onRebind(Intent intent) { 
  86.         // TODO Auto-generated method stub 
  87.         Log.i(TAG, "onRebind"); 
  88.  
  89.     } 
  90.  
  91. }  
package com.xwangly.apidemo.app;

import java.util.Random;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

public class MessengerService extends Service {
	private String TAG = "MessengerService";

	@Override
	public void onDestroy() {
		// TODO Auto-generated method stub
		Log.i(TAG, "onDestroy");
		cMessenger = null;
		super.onDestroy();
	}

	@Override
	public boolean onUnbind(Intent intent) {
		// TODO Auto-generated method stub
		Log.i(TAG, "onUnbind");
		return super.onUnbind(intent);
	}

	static final int MSG_REGISTER_CLIENT = 1;
	static final int MSG_UNREGISTER_CLIENT = 2;
	static final int MSG_SET_VALUE = 3;

	private Random random = new Random();

	private Handler mHandler = new Handler() {

		@Override
		public void handleMessage(Message msg) {
			// TODO Auto-generated method stub
			Log.i(TAG, "handleMessage");
			switch (msg.what) {
			case MSG_SET_VALUE:
				try {
					Message message = Message.obtain(null,
							MessengerService.MSG_SET_VALUE);
					message.arg1 = random.nextInt(100);
					
					//得到客户端的信使对象，并向它发送消息
					cMessenger = msg.replyTo;
					cMessenger.send(message);
				} catch (RemoteException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				break;
			default:
				super.handleMessage(msg);
			}

		}
	};

	/**
	 * 自己的信使对象
	 */
	private Messenger mMessenger = new Messenger(mHandler);

	/**
	 * 客户的信使
	 */
	private Messenger cMessenger;

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		Log.i(TAG, "onBind");
		//返回自己信使的bindler,以供客户端通过这个bindler得到服务端的信使对象（通过new Messenger(bindler)）
		return mMessenger.getBinder();
	}

	@Override
	public void onRebind(Intent intent) {
		// TODO Auto-generated method stub
		Log.i(TAG, "onRebind");

	}

}

MessengerServiceActivities.java

Java代码 
  1. package com.xwangly.apidemo.app; 
  2.  
  3. import com.xwangly.apidemo.R; 
  4.  
  5. import android.app.Activity; 
  6. import android.content.ComponentName; 
  7. import android.content.Intent; 
  8. import android.content.ServiceConnection; 
  9. import android.os.Bundle; 
  10. import android.os.Handler; 
  11. import android.os.IBinder; 
  12. import android.os.Message; 
  13. import android.os.Messenger; 
  14. import android.os.RemoteException; 
  15. import android.util.Log; 
  16. import android.view.View; 
  17. import android.widget.TextView; 
  18.  
  19. public class MessengerServiceActivities { 
  20.     public static class Binding extends Activity implements 
  21.             View.OnClickListener { 
  22.         private String TAG = "Binding"; 
  23.  
  24.         TextView mCallbackText; 
  25.  
  26.         private boolean isBound; 
  27.  
  28.         @Override 
  29.         protected void onCreate(Bundle savedInstanceState) { 
  30.             // TODO Auto-generated method stub 
  31.             super.onCreate(savedInstanceState); 
  32.             setContentView(R.layout.messenger_service_binding); 
  33.             findViewById(R.id.bind).setOnClickListener(this); 
  34.             findViewById(R.id.unbind).setOnClickListener(this); 
  35.  
  36.             mCallbackText = (TextView) findViewById(R.id.callback); 
  37.             mCallbackText.setText("Not attached."); 
  38.  
  39.         } 
  40.  
  41.         private Handler mHandler = new Handler() { 
  42.             @Override 
  43.             public void handleMessage(Message msg) { 
  44.                 Log.i(TAG, "handleMessage"); 
  45.                 switch (msg.what) { 
  46.                 case MessengerService.MSG_SET_VALUE: 
  47.                     mCallbackText.setText("Received from service: " + msg.arg1); 
  48.                     break; 
  49.                 default: 
  50.                     super.handleMessage(msg); 
  51.                 } 
  52.             } 
  53.         }; 
  54.  
  55.         /**
  56.          * 自己的信使
  57.          */ 
  58.         private Messenger mMessenger; 
  59.          
  60.         /**
  61.          * 远程服务的信使
  62.          */ 
  63.         private Messenger rMessenger; 
  64.          
  65.         private ServiceConnection connection = new ServiceConnection() { 
  66.  
  67.             public void onServiceConnected(ComponentName name, IBinder service) { 
  68.                 // TODO Auto-generated method stub 
  69.                 Log.i(TAG, "onServiceConnected"); 
  70.                 rMessenger = new Messenger(service); 
  71.                 mMessenger = new Messenger(mHandler); 
  72.                  
  73.                 sendMessage(); 
  74.             } 
  75.  
  76.  
  77.             public void onServiceDisconnected(ComponentName name) { 
  78.                 // TODO Auto-generated method stub 
  79.                 rMessenger = null; 
  80.             } 
  81.         }; 
  82.  
  83.         public void onClick(View v) { 
  84.             // TODO Auto-generated method stub 
  85.             Intent intent = new Intent( 
  86.                     "com.xwangly.apidemo.app.messenger_service"); 
  87.             switch (v.getId()) { 
  88.             case R.id.bind: 
  89.                 if (!isBound) { 
  90.                     isBound = bindService(intent, connection, BIND_AUTO_CREATE); 
  91.                     //isBound = true; 
  92.                 }else { 
  93.                     sendMessage(); 
  94.                 } 
  95.                 break; 
  96.             case R.id.unbind: 
  97.                 if (isBound) { 
  98.                     unbindService(connection); 
  99.                     isBound = false; 
  100.                 } 
  101.                 break; 
  102.             default: 
  103.                 break; 
  104.             } 
  105.         } 
  106.          
  107.         /**
  108.          * 使用服务端的信使向它发送一个消息。
  109.          */ 
  110.         private void sendMessage() { 
  111.             // TODO Auto-generated method stub 
  112.             Message message = Message.obtain(null, MessengerService.MSG_SET_VALUE); 
  113.             message.replyTo = mMessenger; 
  114.             try { 
  115.                 rMessenger.send(message); 
  116.             } catch (RemoteException e) { 
  117.                 // TODO Auto-generated catch block 
  118.                 e.printStackTrace(); 
  119.             } 
  120.         } 
  121.  
  122.     } 
  123.  
  124. }  
package com.xwangly.apidemo.app;

import com.xwangly.apidemo.R;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
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 android.view.View;
import android.widget.TextView;

public class MessengerServiceActivities {
	public static class Binding extends Activity implements
			View.OnClickListener {
		private String TAG = "Binding";

		TextView mCallbackText;

		private boolean isBound;

		@Override
		protected void onCreate(Bundle savedInstanceState) {
			// TODO Auto-generated method stub
			super.onCreate(savedInstanceState);
			setContentView(R.layout.messenger_service_binding);
			findViewById(R.id.bind).setOnClickListener(this);
			findViewById(R.id.unbind).setOnClickListener(this);

			mCallbackText = (TextView) findViewById(R.id.callback);
			mCallbackText.setText("Not attached.");

		}

		private Handler mHandler = new Handler() {
			@Override
			public void handleMessage(Message msg) {
				Log.i(TAG, "handleMessage");
				switch (msg.what) {
				case MessengerService.MSG_SET_VALUE:
					mCallbackText.setText("Received from service: " + msg.arg1);
					break;
				default:
					super.handleMessage(msg);
				}
			}
		};

		/**
		 * 自己的信使
		 */
		private Messenger mMessenger;
		
		/**
		 * 远程服务的信使
		 */
		private Messenger rMessenger;
		
		private ServiceConnection connection = new ServiceConnection() {

			public void onServiceConnected(ComponentName name, IBinder service) {
				// TODO Auto-generated method stub
				Log.i(TAG, "onServiceConnected");
				rMessenger = new Messenger(service);
				mMessenger = new Messenger(mHandler);
				
				sendMessage();
			}


			public void onServiceDisconnected(ComponentName name) {
				// TODO Auto-generated method stub
				rMessenger = null;
			}
		};

		public void onClick(View v) {
			// TODO Auto-generated method stub
			Intent intent = new Intent(
					"com.xwangly.apidemo.app.messenger_service");
			switch (v.getId()) {
			case R.id.bind:
				if (!isBound) {
					isBound = bindService(intent, connection, BIND_AUTO_CREATE);
					//isBound = true;
				}else {
					sendMessage();
				}
				break;
			case R.id.unbind:
				if (isBound) {
					unbindService(connection);
					isBound = false;
				}
				break;
			default:
				break;
			}
		}
		
		/**
		 * 使用服务端的信使向它发送一个消息。
		 */
		private void sendMessage() {
			// TODO Auto-generated method stub
			Message message = Message.obtain(null, MessengerService.MSG_SET_VALUE);
			message.replyTo = mMessenger;
			try {
				rMessenger.send(message);
			} catch (RemoteException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

}

AndroidManifest.xml相关配置如下：

Xml代码 
  1. <service android:name=".app.MessengerService" > 
  2.     <intent-filter> 
  3.         <action android:name="com.xwangly.apidemo.app.messenger_service" /> 
  4.     </intent-filter> 
  5. </service> 
  6.       <activity android:name=".app.MessengerServiceActivities$Binding" 
  7.               android:label="@string/activity_messenger_service_binding" 
  8.               android:launchMode="singleTop"> 
  9.           <intent-filter> 
  10.               <action android:name="android.intent.action.MAIN" /> 
  11.               <category android:name="android.intent.category.LAUNCHER" /> 
  12.           </intent-filter> 
  13.       </activity> 

 

win2k3net
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android IPC机制利用Messenger实现跨进程通信
01-20
本文将重点探讨如何利用Messenger实现Android的跨进程通信。Messenger是一种轻量级的IPC机制，它基于Handler和Message，允许服务端和客户端之间进行一对一的消息传递，适合于简单的双向通信场景。 首先，让我们了解...
Android-Handler源码解析-Message
11-15 372
传输，所以我们接下来看下它的具体实现。方法，我们接下来看下它们的实现。，所以我们接下来看下它是如何被。，所以我们接下来看下它是如何被。对象，之后可以设置它的。方法（绑定App）内。
跨进程 使用Messenger(信使) 实现双向通信。
qq_34784151的博客
07-25 177
关键核心在于 客户端和服务端 双方持有一个对方发过来的Messenger , 后面利用Messenger发送Message实现双向通信，其实Messenger底层也是用Binder通信的。服务端：MessengerService。客户端:One_Fragment。
Android进程间通信 - Messenger的使用和理解
学习，思考，输出
07-18 7367
Messenger简介 Messenger是基于Message对象进行跨进程通信的，类似于Handler发送消息实现线程间通信一样的用法。 Messenger使用 下面写个客户端跨进程发送消息到服务端，服务端接受到立即回复的例子。 服务端 实现流程 首先创建一个Handler对象 接着创建一个Messenger对象，并把Handler对象以形参传入Messenger中 最后通...
Messenger 双向通讯实例
wsyizmao的博客
01-22 944
首先，先上一个messenger的工作原理图 从图片可以看出，messenger的通讯是这样的 1，在服务端，我们要构造一个messenger用来接收信息，而这个messenger发送消息的方向是固定的，只能从client发送到service端 2，在客户端，我们要想接收到客户端会传过来的消息，同样也要构造一个messenger来接收消息 下面来看实例， 首先是服务端的代
Android跨进程通信Binder、Messenger、AIDL
08-28
Android提供了多种跨进程通信的方式，其中Binder、Messenger和AIDL是最常见且重要的三种。下面将详细阐述这三种机制的工作原理、使用场景以及如何实现。 **Binder** Binder是Android系统的核心组件，是Android IPC...
使用Messenger实现跨进程通信(IPC)
11-02
代码中包含两个应用程序，两者之间通信采用Messenger信使 使用方法：将下载下来的图片后缀名改为.zip，再解压即可得到源代码
Messenger跨进程通信.zip
04-05
本示例是一个关于如何使用Messenger进行跨进程通信的实战演示，包含了客户端和服务端两个模块。 首先，我们来看一下`aidl`，它是Android Interface Definition Language的缩写，用于定义进程间通信的接口。在服务端...
Android Messenger(跨进程)
zenmela2011的专栏
10-17 3111
1.Messager 我们知道，Service通过IBinder可以实现同一应用内同一进程的通信，而不同进程间的通信，最简单的方式就是使用Messenger服务提供通信接口。利用Messager，我们无需使用AIDL便可执行进程间通信 (IPC)。 首先看一下Messager的定义：允许实现基于消息的进程间通信的方式。 以下是Messenger使用的主要步骤： ①服务Service实现一个Handler，由其接收来自客户端的每个调用的回调； ②Handler用于创建Messenger对象（对Handler的
android开发笔记之进程通信Messenger
hfreeman2008的专栏
08-15 1087
写在前面的话前面我写了一篇文章—android学习之remote service 的aidl详解，讲到跨进程多线程通信，我们使用aidl技术来实现。 但是平时我们大部分的应用可能只要要求跨进程通信，而不需要使用多线程，那么这时候，Messenger就是我们的一个非常好的选择。比起aidl来，Messenger实现更简单，并且不需要考虑线程安全的问题。我参考了文章： Android 基于Messa
使用Messenger 实现跨进程双向通信
xiaowang_lj的博客
02-19 1403
Messenger ：信使 1.客户端使用Activity private Messenger messenger;//信使 //处理服务端发来的消息 Handler handler = new Handler(){ @Override public void handleMessage(@NonNull Message msg) { super.handleMessage(msg); switch (msg.wh
android Messenger跨进程通信
u011324501的专栏
09-26 363
1、android messager可以实现不同进程之间数据的传递。通过点击进去看messenger类可以看到，我们可以创建一个service用于处理和客户端的连接请求，然后通过handler中创建一个messener对象，实现对service数据传递。/** * Create a new Messenger pointing to the given Handler. Any Mes
Android 进程与进程之间的通信--Messager 详细教程，两个app实现
afufufufu的博客
07-19 979
Messenger是一种轻量级的IPC方案,它的底层实现其实就是AIDL.跨进程通信使用Messenger时,Messenger会将所有服务调用加入队列,然后服务端那边一次处理一个调用,不会存在同时调用的情况.而AIDL则可能是多个调用同时执行,必须处理多线程问。
Android 基于Message的进程间通信 Messenger完全解析
最新发布
erhtre的博客
04-08 872
如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。欢迎大家一起交流讨论啊~《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-5ehLndtD-1712517484718)][外链图片转存中…(img-YO8gPvfH-1712517484719)][外链图片转存中…(img-ryK6eTbM-1712517484719)]
Android跨进程通信（三）：Messenger使用教程
PYJTLK的博客
02-01 2935
前面的文章讲述了如何通过AIDL来实现Android的跨进程通信，本篇文章来讲解如何使用Messenger来实现同样的功能。 介绍 Messenger是AIDL的封装，进程可以通过Messenger来实现通信。直接编写AIDL相当复杂，而Messenger大大简化了编写流程。 下面先介绍Messenger的基本使用方法。 准备工作 创建Messenger对象需要传入一个Handler，在这个Handler里对接收到的数据进行处理。 Handler handler = new Handler(){ @Ove
Messenger
时代我西的博客
07-10 262
Messenger Messenger是一种轻量级的IPC方案，底层实现是AIDL。它对AIDL进行了封装，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步的问题，因为不存在并发执行的情形。 服务端进程：需要创建一个Service处理服务端的连接请求，同时创建一个Handler并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层的Binder即可。 客户端进程：首先需要绑定服务端的Service，绑定成功后用服务端返回的I
Android Messenger 原理分析
TMS320VC5509的博客
04-17 319
一、个人理解 使用场景：用于进程间通信，当进程间通信只需要收发消息，没有其他复杂的逻辑的时候。 实现原理：AIDL +Handler。内部定义并实现了只有一个接口的AIDL文件（IMessenger.aidl）；Handler存在是为了实现反向通信，代替AIDL中定义的回调接口。 特点：与AIDL相比，用户无需自己定义AIDL接口，实现进程间双向通信时也无需定义AIDL回调。但Messenger通信接口只有一个。 一、原理分析 Messenger有两个构造函数： ...
SpringBoot系列之邮件发送姿势介绍
小灰灰blog的专栏
08-09 814
SpringBoot系列之邮件发送姿势介绍 邮件发送，在实际的项目开发中，可能用的不是特别多，如果没有特定的需求，相信也没有多少小伙伴会特意的去关注，那么如果现在我们希望针对项目做一个异常的报警系统，当出现异常的时候，可以向指定的小伙伴发送邮件提醒，那么让我们来实现这个功能，可以怎么办呢？ 这里介绍一下如何使用SpringBoot封装好的MailSender来实现邮件发送 I. 项目环境 1. 项目依赖 本项目借助SpringBoot 2.2.1.RELEASE + maven 3.5.3 + ID..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值