AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android--Service完全解析,关于服务你所需知道的一切（上）

2016-04-01 810
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
云解析 DNS，旗舰版 1个月
全局流量管理 GTM，标准版 1个月
简介： 相信大多数朋友对Service这个名词都不会陌生，没错，一个老练的Android程序员如果连Service都没听说过的话，那确实也太逊了。

相信大多数朋友对Service这个名词都不会陌生，没错，一个老练的Android程序员如果连Service都没听说过的话，那确实也太逊了。Service作为Android四大组件之一，在每一个应用程序中都扮演着非常重要的角色。它主要用于在后台处理一些耗时的逻辑，或者去执行某些需要长期运行的任务。必要的时候我们甚至可以在程序退出的情况下，让Service在后台继续保持运行状态。

不过，虽然Service几乎被每一个Android程序员所熟知，但并不是每个人都已经将Service的各个知识点都掌握得非常透彻。那么今天我就将带着大家对Service进行一次全面、深入的探究，希望每个人在读完本篇文章后都能对Service有更深一层的理解。

Service的基本用法

关于Service最基本的用法自然就是如何启动一个Service了，启动Service的方法和启动Activity很类似，都需要借助Intent来实现，下面我们就通过一个具体的例子来看一下。

新建一个Android项目，项目名就叫ServiceTest，这里我选择使用4.0的API。

然后新建一个MyService继承自Service，并重写父类的onCreate()、onStartCommand()和onDestroy()方法，如下所示：

[java]  view plain copy
  1. public class MyService extends Service {  
  2.   
  3.     public static final String TAG = "MyService";  
  4.   
  5.     @Override  
  6.     public void onCreate() {  
  7.         super.onCreate();  
  8.         Log.d(TAG, "onCreate() executed");  
  9.     }  
  10.   
  11.     @Override  
  12.     public int onStartCommand(Intent intent, int flags, int startId) {  
  13.         Log.d(TAG, "onStartCommand() executed");  
  14.         return super.onStartCommand(intent, flags, startId);  
  15.     }  
  16.       
  17.     @Override  
  18.     public void onDestroy() {  
  19.         super.onDestroy();  
  20.         Log.d(TAG, "onDestroy() executed");  
  21.     }  
  22.   
  23.     @Override  
  24.     public IBinder onBind(Intent intent) {  
  25.         return null;  
  26.     }  
  27.   
  28. }  
可以看到，我们只是在onCreate()、onStartCommand()和onDestroy()方法中分别打印了一句话，并没有进行其它任何的操作。

然后打开或新建activity_main.xml作为程序的主布局文件，代码如下所示：

[html]  view plain copy
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     android:layout_width="match_parent"  
  3.     android:layout_height="match_parent"  
  4.     android:orientation="vertical" >  
  5.   
  6.     <Button  
  7.         android:id="@+id/start_service"  
  8.         android:layout_width="match_parent"  
  9.         android:layout_height="wrap_content"  
  10.         android:text="Start Service" />  
  11.   
  12.     <Button  
  13.         android:id="@+id/stop_service"  
  14.         android:layout_width="match_parent"  
  15.         android:layout_height="wrap_content"  
  16.         android:text="Stop Service" />  
  17.   
  18. </LinearLayout>  
我们在布局文件中加入了两个按钮，一个用于启动Service，一个用于停止Service。

然后打开或新建MainActivity作为程序的主Activity，在里面加入启动Service和停止Service的逻辑，代码如下所示：

[java]  view plain copy
  1. public class MainActivity extends Activity implements OnClickListener {  
  2.   
  3.     private Button startService;  
  4.   
  5.     private Button stopService;  
  6.   
  7.     @Override  
  8.     protected void onCreate(Bundle savedInstanceState) {  
  9.         super.onCreate(savedInstanceState);  
  10.         setContentView(R.layout.activity_main);  
  11.         startService = (Button) findViewById(R.id.start_service);  
  12.         stopService = (Button) findViewById(R.id.stop_service);  
  13.         startService.setOnClickListener(this);  
  14.         stopService.setOnClickListener(this);  
  15.     }  
  16.   
  17.     @Override  
  18.     public void onClick(View v) {  
  19.         switch (v.getId()) {  
  20.         case R.id.start_service:  
  21.             Intent startIntent = new Intent(this, MyService.class);  
  22.             startService(startIntent);  
  23.             break;  
  24.         case R.id.stop_service:  
  25.             Intent stopIntent = new Intent(this, MyService.class);  
  26.             stopService(stopIntent);  
  27.             break;  
  28.         default:  
  29.             break;  
  30.         }  
  31.     }  
  32.   
  33. }  
