CN117234622B - Multi-language runtime on-demand calling method and system - Google Patents
Multi-language runtime on-demand calling method and system Download PDFInfo
- Publication number
- CN117234622B CN117234622B CN202311523137.0A CN202311523137A CN117234622B CN 117234622 B CN117234622 B CN 117234622B CN 202311523137 A CN202311523137 A CN 202311523137A CN 117234622 B CN117234622 B CN 117234622B
- Authority
- CN
- China
- Prior art keywords
- library
- loading
- class
- application
- path
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 82
- 244000035744 Hura crepitans Species 0.000 claims abstract description 88
- 230000007246 mechanism Effects 0.000 claims abstract description 30
- 238000012545 processing Methods 0.000 claims abstract description 19
- 238000002955 isolation Methods 0.000 claims description 16
- 230000001419 dependent effect Effects 0.000 claims description 6
- 230000002708 enhancing effect Effects 0.000 claims description 4
- 238000011161 development Methods 0.000 abstract description 8
- 230000008569 process Effects 0.000 description 27
- 230000006870 function Effects 0.000 description 10
- 238000009434 installation Methods 0.000 description 8
- 238000010586 diagram Methods 0.000 description 7
- 238000004806 packaging method and process Methods 0.000 description 3
- 238000012858 packaging process Methods 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 230000005012 migration Effects 0.000 description 2
- 238000013508 migration Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 229920004142 LEXAN™ Polymers 0.000 description 1
- 239000004418 Lexan Substances 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 239000006227 byproduct Substances 0.000 description 1
- 210000001072 colon Anatomy 0.000 description 1
- 230000001934 delay Effects 0.000 description 1
- 238000002347 injection Methods 0.000 description 1
- 239000007924 injection Substances 0.000 description 1
- 230000009545 invasion Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 239000000047 product Substances 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 230000002123 temporal effect Effects 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Stored Programmes (AREA)
Abstract
The invention belongs to the technical field of software development, and provides a multi-language runtime on-demand calling method and system. The method comprises the following steps: when the specified application in the Linux operating system runs in the running stage and performs loading processing of the library to be loaded according to the requirement, controlling the specified application in the Linux operating system to be loaded to the library to be used in the running stage according to a preset library loading path strategy; the method comprises the steps that an original class is expanded, enhanced or intercepted under the condition that the original class is not modified based on the created proxy loading mechanism, and Java application programs in an application framework perform loading processing of the class to be loaded according to requirements through a customized loading strategy and a sandbox customized class loader so as to acquire files of the class to be loaded. When the C/C++ language is operated, the C/C++ on-demand calling method is used, and when the java language is operated, the java on-demand calling method is used. The invention can avoid repeated writing of the same codes and improve the development efficiency.
Description
The invention relates to the technical field of software development, in particular to a multi-language runtime on-demand calling method and system.
Background
Runtime library invocation techniques refer to the use of a runtime library (also known as a library or library file) in software development to access and execute functions and services provided in the library.
On-demand library loading is an optimization technique that delays loading and linking shared libraries while the program is running, and does not load until the use of functions or symbols in the libraries is actually needed. The runtime library is a set of precompiled reusable code modules that contain common functional implementations such as input and output functions, network communication functions, database connection functions, and the like. For large applications, which may contain multiple shared library files, not all functions will be used in each execution, loading the required library files only when needed; for the application program supporting plug-in or the dynamic loading module, library calling according to the need can ensure that the library required by the plug-in is loaded only when needed, so that flexible expansibility can be realized, and meanwhile, the dependence on specific plug-ins is reduced; for libraries which may need relatively long initialization time, calling libraries as needed can delay the initialization step until actual use, avoid unnecessary initialization overhead, and improve the response performance of the program. In summary, call-on-demand libraries are suitable for application scenarios that have complexity, large size, or require flexible loading of libraries. The method can improve the starting speed of the program, reduce the memory occupation, and ensure the availability of the needed functions and symbols when needed so as to optimize the performance and resource utilization of the application program.
In addition, when software development is carried out, common functions and codes need to be written, and the repeated writing affects the development efficiency; there are also common applications that include the same code and repeatedly occupy memory space. When these repeated codes need to be updated or repaired, the effort is large. Moreover, it is inconvenient to refer to cross-platform migration and support if the application program wants to run on different operating systems and platforms.
Accordingly, there is a need to provide an improved multi-lingual runtime on-demand method that addresses the above-described problems.
Disclosure of Invention
The invention aims to provide a multi-language runtime on-demand calling method and system, which are used for solving the technical problems that in the prior art, when software development is carried out, development efficiency is low because a plurality of common functions and codes are required to be written, memory space is repeatedly occupied because a plurality of common application programs comprise the same codes, and the repeated codes are required to be updated or repaired, so that the workload is large, and cross-platform migration and support and the like when running on different operating systems and platforms cannot be realized.
The first aspect of the present invention proposes a method for calling a multilingual runtime on demand, including: when the specified application in the Linux operating system runs in the running stage and performs loading processing of the library to be loaded according to the requirement, controlling the specified application in the Linux operating system to be loaded to the library to be used in the running stage according to a preset library loading path strategy; the library loading path strategy comprises path control points with different priorities and search paths pointed by the path control points, wherein the path control points and application programs with different versions required by C/C++ when the application sandboxes are called as required are placed in advance, and control point information can be edited and updated and the application programs can be uploaded and updated; defining a search path for the shared library at the compiling stage and the linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters; defining a search path for the shared library at the compiling stage and the linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters; when the java library multi-version is called as required, the application program can run on the machine corresponding to the operating system with different release versions by utilizing the running environment of the application sandbox; creating a proxy class in a Java system to load and proxy a proxy loading mechanism of an original class, expanding, enhancing or intercepting the original class on the basis of the proxy loading mechanism under the condition of not modifying the original class, and carrying out loading processing of the class to be loaded in a Java application program according to requirements in an application framework through a customized loading strategy and a sandbox customized class loader; and acquiring a file of the class to be loaded or the library to be loaded according to the determined loading path.
According to an alternative embodiment, before the loading process, it is determined whether the preset library loading path policy includes a customized loading sequence with the library to be loaded or the class to be loaded.
According to an alternative embodiment, if a customized loading sequence with the library or class to be loaded is included, loading the class or library to be loaded according to a specified loading path; if the customized loading sequence of the class to be loaded or the class to be loaded is not contained, searching the class to be loaded or the file corresponding to the class to be loaded according to a default loading path.
According to an alternative embodiment, further comprising: in the first on-demand calling mode, in the application installation and running process, the application loads related files from the self-encapsulated library preferentially in the loading process by a mode of designating a path, and then loads related files from the application framework and the dependent library; in the second on-demand call mode, classes of the application implementation layer, classes of the application framework layer, and base classes can be loaded as needed by the application without order restrictions.
According to an alternative embodiment, further comprising: the method comprises the steps of configuring a plurality of path control points with different priorities, wherein the control points are placed in an application sandbox in advance and can be edited and updated, and specifically comprise a first priority path control point for a compiling stage, a second priority path control point for an operating stage, a third priority control point for a configuration file and a fourth priority control point for a default searching path; the path control point is used for controlling the search path of the appointed application program, the self-contained system library or the basic library to be executed, the search path of the appointed application program, the self-contained system library/basic library of the application program, the search path of the runtime base library and the search path of the runtime base.
According to an alternative embodiment, when an application program needs to be run and multiple versions corresponding to the application program exist on the same machine at the same time, the version corresponding to the designated loading path is loaded preferentially.
According to an alternative embodiment, the running of the application in the Java system depends on the running environment provided by the application sandbox; the application sandboxes are isolated by utilizing a sandboxed customized class loader, so that different sandboxed customized class loaders are responsible for loading different classes to form class loading isolation in a Java virtual machine.
A second aspect of the present invention proposes a multi-language runtime on-demand invocation system, comprising: the first loading processing module is used for controlling the application specified in the Linux operating system to be loaded to a library required to be used in the running stage according to a preset library loading path strategy when the application specified in the Linux operating system runs in the running stage and the loading processing of the library to be loaded is carried out according to the requirement; the library loading path strategy comprises path control points with different priorities and search paths pointed by the path control points, wherein control point information of the path control points is placed in an application sandbox in advance and can be edited and updated, and the search paths of the shared library are defined in a compiling stage and a linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters; providing an application sandbox module, wherein when a first on-demand calling mode is adopted, a path control point and application programs of different versions required by C/C++ on-demand calling are placed in the application sandbox in advance, and control point information can be edited and updated and the application programs can be uploaded and updated; meanwhile, by utilizing the running environment of the application sandbox, the application program can run on machines corresponding to operating systems with different release versions; when the second on-demand calling mode is adopted, the running environment of the application sandbox is utilized, so that the application program can run on machines corresponding to operating systems with different release versions; and the second loading processing module is used for creating a proxy class in the Java system to load and proxy a proxy loading mechanism of the original class, expanding, enhancing or intercepting the original class under the condition of not modifying the original class based on the proxy loading mechanism, and carrying out loading processing of the class to be loaded in the Java application program according to the requirement in the application framework through a customized loading strategy and a sandbox customized class loader.
The embodiment of the invention has the following advantages:
compared with the prior art, the method of the invention enables the C/C++ application to load the library of the appointed version in the running process through the first calling-on-demand mode (namely, the C/C++ local library calling-on-demand method), and determines the appointed loading path according to the preset loading path strategy in the application installation and running process, so that the application program loads the self-encapsulated library preferentially in the loading process, and then controls the preset library loading path strategy of the Linux operating system to realize the loading of the application to the required library in the running stage, thereby realizing the calling-on-demand of the library; through a second on-demand calling mode (namely a java library multi-version on-demand calling method), mutual interference or conflict among different versions of the library is prevented through application sandboxes, an original class proxy loading mechanism is destroyed through a customized loading strategy and a sandbox customized class loader, a java application program can dynamically load classes of a designated version during running, and in the application packaging process, classes of an application implementation layer, classes of an application framework layer and basic classes can be loaded without order limitation according to the application requirements.
In addition, the invention can avoid repeated writing of the same codes, improve development efficiency, avoid each application program to contain the same codes, save memory space, and simultaneously can carry out version management on the shared library, and different application programs can use the shared library with different versions so as to meet specific requirements. Backwards compatibility is achieved by properly managing and maintaining versions of the shared library.
Drawings
FIG. 1 is a flow chart of steps of an example of a multi-lingual runtime on-demand method of the present invention;
FIG. 2 is a schematic diagram of a framework of a specific example of a preset library load path policy provided in the multi-language runtime on-demand method of the present invention;
FIG. 3 is a schematic diagram illustrating an example of a second call-on-demand manner in the multi-lingual runtime on-demand method of the present invention;
FIG. 4 is a flowchart of steps of another example of a multi-lingual runtime on-demand method of the invention;
FIG. 5 is a schematic diagram of an example architecture of a multi-lingual runtime on-demand system in accordance with the present invention.
Detailed Description
It should be noted that, in the case of no conflict, the embodiments and features in the embodiments may be combined with each other. The invention will be described in detail below with reference to the drawings in connection with embodiments.
In order to enable a developer to fully utilize the realized functions, avoid re-writing complex codes, and improve the efficiency and flexibility of software development in a modularized and reusable development mode, the invention provides a multi-language runtime on-demand calling method, which specifically comprises a first on-demand calling mode (namely a C/C++ local library on-demand calling method) and a second on-demand calling mode (namely a java library multi-version on-demand calling method). The first on-demand calling mode (namely a C/C++ local library on-demand calling method) is used for controlling a preset library loading path strategy of the Linux operating system so as to realize that the application is loaded to a library to be used in an operation stage, thereby realizing on-demand calling of the library. The second on-demand calling mode (namely a java library multi-version on-demand calling method) prevents mutual interference or conflict among different versions of the library by applying a sandbox, and an original class proxy loading mechanism is destroyed by a customized loading strategy and a sandbox customized class loader, so that the class and the library are loaded in an application framework according to the need.
It should be noted that, in the present invention, a runtime library refers to a set of precompiled reusable code modules, which includes common functional implementations, such as input and output, network communication, database connection, and so on. Furthermore, the sandbox provides a virtualized isolation environment for the application and ensures that all operations of the program execute within this isolation environment. The application sandbox mainly aims to provide a compatible running mechanism of the application running across release boards and the same machine, comprises a virtualized environment of libraries and frameworks on which the application runs, and ensures that the application can run in a compatible mode without being influenced by the running environment difference of different release boards. However, the foregoing is illustrative only and is not to be construed as limiting the invention.
Example 1
The multi-language runtime on-demand method of the present invention will be described in detail below with reference to fig. 1, 2, 3, and 4.
FIG. 1 is a flow chart of steps of an example of a multi-lingual runtime on-demand method of the present invention.
Firstly, in step S101, when a specified application in the Linux operating system runs in a running stage and performs loading processing of a library to be loaded according to needs, according to a preset library loading path policy, the specified application in the Linux operating system is controlled to be loaded to a library to be used in the running stage; the library loading path strategy comprises path control points with different priorities and search paths pointed by the path control points, wherein the path control points and application programs with different versions required by C/C++ calling on demand are placed in advance by an application sandbox, and control point information of the path control points can be edited and updated and the application programs can be uploaded and updated; defining a search path for the shared library at the compiling stage and the linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters.
To ensure that the C/C++ application can be loaded to the desired library on demand, a library load path policy (i.e., a preset library load path policy) needs to be provided.
In a specific embodiment, for example, a scenario in which an application program Y1 (i.e., a designated application) of the Linux operating system is library-loaded or run.
Specifically, a plurality of path control points of different priorities are provided. The control point information of the plurality of path control points is placed in an application sandbox in advance and can be edited and updated, and is used for controlling the search paths of the appointed application program to be executed, the application program self-contained system library or the basic library, the search paths of the appointed application program, the application program self-contained system library/the basic library, the search paths of the runtime base library and the search paths of the runtime system library.
FIG. 2 is a schematic diagram of a framework of a specific example of a preset library load path policy provided in the multi-language runtime on-demand method of the present invention.
In the example of fig. 2, the preset library loading path policy of the Linux operating system includes a plurality of path control points with different priorities, wherein control point information of the path control points is placed in an application sandbox in advance and can be edited and updated.
The method specifically comprises the steps of configuring a first priority path control point for a compiling stage, a second priority path control point for a running stage, a third priority control point for a configuration file and a fourth priority control point for a default searching path.
Further, these control points and directed paths are configured according to the support relationship between the runtime and the application, and the support relationship between the libraries of the different systems and the runtime library of the application.
It should be noted that, the four-level priority control points are configured as described above, but the method is not limited thereto, and three-level priority control points, five-level priority control points, or more priority control points may be configured according to actual system needs or service needs. In addition, for the control point and its priority, it may be performed in accordance with the existing correspondence formed. The foregoing is illustrative only and is not to be construed as limiting the invention.
Specifically, a search path of a shared library is defined in a compiling stage and a linking stage: path parameters, command parameters, compilation parameters, link parameters, and system parameters.
For the four-level priority control points and the search paths pointed by the four-level priority control points, the first priority control point is a library loading path control point designated by a compiling stage, is a control point higher than other three-level priority, is directly used by a C/C++ application, and can use GCC parameters (parameters of C and C++ compilers of GNU) such as-Wl, -rpath and the like to prescribe a library loading path of a library to be loaded in the compiling stage. The first priority control point is used for designating an executable file of the application program, a loading path of a running library developed by the application program, and a loading path of an application running library of the application when the application running library provided by the running process and the version of the application running library do not meet the application requirements.
For example, in a scenario where the C/c++ local library is called as needed, taking FFmpeg as an example, the FFmpeg is called to implement operations such as encoding and decoding, transcoding, and packaging of audio and video. The specific compiling time can specify a library loading path, and the running time adopts the specified library loading path to call. When an application program needs to be run, and when multiple versions corresponding to the application program exist on the same machine at the same time, the version of the specified path (i.e. the specified library loading path) is loaded preferentially.
In one embodiment, the path specified using, for example, the-Wl-rpath parameter is as follows:
for example, there is a custom shared library file liboxample.so stored under the/path/to/mylibs directory. This custom shared library file is used when compiling a given program. The search path (or search path) for the shared library may be specified using the-Wl and-rpath parameters in the following manner:
gcc-o myprogram. C-L/path/to/mylibs-lexamp-Wl, -rpath=/path/to/mylibs, the parameters in the above commands are used as follows.
wherein-L/path/to/mylibs specifies/path/to/mylibs as the library search path for the compilation phase under which library files are searched. Such as a notification linker, to find and load the desired library file based on the linking instructions and library search paths in the application.
Lexamp means that library files named libexiple. So are to be linked. The linker will attempt to find the library file in the default library search path and the library search path specified by the-L parameter.
-Wl, -rpath=/path/to/mylibs for informing the linker to add/path/to/mylibs to the runtime library search path when the application is running to search the shared library file. Thus, the application program will preferentially search and load the required library files under the/path/to/mylibs directory when running.
By using these parameters, the search path (or search path) of the shared library can be specified during the compilation and linking phase, ensuring that the program can properly link and load custom shared library files.
For the control point of the operation stage, the second priority control point is an operation stage environment variable LD_LIBRARY_PATH control point, and is directly used by the C/C++ application program, and the application program can define a specified loading PATH of the LIBRARY to be loaded by modifying the LD_LIBRARY_PATH environment variable. The role of the second priority control point is to specify the ld_libry_path control point more flexibly at run-time than at compile-time for applications and self-contained libraries.
It should be noted that the ld_libry_path environment variable is applicable to Linux systems, and the ld_libry_path environment variable includes one or more directory PATHs separated by a colon. When an application is started, the operating system will search the paths for libraries to be loaded (e.g., shared library files) in order until the desired library file is found or all paths are searched. By modifying the LD_LIBRARY_PATH environment variable, a custom directory PATH can be added to the load PATH of the shared LIBRARY, thereby controlling the order and location in which the application searches for shared LIBRARY files at run-time.
For example, assume that a shared library file named liboxample.so is located under the/path/to/mylibs/directory. The ld_libry_path environment variable may be modified using the following commands:
export LD_LIBRARY_PATH=/path/to/mylibs:$LD_LIBRARY_PATH。
by adding the/PATH/to/mylibs to the LD_LIBRARY_PATH, the operating system automatically searches and loads the LIBRARY to be loaded (e.g., shared LIBRARY files) under the/PATH/to/mylibs directory first when the application is running. By modifying the LD_LIBRARY_PATH environment variable, shared LIBRARY files in the custom PATH may be preferentially used over LIBRARY files in the default PATH. This is useful for shared library files that need to be used with a particular version or custom under a particular path.
For the third priority control point, the configuration file/etc/ld.so.conf control point is directly used by products at the C/c++ runtime, for example, products at the base runtime, c++ client base runtime, and c++ server application runtime. The third priority control point designates the loading path of the C/C++ application framework and the application runtime.
For example, the/etc/ld.so.conf file contains a series of directory paths, one for each row, the paths listed in the file being search path control points for the shared library. The operating system searches the paths in sequence according to the sequence of the paths in the file until the required shared library file is found or all paths are searched. By editing/etc/ld.so.conf files, search path control points of the shared library can be added, deleted or modified. The modified configuration may affect the system-wide shared library search behavior. After modifying/etc/ld.so.conf file, an ldconfig command needs to be run to update the shared library cache to validate the new search path.
For example, assume that a/path/to/mylibs directory is to be added to the search path of the shared library. The/etc/ld.so.conf file may be edited by: sudo vi/etc/ld.so.conf.
The file is then saved and closed by adding the/path/to/mylibs path in the new row of the file. Next, the following commands are run to update the shared library cache: sudo ldconfig.
Thus, the operating system will preferentially search for shared library files under the path/to/mylibs directory when the application is running. By modifying the/etc/ld.so.conf file, the search path of the shared library can be controlled at the system level and the new path can be validated.
For the fourth priority control point, i.e., the default lookup path control point of the system, the control point points directly to default paths of/lib,/usr/lib, etc., including the C-system library and system tools.
For example, when default paths of/lib,/usr/lib, etc. are used to specify search paths for shared libraries, these paths may be used directly in compiling and linking commands.
For example, the command gcc-o myprogram. C-L/lib-L/usr/lib-lexan. In the above command: l/lib specifies/lib as the library search path control point for the compilation stage. The linker will search for shared library files under this path.
L/usr/lib specifies/usr/lib as another library search path control point for the compilation stage. The linker will also search for shared library files under this path.
Lexamp means that library files named libexiple. So are to be linked. The linker will attempt to find the library file in the default library search path (including/lib and/usr/lib) and the path specified by the-L parameter.
By using these default paths as described above, they can be directly used as library search paths for the compile and link stage without additional parameters. The linker searches and loads the required library files according to the priority of the default path.
It should be noted that the foregoing description of the present invention is merely an optional example, and the present invention is not limited thereto.
Traditionally, java applications can only load and use a single version of a library at runtime. When an application relies on the same library in different versions, problems of dependency conflicts or version incompatibilities may occur. This makes library upgrades and management complex and difficult. The second on-demand call approach of the present invention can solve the above-described problems.
In step S102, when the java library is called on demand, the application sandboxed running environment is utilized, so that the application program can run on the machine corresponding to the operating system with different release versions.
Specifically, by applying the sandbox, each application may be isolated in a limited environment independent of the underlying operating system and other applications, avoiding interference and conflict with the underlying system, while also providing an isolated environment that enables different release operating systems to run on the same device machine and to communicate and interact with each other. At the heart of the application sandbox is the root file system of the sandbox, independent of the host root file system, and the running of the application program mainly depends on the library and configuration files in the sandbox. The application sandbox is only active during the running of the application.
Further, the application sandbox can provide a layer of security control, which can limit the access rights of the application program to external resources. Therefore, by introducing the application sandbox, the problems of security loopholes or incompatibility of libraries of different versions in multi-version calling of the libraries can be effectively avoided, and the risk of being utilized by malicious libraries can be reduced.
The layer of security control includes a file system isolation mechanism. The file system isolation mechanism specifically means that the application sandbox uses an independent root file system and is separated from the root file system of the host machine, so that an application program can only access specific files and directories in the application sandbox and cannot directly access the file system on the host machine.
In addition, the application sandbox can control and manage the class loading process to ensure that only trusted classes or resources are loaded, thereby improving the security of the application program.
Specifically, a separate class loader (sandboxed custom class loader) is used within the application sandbox, isolated from the class loader of the host machine, e.g., by class loader isolation. Thus, it can be ensured that an application can only load classes defined inside the application sandbox, but cannot access other classes on the host.
More specifically, the class loading policy includes a class loading policy that the application sandbox is able to set itself. For example, only classes under a specified directory or in a particular library file are allowed to be loaded. Thus, it is possible to restrict the application program to load only classes of a specific origin, preventing malicious code injection.
Further, a security check is included. In particular, during class loading, the application sandbox can perform security checks, such as checking information about signatures, rights, etc. of classes to ensure that only authenticated and authorized classes are loaded. This helps prevent malicious code from attacking by masquerading as a legitimate class.
In addition, the application sandboxes can restrict access rights of the application to certain classes. By Access Control List (ACL) or whitelist mechanism, only applications are allowed to access specific classes, and unauthorized class calls are prevented to implement class access restrictions. Only authenticated libraries are loaded and used. Therefore, the dependency relationship of the application program can be better managed, and version conflict and dependency problems are avoided.
Furthermore, the introduction of application sandboxes may provide better extensibility for each application program. The application sandboxes can dynamically load and unload libraries at runtime to meet the needs of the application. Thus enabling more flexible library management and upgrades without stopping or restarting the entire application.
By introducing the application sandbox into the second on-demand calling mode (namely the java library multi-version on-demand calling method), better isolation, safety, management and control can be provided, and the expandability of the application program can be enhanced. Therefore, the multi-version problem of the library can be better processed, and the stability and the safety of the application program are ensured.
It should be noted that, in general, the java application directly loads and uses the library in the runtime of the java application, but if the java application has special requirements on the version of the library, for example, the log4j version of the runtime band is 1.0, and the java application needs to use the log4j2.0 version, the java application needs to load the log4j2.0 and load the library of the java application preferentially. By utilizing the running environment of the application sandbox, the application program can run on the machines corresponding to the operating systems with different release versions. Therefore, the problems that the stability and the reliability of the application program are affected by mutual interference or conflict among different versions of the call library can be avoided, and a more flexible library management and upgrading mechanism can be provided.
It should be noted that the foregoing is merely illustrative of the alternative examples, and is not to be construed as limiting the present invention.
Next, in step S103, a proxy class is created in the Java system to load and proxy the proxy loading mechanism of the original class, the original class is expanded, enhanced or intercepted without modifying the original class based on the proxy loading mechanism, and the Java application program performs the loading process of the class to be loaded as required in the application framework through the customized loading strategy and the sandbox customized class loader.
FIG. 3 is a schematic diagram illustrating an example of a second call-on-demand manner in the multi-lingual runtime on-demand method of the invention.
A mechanism for loading and brokering original classes by creating proxy classes in a Java system (i.e., a proxy loading mechanism). The proxy in the proxy loading mechanism refers to delegation loading. The proxy loading mechanism is a mechanism that loads and proxies the original class by creating a proxy class in Java.
Specifically, when a class/library loading requirement exists, searching the class/library to be loaded in the expansion/context loader, and if the class/library is found, successfully outputting the class/library. If the class/library is not found, the class/library is successfully output in the loader applying the sandbox according to the loading strategy; if not, the search is continued in the system loader, and if so, the class/library is successfully exported. If the search result is not found, the search is continued in the expansion loader; if so, successfully outputting the class/library; if not, the search is continued in the boot loader until found.
It should be noted that the loader and the loading policy of the sandbox are formed by purposely designing them. The application sandbox loader, also called sandbox custom class loader, is an intelligent hybrid class loader which combines application server extension class loading, application runtime library loading, application framework loading and application loading into one on the basis of a class loading proxy mechanism provided by Java, and is custom-built according to the requirements of an application sandbox, for example, custom class loader used in the running environment provided by the application sandbox. The sandbox customized class loader is mainly used for controlling the loading and access rights of classes in an application sandbox to limit the application program to only load specific classes or resources and prevent malicious codes or untrusted classes from being loaded, and can be automatically loaded in the running process, so that the sandbox customized class loader has no invasion to the application, i.e. does not need to make additional configuration (such as default configuration) and development to the application.
For the loading policy, there are different loading policies for each of the plurality of different application types that are scattered at different installation layers for the application classes and dependency libraries running within the application sandbox. When the method is implemented, before loading a class, whether the loading strategy has customized the loading sequence of the class is judged. When it is determined that customization has been performed, then the class is loaded according to the customized class loading path. And when the fact that customization is not carried out is determined, searching and loading the class file under the corresponding path according to the default loading sequence. The default loading strategy of the hybrid class loader is to preferentially load an application package required by application realization, then an application framework and a base library, and finally the hybrid class loader is combined with a runtime system loaded by an application server, so that zero package dependence of the application can be realized, and a dependence library package provided by the system is loaded in the runtime. The customized loading policy depends on the policy configuration file implementation, in which the loading order may be customized, policy files such as yaml files, json files, or other files. Therefore, the application can configure the loading sequence of the class according to the characteristics of the application, for example, the application can load a type of dependent jar package which is uniformly updated under the application running library, and the loading device and the loading strategy of the application sandbox can be easily realized without re-split packaging, packaging and installation of the application.
The original class is expanded, enhanced or intercepted without modification based on the proxy loading mechanism. The original class proxy loading mechanism is destroyed through the customized loading strategy and the sandbox customized class loader, and the class is loaded (namely, the class to be loaded is loaded) in the application framework according to the need. The sandbox customization class loader inherits the Java class loader from the standard and performs customization according to the requirements of the sandbox, and controls the loading and access rights of the classes in the application sandbox to limit the specific application program to only load specific classes or resources and prevent malicious codes or untrusted classes from being loaded.
Specifically, the classes of the application implementation layer, the classes of the application framework layer, and the base classes can be loaded without order limitation as required by the application.
When an application program needs to be run and a plurality of versions corresponding to the application program exist on the same machine at the same time, the version corresponding to the appointed loading path is loaded preferentially.
And when it is determined that the specified loading path is not included, loading is performed using the default pseudo path.
The running of applications in the Java system depends on the running environment provided by the application sandbox.
The application sandboxes are isolated by utilizing a sandboxed customized class loader, so that different sandboxed customized class loaders are responsible for loading different classes to form class loading isolation in a Java virtual machine.
The application sandboxes utilize the characteristics of sandboxed custom class loader isolation to enhance security and isolation. Class loader isolation refers to the fact that in a Java virtual machine in a Java system, different sandboxed custom class loaders are responsible for loading different classes, so that class loading isolation is formed. Each class loader has its own namespace, and each class loader can only see the classes loaded by itself and the classes loaded by its parent loader, but cannot directly access the classes loaded by other loaders. Therefore, problems such as class conflict and class version inconsistency can be avoided. By using different class loaders, an independent class loading environment is created for each library version, thereby avoiding class conflicts between libraries of different versions, and enabling an application to load and use libraries of different versions simultaneously.
It should be noted that the foregoing is merely illustrative of the alternative examples, and is not to be construed as limiting the present invention.
Next, in step S104, a file of the class to be loaded or the library to be loaded is acquired according to the determined loading path.
For example, if it is determined that the specified loading path is used, a class to be loaded or a file of a library to be loaded is obtained from the corresponding directory according to the specified loading path.
For example, if it is determined that the default loading path is used, a class to be loaded or a file of a library to be loaded is obtained from the corresponding directory according to the default loading path.
It should be noted that the foregoing is merely illustrative of the alternative examples, and is not to be construed as limiting the present invention.
FIG. 4 is a step flow diagram illustrating another example of a multi-lingual runtime on-demand method of the invention.
In another example, the multi-language runtime on-demand calling method of the present invention further includes the following step S201.
In the example of fig. 4, steps S101, S102, S103, and S104 are substantially the same as steps S101, S102, S103, and S104 in fig. 1, and therefore, the description of the same parts is omitted. Step S201 will be specifically described below.
In step S201, before the loading process, it is first determined whether the preset library loading path policy includes a customized loading sequence with the library to be loaded or the class to be loaded.
If the customized loading sequence of the library or the class to be loaded is contained, loading the class to be loaded according to a designated loading path;
If the customized loading sequence of the class to be loaded or the class to be loaded is not contained, searching the class to be loaded or the file corresponding to the class to be loaded according to a default loading path.
Specifically, in a first on-demand calling mode (namely, a C/C++ local library on-demand calling method), in the application installation and operation process, the application loads related files from a self-encapsulated library preferentially in a mode of a specified path, and loads related files from an application framework and a dependent library; in the second on-demand calling mode (namely the java library multi-version on-demand calling method), classes of the application realization layer, classes of the application framework layer and basic classes can be loaded without sequence limitation according to the application requirement.
It is noted that the above-described figures are only schematic illustrations of processes involved in a method according to an exemplary embodiment of the invention, and are not intended to be limiting. It will be readily appreciated that the processes shown in the above figures do not indicate or limit the temporal order of these processes. In addition, it is also readily understood that these processes may be performed synchronously or asynchronously, for example, among a plurality of modules.
Compared with the prior art, the method of the invention enables the C/C++ application to load the library of the appointed version in the running process through the first calling-on-demand mode (namely, the C/C++ local library calling-on-demand method), and determines the appointed loading path according to the preset loading path strategy in the application installation and running process, so that the application program loads the self-encapsulated library preferentially in the loading process, and then controls the preset library loading path strategy of the Linux operating system to realize the loading of the application to the required library in the running stage, thereby realizing the calling-on-demand of the library; the second on-demand calling mode (namely a java library multi-version on-demand calling method) is adopted, mutual interference or conflict among different versions of libraries is prevented through application sandboxes, an original class proxy loading mechanism is destroyed through a customized loading strategy and a sandbox customized class loader, classes and libraries are loaded in an application framework according to requirements, java application programs dynamically load the libraries with appointed versions in the running process, and classes of an application implementation layer, classes of an application framework layer and basic classes can be loaded according to the requirements of applications without sequence limitation in the application packaging process.
In addition, the invention can avoid repeated writing of the same codes, improve development efficiency, avoid each application program to contain the same codes, save memory space, and simultaneously can carry out version management on the shared library, and different application programs can use the shared library with different versions so as to meet specific requirements. Backwards compatibility is achieved by properly managing and maintaining versions of the shared library.
Example 2
The following are system embodiments of the present invention that may be used to perform method embodiments of the present invention. For details not disclosed in the system embodiments of the present invention, please refer to the method embodiments of the present invention.
FIG. 5 is a schematic diagram of an example architecture of a multi-lingual runtime on-demand system in accordance with the present invention.
As shown in fig. 5, a second aspect of the present disclosure provides a multi-language runtime on-demand system 500, the multi-language runtime on-demand system 500 including a first load processing module 510, a provisioning application sandbox module 520, a second load processing module 530, and a file retrieval module 540.
In a specific embodiment, when the specified application in the Linux operating system runs in the running stage and performs the loading process of the library to be loaded according to the requirement, the first loading processing module 510 controls the specified application in the Linux operating system to be loaded to the library to be used in the running stage according to the preset library loading path strategy; the library loading path strategy comprises path control points with different priorities and search paths pointed by the path control points, wherein the control point information of the path control points is placed in an application sandbox in advance and can be edited and updated; defining a search path for the shared library at the compiling stage and the linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters.
When the application sandbox module 520 adopts the first on-demand calling mode, the application sandbox is provided with path control points in advance and application programs of different versions required by C/C++ on-demand calling, and the control point information can be edited and updated and the application programs can be uploaded and updated; meanwhile, by utilizing the running environment of the application sandbox, the application program can run on machines corresponding to operating systems with different release versions; when the second on-demand calling mode is adopted, the application program can run on machines corresponding to operating systems with different release versions by utilizing the running environment of the application sandbox.
The second loading processing module 530 creates a proxy class in the Java system to load and proxy the proxy loading mechanism of the original class, expands, enhances or intercepts the original class based on the proxy loading mechanism under the condition of not modifying the original class, and loads the class to be loaded according to the need by Java application programs in the application framework through a customized loading strategy and a sandbox customized class loader.
The file obtaining module 540 obtains the file of the class to be loaded according to the determined loading path.
According to an alternative embodiment, before the loading process, it is determined whether the preset library loading path policy includes a customized loading sequence with the library to be loaded or the class to be loaded.
According to an alternative embodiment, it comprises: if the customized loading sequence of the class to be loaded or the class to be loaded is contained, loading the class to be loaded or the class to be loaded according to a designated loading path; if the customized loading sequence of the class to be loaded or the class to be loaded is not contained, searching the class to be loaded or the file corresponding to the class to be loaded according to a default loading path.
According to an alternative embodiment, further comprising: in the process of application installation or application running, the library to be loaded is loaded according to a designated loading path, so that the library is loaded from the library packaged by the application itself preferentially, and then the library is loaded from the application framework and the dependent library.
According to an alternative embodiment, further comprising: a plurality of path control points with different priorities are arranged, control point information of the path control points is placed in an application sandbox in advance, and the control point information can be edited and updated; the method specifically comprises the steps of configuring a first priority path control point for a compiling stage, a second priority path control point for a running stage, a third priority control point for a configuration file and a fourth priority control point for a default searching path; the path control point is used for controlling the search path of the appointed application program, the self-contained system library or the basic library to be executed, the search path of the appointed application program, the self-contained system library/basic library of the application program, the search path of the runtime base library and the search path of the runtime base.
According to an alternative embodiment, it comprises: when an application program needs to be run and a plurality of versions corresponding to the application program exist on the same machine at the same time, the version corresponding to the appointed loading path is loaded preferentially.
According to an alternative embodiment, the running of the application in the Java system depends on the running environment provided by the application sandbox; the application sandbox utilizes sandbox custom class loader isolation such that in a Java virtual machine, different class loaders are responsible for loading different classes to form class loading isolation.
It should be noted that the foregoing is merely illustrative of the alternative examples, and is not to be construed as limiting the present invention.
Compared with the prior art, the method has the advantages that the C/C++ application loads the library of the appointed version in the running process through the first on-demand calling mode (namely, the C/C++ local library on-demand calling method), the appointed loading path is determined according to the preset loading path strategy in the application installation and running process, the application program loads the self-encapsulated library preferentially in the loading process, then the application frame and the dependent library control the preset library loading path strategy of the Linux operating system, so that the application is loaded to the required library in the running stage, and the on-demand calling of the library is realized; the second on-demand calling mode (namely a java library multi-version on-demand calling method) is adopted, mutual interference or conflict among different versions of libraries is prevented through application sandboxes, an original class proxy loading mechanism is destroyed through a customized loading strategy and a sandbox customized class loader, classes and libraries are loaded in an application framework according to requirements, java application programs dynamically load the libraries with appointed versions in the running process, and classes of an application implementation layer, classes of an application framework layer and basic classes can be loaded according to the requirements of applications without sequence limitation in the application packaging process.
In addition, the invention can avoid repeated writing of the same codes, improve development efficiency, avoid each application program to contain the same codes, save memory space, and simultaneously can carry out version management on the shared library, and different application programs can use the shared library with different versions so as to meet specific requirements. Backwards compatibility is achieved by properly managing and maintaining versions of the shared library.
The exemplary embodiments of the present invention have been particularly shown and described above. It is to be understood that this invention is not limited to the precise arrangements, instrumentalities and instrumentalities described herein; on the contrary, the invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.
Claims (8)
1. A multi-language runtime on-demand calling method, comprising:
when the specified application in the Linux operating system runs in the running stage and performs loading processing of the library to be loaded according to the requirement, controlling the specified application in the Linux operating system to be loaded to the library to be used in the running stage according to a preset library loading path strategy; the library loading path strategy comprises path control points with different priorities and search paths pointed by the path control points, wherein the path control points and application programs with different versions required by C/C++ when the application sandboxes are called as required are placed in advance, and control point information can be edited and updated and the application programs can be uploaded and updated; defining a search path for the shared library at the compiling stage and the linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters; the method comprises the steps of configuring a plurality of path control points with different priorities, wherein the path control points specifically comprise a first priority path control point for a compiling stage, a second priority path control point for a running stage, a third priority control point for a configuration file and a fourth priority control point for a default searching path; the path control point is used for controlling the search paths of the appointed application program, the self-contained system library or the basic library of the application program to be executed, the search paths of the appointed application program, the self-contained system library/the basic library of the application program, the search paths of the runtime base library and the search paths of the runtime system library;
When the java library multi-version is called as required, the application program is operated on the machine corresponding to the operating system with different release versions by utilizing the operating environment of the application sandbox;
creating a proxy class in a Java system to load and proxy a proxy loading mechanism of an original class, expanding, enhancing or intercepting the original class on the basis of the proxy loading mechanism under the condition of not modifying the original class, and carrying out loading processing of the class to be loaded in a Java application program according to requirements in an application framework through a customized loading strategy and a sandbox customized class loader;
and acquiring a file of the class to be loaded or the library to be loaded according to the determined loading path.
2. The multi-language runtime on-demand method of claim 1, comprising:
before loading, judging whether the preset library loading path strategy contains a customized loading sequence of the library to be loaded or the class to be loaded.
3. The multi-language runtime on-demand method of claim 2, comprising:
if the customized loading sequence of the class to be loaded or the class to be loaded is contained, loading the class to be loaded or the class to be loaded according to a designated loading path;
If the customized loading sequence of the class to be loaded or the class to be loaded is not contained, searching the class to be loaded or the file corresponding to the class to be loaded according to a default loading path.
4. The multi-language runtime on-demand method of claim 1, comprising:
when an application program needs to be run and a plurality of versions corresponding to the application program exist on the same machine at the same time, the version corresponding to the appointed loading path is loaded preferentially.
5. The multi-language runtime on-demand method of claim 1, wherein,
running of applications in the Java system depends on the running environment provided by the application sandbox;
the application sandboxes are isolated by utilizing a sandboxed customized class loader, so that different sandboxed customized class loaders are responsible for loading different classes to form class loading isolation in a Java virtual machine.
6. A multi-language runtime on-demand call system, comprising:
the first loading processing module is used for controlling the application specified in the Linux operating system to be loaded to a library required to be used in the running stage according to a preset library loading path strategy when the application specified in the Linux operating system is in the running stage and the loading processing of the library to be loaded is carried out according to the requirement; the library loading path strategy comprises path control points with different priorities and search paths pointed by the path control points, wherein the control points are placed in an application sandbox in advance and can be edited and updated, and the search paths of the shared library are defined in a compiling stage and a linking stage by using at least two of the following specific parameters: path parameters, command parameters, compilation parameters, link parameters, and system parameters; the method comprises the steps of configuring a plurality of path control points with different priorities, wherein the path control points specifically comprise a first priority path control point for a compiling stage, a second priority path control point for a running stage, a third priority control point for a configuration file and a fourth priority control point for a default searching path; the path control point is used for controlling the search paths of the appointed application program, the self-contained system library or the basic library of the application program to be executed, the search paths of the appointed application program, the self-contained system library/the basic library of the application program, the search paths of the runtime base library and the search paths of the runtime system library;
Providing an application sandbox module, wherein when C/C++ is adopted for on-demand calling, a path control point and application programs of different versions required by the C/C++ when the C/C++ is adopted for on-demand calling are placed in the application sandbox in advance, and the control point information can be edited and updated and the application programs can be uploaded and updated; meanwhile, by utilizing the running environment of the application sandbox, the application program can run on machines corresponding to operating systems with different release versions; when the java library multi-version is adopted for calling as required, the application program can run on the machine corresponding to the operating system with different release versions by utilizing the running environment of the application sandbox;
the second loading processing module is used for creating a proxy class in the Java system to load and proxy a proxy loading mechanism of the original class, expanding, enhancing or intercepting the original class under the condition of not modifying the original class based on the proxy loading mechanism, and carrying out loading processing of the class to be loaded in the Java application program according to the requirement in the application framework through a customized loading strategy and a sandbox customized class loader;
and the file acquisition module acquires files of the class to be loaded or the library to be loaded according to the determined loading path.
7. The system of claim 6, wherein before loading, determining whether the preset library loading path policy includes a custom loading order with the library or class to be loaded.
8. The multi-language runtime on-demand system of claim 6, wherein the running of the application in the Java system is dependent on the running environment provided by the application sandbox;
the application sandboxes are isolated by utilizing a sandboxed customized class loader, so that different sandboxed customized class loaders are responsible for loading different classes to form class loading isolation in a Java virtual machine.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311523137.0A CN117234622B (en) | 2023-11-16 | 2023-11-16 | Multi-language runtime on-demand calling method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311523137.0A CN117234622B (en) | 2023-11-16 | 2023-11-16 | Multi-language runtime on-demand calling method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117234622A CN117234622A (en) | 2023-12-15 |
| CN117234622B true CN117234622B (en) | 2024-02-27 |
Family
ID=89086547
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311523137.0A Active CN117234622B (en) | 2023-11-16 | 2023-11-16 | Multi-language runtime on-demand calling method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117234622B (en) |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR101565590B1 (en) * | 2015-01-07 | 2015-11-04 | (주) 바이러스체이서 | A system for expanding the security kernel with system for privilege flow prevention based on white list |
| CN105988821A (en) * | 2016-01-19 | 2016-10-05 | 北京匡恩网络科技有限责任公司 | Distributed function plug-in-based data statistic analysis platform |
| CN106406852A (en) * | 2016-08-25 | 2017-02-15 | 北京北信源软件股份有限公司 | Optimal management method for injecting multi-DLL (dynamic link library) into target procedure |
| CN109784039A (en) * | 2018-11-28 | 2019-05-21 | 杭州天宽科技有限公司 | Construction method, electronic equipment, the storage medium of mobile terminal safety running space |
| CN114286994A (en) * | 2019-08-30 | 2022-04-05 | 甲骨文国际公司 | Dynamic resolution of dependency of database guest languages |
| CN114780950A (en) * | 2022-06-20 | 2022-07-22 | 中国人民解放军国防科技大学 | Method, system, device and storage medium for cross-version compatible operation of application software |
| CN115168838A (en) * | 2022-06-02 | 2022-10-11 | 南京赛宁信息技术有限公司 | Script language operation management method and system based on virtual machine safety sandbox |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9703551B2 (en) * | 2014-04-28 | 2017-07-11 | Ca, Inc. | Modifying mobile application binaries to call external libraries |
| US9519468B2 (en) * | 2015-02-13 | 2016-12-13 | Oracle International Corporation | Modular co-versioning in a dynamically linked runtime environment |
-
2023
- 2023-11-16 CN CN202311523137.0A patent/CN117234622B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR101565590B1 (en) * | 2015-01-07 | 2015-11-04 | (주) 바이러스체이서 | A system for expanding the security kernel with system for privilege flow prevention based on white list |
| CN105988821A (en) * | 2016-01-19 | 2016-10-05 | 北京匡恩网络科技有限责任公司 | Distributed function plug-in-based data statistic analysis platform |
| CN106406852A (en) * | 2016-08-25 | 2017-02-15 | 北京北信源软件股份有限公司 | Optimal management method for injecting multi-DLL (dynamic link library) into target procedure |
| CN109784039A (en) * | 2018-11-28 | 2019-05-21 | 杭州天宽科技有限公司 | Construction method, electronic equipment, the storage medium of mobile terminal safety running space |
| CN114286994A (en) * | 2019-08-30 | 2022-04-05 | 甲骨文国际公司 | Dynamic resolution of dependency of database guest languages |
| CN115168838A (en) * | 2022-06-02 | 2022-10-11 | 南京赛宁信息技术有限公司 | Script language operation management method and system based on virtual machine safety sandbox |
| CN114780950A (en) * | 2022-06-20 | 2022-07-22 | 中国人民解放军国防科技大学 | Method, system, device and storage medium for cross-version compatible operation of application software |
Non-Patent Citations (2)
| Title |
|---|
| HPC++:一种支持多线索和远程对象调用的并行语言;刘振英 等;《信息对抗技术》(第1期);第64-66页 * |
| Improvements in a functional core lanauage with call-by-need operational semantics;Manfred schmidt schaup 等;《Proceedings of the 17th International symposium on principles and declarative programming》;第220-231页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117234622A (en) | 2023-12-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8924922B2 (en) | Pre-compiling hosted managed code | |
| US11354144B2 (en) | Java native interface and windows universal app hooking | |
| US9880819B2 (en) | Methods and apparatuses for a compiler server | |
| US8074231B2 (en) | Configuration of isolated extensions and device drivers | |
| US7774762B2 (en) | System including run-time software to enable a software application to execute on an incompatible computer platform | |
| US8112745B2 (en) | Apparatus and method for capabilities verification and restriction of managed applications in an execution environment | |
| US8739147B2 (en) | Class isolation to minimize memory usage in a device | |
| CN108121594B (en) | Process management method and device | |
| US7818733B2 (en) | Improving bundle control in computing environment | |
| CN101452402A (en) | Software operation system and software operation method | |
| JP2006092544A (en) | Dynamic link of module in pre-operating system environment | |
| US6834391B2 (en) | Method and apparatus for automated native code isolation | |
| US20070282801A1 (en) | Dynamically creating and executing an application lifecycle management operation | |
| US7647629B2 (en) | Hosted code runtime protection | |
| CN114077460A (en) | Method, equipment and medium for calling Android dynamic library HAL interface by software operating system | |
| US20120246634A1 (en) | Portable virtual applications | |
| CN116028163A (en) | Method, device and storage medium for scheduling dynamic link library of container group | |
| US9110758B2 (en) | Cross-platform software framework for embedded systems on data storage device | |
| JP2012212431A (en) | System and method implemented in security service | |
| CN117234622B (en) | Multi-language runtime on-demand calling method and system | |
| CN115495158B (en) | Dynamic construction method for system service in microkernel operating system | |
| CN108415737B (en) | Method for loading plug-in virtual machine and electronic terminal | |
| CN116401003A (en) | Android application running method, system and storage medium based on desktop operating system | |
| US20220004422A1 (en) | Method and Apparatus of Providing a Function as a Service (FAAS) Deployment of an Application | |
| US20230074580A1 (en) | Runtime-tailored security policies for applications |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |