Android中的四大组件Service

最新推荐文章于 2024-04-06 12:09:56 发布
最新推荐文章于 2024-04-06 12:09:56 发布
阅读量341 收藏
点赞数 1
分类专栏： Android 文章标签： 四大组件 Service Android

前言


服务（Service）是Android系统中的四大组件之一。服务主要用于两个目的：后台运行和跨进程访问。通过启动


一个服务，可以在不显示界面的前提下在后台运行指定的任务，这样可以不影响用户做其他事情。通过AIDL服务可以


实现不同进程之间的通信，这也是服务的重要用途之一。


Service基础


Service并没有实际界面，而是一直在android系统的后台运行。一般使用Service为应用程序提供一些服务，或不


需要界面的功能，例如下载文件、播放音频等。


如何创建与配置Service


在日常开发中Service的创建与配置可以按照以下两个步骤进行：


（1）定义一个继承Service的子类。


（2）在AndroidManifest.xml文件中配置该Service。


Service与Activity一样，也有一个启动到销毁的过程，不过这个过程Service要比Activity简单多了。一个服务实际


上是一个继承自android.app.Service的类。查看Service源码，可以看出Service实际上是一个抽象类，在这个抽象类


中有一个抽象方法onBind，因此我们在继承一个Service类时，必须要实现这个方法。


[java] view plain copy
print ?
  1. public abstract class Service extends ContextWrapper implements ComponentCallbacks2 {  
  2.     .......  
  3.     public abstract IBinder onBind(Intent intent);  
  4.     .......  
  5. }  
public abstract class Service extends ContextWrapper implements ComponentCallbacks2 {
	.......
	public abstract IBinder onBind(Intent intent);
	.......
}


下面类定义了一个Service组件。


[java] view plain copy
print ?
  1. public class MyFirstService extends Service{  
  2.   
  3.     public static final String TAG="MyFirstService";  
  4.       
  5.     @Override  
  6.     public IBinder onBind(Intent intent) {  
  7.         return null;  
  8.     }  
  9.       
  10.     @Override  
  11.     public void onCreate() {  
  12.         super.onCreate();  
  13.         Log.e(TAG, "--------onCreate--------");  
  14.     }  
  15.       
  16.     @Override  
  17.     public int onStartCommand(Intent intent, int flags, int startId) {  
  18.         Log.e(TAG, "--------onStartCommand--------");  
  19.         return super.onStartCommand(intent, flags, startId);  
  20.     }  
  21.       
  22.     @Override  
  23.     public void onDestroy() {  
  24.         super.onDestroy();  
  25.         Log.e(TAG, "--------onDestroy--------");  
  26.     }  
  27.   
  28. }  
public class MyFirstService extends Service{

	public static final String TAG="MyFirstService";
	
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
	
	@Override
	public void onCreate() {
		super.onCreate();
		Log.e(TAG, "--------onCreate--------");
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.e(TAG, "--------onStartCommand--------");
		return super.onStartCommand(intent, flags, startId);
	}
	
	@Override
	public void onDestroy() {
		super.onDestroy();
		Log.e(TAG, "--------onDestroy--------");
	}

}


以上代码完成了创建Service，接下来需要在AndroidMainfest.xml文件中进行配置该Service，以下配置代码展示了


如何配置Service:


[html] view plain copy
print ?
  1. <application  
  2.         android:allowBackup="true"  
  3.         android:icon="@drawable/ic_launcher"  
  4.         android:label="@string/app_name"  
  5.         android:theme="@style/AppTheme" >  
  6.         <activity  
  7.             android:name=".MainActivity"  
  8.             android:label="@string/app_name" >  
  9.             <intent-filter>  
  10.                 <action android:name="android.intent.action.MAIN" />  
  11.   
  12.                 <category android:name="android.intent.category.LAUNCHER" />  
  13.             </intent-filter>  
  14.         </activity>  
  15.   
  16.         <service android:name="com.example.servicetest.startservice.MyFirstService" >  
  17.         </service>  
  18.     </application>  
<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service android:name="com.example.servicetest.startservice.MyFirstService" >
        </service>
    </application>