可以看到，在Start Service按钮的点击事件里，我们构建出了一个Intent对象，并调用startService()方法来启动MyService。然后在Stop Serivce按钮的点击事件里，我们同样构建出了一个Intent对象，并调用stopService()方法来停止MyService。代码的逻辑非常简单，相信不需要我再多做解释了吧。

另外需要注意，项目中的每一个Service都必须在AndroidManifest.xml中注册才行，所以还需要编辑AndroidManifest.xml文件，代码如下所示：

[html]  view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     package="com.example.servicetest"  
  4.     android:versionCode="1"  
  5.     android:versionName="1.0" >  
  6.   
  7.     <uses-sdk  
  8.         android:minSdkVersion="14"  
  9.         android:targetSdkVersion="17" />  
  10.   
  11.     <application  
  12.         android:allowBackup="true"  
  13.         android:icon="@drawable/ic_launcher"  
  14.         android:label="@string/app_name"  
  15.         android:theme="@style/AppTheme" >  
  16.           
  17.     ……  
  18.   
  19.         <service android:name="com.example.servicetest.MyService" >  
  20.         </service>  
  21.     </application>  
  22.   
  23. </manifest>  
这样的话，一个简单的带有Service功能的程序就写好了，现在我们将程序运行起来，并点击一下Start Service按钮，可以看到LogCat的打印日志如下：
                                              

也就是说，当启动一个Service的时候，会调用该Service中的onCreate()和onStartCommand()方法。

那么如果我再点击一次Start Service按钮呢？这个时候的打印日志如下：

                                          

可以看到，这次只有onStartCommand()方法执行了，onCreate()方法并没有执行，为什么会这样呢？这是由于onCreate()方法只会在Service第一次被创建的时候调用，如果当前Service已经被创建过了，不管怎样调用startService()方法，onCreate()方法都不会再执行。因此你可以再多点击几次Start Service按钮试一次，每次都只会有onStartCommand()方法中的打印日志。

我们还可以到手机的应用程序管理界面来检查一下MyService是不是正在运行，如下图所示：

                                         

恩，MyService确实是正在运行的，即使它的内部并没有执行任何的逻辑。

回到ServiceTest程序，然后点击一下Stop Service按钮就可以将MyService停止掉了。

Service和Activity通信

上面我们学习了Service的基本用法，启动Service之后，就可以在onCreate()或onStartCommand()方法里去执行一些具体的逻辑了。不过这样的话Service和Activity的关系并不大，只是Activity通知了Service一下：“你可以启动了。”然后Service就去忙自己的事情了。那么有没有什么办法能让它们俩的关联更多一些呢？比如说在Activity中可以指定让Service去执行什么任务。当然可以，只需要让Activity和Service建立关联就好了。

观察MyService中的代码，你会发现一直有一个onBind()方法我们都没有使用到，这个方法其实就是用于和Activity建立关联的，修改MyService中的代码，如下所示：

