【Framework】bindService启动流程

news2024/11/17 13:57:22

前言

在【Service启动流程之startService】 中，我们已经分析了startService的流程，这篇就继续讲bindService的流程，他们两有很多相似之处。同样，流程图在总结处。

我们在调用bindService方法时候，实际调用的是ContextImpl的实现。

1. ContextImpl

代码路径：frameworks\base\core\java\android\app\ContextImpl.java

1.1 bindService

@Override
public boolean bindService(Intent service, ServiceConnection conn, int flags) {
    warnIfCallingFromSystemProcess();
    return bindServiceCommon(service, conn, flags, null, mMainThread.getHandler(), null,
            getUser());
}

1.2 bindServiceCommon

private boolean bindServiceCommon(Intent service, ServiceConnection conn, 
                                  int flags, String instanceName, Handler handler, 
                                  Executor executor, UserHandle user) {
    IServiceConnection sd;
    if (mPackageInfo != null) {
        // 将ServiceConnection 通过LoadedApk包装到 ServiceDispatcher 中
        if (executor != null) {
            sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), executor, flags);
        } else {
            sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
        }
    }
    try {
        IBinder token = getActivityToken();
        if (token == null && (flags&BIND_AUTO_CREATE) == 0 && mPackageInfo != null
                && mPackageInfo.getApplicationInfo().targetSdkVersion
                < android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
            flags |= BIND_WAIVE_PRIORITY;
        }
        service.prepareToLeaveProcess(this);
        // 调用 AMS 接口
        int res = ActivityManager.getService().bindServiceInstance(
                mMainThread.getApplicationThread(), getActivityToken(), service,
                service.resolveTypeIfNeeded(getContentResolver()),
                sd, flags, instanceName, getOpPackageName(), user.getIdentifier());
        return res != 0;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}

2. LoaderApk

代码路径：frameworks\base\core\java\android\app\LoadedApk.java

getServiceDispatcher 直接调用getServiceDispatcherCommon 方法

2.1 getServiceDispatcherCommon

private IServiceConnection getServiceDispatcherCommon(ServiceConnection c,
            Context context, Handler handler, Executor executor, int flags) {
        synchronized (mServices) {
            LoadedApk.ServiceDispatcher sd = null;
            ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher> map = mServices.get(context);
            if (map != null) {
                sd = map.get(c);
            }
            if (sd == null) {
                if (executor != null) {
                    // 将ServiceConnection 保存到ServiceDispatcher中
                    sd = new ServiceDispatcher(c, context, executor, flags);
                } else {
                    sd = new ServiceDispatcher(c, context, handler, flags);
                }
                if (map == null) {
                    map = new ArrayMap<>();
                    mServices.put(context, map);
                }
                map.put(c, sd);
            } else {
                sd.validate(context, handler, executor);
            }
            // 最后返回的是一个bind对象，即IServiceConnection
            return sd.getIServiceConnection();
        }
    }

3. ActivityManagerService

代码路径：frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java

3.1 bindServiceInstance

    private int bindServiceInstance(IApplicationThread caller, IBinder token, 
                                    Intent service, String resolvedType,
                                    ServiceConnection connection ...) {
		....
        try {
            synchronized (this) {
                // 调用ActiveServices的bindServiceLocked
                return mServices.bindServiceLocked(caller, token, service, resolvedType, connection,flags, instanceName, isSdkSandboxService, sdkSandboxClientAppUid,        sdkSandboxClientAppPackage, callingPackage, userId);
            }
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        }
    }

4. ActiveService

代码路径：frameworks\base\services\core\java\com\android\server\am\ActiveServices.java

4.1 bindServiceLocked

其中：

  • ServiceRecord：用于描述一个Service
  • processRecord：一个进程的信息
  • ConnectionRecord：用于描述应用程序进程和Service建立的通信
  • AppBindRecord：维护Service与应用进程的关联，包含通信记录ArraySet，绑定Service的intent。
  • IntentBindRecord：描述绑定Service的intent。
