Android服务之PackageManagerService启动源码分析

2024-02-05 10:32
文章标签 分析 android 源码 服务 启动 packagemanagerservice

本文主要是介绍Android服务之PackageManagerService启动源码分析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

http://blog.csdn.net/yangwen123/article/details/9464779


版权声明：本文为博主原创文章，未经博主允许不得转载。

了解了Android系统的启动过程的读者应该知道，Android的所有Java服务都是通过SystemServer进程启动的，并且驻留在SystemServer进程中。SystemServer进程在启动时，通过创建一个ServerThread线程来启动所有服务，本文主要介绍Android服务中PackageManagerService服务启动过程。首先介绍一些PackageManagerService服务下的相关类关系图：


在SystemServer进程的ServerThread线程中，执行以下代码启动PackageManagerService服务：

[java]  view plain copy
  1. // 通过读取属性来判断运行核心应用  
  2. String cryptState = SystemProperties.get("vold.decrypt");  
  3. boolean onlyCore = false;  
  4. if (ENCRYPTING_STATE.equals(cryptState)) {  
  5.     Slog.w(TAG, "Detected encryption in progress - only parsing core apps");  
  6.     onlyCore = true;  
  7. } else if (ENCRYPTED_STATE.equals(cryptState)) {  
  8.     Slog.w(TAG, "Device encrypted - only parsing core apps");  
  9.     onlyCore = true;  
  10. }  
  11. //启动PackageManagerService  
  12. pm = PackageManagerService.main(context,  
  13.         factoryTest != SystemServer.FACTORY_TEST_OFF,  
  14.         onlyCore);  
  15. boolean firstBoot = false;  
  16. //判断PackageManagerService是否是第一次启动，SystemServer进程被杀后会被重启  
  17. try {  
  18.     firstBoot = pm.isFirstBoot();  
  19. } catch (RemoteException e) {  
  20. }  
  21. //PackageManagerService执行dex优化  
  22. ...  
  23. try {  
  24.     pm.performBootDexOpt();  
  25. } catch (Throwable e) {  
  26.     reportWtf("performing boot dexopt", e);  
  27. }  

首先启动PackageManagerService，然后判断该服务是否是第一次启动，接着执行dex优化。

[java]  view plain copy
  1. public static final IPackageManager main(Context context, boolean factoryTest,  
  2.         boolean onlyCore) {  
  3.     //构造PackageManagerService服务对象  
  4.     PackageManagerService m = new PackageManagerService(context, factoryTest, onlyCore);  
  5.     //注册PackageManagerService服务  
  6.     ServiceManager.addService("package", m);  
  7.     return m;  
  8. }  

启动过程比较简单，就是构造一个PackageManagerService对象，然后将该服务对象注册到ServiceManger进程中，关于服务注册过程请查看Android服务注册完整过程源码分析。PackageManagerService对象构造过程非常复杂，构造过程分几个阶段.