到了这一步我们的Service组件已经创建完毕。接着我们可以启动Service了，在Android系统中启动Service有两种


方式，分别是startService和bindService。

startService使用


下面程序通过两个按钮进行启动与停止Service，演示Service通过startService从创建到销毁整个过程。

[java] view plain copy
print ?
  1. public class MyFirstService extends Service{  
  2.   
  3.     public static final String TAG="MyFirstService";  
  4.       
  5.     @Override  
  6.     public IBinder onBind(Intent intent) {  
  7.         return null;  
  8.     }  
  9.       
  10.     @Override  
  11.     public void onCreate() {  
  12.         super.onCreate();  
  13.         Log.e(TAG, "--------onCreate--------");  
  14.     }  
  15.       
  16.     @Override  
  17.     public int onStartCommand(Intent intent, int flags, int startId) {  
  18.         Log.e(TAG, "--------onStartCommand--------");  
  19.         return super.onStartCommand(intent, flags, startId);  
  20.     }  
  21.       
  22.     @Override  
  23.     public void onDestroy() {  
  24.         super.onDestroy();  
  25.         Log.e(TAG, "--------onDestroy--------");  
  26.     }  
  27.   
  28. }  
public class MyFirstService extends Service{

	public static final String TAG="MyFirstService";
	
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
	
	@Override
	public void onCreate() {
		super.onCreate();
		Log.e(TAG, "--------onCreate--------");
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.e(TAG, "--------onStartCommand--------");
		return super.onStartCommand(intent, flags, startId);
	}
	
	@Override
	public void onDestroy() {
		super.onDestroy();
		Log.e(TAG, "--------onDestroy--------");
	}

}


两个按钮的点击事件：


[java] view plain copy
print ?
  1. @Override  
  2. public void onClick(View v) {  
  3.     switch (v.getId()) {  
  4.     case R.id.btn_startService:// startService  
  5.         startService(serviceIntent);  
  6.         break;  
  7.     case R.id.btn_stoptService:// stopService  
  8.         stopService(serviceIntent);  
  9.         break;  
  10.     default:  
  11.         break;  
  12.       }  
  13. }  
@Override
public void onClick(View v) {
	switch (v.getId()) {
	case R.id.btn_startService:// startService
		startService(serviceIntent);
		break;
	case R.id.btn_stoptService:// stopService
		stopService(serviceIntent);
		break;
	default:
		break;
      }
}




以上是我们创建的Service组件，接下来对Service进行操作。


（1）当单击一次启动（startService）按钮时：






（2）当服务被启动后单击一次停止（stopService）按钮时：



从上面可以看出Service从创建到销毁分别经历了 onCreate---->onStartCommand---->onDestroy


（3）当我们重复开启Service时：






从上图可以看出，每当Service被创建时回调onCreate方法，每次Service被启动时都会回调onStartCommand方


法，多次启动一个已有的Service组件将不会再回调onCreate方法，但每次启动时都会回调onStartCommand方法。


其中，当我按下home键时，并没有回调onDestroy方法，也就是说此Service并没有随着Android系统的关闭而关


闭。




bindService的使用


使用startService方法启动服务，当程序被强制退出时，并且没有调用stopService来停止服务，Service会保持在


后台一直运行，直到Android系统关闭或调用stopService方法后才会停止。如果我们希望在启动服务的Activity关闭后


服务自动关闭，这就需要将Activity和Service进行绑定。



通过bindService方法可以将Activity和Service绑定。bindService方法的定义如下：


[java] view plain copy
print ?
  1. public boolean bindService(Intent service, ServiceConnection conn,int flags)   
public boolean bindService(Intent service, ServiceConnection conn,int flags)


该方法的三个参数含义如下：


（1）service：该参数通过Intent指定要启动的Service。


（2）conn：该参数的类型是ServiceConnection，负责连接Intent对象指定的服务。当访问者与Service之间连接


成功时将回调ServiceConnecttion对象的onServiceConnected(ComponentName name,IBinder service)方法；当


Service所在的宿主进程由于异常终止或由于其他原因终止，导致该Service与访问者之间断开连接时回调


ServiceConnection对象的onServiceDisconnected(ComponentName name)方法。


（3）flags：该参数是一个标志位，一般设为Context.BIND_AUTO_CREATE。


以下创建了一个继承Service的类，在该类中增加了几个与绑定相关的事件方法:


[java] view plain copy
print ?
  1. public class MyFirstService extends Service{  
  2.       
  3.     private String info;  
  4.     private MyBinder myBinder=new MyBinder();  
  5.   
  6.     public static final String TAG="MyFirstService";  
  7.   
  8.     /** 
  9.      * 重新绑定时调用该方法 
  10.      */  
  11.     @Override  
  12.     public void onRebind(Intent intent) {  
  13.         super.onRebind(intent);  
  14.     }  
  15.       
  16.     /** 
  17.      * 解除绑定时调用该方法 
  18.      */  
  19.     @Override  
  20.     public boolean onUnbind(Intent intent) {  
  21.         return super.onUnbind(intent);  
  22.     }  
  23.       
  24.     @Override  
  25.     public IBinder onBind(Intent intent) {  
  26.         return myBinder;  
  27.     }  
  28.       
  29.     @Override  
  30.     public void onCreate() {  
  31.         super.onCreate();  
  32.         Log.e(TAG, "--------onCreate--------");  
  33.         info="onCreate";  
  34.     }  
  35.       
  36.     @Override  
  37.     public int onStartCommand(Intent intent, int flags, int startId) {  
  38.         Log.e(TAG, "--------onStartCommand--------");  
  39.         return super.onStartCommand(intent, flags, startId);  
  40.     }  
  41.       
  42.     @Override  
  43.     public void onDestroy() {  
  44.         super.onDestroy();  
  45.         Log.e(TAG, "--------onDestroy--------");  
  46.     }  
  47.       
  48.     public class MyBinder extends Binder{  
  49.         public String getInfo(){  
  50.             return info;  
  51.         }  
  52.     }  
  53.   
  54. }  
public class MyFirstService extends Service{
	
	private String info;
	private MyBinder myBinder=new MyBinder();

	public static final String TAG="MyFirstService";

	/**
	 * 重新绑定时调用该方法
	 */
	@Override
	public void onRebind(Intent intent) {
		super.onRebind(intent);
	}
	
	/**
	 * 解除绑定时调用该方法
	 */
	@Override
	public boolean onUnbind(Intent intent) {
		return super.onUnbind(intent);
	}
	
	@Override
	public IBinder onBind(Intent intent) {
		return myBinder;
	}
	
	@Override
	public void onCreate() {
		super.onCreate();
		Log.e(TAG, "--------onCreate--------");
		info="onCreate";
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.e(TAG, "--------onStartCommand--------");
		return super.onStartCommand(intent, flags, startId);
	}
	
	@Override
	public void onDestroy() {
		super.onDestroy();
		Log.e(TAG, "--------onDestroy--------");
	}
	
	public class MyBinder extends Binder{
		public String getInfo(){
			return info;
		}
	}

}