int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
        String resolvedType, final IServiceConnection connection ...)
        throws TransactionTooLargeException {
    final ProcessRecord callerApp = mAm.getRecordForAppLOSP(caller);
    ActivityServiceConnectionsHolder<ConnectionRecord> activity = null;
    int clientLabel = 0;
    PendingIntent clientIntent = null;
    // 获取 ServiceRecord
    ServiceLookupResult res = retrieveServiceLocked(service, instanceName,
            isSdkSandboxService, sdkSandboxClientAppUid, sdkSandboxClientAppPackage,
            resolvedType, callingPackage, callingPid, callingUid, userId, true, callerFg,
            isBindExternal, allowInstant);
    ServiceRecord s = res.record;
    try {
        AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
        // 用于保存 serviceConnect 信息
        ConnectionRecord c = new ConnectionRecord(b, activity,
                connection, flags, clientLabel, clientIntent,
                callerApp.uid, callerApp.processName, callingPackage, res.aliasComponent);
        IBinder binder = connection.asBinder();
        // 将connection binder对象添加到map中
        s.addConnection(binder, c);
        b.connections.add(c);
        boolean needOomAdj = false;
        // 传入flag是BIND_AUTO_CREATE
        if ((flags&Context.BIND_AUTO_CREATE) != 0) {
            // Service还没启动，就走启动流程
            // bringUpServiceLocked 方法返回null意味着成功启动Service
            if (bringUpServiceLocked(s, service.getFlags(), callerFg, false,
                    permissionsReviewRequired, packageFrozen, true) != null) {
                // 启动失败，添加排队
                mAm.updateOomAdjPendingTargetsLocked(OomAdjuster.OOM_ADJ_REASON_BIND_SERVICE);
                return 0;
            }
        }
        // b.intent.received 表示已接收到绑定Service时返回的binder对象。
        if (s.app != null && b.intent.received) {
            // 服务已经在运行，可以直接调用connected
            //如果客户端尝试启动/连接的是别名，那么需要将别名组件名称传递给客户端。
            final ComponentName clientSideComponentName =
                    res.aliasComponent != null ? res.aliasComponent : s.name;
            try {
                // 这里的c.conn 即 IServiceConnection对象
                c.conn.connected(clientSideComponentName, b.intent.binder, false);
            } catch (Exception e) {
            }

            // 如果这是连接回此绑定的第一个应用， 并且Service已经调用过onUnBind方法
            // 则需要调用requestServiceBindingLocked。
            if (b.intent.apps.size() == 1 && b.intent.doRebind) {
                requestServiceBindingLocked(s, b.intent, callerFg, true);
            }
        } else if (!b.intent.requested) {
            requestServiceBindingLocked(s, b.intent, callerFg, false);
        }

    } finally {
        Binder.restoreCallingIdentity(origId);
    }
    return 1;
}

4.2 realStartServiceLocked

如startService流程中的分析，bringUpServiceLocked 调用 realStartServiceLocked来启动Service

private void realStartServiceLocked(ServiceRecord r, ProcessRecord app,
        IApplicationThread thread ...) throws RemoteException {
    // 通知客户端创建service
    thread.scheduleCreateService(r, r.serviceInfo,
            mAm.compatibilityInfoForPackage(r.serviceInfo.applicationInfo),
            app.mState.getReportedProcState());
    // 调用Service的onBind方法
    requestServiceBindingsLocked(r, execInFg);
    .....
}

4.3 requestServiceBindingsLocked

    private final void requestServiceBindingsLocked(ServiceRecord r, boolean execInFg)
            throws TransactionTooLargeException {
        for (int i=r.bindings.size()-1; i>=0; i--) {
            IntentBindRecord ibr = r.bindings.valueAt(i);
            if (!requestServiceBindingLocked(r, ibr, execInFg, false)) {
                break;
            }
        }
    }

4.4 requestServiceBindingLocked

private final boolean requestServiceBindingLocked(ServiceRecord r, IntentBindRecord i,
            boolean execInFg, boolean rebind) throws TransactionTooLargeException {
	   // i.requested:表示是否发送过绑定Service的请求，这里为true
       // i.apps.size():表示当前intent绑定Service的应用进程个数
	   if ((!i.requested || rebind) && i.apps.size() > 0) {
            try {
                // 启动计时
                bumpServiceExecutingLocked(r, execInFg, "bind",
                        OomAdjuster.OOM_ADJ_REASON_BIND_SERVICE);
                // 通知客户端调用bind
                r.app.getThread().scheduleBindService(r, i.intent.getIntent(), rebind,
                        r.app.mState.getReportedProcState());
                if (!rebind) {
                    i.requested = true;
                }
                i.hasBound = true;
                i.doRebind = false;
            } catch (TransactionTooLargeException e) {
                ....
            }
      }
      return true;
}

5. ApplicationThread

代码路径：frameworks\base\core\java\android\app\ActivityThread.java

5.1 scheduleBindService

public final void scheduleBindService(IBinder token, Intent intent,
        boolean rebind, int processState) {
    updateProcessState(processState, false);
    BindServiceData s = new BindServiceData();
    s.token = token;
    s.intent = intent;
    s.rebind = rebind;
    sendMessage(H.BIND_SERVICE, s);
}

6. ActivityThread

代码路径：frameworks\base\core\java\android\app\ActivityThread.java

在发送BIND_SERVICE 消息后，最后调用到ActivityThread#handleBindService 方法

6.1 handleBindService

    private void handleBindService(BindServiceData data) {
        CreateServiceData createData = mServicesData.get(data.token);
        Service s = mServices.get(data.token);
        try {
           if (!data.rebind) {
               // 不是重新bind，即没有绑定过，调用onBind方法
               IBinder binder = s.onBind(data.intent);
               // 将binder对象传给AMS
               ActivityManager.getService().publishService(
                       data.token, data.intent, binder);
           } else {
               // 调用onRebind方法
               s.onRebind(data.intent);
               ActivityManager.getService().serviceDoneExecuting(
                       data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
           }
       } catch (RemoteException ex) {
           throw ex.rethrowFromSystemServer();
       }
    }

7. ActivityManagerService

代码路径：frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java

7.1 publishService

public void publishService(IBinder token, Intent intent, IBinder service) {
    ....
    synchronized(this) {
        mServices.publishServiceLocked((ServiceRecord)token, intent, service);
    }
}

8. ActiveServices

代码路径：frameworks\base\services\core\java\com\android\server\am\ActiveServices.java

8.1 publishServiceLocked

void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
        final long origId = Binder.clearCallingIdentity();
        try {
            if (r != null) {
                Intent.FilterComparison filter
                        = new Intent.FilterComparison(intent);
                IntentBindRecord b = r.bindings.get(filter);
                if (b != null && !b.received) {
                    b.binder = service; // 保存Service#onBind方法返回的binder对象
                    b.requested = true;
                    b.received = true;
                    ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
                    for (int conni = connections.size() - 1; conni >= 0; conni--) {
                        ArrayList<ConnectionRecord> clist = connections.valueAt(conni);
                        for (int i=0; i<clist.size(); i++) {
                            ConnectionRecord c = clist.get(i);
                            if (!filter.equals(c.binding.intent.intent)) {
                                continue;
                            }
                            try {
                                // 调用ServiceConnection的回调
                                c.conn.connected(clientSideComponentName, service, false);
                            } catch (Exception e) {
                            }
                        }
                    }
                }
                // 移除定时任务等
                serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false, false);
            }
        } finally {
            Binder.restoreCallingIdentity(origId);
        }
    }

8.2 ConnectionRecord

代码路径：frameworks\base\services\core\java\com\android\server\am\ConnectionRecord.java

该类定义如下

final class ConnectionRecord {
    final IServiceConnection conn;  // The client connection.
    .....
}

这里的IServiceConnection 即我们在bindService的时候，生成的ServiceDispatcher中内部mIServiceConnection 变量

9. LoadedApk

代码路径：frameworks\base\core\java\android\app\LoadedApk.java

9.1 InnerConnection

private static class InnerConnection extends IServiceConnection.Stub {
    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;