[java]  view plain copy
  1. public class MyService extends Service {  
  2.   
  3.     public static final String TAG = "MyService";  
  4.   
  5.     private MyBinder mBinder = new MyBinder();  
  6.   
  7.     @Override  
  8.     public void onCreate() {  
  9.         super.onCreate();  
  10.         Log.d(TAG, "onCreate() executed");  
  11.     }  
  12.   
  13.     @Override  
  14.     public int onStartCommand(Intent intent, int flags, int startId) {  
  15.         Log.d(TAG, "onStartCommand() executed");  
  16.         return super.onStartCommand(intent, flags, startId);  
  17.     }  
  18.   
  19.     @Override  
  20.     public void onDestroy() {  
  21.         super.onDestroy();  
  22.         Log.d(TAG, "onDestroy() executed");  
  23.     }  
  24.   
  25.     @Override  
  26.     public IBinder onBind(Intent intent) {  
  27.         return mBinder;  
  28.     }  
  29.   
  30.     class MyBinder extends Binder {  
  31.   
  32.         public void startDownload() {  
  33.             Log.d("TAG", "startDownload() executed");  
  34.             // 执行具体的下载任务  
  35.         }  
  36.   
  37.     }  
  38.   
  39. }  
这里我们新增了一个MyBinder类继承自Binder类，然后在MyBinder中添加了一个startDownload()方法用于在后台执行下载任务，当然这里并不是真正地去下载某个东西，只是做个测试，所以startDownload()方法只是打印了一行日志。

然后修改activity_main.xml中的代码，在布局文件中添加用于绑定Service和取消绑定Service的按钮：

[html]  view plain copy
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     android:layout_width="match_parent"  
  3.     android:layout_height="match_parent"  
  4.     android:orientation="vertical" >  
  5.   
  6.     <Button  
  7.         android:id="@+id/start_service"  
  8.         android:layout_width="match_parent"  
  9.         android:layout_height="wrap_content"  
  10.         android:text="Start Service" />  
  11.   
  12.     <Button  
  13.         android:id="@+id/stop_service"  
  14.         android:layout_width="match_parent"  
  15.         android:layout_height="wrap_content"  
  16.         android:text="Stop Service" />  
  17.   
  18.     <Button  
  19.         android:id="@+id/bind_service"  
  20.         android:layout_width="match_parent"  
  21.         android:layout_height="wrap_content"  
  22.         android:text="Bind Service" />  
  23.       
  24.     <Button   
  25.         android:id="@+id/unbind_service"  
  26.         android:layout_width="match_parent"  
  27.         android:layout_height="wrap_content"  
  28.         android:text="Unbind Service"  
  29.         />  
  30.       
  31. </LinearLayout>  
接下来再修改MainActivity中的代码，让MainActivity和MyService之间建立关联，代码如下所示：
[java]  view plain copy
  1. public class MainActivity extends Activity implements OnClickListener {  
  2.   
  3.     private Button startService;  
  4.   
  5.     private Button stopService;  
  6.   
  7.     private Button bindService;  
  8.   
  9.     private Button unbindService;  
  10.   
  11.     private MyService.MyBinder myBinder;  
  12.   
  13.     private ServiceConnection connection = new ServiceConnection() {  
  14.   
  15.         @Override  
  16.         public void onServiceDisconnected(ComponentName name) {  
  17.         }  
  18.   
  19.         @Override  
  20.         public void onServiceConnected(ComponentName name, IBinder service) {  
  21.             myBinder = (MyService.MyBinder) service;  
  22.             myBinder.startDownload();  
  23.         }  
  24.     };  
  25.   
  26.     @Override  
  27.     protected void onCreate(Bundle savedInstanceState) {  
  28.         super.onCreate(savedInstanceState);  
  29.         setContentView(R.layout.activity_main);  
  30.         startService = (Button) findViewById(R.id.start_service);  
  31.         stopService = (Button) findViewById(R.id.stop_service);  
  32.         bindService = (Button) findViewById(R.id.bind_service);  
  33.         unbindService = (Button) findViewById(R.id.unbind_service);  
  34.         startService.setOnClickListener(this);  
  35.         stopService.setOnClickListener(this);  
  36.         bindService.setOnClickListener(this);  
  37.         unbindService.setOnClickListener(this);  
  38.     }  
  39.   
  40.     @Override  
  41.     public void onClick(View v) {  
  42.         switch (v.getId()) {  
  43.         case R.id.start_service:  
  44.             Intent startIntent = new Intent(this, MyService.class);  
  45.             startService(startIntent);  
  46.             break;  
  47.         case R.id.stop_service:  
  48.             Intent stopIntent = new Intent(this, MyService.class);  
  49.             stopService(stopIntent);  
  50.             break;  
  51.         case R.id.bind_service:  
  52.             Intent bindIntent = new Intent(this, MyService.class);  
  53.             bindService(bindIntent, connection, BIND_AUTO_CREATE);  
  54.             break;  
  55.         case R.id.unbind_service:  
  56.             unbindService(connection);  
  57.             break;  
  58.         default:  
  59.             break;  
  60.         }  
  61.     }  
  62.   
  63. }  