[java]  view plain copy
  1. //PackageManagerService启动开始  
  2. EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,SystemClock.uptimeMillis());  
  3. //SDK版本检查  
  4. if (mSdkVersion <= 0) {  
  5.     Slog.w(TAG, "**** ro.build.version.sdk not set!");  
  6. }  
  7. //读取开机启动模式  
  8. String mode = SystemProperties.get("ro.bootmode", "mode");  
  9. engModeEnable = "engtest".equals(mode)?true:false;  
  10. Slog.i(TAG, "engModeEnable: " + engModeEnable + " ,mode:"+mode);  
  11. mContext = context;  
  12. mFactoryTest = factoryTest;//开机模式  
  13. mOnlyCore = onlyCore;//是否对包做dex优化  
  14. //如果编译版本为eng，则不需要dex优化  
  15. mNoDexOpt = "eng".equals(SystemProperties.get("ro.build.type"));  
  16. //创建显示尺寸信息  
  17. mMetrics = new DisplayMetrics();  
  18. //存储系统运行过程中的设置信息  
  19. mSettings = new Settings();  
  20. /*创建SharedUserSetting对象并添加到Settings的成员变量mSharedUsers中,在Android系统中，多个package通过设置sharedUserId属性可以运行在同一个进程，共享同一个UID*/  
  21. mSettings.addSharedUserLPw("android.uid.system",Process.SYSTEM_UID, ApplicationInfo.FLAG_SYSTEM);  
  22. mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID, ApplicationInfo.FLAG_SYSTEM);  
  23. mSettings.addSharedUserLPw("android.uid.log", LOG_UID, ApplicationInfo.FLAG_SYSTEM);  
  24. mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID, ApplicationInfo.FLAG_SYSTEM);  
  25. String separateProcesses = SystemProperties.get("debug.separate_processes");  
  26. if (separateProcesses != null && separateProcesses.length() > 0) {  
  27.     if ("*".equals(separateProcesses)) {  
  28.         mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;  
  29.         mSeparateProcesses = null;  
  30.         Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");  
  31.     } else {  
  32.         mDefParseFlags = 0;  
  33.         mSeparateProcesses = separateProcesses.split(",");  
  34.         Slog.w(TAG, "Running with debug.separate_processes: "  
  35.                 + separateProcesses);  
  36.     }  
  37. } else {  
  38.     mDefParseFlags = 0;  
  39.     mSeparateProcesses = null;  
  40. }  
  41. mPreInstallDir = new File("/system/preloadapp");  
  42. //创建应用安装器  
  43. mInstaller = new Installer();  
  44. //获取屏幕尺寸大小  
  45. WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);  
  46. Display d = wm.getDefaultDisplay();  
  47. d.getMetrics(mMetrics);  
  48. synchronized (mInstallLock) {  
  49. // writer  
  50. synchronized (mPackages) {  
  51.     //启动消息处理线程  
  52.     mHandlerThread.start();  
  53.     //为消息处理线程创建一个消息分发handler  
  54.     mHandler = new PackageHandler(mHandlerThread.getLooper());  
  55.     // dataDir =/data/  
  56.     File dataDir = Environment.getDataDirectory();  
  57.     // mAppDataDir = /data/data  
  58.     mAppDataDir = new File(dataDir, "data");  
  59.     // mAsecInternalPath = /data/app-asec  
  60.     mAsecInternalPath = new File(dataDir, "app-asec").getPath();  
  61.     // mUserAppDataDir = /data/user  
  62.     mUserAppDataDir = new File(dataDir, "user");  
  63.     // mDrmAppPrivateInstallDir = /data/app-private  
  64.     mDrmAppPrivateInstallDir = new File(dataDir, "app-private");  
  65.     sUserManager = new UserManager(mInstaller, mUserAppDataDir);  
  66.     //读取并解析/etc/permissions下的XML文件  
  67.     readPermissions();  
  68.     mRestoredSettings = mSettings.readLPw(getUsers());  
函数首先创建一个Settings对象，用来保存一些设置信息，然后调用addSharedUserLPw向Settings类的成员变量mSharedUsers中添加SharedUserSetting对象，在Android系统中，通过设置android:sharedUserId="android.uid.system"属性可以为应用程序指定UID，SharedUserSetting对象保存同一共享进程UID的所有包信息，Settings对象用于管理Android系统运行过程中的一些设置信息，Settings的成员变量mSharedUsers以键值对的方式保存UID对应的SharedUserSetting对象。在Android系统中，可以通过在AndroidManifest.xml文件中设置sharedUserId属性来设置多个APK运行在同一个进程中。PackageManagerService的任务就是构造一些数据结构来保存所有APK的配置信息，关于Settings类之间的关系图如下：


PackageSignatures来用来描述Android应用程序安装包的签名信息，GrantedPermissions类用于描述应用APK的权限信息。Settings类的成员变量mSharedUsers是一个HashMap，用键值对的形式保存所有的SharedUserSetting对象，SharedUserSetting对象用于记录共享同一进程的所有APK信息，该类的成员变量packages的类型为PackageSetting，用来保存所有共享同一UID的包信息，而成员变量userId则是记录多个APK共享的UID。首先介绍Settings对象的构造过程：

[java]  view plain copy
  1. Settings() {  
  2.     //调用另外一个有参构造函数  
  3.     this(Environment.getDataDirectory());  
  4. }  
  5.   
  6. Settings(File dataDir) {  
  7.     //创建/data/system/目录  
  8.     mSystemDir = new File(dataDir, "system");  
  9.     mSystemDir.mkdirs();  
  10.     //设置/data/system目录的权限  
  11.     FileUtils.setPermissions(mSystemDir.toString(),  
  12.             FileUtils.S_IRWXU|FileUtils.S_IRWXG  
  13.             |FileUtils.S_IROTH|FileUtils.S_IXOTH,  
  14.             -1, -1);  
  15.     //mSettingsFilename=/data/system/packages.xml  
  16.     mSettingsFilename = new File(mSystemDir, "packages.xml");  
  17.     //mBackupSettingsFilename=/data/system/packages-backup.xml  
  18.     mBackupSettingsFilename = new File(mSystemDir, "packages-backup.xml");  
  19.     //mPackageListFilename=/data/system/packages.list  
  20.     mPackageListFilename = new File(mSystemDir, "packages.list");  
  21.     // Deprecated: Needed for migration  
  22.     //mStoppedPackagesFilename = /data/system/packages-stopped.xml  
  23.     mStoppedPackagesFilename = new File(mSystemDir, "packages-stopped.xml");  
  24.     //mStoppedPackagesFilename = /data/system/packages-stopped-backup.xml  
  25.     mBackupStoppedPackagesFilename = new File(mSystemDir, "packages-stopped-backup.xml");  
  26. }  

Settings对象的构造过程很简单，就是创建一些目录和文件。首先创建/data/system/目录，然后分别创建以下四个文件：

/data/system/packages.xml

/data/system/packages-backup.xml

/data/system/packages.list

/data/system/packages-stopped.xml

/data/system/packages-stopped-backup.xml

Settings通过addSharedUserLPw函数添加向mSharedUsers预先添加SharedUserSetting对象

[java]  view plain copy
  1. SharedUserSetting addSharedUserLPw(String name, int uid, int pkgFlags) {  
  2.     //根据进程UID对应的名称从成员变量mSharedUsers中查找对应的SharedUserSetting对象  
  3.     SharedUserSetting s = mSharedUsers.get(name);  
  4.     //返回查找到的结果  
  5.     if (s != null) {  
  6.         if (s.userId == uid) {  
  7.             return s;  
  8.         }  
  9.         PackageManagerService.reportSettingsProblem(Log.ERROR,  
  10.                 "Adding duplicate shared user, keeping first: " + name);  
  11.         return null;  
  12.     }  
  13.     //没有查找到对应的SharedUserSetting对象，则创建一个新的SharedUserSetting对象。  
  14.     s = new SharedUserSetting(name, pkgFlags);  
  15.     s.userId = uid;  
  16.     //添加到成员变量mUserIds，mOtherUserIds中，这两个变量主要是加快查找速度  
  17.     if (addUserIdLPw(uid, s, name)) {  
  18.         //添加到mSharedUsers表中  
  19.         mSharedUsers.put(name, s);  
  20.         return s;  
  21.     }  
  22.     return null;  
  23. }  

函数首先根据字符串名称从成员变量mSharedUsers哈希表中查找对应的SharedUserSetting对象，如果表中不存在对应的SharedUserSetting对象，则创建一个新的SharedUserSetting对象，并初始化该对象的域，然后根据UID的大小通过函数addUserIdLPw添加到mUserIds或mOtherUserIds中，同时以键值对的形式保存在mSharedUsers中。

[java]  view plain copy
  1. private boolean addUserIdLPw(int uid, Object obj, Object name) {  
  2.     //判断添加的UID是否大于19999  
  3.     if (uid > Process.LAST_APPLICATION_UID) {  
  4.         return false;  
  5.     }  
  6.     //判断添加的UID是否大于等于10000  
  7.     if (uid >= Process.FIRST_APPLICATION_UID) {  
  8.         //计算在数组中的索引为uid-10000  
  9.         int N = mUserIds.size();  
  10.         final int index = uid - Process.FIRST_APPLICATION_UID;  
  11.         while (index >= N) {  
  12.             mUserIds.add(null);  
  13.             N++;  
  14.         }  
  15.         if (mUserIds.get(index) != null) {  
  16.             PackageManagerService.reportSettingsProblem(Log.ERROR,  
  17.                     "Adding duplicate user id: " + uid  
  18.                     + " name=" + name);  
  19.             return false;  
  20.         }  
  21.         //添加的SharedUserSetting对象到mUserIds动态数组中  
  22.         mUserIds.set(index, obj);  
  23.     } else {//将UID小于1000，则将SharedUserSetting对象添加到mOtherUserIds数组中  
  24.         if (mOtherUserIds.get(uid) != null) {  
  25.             PackageManagerService.reportSettingsProblem(Log.ERROR,  
  26.                     "Adding duplicate shared id: " + uid  
  27.                     + " name=" + name);  
  28.             return false;  
  29.         }  
  30.         mOtherUserIds.put(uid, obj);  
  31.     }  
  32.     return true;  
  33. }  

Android定义了应用程序的UID范围，对于非系统应用，UID介于1000到1999之间，而对于系统应用，UID小于1000

[java]  view plain copy
  1. public static final int SYSTEM_UID = 1000;  
  2. public static final int PHONE_UID = 1001;  
  3. public static final int SHELL_UID = 2000;  
  4. public static final int LOG_UID = 1007;  
  5. public static final int WIFI_UID = 1010;  
  6. public static final int MEDIA_UID = 1013;  
  7. public static final int DRM_UID = 1019;  
  8. public static final int SDCARD_RW_GID = 1015;  
  9. public static final int VPN_UID = 1016;  
  10. public static final int NFC_UID = 1027;  
  11. public static final int MEDIA_RW_GID = 1023;  
  12. //应用程序UID范围  
  13. public static final int FIRST_APPLICATION_UID = 10000;  
  14. public static final int LAST_APPLICATION_UID = 19999;  
  15. //fully isolated sandboxed processes UID范围  
  16. public static final int FIRST_ISOLATED_UID = 99000;  
  17. public static final int LAST_ISOLATED_UID = 99999;  

addUserIdLPw函数将UID介于1000到1999之间的SharedUserSetting对象添加到mUserIds数组中，通过UID来索引数组元素。



UID小于1000的SharedUserSetting保存到数组mOtherUserIds中。回到PackageManagerService的构造函数中，通过Settings的addSharedUserLPw函数向mSharedUsers，mUserIds，mOtherUserIds数组添加了4个特定进程的SharedUserSetting对象。


[java]  view plain copy
  1. mPreInstallDir = new File("/system/preloadapp");  
  2. //创建应用安装器  
  3. mInstaller = new Installer();  
  4. //获取屏幕尺寸大小  
  5. WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);  
  6. Display d = wm.getDefaultDisplay();  
  7. d.getMetrics(mMetrics);  
  8. synchronized (mInstallLock) {  
  9. // writer  
  10. synchronized (mPackages) {  
  11.     //启动消息处理线程  
  12.     mHandlerThread.start();  
  13.     //为消息处理线程创建一个消息分发handler  
  14.     mHandler = new PackageHandler(mHandlerThread.getLooper());  
  15.     // dataDir =/data/  
  16.     File dataDir = Environment.getDataDirectory();  
  17.     // mAppDataDir = /data/data  
  18.     mAppDataDir = new File(dataDir, "data");  
  19.     // mAsecInternalPath = /data/app-asec  
  20.     mAsecInternalPath = new File(dataDir, "app-asec").getPath();  
  21.     // mUserAppDataDir = /data/user  
  22.     mUserAppDataDir = new File(dataDir, "user");  
  23.     // mDrmAppPrivateInstallDir = /data/app-private  
  24.     mDrmAppPrivateInstallDir = new File(dataDir, "app-private");  

首先创建Installer对象，用于访问installd服务进程，完成一些apk安装，卸载，优化工作。然后通过WindowManager得到屏幕尺寸信息，接着启动一个名为PackageManager的消息线程，该线程是PackageManagerService的工作线程，mHandlerThread线程是一个带消息循环的工作线程，在定义该线程对象的时候就已经创建

[java]  view plain copy
  1. final HandlerThread mHandlerThread = new HandlerThread("PackageManager",Process.THREAD_PRIORITY_BACKGROUND);  

同时为该消息线程创建了一个消息分发器PackageHandler对象，通过该handler对象可以往PackageManager线程发送消息，PackageManager线程通过消息循环处理发送进来的消息，消息处理过程如下：

[java]  view plain copy
  1. public void handleMessage(Message msg) {  
  2.     try {  
  3.         //直接调用doHandleMessage函数来处理各种消息  
  4.         doHandleMessage(msg);  
  5.     } finally {  
  6.         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
  7.     }  
  8. }  

这里暂时不介绍doHandleMessage函数，在介绍特定消息时，在来分析该函数对各种消息的处理过程。PackageManagerService的线程模型如下：




最后就是创建一些安装目录：

/system/preloadapp

/data/data

/data/app-asec

/data/user

/data/data

/data/app-private

创建用户管理对象UserManager：

[java]  view plain copy
  1. sUserManager = new UserManager(mInstaller, mUserAppDataDir);  

构造了一个UserManager，参数一为应用程序安装器Installer，参数二为用户安装目录/data/user

[java]  view plain copy
  1. public UserManager(Installer installer, File baseUserPath) {  
  2.     this(Environment.getDataDirectory(), baseUserPath);  
  3.     mInstaller = installer;  
  4. 　　}  
  5. 　　  
  6. 　　UserManager(File dataDir, File baseUserPath) {  
  7. 　　  // mUsersDir=/data/system/users  
  8.     mUsersDir = new File(dataDir, USER_INFO_DIR);  
  9.     mUsersDir.mkdirs();  
  10. 　　  // userZeroDir=/data/system/users/0  
  11.     File userZeroDir = new File(mUsersDir, "0");  
  12.     userZeroDir.mkdirs();  
  13.     //mBaseUserPath=/data/user  
  14.     mBaseUserPath = baseUserPath;  
  15.     FileUtils.setPermissions(mUsersDir.toString(),  
  16.                    FileUtils.S_IRWXU|FileUtils.S_IRWXG  
  17.             |FileUtils.S_IROTH|FileUtils.S_IXOTH,  
  18.             -1, -1);  
  19.     // mUserListFile=/data/system/users/userlist.xml  
  20.     mUserListFile = new File(mUsersDir, USER_LIST_FILENAME);  
  21.     readUserList();  
  22. }  

构造过程比较简单，就是创建几个目录和几个文件：

/data/system/users

/data/system/users/0

/data/system/users/userlist.xml

然后通过函数readUserList读取用户列表，这里不在介绍该函数的实现，该函数就是从userlist.xml文件中读取用户信息，保存到UserManager的成员变量mUsers中。

读取权限配置信息：
[java]  view plain copy
  1. //读取并解析/etc/permissions下的XML文件  
  2. readPermissions();  

函数首先调用readPermissions扫描读取并解析/etc/permissions文件夹下的XML文件，并将解析的数据保存到PackageManagerService的成员变量中



[java]  view plain copy
  1. void readPermissions() {  
  2.     // Read permissions from .../etc/permission directory.  
  3.     File libraryDir = new File(Environment.getRootDirectory(), "etc/permissions");  
  4.     if (!libraryDir.exists() || !libraryDir.isDirectory()) {  
  5.         Slog.w(TAG, "No directory " + libraryDir + ", skipping");  
  6.         return;  
  7.     }  
  8.     if (!libraryDir.canRead()) {  
  9.         Slog.w(TAG, "Directory " + libraryDir + " cannot be read");  
  10.         return;  
  11.     }  
  12.     // 循环读取etc/permissions目录下的XML文件  
  13.     for (File f : libraryDir.listFiles()) {  
  14.         // 跳过platform.xml文件，最后读取该文件  
  15.         if (f.getPath().endsWith("etc/permissions/platform.xml")) {  
  16.             continue;  
  17.         }  
  18.         if (!f.getPath().endsWith(".xml")) {  
  19.             Slog.i(TAG, "Non-xml file " + f + " in " + libraryDir + " directory, ignoring");  
  20.             continue;  
  21.         }  
  22.         if (!f.canRead()) {  
  23.             Slog.w(TAG, "Permissions library file " + f + " cannot be read");  
  24.             continue;  
  25.         }  
  26.         readPermissionsFromXml(f);  
  27.     }  
  28.     // Read permissions from .../etc/permissions/platform.xml last so it will take precedence  
  29.     final File permFile = new File(Environment.getRootDirectory(),"etc/permissions/platform.xml");  
  30.     readPermissionsFromXml(permFile);  
  31. }  
在etc/permissions目录下保存了一下配置文件


这些文件在编译的时候直接从frameworks指定目录下拷贝过来的，在特定product编译目录下的base.mk文件中的配置如下：


函数readPermissionsFromXml使用PULL方式解析这些XML文件,下面分别介绍各个标签的解析过程。

feature标签用来描述设备应该支持的硬件特性。解析过程如下：

[java]  view plain copy
  1. else if ("feature".equals(name)) {  
  2.     //读取熟悉name的值  
  3.     String fname = parser.getAttributeValue(null, "name");  
  4.     if (fname == null) {  
  5.         Slog.w(TAG, "<feature> without name at "+ parser.getPositionDescription());  
  6.     } else {  
  7.         //创建一个FeatureInfo对象  
  8.         FeatureInfo fi = new FeatureInfo();  
  9.         fi.name = fname;  
  10.         //mAvailableFeatures是PackageManagerService的成员变量，以HashMap的方式保存硬件支持的特性  
  11.         mAvailableFeatures.put(fname, fi);  
  12.     }  
  13.     XmlUtils.skipCurrentTag(parser);  
  14.     continue;  
  15. }  

library用于指定系统库，当应用程序运行时，系统会为进程加载一些必要库。该标签的解析过程如下：

[java]  view plain copy
  1. else if ("library".equals(name)) {  
  2.     //读取属性name的值  
  3.     String lname = parser.getAttributeValue(null, "name");  
  4.     //读取属性file的值  
  5.     String lfile = parser.getAttributeValue(null, "file");  
  6.     if (lname == null) {  
  7.         Slog.w(TAG, "<library> without name at "+ parser.getPositionDescription());  
  8.     } else if (lfile == null) {  
  9.         Slog.w(TAG, "<library> without file at "+ parser.getPositionDescription());  
  10.     } else {  
  11.         //mSharedLibraries是PackageManagerService的成员变量，以HashMap的形式保存进程运行库  
  12.         mSharedLibraries.put(lname, lfile);  
  13.     }  
  14.     XmlUtils.skipCurrentTag(parser);  
  15.     continue;  
  16. }  

group标签用于建立Android层与Linux层之间的权限映射关系。

[java]  view plain copy
  1. else if ("permission".equals(name)) {  
  2.     //读取属性name的值  
  3.     String perm = parser.getAttributeValue(null, "name");  
  4.     if (perm == null) {  
  5.         Slog.w(TAG, "<permission> without name at "+ parser.getPositionDescription());  
  6.         XmlUtils.skipCurrentTag(parser);  
  7.         continue;  
  8.     }  
  9.     perm = perm.intern();  
  10.     readPermission(parser, perm);  
  11. }   
  12.   
  13. void readPermission(XmlPullParser parser, String name)  
  14.         throws IOException, XmlPullParserException {  
  15.     name = name.intern();  
  16.     //根据name在mSettings.mPermissions表中查找对应的BasePermission对象  
  17.     BasePermission bp = mSettings.mPermissions.get(name);  
  18.     //如果不存在，则创建一个新的BasePermission对象，并保存到mSettings.mPermissions中  
  19.     if (bp == null) {  
  20.         bp = new BasePermission(name, null, BasePermission.TYPE_BUILTIN);  
  21.         mSettings.mPermissions.put(name, bp);  
  22.     }  
  23.     int outerDepth = parser.getDepth();  
  24.     int type;  
  25.     while ((type=parser.next()) != XmlPullParser.END_DOCUMENT  
  26.            && (type != XmlPullParser.END_TAG  
  27.                    || parser.getDepth() > outerDepth)) {  
  28.         if (type == XmlPullParser.END_TAG  
  29.                 || type == XmlPullParser.TEXT) {  
  30.             continue;  
  31.         }  
  32.         String tagName = parser.getName();  
  33.         //读取标签group的属性gid值  
  34.         if ("group".equals(tagName)) {  
  35.             String gidStr = parser.getAttributeValue(null, "gid");  
  36.             if (gidStr != null) {  
  37.                 //根据gid字符串，找到对应的gid数值  
  38.                 int gid = Process.getGidForName(gidStr);  
  39.                 //设置BasePermission对象的gid值  
  40.                 bp.gids = appendInt(bp.gids, gid);  
  41.             } else {  
  42.                 Slog.w(TAG, "<group> without gid at "+ parser.getPositionDescription());  
  43.             }  
  44.         }  
  45.         XmlUtils.skipCurrentTag(parser);  
  46.     }  
  47. }  
assign-permission标签将解析到的内容保存到mSettings.mPermissions中
[java]  view plain copy
  1. else if ("assign-permission".equals(name)) {  
  2.      //读取属性name的值  
  3.     String perm = parser.getAttributeValue(null, "name");  
  4.     if (perm == null) {  
  5.         Slog.w(TAG, "<assign-permission> without name at "+ parser.getPositionDescription());  
  6.         XmlUtils.skipCurrentTag(parser);  
  7.         continue;  
  8.     }  
  9.     //读取属性uid的值  
  10.     String uidStr = parser.getAttributeValue(null, "uid");  
  11.     if (uidStr == null) {  
  12.         Slog.w(TAG, "<assign-permission> without uid at "+ parser.getPositionDescription());  
  13.         XmlUtils.skipCurrentTag(parser);  
  14.         continue;  
  15.     }  
  16.     //根据属性uid字符串转换为uid数值  
  17.     int uid = Process.getUidForName(uidStr);  
  18.     if (uid < 0) {  
  19.         Slog.w(TAG, "<assign-permission> with unknown uid \""+ uidStr + "\" at "+ parser.getPositionDescription());  
  20.         XmlUtils.skipCurrentTag(parser);  
  21.         continue;  
  22.     }  
  23.     //保存到mSystemPermissions表中  
  24.     perm = perm.intern();  
  25.     HashSet<String> perms = mSystemPermissions.get(uid);  
  26.     if (perms == null) {  
  27.         perms = new HashSet<String>();  
  28.         mSystemPermissions.put(uid, perms);  
  29.     }  
  30.     perms.add(perm);  
  31.     XmlUtils.skipCurrentTag(parser);  
  32. }   

读取安装包信息

/data/system/packages.xml文件用于记录系统中所安装的Package信息；/data/system/packages-backup.xml文件是/data/packages.xml文件的备份。在PackageManagerService扫描完目标文件夹后会创建该文件，当系统进行程序安装卸载时会更新该文件。
/data/system/packages-stopped.xml文件用于记录系统中强制停止运行的Package信息。/data/system/packages-stopped-backup.xml是/data/packages-stopped.xml文件的备份。在强制停止某个应用时，会将应用相关信息记录到该文件中。
/data/system/packages.list保存系统中存在的所有非系统自带的APK信息，即UID大于1000的apk。


当系统第一次开机时，这些文件并不存在，而在以后的开机中，扫描到的这些XML文件是上一次运行过程中创建的。

[java]  view plain copy
  1. boolean readLPw(List<UserInfo> users) {  
  2.     FileInputStream str = null;  
  3.     //如果/data/system/packages-backup.xml文件存在  
  4.     if (mBackupSettingsFilename.exists()) {  
  5.         try {  
  6.             //读取/data/system/packages-backup.xml文件  
  7.             str = new FileInputStream(mBackupSettingsFilename);  
  8.             mReadMessages.append("Reading from backup settings file\n");  
  9.             PackageManagerService.reportSettingsProblem(Log.INFO,"Need to read from backup settings file");  
  10.             //当/data/system/packages.xml文件的备份文件存在时，删除packages.xml文件  
  11.             if (mSettingsFilename.exists()) {  
  12.                 Slog.w(PackageManagerService.TAG, "Cleaning up settings file "+ mSettingsFilename);  
  13.                 mSettingsFilename.delete();  
  14.             }  
  15.         } catch (java.io.IOException e) {  
  16.             // We'll try for the normal settings file.  
  17.         }  
  18.     }  
  19.     mPendingPackages.clear();  
  20.     mPastSignatures.clear();  
  21.     try {  
  22.         //如果/data/system/packages-backup.xml文件为空  
  23.         if (str == null) {  
  24.             //同时/data/system/packages.xml文件不存在  
  25.             if (!mSettingsFilename.exists()) {  
  26.                 mReadMessages.append("No settings file found\n");  
  27.                 PackageManagerService.reportSettingsProblem(Log.INFO,  
  28.                         "No settings file; creating initial state");  
  29.                 //读取/etc/preferred-apps目录下的xml文件  
  30.                 readDefaultPreferredAppsLPw();  
  31.                 return false;  
  32.             }  
  33.             //如果packages.xml的备份文件为空，读取packages.xml文件内容  
  34.             str = new FileInputStream(mSettingsFilename);  
  35.         }  
  36.         //解析文件内容  
  37.         XmlPullParser parser = Xml.newPullParser();  
  38.         parser.setInput(str, null);  
  39.         int type;  
  40.         while ((type = parser.next()) != XmlPullParser.START_TAG  
  41.                 && type != XmlPullParser.END_DOCUMENT) {  
  42.             ;  
  43.         }  
  44.         ...  
  45. }  

接下来检测并优化BOOTCLASSPATH环境变量指定的Java运行库及platform.xml中配置的Java库，同时优化/system/framework目录下的Jar包和apk文件，最后删除/data/dalvik-cache目录下的一些缓存文件。在init.rc中配置的BOOTCLASSPATH如下：

[java]  view plain copy
  1. long startTime = SystemClock.uptimeMillis();  
  2. EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,startTime);  
  3. // 设置扫描模式  
  4. int scanMode = SCAN_MONITOR | SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING;  
  5. if (mNoDexOpt) {  
  6.     Slog.w(TAG, "Running ENG build: no pre-dexopt!");  
  7.     scanMode |= SCAN_NO_DEX;  
  8. }  
  9. //保存库文件路径  
  10. final HashSet<String> libFiles = new HashSet<String>();  
  11. //mFrameworkDir = /framework/  
  12. mFrameworkDir = new File(Environment.getRootDirectory(), "framework");  
  13. //mDalvikCacheDir = /data/dalvik-cache/  
  14. mDalvikCacheDir = new File(dataDir, "dalvik-cache");  
  15. boolean didDexOpt = false;  
  16. //通过属性的方式得到启动Java启动类库的路径,在init.rc中通过BOOTCLASSPATH环境变量的方式设置  
  17. String bootClassPath = System.getProperty("java.boot.class.path");  
  18. if (bootClassPath != null) {  
  19.     String[] paths = splitString(bootClassPath, ':');  
  20.     for (int i=0; i<paths.length; i++) {  
  21.         try {  
  22.             //判断Jar包是否需要dex优化  
  23.             if (dalvik.system.DexFile.isDexOptNeeded(paths[i])) {  
  24.                 //如果需要则添加到libFiles表中  
  25.                 libFiles.add(paths[i]);  
  26.                 //通过安装器请求installd服务进程执行dex优化  
  27.                 mInstaller.dexopt(paths[i], Process.SYSTEM_UID, true);  
  28.                 didDexOpt = true;  
  29.             }  
  30.         } catch (FileNotFoundException e) {  
  31.             Slog.w(TAG, "Boot class path not found: " + paths[i]);  
  32.         } catch (IOException e) {  
  33.             Slog.w(TAG, "Cannot dexopt " + paths[i] + "; is it an APK or JAR? "  
  34.                     + e.getMessage());  
  35.         }  
  36.     }  
  37. } else {  
  38.     Slog.w(TAG, "No BOOTCLASSPATH found!");  
  39. }  
  40. //在前面解析platfor.xml时，将一些额外的类库路径保存到了mSharedLibraries变量中  
  41. if (mSharedLibraries.size() > 0) {  
  42.     //循环变量mSharedLibraries变量  
  43.     Iterator<String> libs = mSharedLibraries.values().iterator();  
  44.     while (libs.hasNext()) {  
  45.         String lib = libs.next();  
  46.         try {  
  47.             //判断Jar包是否需要dex优化  
  48.             if (dalvik.system.DexFile.isDexOptNeeded(lib)) {  
  49.                 //如果需要则添加到libFiles表中  
  50.                 libFiles.add(lib);  
  51.                 //通过安装器进行dex优化  
  52.                 mInstaller.dexopt(lib, Process.SYSTEM_UID, true);  
  53.                 didDexOpt = true;  
  54.             }  
  55.         } catch (FileNotFoundException e) {  
  56.             Slog.w(TAG, "Library not found: " + lib);  
  57.         } catch (IOException e) {  
  58.             Slog.w(TAG, "Cannot dexopt " + lib + "; is it an APK or JAR? "  
  59.                     + e.getMessage());  
  60.         }  
  61.     }  
  62. }  
  63. //将/system/frameworks/framework-res.apk添加到libFiles中  
  64. libFiles.add(mFrameworkDir.getPath() + "/framework-res.apk");  
  65. //列出/system/frameworks目录下的文件  
  66. String[] frameworkFiles = mFrameworkDir.list();  
  67. if (frameworkFiles != null) {  
  68.     //遍历/system/frameworks目录下的文件  
  69.     for (int i=0; i<frameworkFiles.length; i++) {  
  70.         File libPath = new File(mFrameworkDir, frameworkFiles[i]);  
  71.         String path = libPath.getPath();  
  72.         //判断libFiles中是否已经包含该文件，如果包含则跳过  
  73.         if (libFiles.contains(path)) {  
  74.             continue;  
  75.         }  
  76.         //跳过不是apk或jar文件  
  77.         if (!path.endsWith(".apk") && !path.endsWith(".jar")) {  
  78.             continue;  
  79.         }  
  80.         try {  
  81.             //判断Jar包或apk是否需要dex优化  
  82.             if (dalvik.system.DexFile.isDexOptNeeded(path)) {  
  83.                 //通过安装器进行dex优化  
  84.                 mInstaller.dexopt(path, Process.SYSTEM_UID, true);  
  85.                 didDexOpt = true;  
  86.             }  
  87.         } catch (FileNotFoundException e) {  
  88.             Slog.w(TAG, "Jar not found: " + path);  
  89.         } catch (IOException e) {  
  90.             Slog.w(TAG, "Exception reading jar: " + path, e);  
  91.         }  
  92.     }  
  93. }  
  94. //如果前面对某个文件做过优化，只要优化了，didDexOpt就被设置为true  
  95. if (didDexOpt) {  
  96.     //遍历/data/dalvik-cache目录下的文件  
  97.     String[] files = mDalvikCacheDir.list();  
  98.     if (files != null) {  
  99.         for (int i=0; i<files.length; i++) {  
  100.             String fn = files[i];  
  101.             //删除文件名以"data@app@"和"data@app-private@"开头的文件  
  102.             if (fn.startsWith("data@app@")  
  103.                     || fn.startsWith("data@app-private@")) {  
  104.                 Slog.i(TAG, "Pruning dalvik file: " + fn);  
  105.                 (new File(mDalvikCacheDir, fn)).delete();  
  106.             }  
  107.         }  
  108.     }  
  109. }  
接着扫描系统apk信息

[java]  view plain copy
  1. mFlagInstall = false;  
  2. //创建文件夹监控对象，监视/system/framework目录  
  3. mFrameworkInstallObserver = new AppDirObserver(mFrameworkDir.getPath(), OBSERVER_EVENTS, true);  
  4. mFrameworkInstallObserver.startWatching();  
  5. //扫描/system/framework目录下的apk文件，扫描模式设置为非优化模式  
  6. scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM| PackageParser.PARSE_IS_SYSTEM_DIR,scanMode | SCAN_NO_DEX, 0);  
  7. //在工厂模式下，调用函数scanDirLIOnly只扫描特定的apk文件  
  8. if(engModeEnable){  
  9.     //temp null  
  10.     mVendorAppDir = null;  
  11.     mDrmAppInstallObserver = null;  
  12.     mSystemAppDir = null;  
  13.     mAppInstallObserver = null;  
  14.     mSystemInstallObserver = null;  
  15.     mPreInstallObserver = null;  
  16.     mVendorInstallObserver = null;  
  17.     mAppInstallDir = null;  
  18.     Slog.i(TAG, " begin scan the apps !");  
  19.     scanDirLIOnly(PackageParser.PARSE_IS_SYSTEM | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);  
  20.     Slog.i(TAG, " end scan the apps !");  
  21.     engModeEnable = false;  
  22. }else{//正常模式下  
  23.     //创建文件夹监控对象，监视/system/app目录  
  24.     mSystemAppDir = new File(Environment.getRootDirectory(), "app");  
  25.     mSystemInstallObserver = new AppDirObserver(  
  26.         mSystemAppDir.getPath(), OBSERVER_EVENTS, true);  
  27.     mSystemInstallObserver.startWatching();  
  28.     //扫描/system/app目录  
  29.     scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM| PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);  
  30.     //创建文件夹监控对象，监视/vendor/app目录  
  31.     mVendorAppDir = new File("/vendor/app");  
  32.     mVendorInstallObserver = new AppDirObserver(  
  33.         mVendorAppDir.getPath(), OBSERVER_EVENTS, true);  
  34.     mVendorInstallObserver.startWatching();  
  35.     //扫描/vendor/app目录  
  36.     scanDirLI(mVendorAppDir, PackageParser.PARSE_IS_SYSTEM| PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);  
  37.   
  38.     if (DEBUG_UPGRADE) Log.v(TAG, "Running installd update commands");  
  39.     mInstaller.moveFiles();  
  40.     // Prune any system packages that no longer exist.  
  41.     final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<String>();  
  42.     if (!mOnlyCore) {  
  43.         //遍历Settings的成员变量mPackages  
  44.         Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();  
  45.         while (psit.hasNext()) {  
  46.             PackageSetting ps = psit.next();  
  47.             //不是系统app  
  48.             if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {  
  49.                 continue;  
  50.             }  
  51.             //如果是系统app，同时已经被PackageManagerService扫描过了  
  52.             final PackageParser.Package scannedPkg = mPackages.get(ps.name);  
  53.             if (scannedPkg != null) {  
  54.                 //该apk包已不能使用  
  55.                 if (mSettings.isDisabledSystemPackageLPr(ps.name)) {  
  56.                     Slog.i(TAG, "Expecting better updatd system app for " + ps.name  
  57.                             + "; removing system app");  
  58.                     //移除该apk包信息  
  59.                     removePackageLI(scannedPkg, true);  
  60.                 }  
  61.                 continue;  
  62.             }  
  63.             if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {  
  64.                 psit.remove();  
  65.                 String msg = "System package " + ps.name  
  66.                         + " no longer exists; wiping its data";  
  67.                 reportSettingsProblem(Log.WARN, msg);  
  68.                 mInstaller.remove(ps.name, 0);  
  69.                 sUserManager.removePackageForAllUsers(ps.name);  
  70.             } else {  
  71.                 final PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(ps.name);  
  72.                 if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {  
  73.                     possiblyDeletedUpdatedSystemApps.add(ps.name);  
  74.                 }  
  75.             }  
  76.         }  
  77.     }  
  78.     //mAppInstallDir = /data/app/  
  79.     mAppInstallDir = new File(dataDir, "app");  
  80.     //查找未完成安装的apk包  
  81.     ArrayList<PackageSetting> deletePkgsList = mSettings.getListOfIncompleteInstallPackagesLPr();  
  82.     //清除未完成安装包  
  83.     for(int i = 0; i < deletePkgsList.size(); i++) {  
  84.         //clean up here  
  85.         cleanupInstallFailedPackage(deletePkgsList.get(i));  
  86.     }  
  87.     //删除临时文件  
  88.     deleteTempPackageFiles();  

监控并扫描以下三个系统包安装目录：

/system/framework ：该目录下的文件都是系统库

/system/app ：该目录下是默认的系统应用

/vendor/app ：该目录下是厂商定制的应用

最后扫描非系统apk信息

[java]  view plain copy
  1. if (!mOnlyCore) {  
  2.     //标识数据扫描开始  EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,SystemClock.uptimeMillis());  
  3.     //创建文件夹监控对象，监视/data/app/目录  
  4.     mAppInstallObserver = new AppDirObserver(mAppInstallDir.getPath(), OBSERVER_EVENTS, false);  
  5.     mAppInstallObserver.startWatching();  
  6.     //扫描/data/app/目录下的apk文件  
  7.     scanDirLI(mAppInstallDir, 0, scanMode, 0);  
  8.     //创建文件夹监控对象，监视/system/preloadapp/目录  
  9.     mPreInstallObserver = new AppDirObserver(mPreInstallDir.getPath(), OBSERVER_EVENTS, false);  
  10.     mPreInstallObserver.startWatching();  
  11.     //扫描/system/preloadapp/目录下的apk文件  
  12.     scanDirLI(mPreInstallDir, 0, scanMode, 0);  
  13.     //创建文件夹监控对象，监视/data/app-private/目录  
  14.     mDrmAppInstallObserver = new AppDirObserver(mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false);  
  15.     mDrmAppInstallObserver.startWatching();  
  16.     //扫描/data/app-private/目录下的apk文件  
  17.     scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,scanMode, 0);  
  18.     /** 
  19.      * Remove disable package settings for any updated system 
  20.      * apps that were removed via an OTA. If they're not a 
  21.      * previously-updated app, remove them completely. 
  22.      * Otherwise, just revoke their system-level permissions. 
  23.      */  
  24.     for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {  
  25.         PackageParser.Package deletedPkg = mPackages.get(deletedAppName);  
  26.         mSettings.removeDisabledSystemPackageLPw(deletedAppName);  
  27.         String msg;  
  28.         if (deletedPkg == null) {  
  29.             msg = "Updated system package " + deletedAppName+ " no longer exists; wiping its data";  
  30.             mInstaller.remove(deletedAppName, 0);  
  31.             sUserManager.removePackageForAllUsers(deletedAppName);  
  32.         } else {  
  33.             msg = "Updated system app + " + deletedAppName+ " no longer present; removing system privileges for "+ deletedAppName;  
  34.             deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;  
  35.             PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);  
  36.             deletedPs.pkgFlags &= ~ApplicationInfo.FLAG_SYSTEM;  
  37.         }  
  38.         reportSettingsProblem(Log.WARN, msg);  
  39.     }  
  40. } else {  
  41.     mPreInstallObserver = null;  
  42.     mAppInstallObserver = null;  
  43.     mDrmAppInstallObserver = null;  
  44. }  

监控并扫描以下三个数据目录：

/data/app/

/system/preloadapp/

/data/app-private/

最后进入结尾阶段，将扫描到的信息保存到文件中。

[java]  view plain copy
  1. mFlagInstall = true;  
  2. EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,SystemClock.uptimeMillis());  
  3. final boolean regrantPermissions = mSettings.mInternalSdkPlatform != mSdkVersion;  
  4. mSettings.mInternalSdkPlatform = mSdkVersion;  
  5. updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL | (regrantPermissions  
  6.                 ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL): 0));  
  7. ArrayList<PreferredActivity> removed = new ArrayList<PreferredActivity>();  
  8. for (PreferredActivity pa : mSettings.mPreferredActivities.filterSet()) {  
  9.     if (mActivities.mActivities.get(pa.mPref.mComponent) == null) {  
  10.         removed.add(pa);  
  11.     }  
  12. }  
  13. for (int i=0; i<removed.size(); i++) {  
  14.     PreferredActivity pa = removed.get(i);  
  15.     Slog.w(TAG, "Removing dangling preferred activity: "  
  16.             + pa.mPref.mComponent);  
  17.     mSettings.mPreferredActivities.removeFilter(pa);  
  18. }  
  19. // can downgrade to reader  
  20. mSettings.writeLPr();  
  21.   
  22. EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,SystemClock.uptimeMillis());  
  23. Runtime.getRuntime().gc();  
  24. mRequiredVerifierPackage = getRequiredVerifierLPr();  