    InnerConnection(LoadedApk.ServiceDispatcher sd) {
        mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
    }

    public void connected(ComponentName name, IBinder service, boolean dead)
            throws RemoteException {
        LoadedApk.ServiceDispatcher sd = mDispatcher.get();
        if (sd != null) {
            sd.connected(name, service, dead);
        }
    }
}

9.2 ServiceDispatcher

connect方法中会做切线程的动作，RunConnection 内部实际是调用到doConnected 方法。

static final class ServiceDispatcher {
  public void connected(ComponentName name, IBinder service, boolean dead) {
      if (mActivityExecutor != null) {
          mActivityExecutor.execute(new RunConnection(name, service, 0, dead));
      } else if (mActivityThread != null) {
          mActivityThread.post(new RunConnection(name, service, 0, dead));
      } else {
          doConnected(name, service, dead);
      }
  }
}

9.3 doConnected

public void doConnected(ComponentName name, IBinder service, boolean dead) {
    ServiceDispatcher.ConnectionInfo old;
    ServiceDispatcher.ConnectionInfo info;
    synchronized (this) {
        old = mActiveConnections.get(name)
        if (service != null) {
            info = new ConnectionInfo();
            info.binder = service;
            info.deathMonitor = new DeathMonitor(name, service);
            try {
                // 监听bind的死亡回调
                service.linkToDeath(info.deathMonitor, 0);
                mActiveConnections.put(name, info);
            } catch (RemoteException e) {
                mActiveConnections.remove(name);
                return;
            }
        } else {
            // The named service is being disconnected... clean up.
            mActiveConnections.remove(name);
        }
        if (old != null) {
            old.binder.unlinkToDeath(old.deathMonitor, 0);
        }
    }
    // 如果有老的服务，那就通知断开
    if (old != null) {
        mConnection.onServiceDisconnected(name);
    }
    if (dead) {
        // 如果service端已经dead，就调用onBindingDied
        mConnection.onBindingDied(name);
    } else {
        // 通知service已经连接上，并且远程服务返回的bind对象不为null
        if (service != null) {
            mConnection.onServiceConnected(name, service);
        } else {
            // 远程服务返回null的bind对象，
            mConnection.onNullBinding(name);
        }
    }
}

总结

如果当前应用是第一个与Service绑定，并且Service已经调用过unUnBind方法，则会调用Service的onRebind方法

对应的uml图如下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QDqpmTge-1688202336458)(\img\blog_bind_service_flow\1.png)]

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/707319.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

台庆|三联开关怎么接线？

台庆|三联开关怎么接线？

三联开关是一种常见的开关类型&#xff0c;通常用于控制一个电路中的三个不同的电器或灯具。它的用途非常广泛&#xff0c;因此了解如何正确接线是非常重要的。在本文中&#xff0c;我们将详细讨论三联开关的接线方法。 我们先来看看三联开关实物图与线路图&#xff1a; 接下来…
阅读更多...
【音视频处理】FFmpeg详解，命令行、源码、编译安装

【音视频处理】FFmpeg详解，命令行、源码、编译安装

大家好&#xff0c;欢迎来到停止重构的频道。 本期我们讨论FFmpeg。 这里先提一个问题&#xff0c;FFmpeg命令行功能如此强大&#xff0c;为什么还需要舍近求远地调用库函数呢 &#xff1f; 我们按这样的顺序讨论 &#xff1a; 1、 FFmpeg命令行说明 2、 FFmpeg代码结构…
阅读更多...
如何在 JavaScript 中压缩字符串

如何在 JavaScript 中压缩字符串

在 JavaScript 中&#xff0c;可以有范围很广的压缩&#xff0c;比如 gzip 之类的文件压缩等等。 在这里&#xff0c;我们将讨论两种压缩字符串的方法。 最初&#xff0c;我们将重点介绍霍夫曼算法。 稍后&#xff0c;我们将介绍解决任务的 LZString 方法。 在 JavaScript 中使…
阅读更多...
主成分分析系列（一）概览及数据为何要中心化

主成分分析系列（一）概览及数据为何要中心化