可以看到，这里我们首先创建了一个ServiceConnection的匿名类，在里面重写了onServiceConnected()方法和onServiceDisconnected()方法，这两个方法分别会在Activity与Service建立关联和解除关联的时候调用。在onServiceConnected()方法中，我们又通过向下转型得到了MyBinder的实例，有了这个实例，Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用MyBinder中的任何public方法，即实现了Activity指挥Service干什么Service就去干什么的功能。

当然，现在Activity和Service其实还没关联起来了呢，这个功能是在Bind Service按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数，第一个参数就是刚刚构建出的Intent对象，第二个参数是前面创建出的ServiceConnection的实例，第三个参数是一个标志位，这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后自动创建Service，这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。

然后如何我们想解除Activity和Service之间的关联怎么办呢？调用一下unbindService()方法就可以了，这也是Unbind Service按钮的点击事件里实现的逻辑。

现在让我们重新运行一下程序吧，在MainActivity中点击一下Bind Service按钮，LogCat里的打印日志如下图所示：

                                         

另外需要注意，任何一个Service在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity建立关联，还可以和任何一个Activity建立关联，而且在建立关联时它们都可以获取到相同的MyBinder实例。

如何销毁Service

在Service的基本用法这一部分，我们介绍了销毁Service最简单的一种情况，点击Start Service按钮启动Service，再点击Stop Service按钮停止Service，这样MyService就被销毁了，可以看到打印日志如下所示：

                           

那么如果我们是点击的Bind Service按钮呢？由于在绑定Service的时候指定的标志位是BIND_AUTO_CREATE，说明点击Bind Service按钮的时候Service也会被创建，这时应该怎么销毁Service呢？其实也很简单，点击一下Unbind Service按钮，将Activity和Service的关联解除就可以了。

先点击一下Bind Service按钮，再点击一下Unbind Service按钮，打印日志如下所示：

                                     

以上这两种销毁的方式都很好理解。那么如果我们既点击了Start Service按钮，又点击了Bind Service按钮会怎么样呢？这个时候你会发现，不管你是单独点击Stop Service按钮还是Unbind Service按钮，Service都不会被销毁，必要将两个按钮都点击一下，Service才会被销毁。也就是说，点击Stop Service按钮只会让Service停止，点击Unbind Service按钮只会让Service和Activity解除关联，一个Service必须要在既没有和任何Activity关联又处理停止状态的时候才会被销毁。

为了证实一下，我们在Stop Service和Unbind Service按钮的点击事件里面加入一行打印日志：

[java]  view plain copy
  1. public void onClick(View v) {  
  2.     switch (v.getId()) {  
  3.     case R.id.start_service:  
  4.         Intent startIntent = new Intent(this, MyService.class);  
  5.         startService(startIntent);  
  6.         break;  
  7.     case R.id.stop_service:  
  8.         Log.d("MyService", "click Stop Service button");  
  9.         Intent stopIntent = new Intent(this, MyService.class);  
  10.         stopService(stopIntent);  
  11.         break;  
  12.     case R.id.bind_service:  
  13.         Intent bindIntent = new Intent(this, MyService.class);  
  14.         bindService(bindIntent, connection, BIND_AUTO_CREATE);  
  15.         break;  
  16.     case R.id.unbind_service:  
  17.         Log.d("MyService", "click Unbind Service button");  
  18.         unbindService(connection);  
  19.         break;  
  20.     default:  
  21.         break;  
  22.     }  
  23. }  