[java] view plain copy
print ?
  1. public class MainActivity extends Activity implements OnClickListener {  
  2.   
  3.     private Button btn_startService;  
  4.     private Button btn_stopService;  
  5.     private Button btn_bindService;  
  6.     private Button btn_unbindService;  
  7.     private Button btn_getinfo;  
  8.   
  9.     private Intent serviceIntent;  
  10.   
  11.     private MyFirstService.MyBinder myBinder;  
  12.   
  13.     private ServiceConnection conn = new ServiceConnection() {  
  14.   
  15.         @Override  
  16.         public void onServiceDisconnected(ComponentName name) {  
  17.             Log.e(MyFirstService.TAG, "------onServiceDisconnected---------");  
  18.         }  
  19.   
  20.         @Override  
  21.         public void onServiceConnected(ComponentName name, IBinder service) {  
  22.             Log.e(MyFirstService.TAG, "------onServiceConnected---------");  
  23.             myBinder = (MyFirstService.MyBinder) service;  
  24.         }  
  25.     };  
  26.   
  27.     @Override  
  28.     protected void onCreate(Bundle savedInstanceState) {  
  29.         super.onCreate(savedInstanceState);  
  30.         setContentView(R.layout.activity_main);  
  31.         initData();  
  32.         initView();  
  33.         initEvent();  
  34.     }  
  35.   
  36.     private void initData() {  
  37.         serviceIntent = new Intent(this, MyFirstService.class);  
  38.     }  
  39.   
  40.     private void initView() {  
  41.         btn_startService = (Button) this.findViewById(R.id.btn_startService);  
  42.         btn_stopService = (Button) this.findViewById(R.id.btn_stoptService);  
  43.         btn_bindService = (Button) this.findViewById(R.id.btn_bindService);  
  44.         btn_unbindService = (Button) this.findViewById(R.id.btn_unbindService);  
  45.         btn_getinfo = (Button) this.findViewById(R.id.btn_getinfo);  
  46.     }  
  47.   
  48.     private void initEvent() {  
  49.         btn_startService.setOnClickListener(this);  
  50.         btn_stopService.setOnClickListener(this);  
  51.         btn_bindService.setOnClickListener(this);  
  52.         btn_unbindService.setOnClickListener(this);  
  53.         btn_getinfo.setOnClickListener(this);  
  54.     }  
  55.   
  56.     @Override  
  57.     public void onClick(View v) {  
  58.         switch (v.getId()) {  
  59.         case R.id.btn_startService:// startService  
  60.             startService(serviceIntent);  
  61.             break;  
  62.         case R.id.btn_stoptService:// stopService  
  63.             stopService(serviceIntent);  
  64.             break;  
  65.         case R.id.btn_bindService:// bindService  
  66.             bindService(serviceIntent, conn, Service.BIND_AUTO_CREATE);  
  67.             break;  
  68.         case R.id.btn_unbindService:// unbindService  
  69.             unbindService(conn);  
  70.             break;  
  71.         case R.id.btn_getinfo:// 获取数据  
  72.             Toast.makeText(MainActivity.this, myBinder.getInfo(),  
  73.                     Toast.LENGTH_SHORT).show();  
  74.             break;  
  75.         default:  
  76.             break;  
  77.         }  
  78.     }  
  79.   
  80. }  
public class MainActivity extends Activity implements OnClickListener {

	private Button btn_startService;
	private Button btn_stopService;
	private Button btn_bindService;
	private Button btn_unbindService;
	private Button btn_getinfo;

	private Intent serviceIntent;

	private MyFirstService.MyBinder myBinder;

	private ServiceConnection conn = new ServiceConnection() {

		@Override
		public void onServiceDisconnected(ComponentName name) {
			Log.e(MyFirstService.TAG, "------onServiceDisconnected---------");
		}

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			Log.e(MyFirstService.TAG, "------onServiceConnected---------");
			myBinder = (MyFirstService.MyBinder) service;
		}
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		initData();
		initView();
		initEvent();
	}

	private void initData() {
		serviceIntent = new Intent(this, MyFirstService.class);
	}

	private void initView() {
		btn_startService = (Button) this.findViewById(R.id.btn_startService);
		btn_stopService = (Button) this.findViewById(R.id.btn_stoptService);
		btn_bindService = (Button) this.findViewById(R.id.btn_bindService);
		btn_unbindService = (Button) this.findViewById(R.id.btn_unbindService);
		btn_getinfo = (Button) this.findViewById(R.id.btn_getinfo);
	}

	private void initEvent() {
		btn_startService.setOnClickListener(this);
		btn_stopService.setOnClickListener(this);
		btn_bindService.setOnClickListener(this);
		btn_unbindService.setOnClickListener(this);
		btn_getinfo.setOnClickListener(this);
	}

	@Override
	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.btn_startService:// startService
			startService(serviceIntent);
			break;
		case R.id.btn_stoptService:// stopService
			stopService(serviceIntent);
			break;
		case R.id.btn_bindService:// bindService
			bindService(serviceIntent, conn, Service.BIND_AUTO_CREATE);
			break;
		case R.id.btn_unbindService:// unbindService
			unbindService(conn);
			break;
		case R.id.btn_getinfo:// 获取数据
			Toast.makeText(MainActivity.this, myBinder.getInfo(),
					Toast.LENGTH_SHORT).show();
			break;
		default:
			break;
		}
	}

}