一、概览 主成分分析&#xff08;Principle Component Analysis&#xff0c;PCA&#xff09;算法属于数据降维算法里面的一种。数据降维算法的主要想法是从高维度数据中找到一种结构&#xff0c;这种结构蕴含了数据中的大部分信息&#xff0c;从而将高维数据降维到低维数据&am…
阅读更多...
Apikit 自学日记：参数构造器

Apikit 自学日记：参数构造器

构造器是测试时系统提供的快速生成请求数据的工具。一般用于快速对数据进行加密和生成随机数值。可在请求参数中某个字段的右侧选择构造器操作&#xff0c;通过构造器生成该字段的参数值。构造器由两种类型的操作组成&#xff1a;设置初始数据和多重操作。 设置初始数据 其中初…
阅读更多...
基于C语言的开源csv解析库：MiniCSV使用示例

基于C语言的开源csv解析库：MiniCSV使用示例

文章目录 MiniCSV简介官方示例csv文件解析示例CodeBlocks工程下载 MiniCSV简介 之前写了一篇基于C语言字符串操作函数的csv文件解析&#xff1a;C语言解析csv格式文件&#xff0c;本文介绍一个开源简洁的csv解析库的使用&#xff1a;MiniCSV&#xff0c;使用标准C语言设计。 …
阅读更多...
Spring Boot 中的 Redis 的数据操作配置和使用

Spring Boot 中的 Redis 的数据操作配置和使用

Spring Boot 中的 Redis 的数据操作配置和使用 Redis 是一种高性能的 NoSQL 数据库&#xff0c;它支持多种数据结构&#xff0c;包括字符串、哈希、列表、集合和有序集合。Redis 还提供了丰富的命令&#xff0c;可以对数据进行快速的 CRUD 操作。Spring Boot 是一个基于 Sprin…
阅读更多...
数据结构--栈的引用--前中后缀表达式(前部分)

数据结构--栈的引用--前中后缀表达式(前部分)

数据结构–栈的引用–前中后缀表达式(前部分) 常见的算数表达式 由三个部分组成: 操作数、运算符、界限符 \color{red}操作数、运算符、界限符 操作数、运算符、界限符 ps:界限符是必不可少的,反映了计算的先后顺序 波兰表达式(让计算机更容易识别的算数表达式) Reverse Po…
阅读更多...
高性能分布式缓存Redis(一) 快速实战

高性能分布式缓存Redis(一) 快速实战

一、缓存发展史&缓存分类 1.1、大型网站中缓存的使用 访问量越大&#xff0c;响应力越差&#xff0c;用户体验越差。 引入缓存、示意图如下&#xff1a; 读写策略&#xff1a; Cache Aside Pattern&#xff08;旁路缓存模式&#xff09;Read/Write Through Pattern&am…
阅读更多...
AA-TransUNet github： 用于预测任务的注意力增强的TransUNet

AA-TransUNet github： 用于预测任务的注意力增强的TransUNet

文章目录 来源AA_TransUNet架构数据集和预训练模型使用作者 来源 github地址 AA_TransUNet架构 数据集和预训练模型 如果你对本文中使用的数据集&#xff08;降水图和云量数据集&#xff09;感兴趣&#xff0c;请访问SmaAt-UNet了解更多细节。 对于预训练的AA_TransUNet模型…
阅读更多...
从磁盘看 IO

从磁盘看 IO

计算机上的易失和非易失存储器 常见磁盘可以分为两类&#xff1a;机械磁盘和固态磁盘。 第一类&#xff0c;机械磁盘&#xff0c;也称为硬盘驱动器&#xff08;Hard Disk Driver&#xff09;&#xff0c;通常缩写为 HDD。机械磁 盘主要由盘片和读写磁头组成&#xff0c;数据就…
阅读更多...
认识固态继电器及其工作原理

认识固态继电器及其工作原理

什么是固态继电器&#xff0c;有什么优缺点&#xff1f; 固态继电器 简称SSR&#xff0c;又被称之为“无触点开关”它利用电子元件&#xff08;如双向可控硅等半导体器件&#xff09;的开关特性&#xff0c;可到达无触点无火花地接通和断开电路。 固态继电器工作可靠&#…
阅读更多...
1.3 Metasploit 生成SSL加密载荷