然后重新运行程序，先点击一下Start Service按钮，再点击一下Bind Service按钮，这样就将Service启动起来，并和Activity建立了关联。然后点击Stop Service按钮后Service并不会销毁，再点击一下Unbind Service按钮，Service就会销毁了，打印日志如下所示：

                                

我们应该始终记得在Service的onDestroy()方法里去清理掉那些不再使用的资源，防止在Service被销毁后还会有一些不再使用的对象仍占用着内存。

Service和Thread的关系

不少Android初学者都可能会有这样的疑惑，Service和Thread到底有什么关系呢？什么时候应该用Service，什么时候又应该用Thread？答案可能会有点让你吃惊，因为Service和Thread之间没有任何关系！

之所以有不少人会把它们联系起来，主要就是因为Service的后台概念。Thread我们大家都知道，是用于开启一个子线程，在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候，总会觉得它是用来处理一些后台任务的，一些比较耗时的操作也可以放在这里运行，这就会让人产生混淆了。但是，如果我告诉你Service其实是运行在主线程里的，你还会觉得它和Thread有什么关系吗？让我们看一下这个残酷的事实吧。

在MainActivity的onCreate()方法里加入一行打印当前线程id的语句：

[java]  view plain copy
  1. Log.d("MyService", "MainActivity thread id is " + Thread.currentThread().getId());  
然后在MyService的onCreate()方法里也加入一行打印当前线程id的语句：
[java]  view plain copy
  1. Log.d("MyService", "MyService thread id is " + Thread.currentThread().getId());  

现在重新运行一下程序，并点击Start Service按钮，会看到如下打印日志：

                                 

可以看到，它们的线程id完全是一样的，由此证实了Service确实是运行在主线程里的，也就是说如果你在Service里编写了非常耗时的代码，程序必定会出现ANR的。

你可能会惊呼，这不是坑爹么！？那我要Service又有何用呢？其实大家不要把后台和子线程联系在一起就行了，这是两个完全不同的概念。Android的后台就是指，它的运行是完全不依赖UI的。即使Activity被销毁，或者程序被关闭，只要进程还在，Service就可以继续运行。比如说一些应用程序，始终需要与服务器之间始终保持着心跳连接，就可以使用Service来实现。你可能又会问，前面不是刚刚验证过Service是运行在主线程里的么？在这里一直执行着心跳连接，难道就不会阻塞主线程的运行吗？当然会，但是我们可以在Service中再创建一个子线程，然后在这里去处理耗时逻辑就没问题了。

额，既然在Service里也要创建一个子线程，那为什么不直接在Activity里创建呢？这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。

一个比较标准的Service就可以写成：

[java]  view plain copy
  1. @Override  
  2. public int onStartCommand(Intent intent, int flags, int startId) {  
  3.     new Thread(new Runnable() {  
  4.         @Override  
  5.         public void run() {  
  6.             // 开始执行后台任务  
  7.         }  
  8.     }).start();  
  9.     return super.onStartCommand(intent, flags, startId);  
  10. }  
  11.   
  12. class MyBinder extends Binder {  
  13.   
  14.     public void startDownload() {  
  15.         new Thread(new Runnable() {  
  16.             @Override  
  17.             public void run() {  
  18.                 // 执行具体的下载任务  
  19.             }  
  20.         }).start();  
  21.     }  
  22.   
  23. }  

创建前台Service

Service几乎都是在后台运行的，一直以来它都是默默地做着辛苦的工作。但是Service的系统优先级还是比较低的，当系统出现内存不足情况时，就有可能会回收掉正在后台运行的Service。如果你希望Service可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台Service。前台Service和普通Service最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service，有些项目由于特殊的需求会要求必须使用前台Service，比如说墨迹天气，它的Service在后台更新天气数据的同时，还会在系统状态栏一直显示当前天气的信息，如下图所示：

                                                   

那么我们就来看一下如何才能创建一个前台Service吧，其实并不复杂，修改MyService中的代码，如下所示：