运行效果：





在MyFirstService类中定义了一个MyBinder类，该类用于获取一个String类型的返回值，


ServiceConnection.onServiceConnected方法的第2个参数是一个IBinder类型的变量，将该参数转换成


MyFirstService.MyBinder对象，并使用myBinder.getInfo()方法获取String类型的值。


接着看下我们是如何使用bindService和unbindService操作的。


（1）当我们单击一次bindService(bindService(service,conn,flags))按钮时：







（2）当我们单击一次unbindService按钮时：




从上面可以看出通过bindService开启服务，再通过unbindService停止服务的过程是 onCreate------>onBind------


->onServiceConnected------->onUnbind------>onDestory


这里面值得注意的是，当我按下home键时，此时并没有调用unbindService方法进行停止服务，但依然能打印出


onUnbind---->onDestory，也就是说通过bindService开启的服务是随着Activity的销毁而销毁。


Service的生命周期


下图的左半部分是通过startService()方法启动时的Service生命周期，右半部分是通过bindService()方法启动时


的Service生命周期。








Service生命周期有一种特殊的情形，如果Service已由某个客户端通过startService()方法启动了，接下来其他客


户端再调用bindService()方法来绑定该Service后，再调用unbindService()方法解除绑定，最后又调用了bindService()


方法再次绑定到Service，这个过程所触发的生命周期如下：





进行拆解步骤：


（1）调用startService时的生命周期：onCreate------>onStartCommand


（2）调用bindService时的生命周期：onBind------>onServiceConnected


（3）调用unbindService时的生命周期：onUnbind


（4）再一次调用bindService时的生命周期：onServiceConnected----->onRebind



以上调用unbindService时，并没有回调onDestroy()方法，这是因为该Service并不是由Activity通过bindService()


方法来启动的，因此当Activity调用unbindService()方法取消与该Activity的绑定时，该Service也不会终止。当Activity


调用bindService()绑定一个已经启动的Service时，系统只是把Service内部IBinder对象传给Activity，当Activity调用


unbindService()方法取消与该Service的绑定时，只是切断了Activity与Service之间的联系，并不能停止Service组件。





-------------------------------------------------------------------------------------------------------------------------------------------------------

转载请注明出处：http://blog.csdn.net/hai_qing_xu_kong/article/details/47722185情绪控