1.3 Metasploit 生成SSL加密载荷

在本节中&#xff0c;我们将介绍如何通过使用Metasploit生成加密载荷&#xff0c;以隐藏网络特征。前一章节我们已经通过Metasploit生成了一段明文的ShellCode&#xff0c;但明文的网络传输存在安全隐患&#xff0c;因此本节将介绍如何通过生成SSL证书来加密ShellCode&#xff…
阅读更多...
ChatGPT应用工具推荐

ChatGPT应用工具推荐

ChatGPT作为一种先进的自然生成技术&#xff0c;已经在各个领域展现出了其强大的应用能力&#xff0c;下面将给大家介绍一些ChatGPT的功能应用。 简介 此系统是基于likeadmin—PHP开发的智能对话系统&#xff0c;ChatGPT是一种基于人工智能技术的聊天机器人&#xff0c;它可以…
阅读更多...
如何利用AI智能聊天机器人 10秒钟做出一个故事绘本的神奇插件

如何利用AI智能聊天机器人 10秒钟做出一个故事绘本的神奇插件

原文链接&#xff1a;如何利用AI智能聊天机器人10秒钟做出一个故事绘本的神奇插件 C_h~at_&G&&P_T : 以下称为AI智能聊天机器人 一、AI智能聊天机器人4中集成“Stories”插件 对于已经熟悉使用AI智能聊天机器人4 的插件的朋友们&#xff0c;直接在应用市场里搜索…
阅读更多...
vtkdicom0.8_vtk9.2_dcmtk3.6.7_qt6.2编译OK

vtkdicom0.8_vtk9.2_dcmtk3.6.7_qt6.2编译OK

目录 0 结果展示 1 cmake要点 2 编译报错解决 3 参考链接 0 结果展示 1 cmake要点 注意DCMTK_dcmtk_INCLUDE_DIR 2 编译报错解决 D:\Work\C\qt6Work\DCMTK\install\bin\dcmtkcharls.dll : fatal error LNK1107: 文件无效或损坏: 无法在 0x308 处读取 修改&#xff0c;从…
阅读更多...
docker安装mysql并且进行连接

docker安装mysql并且进行连接

1、拉取镜像、在linux中执行命令 docker pull mysql 2、运行容器、在linux中执行命令 docker run -d --name mysql -p 3308:3306 -e MYSQL_ROOT_PASSWORD123456 mysql3、 进入容器、在linux中执行命令 docker ps -a docker exec -it 2a85f05d4090 /bin/bash 4、登录docker中的m…
阅读更多...
MySQL日志详解

MySQL日志详解

♥️作者&#xff1a;小刘在C站 ♥️个人主页&#xff1a; 小刘主页 ♥️努力不一定有回报&#xff0c;但一定会有收获加油&#xff01;一起努力&#xff0c;共赴美好人生&#xff01; ♥️学习两年总结出的运维经验&#xff0c;以及思科模拟器全套网络实验教程。专栏&#xf…
阅读更多...
基于SpringBoot+vue的校园新闻网站设计与实现

基于SpringBoot+vue的校园新闻网站设计与实现

博主介绍&#xff1a; 大家好&#xff0c;我是一名在Java圈混迹十余年的程序员&#xff0c;精通Java编程语言&#xff0c;同时也熟练掌握微信小程序、Python和Android等技术&#xff0c;能够为大家提供全方位的技术支持和交流。 我擅长在JavaWeb、SSH、SSM、SpringBoot等框架…
阅读更多...
移动WEB开发之流式布局

移动WEB开发之流式布局

css基础&#xff08;一&#xff09;css基础&#xff08;一&#xff09;_上半场结束&#xff0c;中场已休息&#xff0c;下半场ing的博客-CSDN博客Emmet语法Emmet语法_上半场结束&#xff0c;中场已休息&#xff0c;下半场ing的博客-CSDN博客css基础&#xff08;二&#xff09;c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023