[java]  view plain copy
  1. public class MyService extends Service {  
  2.   
  3.     public static final String TAG = "MyService";  
  4.   
  5.     private MyBinder mBinder = new MyBinder();  
  6.   
  7.     @Override  
  8.     public void onCreate() {  
  9.         super.onCreate();  
  10.         Notification notification = new Notification(R.drawable.ic_launcher,  
  11.                 "有通知到来", System.currentTimeMillis());  
  12.         Intent notificationIntent = new Intent(this, MainActivity.class);  
  13.         PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,  
  14.                 notificationIntent, 0);  
  15.         notification.setLatestEventInfo(this, "这是通知的标题", "这是通知的内容",  
  16.                 pendingIntent);  
  17.         startForeground(1, notification);  
  18.         Log.d(TAG, "onCreate() executed");  
  19.     }  
  20.   
  21.     .........  
  22.   
  23. }  
这里只是修改了MyService中onCreate()方法的代码。可以看到，我们首先创建了一个Notification对象，然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据，并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service，并会将通知的图片显示出来。

现在重新运行一下程序，并点击Start Service或Bind Service按钮，MyService就会以前台Service的模式启动了，并且在系统状态栏会弹出一个通栏图标，下拉状态栏后可以看到通知的详细内容，如下图所示。

                                                   

好了，由于篇幅的原因，本篇文章就先写到这里。目前我们已经把关于Service的很多重要知识点都梳理完了，下一篇文章会承接这篇文章，介绍Android Service中剩下的一个非常重要且复杂的知识点 —— 远程Service的使用，感兴趣的朋友请继续阅读  Android--Service完全解析，关于服务你所需知道的一切(下)

文章标签：
云解析DNS
日志服务
Android开发
Java
程序员
API
关键词：
云解析DNS服务
Android解析
Android服务
android云解析DNS
Android service
sealin
目录
相关文章
喜欢猪猪
|
1月前
|
存储 缓存 算法
分布式锁服务深度解析：以Apache Flink的Checkpointing机制为例
【10月更文挑战第7天】在分布式系统中，多个进程或节点可能需要同时访问和操作共享资源。为了确保数据的一致性和系统的稳定性，我们需要一种机制来协调这些进程或节点的访问，避免并发冲突和竞态条件。分布式锁服务正是为此而生的一种解决方案。它通过在网络环境中实现锁机制，确保同一时间只有一个进程或节点能够访问和操作共享资源。
喜欢猪猪
73 3
liuliunaina
|
2月前
|
IDE Android开发 iOS开发
深入解析Android与iOS的系统架构及开发环境差异
本文旨在探讨Android和iOS两大主流移动操作系统在系统架构、开发环境和用户体验方面的显著差异。通过对比分析，我们将揭示这两种系统在设计理念、技术实现以及市场策略上的不同路径，帮助开发者更好地理解其特点，从而做出更合适的开发决策。
liuliunaina
172 2
qhhf_地道酬勤
|
24天前
|
域名解析 缓存 网络协议
浏览器中输入URL返回页面过程（超级详细）、DNS域名解析服务，TCP三次握手、四次挥手
浏览器中输入URL返回页面过程（超级详细）、DNS域名解析服务，TCP三次握手、四次挥手
qhhf_地道酬勤
65 2
1821858551868125
|
25天前
|
安全 测试技术 数据安全/隐私保护
原生鸿蒙应用市场开发者服务的技术解析：从集成到应用发布的完整体验
原生鸿蒙应用市场开发者服务的技术解析：从集成到应用发布的完整体验
1821858551868125
57 2
悟道了凡
|
1月前
|
安全 Java 网络安全
Android远程连接和登录FTPS服务代码(commons.net库)
Android远程连接和登录FTPS服务代码(commons.net库)
悟道了凡
24 1
丰宝宝
|
1月前
|
开发工具 Android开发 iOS开发
深入解析安卓与iOS开发环境的优劣
【10月更文挑战第4天】 本文将深入探讨安卓和iOS两大主流移动操作系统的开发环境，从技术架构、开发工具、用户体验等方面进行详细比较。通过分析各自的优势和不足，帮助开发者更好地理解这两个平台的异同，从而为项目选择最合适的开发平台提供参考。
丰宝宝
26 3
丰宝宝
|
25天前
|
安全 5G Android开发
安卓与iOS的较量：技术深度解析
【10月更文挑战第24天】 在移动操作系统领域，安卓和iOS无疑是两大巨头。本文将深入探讨这两个系统的技术特点、优势和不足，以及它们在未来可能的发展方向。我们将通过对比分析，帮助读者更好地理解这两个系统的本质和内涵，从而引发对移动操作系统未来发展的深思。
丰宝宝
42 0
131王
|
1月前
|
安全 Android开发 iOS开发
深入解析：安卓与iOS的系统架构及其对应用开发的影响
本文旨在探讨安卓与iOS两大主流操作系统的架构差异，并分析这些差异如何影响应用开发的策略和实践。通过对比两者的设计哲学、安全机制、开发环境及性能优化等方面，本文揭示了各自的特点和优势，为开发者在选择平台和制定开发计划时提供参考依据。
131王
54 4
131王
|
1月前
|
测试技术 数据库 Android开发
深入解析Android架构组件——Jetpack的使用与实践
本文旨在探讨谷歌推出的Android架构组件——Jetpack，在现代Android开发中的应用。Jetpack作为一系列库和工具的集合，旨在帮助开发者更轻松地编写出健壮、可维护且性能优异的应用。通过详细解析各个组件如Lifecycle、ViewModel、LiveData等，我们将了解其原理和使用场景，并结合实例展示如何在实际项目中应用这些组件，提升开发效率和应用质量。
131王
48 6
Codelinghu
|
1月前
|
网络安全 Docker 容器
【Bug修复】秒杀服务器异常，轻松恢复网站访问--从防火墙到Docker服务的全面解析
【Bug修复】秒杀服务器异常，轻松恢复网站访问--从防火墙到Docker服务的全面解析
Codelinghu
26 0