李某人_
关注
专栏目录
Android中怎么启动关闭Service及功能解释 ，Android客户端Web页面通用性能优化实践
m0_64319298的博客
11-25 505
1、  请将它们都挪到新的线程里。 2、  用系统提供的IntentService，它继承了Service，它处理数据是用自身新开的线程。 启动关闭service实例 =main文件====== package com.services.coms; import java.io.FileFilter; import android.app.Activity; import android.content.BroadcastReceiver; import android.content.
android studio四大组件,Android Studio四大组件之Service
weixin_34259816的博客
05-25 1161
Service在Android运行在后台，它没有可视化界面，只是默默运行在后台。我们以一个后台定时器的例子清晰的说明Service的运行流程。 一、创建Service类 项目右键->New->Service新建一个名为Time人Service的Service。将自动在AndroidMainfest中声明Service。 二、Service生命周期 打开刚刚新建的TimerService...
Android之四大组件(Service的开启与关闭)
热门推荐
顾林海
08-17 2万+
个人开发的微信小程序，目前功能是书籍推荐，后续会完善一些新功能，希望大家多多支持！   前言   服务（Service）是Android系统中的四大组件之一。服务主要用于两个目的：后台运行和跨进程访问。通过启动   一个服务，可以在不显示界面的前提下在后台运行指定的任务，这样可以不影响用户做其他事情。通过AIDL服务可以   实现不同进程之间的通信，这也是服务的重要用途之一。 ...
Android Service 详解四：开始停止service
蓝色妖姬
03-08 708
开始一个Service 　　你可以从一个activity或从其它应用的组件通过传递一个Intent(指定了要启动的服务)给startService()启动一个服务．Android系统然后调用service的onStartCommand()方法并且把Intent传递给它．(你永远不能直接调用onStartCommand()．) 　　例如，一个activity可以在调用startService...
Android中怎么启动关闭Service及功能解释
03-20 285
1、 Service不是分离开的进程，除非其他特殊情况，它不会运行在自己的进程，而是作为启动运行它的进程的一部分。 2、 Service不是线程，这意味着它将在主线程里劳作。 启动service有两种方法： 1、 Context.startService() 调用者与服务
Android四大组件之Service(服务)实例详解
09-02
Service是Android系统中的四大组件之一，它是用于在后台执行长时间运行任务而没有用户界面的组件。Service生命周期由系统管理，可以被其他组件如Activity启动或绑定。以下是对Service的详细说明： 1. **Service的...
Android四大组件之Service详解
08-26
Service是Android应用程序开发中的核心组件之一，它是四大组件（Activity、Service、BroadcastReceiver、ContentProvider）中的成员，专门设计用于在后台执行长时间运行的任务，不与用户界面直接交互。Service通常...
Android四大组件之Service
01-03
Android四大组件之ServiceService的生命周期被启动(startService)的服务的生命周期：被绑定(bindService)的服务的生命周期：被启动又被绑定的服务的生命周期：实例布局创建Service类启动ServiceDemo下载 android开发...
Android实现从activity中停止Service的方法
09-02
主要介绍了Android实现从activity中停止Service的方法,结合实例形式简单分析了Android中Service的注册、创建及使用stopService停止Service的方法,需要的朋友可以参考下
Android编程实现开始及停止service的方法
01-21
本文实例讲述了Android编程实现开始及停止service的方法。分享给大家供大家参考，具体如下： 开始一个Service 你可以从一个activity或从其它应用的组件通过传递一个Intent(指定了要启动的服务)给startService()启动一个服务．Android系统然后调用service的onStartCommand()方法并且把Intent传递给它．(你永远不能直接调用onStartCommand()．) 例如，一个activity可以在调用startService()时使用一个明确的intent开始前文的例子中的service(HelloSevice)： Intentint
android如何关闭服务,Android中怎么启动关闭Service及功能解释
weixin_39909212的博客
05-25 4165
满意答案fty9804202016.09.06采纳率：51%等级：10已帮助：516人1、 Service不是分离开的进程，除非其他特殊情况，它不会运行在自己的进程，而是作为启动运行它的进程的一部分。2、 Service不是线程，这意味着它将在主线程里劳作。启动service有两种方法：1、 Context.startService()调用者与服务之间没有关联，即使调用者退出，服务仍...
Android中怎么启动关闭Service及功能解释 ，送大厂面经一份
m0_60635176的博客
03-27 892
Log.i(“onStartCommand”, “接受要更新的广播数据=”+intent.getStringExtra(“data”));(img-UKrur4Tn-1711547490509)](img-xolsYnqQ-1711547490509)](img-ltOyq8Q6-1711547490509)](img-QE8jQ4FW-1711547490510)]因为文件太多，全部展示会影响篇幅，暂时就先列举这些部分截图。因为文件太多，全部展示会影响篇幅，暂时就先列举这些部分截图。
Android中怎么启动关闭Service及功能解释 (1)，那些年Android面试官常问的知识点
最新发布
m0_75012072的博客
04-06 704
Override@OverrideLog.i(“onStartCommand”, “接受要更新的广播数据=”+intent.getStringExtra(“data”));”+“Service的数据为:”+Date+“”));@Override// 创建IntentFilter对象// 注册Broadcast Receiver@Override// 取消注册Broadcast Receiver@Override。
android中四大组件
06-02
Android中四大组件是指Activity、Service、BroadcastReceiver和ContentProvider。 1. Activity：Activity是Android应用程序中的界面部分，一个Activity通常对应一个屏幕界面。它负责显示用户界面、接收和处理用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值