至此，PackageManagerService就构造完成了，构造过程认为繁重，Apk文件扫描解析耗费比较长的时间，这是导致开机速度慢的原因。

这篇关于Android服务之PackageManagerService启动源码分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/680631。

相关文章

Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

Android 悬浮窗开发示例((动态权限请求 | 前台服务和通知 | 悬浮窗创建 )

《Android悬浮窗开发示例((动态权限请求|前台服务和通知|悬浮窗创建)》本文介绍了Android悬浮窗的实现效果,包括动态权限请求、前台服务和通知的使用,悬浮窗权限需要动态申请并引导... 目录一、悬浮窗 动态权限请求1、动态请求权限2、悬浮窗权限说明3、检查动态权限4、申请动态权限5、权限设置完毕后
阅读更多...
Springboot中分析SQL性能的两种方式详解

Springboot中分析SQL性能的两种方式详解

《Springboot中分析SQL性能的两种方式详解》文章介绍了SQL性能分析的两种方式：MyBatis-Plus性能分析插件和p6spy框架,MyBatis-Plus插件配置简单,适用于开发和测试环... 目录SQL性能分析的两种方式:功能介绍实现方式:实现步骤:SQL性能分析的两种方式:功能介绍记录
阅读更多...
TP-Link PDDNS服将于务6月30日正式停运:用户需转向第三方DDNS服务

TP-Link PDDNS服将于务6月30日正式停运:用户需转向第三方DDNS服务

《TP-LinkPDDNS服将于务6月30日正式停运:用户需转向第三方DDNS服务》近期，路由器制造巨头普联（TP-Link）在用户群体中引发了一系列重要变动,上个月，公司发出了一则通知，明确要求所... 路由器厂商普联（TP-Link）上个月发布公告要求所有用户必须完成实名认证后才能继续使用普联提供的 D
阅读更多...
Android里面的Service种类以及启动方式

Android里面的Service种类以及启动方式

《Android里面的Service种类以及启动方式》Android中的Service分为前台服务和后台服务,前台服务需要亮身份牌并显示通知,后台服务则有启动方式选择,包括startService和b... 目录一句话总结：一、Service 的两种类型：1. 前台服务（必须亮身份牌）2. 后台服务（偷偷干
阅读更多...
最长公共子序列问题的深度分析与Java实现方式

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列（LCS）问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动
阅读更多...
Windows设置nginx启动端口的方法

Windows设置nginx启动端口的方法

《Windows设置nginx启动端口的方法》在服务器配置与开发过程中,nginx作为一款高效的HTTP和反向代理服务器,被广泛应用,而在Windows系统中,合理设置nginx的启动端口,是确保其正... 目录一、为什么要设置 nginx 启动端口二、设置步骤三、常见问题及解决一、为什么要设置 nginx
阅读更多...
springboot启动流程过程

springboot启动流程过程

《springboot启动流程过程》SpringBoot简化了Spring框架的使用,通过创建`SpringApplication`对象,判断应用类型并设置初始化器和监听器,在`run`方法中,读取配... 目录springboot启动流程springboot程序启动入口1.创建SpringApplicat
阅读更多...
树莓派启动python的实现方法

树莓派启动python的实现方法

《树莓派启动python的实现方法》本文主要介绍了树莓派启动python的实现方法,文中通过图文介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录一、RASPBerry系统设置二、使用sandroidsh连接上开发板Raspberry Pi三、运
阅读更多...
C#使用DeepSeek API实现自然语言处理,文本分类和情感分析

C#使用DeepSeek API实现自然语言处理,文本分类和情感分析

《C#使用DeepSeekAPI实现自然语言处理,文本分类和情感分析》在C#中使用DeepSeekAPI可以实现多种功能,例如自然语言处理、文本分类、情感分析等,本文主要为大家介绍了具体实现步骤,... 目录准备工作文本生成文本分类问答系统代码生成翻译功能文本摘要文本校对图像描述生成总结在C#中使用Deep
阅读更多...
微服务架构之使用RabbitMQ进行异步处理方式

微服务架构之使用RabbitMQ进行异步处理方式

《微服务架构之使用RabbitMQ进行异步处理方式》本文介绍了RabbitMQ的基本概念、异步调用处理逻辑、RabbitMQ的基本使用方法以及在SpringBoot项目中使用RabbitMQ解决高并发... 目录一.什么是RabbitMQ？二.异步调用处理逻辑：三.RabbitMQ的基本使用1.安装2.架构
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2