热门文章

最新文章

  • 1
    Android音视频——NuPlayer框架
  • 2
    android-async-http框架的学习和使用
  • 3
    大叔也说Xamarin~Android篇~Activity之间传递数组
  • 4
    Android UI学习 - Linear Layout, RelativeLayout
  • 5
    [Java][Android][Process] 暴力的服务能够解决一切，暴力的方式运行命令行语句
  • 6
    android按钮main.xm_基础篇
  • 7
    Android -- ContentProvider
  • 8
    Android响应式编程RxAndroid（1）：简单例程
  • 9
    Android快捷便利但不常被使用的原生工具类
  • 10
    android --静默安装
  • 1
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    101
  • 2
    Dubbo-负载均衡原理解析(1)，一个本科渣渣是怎么逆袭从咸鱼到Offer收割机的
    59
  • 3
    Flutter完整开发实战详解(六、 深入Widget原理)，2024百度Android岗面试真题收录解析
    98
  • 4
    Android-kotlin-接口与多态的表现，面经解析
    45
  • 5
    OKHTTP解析之RetryAndFollowUpInterceptor重试机制
    89
  • 6
    前端开发者必知的缓存淘汰策略：LRU算法解析与实践
    205
  • 7
    第十章（应用场景篇） Single-SPA微前端架构深度解析与实践教程
    237
  • 8
    第九章（应用场景篇）Qiankun微前端深度解析与实践教程
    249
  • 9
    Web前端主题色更换实现方式全解析（二）
    218
  • 10
    HuggingFace Tranformers 源码解析（4）
    125

    • 相关课程

    更多
  • 第八届大学生创新创业大赛阿里命题IoT赛题解析
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 深入解析Docker容器化技术
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • 神龙云服务器产品及技术深度解析
  • 弹性创造价值：基于ECS的最佳性价比实践解析
  • 又快又稳：阿里云下一代虚拟交换机解析

    • 相关实验场景

    更多
  • 通过云拨测对指定服务器进行Ping/DNS监测

    • 推荐镜像

    更多
  • DNS
  • DNS
  • DNS
    • 下一篇
    无影云桌面