CN110262848B - Method and device for loading application program instance in application development framework - Google Patents
Method and device for loading application program instance in application development framework Download PDFInfo
- Publication number
- CN110262848B CN110262848B CN201910487751.3A CN201910487751A CN110262848B CN 110262848 B CN110262848 B CN 110262848B CN 201910487751 A CN201910487751 A CN 201910487751A CN 110262848 B CN110262848 B CN 110262848B
- Authority
- CN
- China
- Prior art keywords
- application
- predetermined number
- instances
- configuration
- application program
- 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 45
- 238000011161 development Methods 0.000 title claims abstract description 28
- 238000013515 script Methods 0.000 claims description 55
- 238000004590 computer program Methods 0.000 claims description 3
- 239000000306 component Substances 0.000 description 13
- 238000004422 calculation algorithm Methods 0.000 description 12
- 230000008569 process Effects 0.000 description 10
- 239000008358 core component Substances 0.000 description 4
- 235000010627 Phaseolus vulgaris Nutrition 0.000 description 3
- 244000046052 Phaseolus vulgaris Species 0.000 description 3
- 238000002955 isolation Methods 0.000 description 3
- 238000013507 mapping Methods 0.000 description 3
- 239000000243 solution Substances 0.000 description 3
- 101100217298 Mus musculus Aspm gene Proteins 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 238000002347 injection Methods 0.000 description 1
- 239000007924 injection Substances 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
Abstract
The embodiment of the specification provides a method and a device for loading an application program instance in an application development framework, wherein the method comprises the following steps: acquiring configuration elements of a plurality of application program instances; dividing the plurality of application instances into a predetermined number of groups; concurrently generating a predetermined number of configuration files, wherein the predetermined number of configuration files correspond to the predetermined number of groups one to one, and each configuration file comprises configuration elements of each application program instance in the group corresponding to the configuration file; and loading the application program instances concurrently based on the predetermined number of configuration files respectively.
Description
Technical Field
The embodiment of the specification relates to the technical field of application development frameworks, and in particular relates to a method and a device for loading an application program instance in an application development framework.
Background
In existing application development frameworks, individual application program instances are loaded, for example, at startup. Taking a Spring framework as an example, when the framework is started, script texts are read from a database, syntax checking is carried out on the scripts, the scripts are compiled into usable classes in real time, and the usable classes are automatically burned into a Spring running environment. In the burning process, a complete xml configuration file is generated for each application program instance (bean), and then the xml configuration file is uniformly loaded by spring. Since the system functionality of the existing framework is strongly dependent on these scripts, it is not possible to skip or load asynchronously at startup. In the prior art, a single thread is used in the syntax checking and compiling process, and in the process of loading the application program instance, the Spring framework merges the xml configuration files corresponding to the application programs and loads the xml configuration files by using the single thread, so that the starting time is very long, and is as much as 15 minutes.
Therefore, there is a need for a more efficient solution for loading application instances in an application development framework.
Disclosure of Invention
The embodiments of the present specification aim to provide a more efficient scheme for loading application program instances in an application development framework, so as to solve the deficiencies in the prior art.
To achieve the above object, one aspect of the present specification provides a method for loading an application instance in an application development framework, including:
acquiring configuration elements of a plurality of application program instances;
dividing the plurality of application instances into a predetermined number of groups;
concurrently generating a predetermined number of configuration files, wherein the predetermined number of configuration files correspond to the predetermined number of groups one to one, and each configuration file comprises configuration elements of each application program instance in the group corresponding to the configuration file; and
and respectively based on the preset number of configuration files, concurrently loading the application program instances.
In one embodiment, the respective application instances have names different from each other, wherein dividing the plurality of application instances into a predetermined number of groups includes calculating hash values of the names of the respective application instances; for each application instance, the application instance is assigned to one of a predetermined number of groups based on a value of at least one predetermined bit in the hash value of its name.
In one embodiment, the application development framework is a Spring framework.
In one embodiment, the configuration file is an xml file.
In one embodiment, obtaining the configuration elements of the application instances comprises obtaining the configuration elements of the application instances by reading a plurality of scripts pre-stored in a database.
In one embodiment, the obtaining of the configuration elements of the application instances by reading a plurality of scripts pre-stored in a database includes obtaining the configuration elements of the application instances by reading a plurality of scripts pre-stored in a database and performing syntax checking and compiling on the scripts concurrently.
In one embodiment, the method is performed at startup of the application development framework or after at least one script of the plurality of scripts is updated.
Another aspect of the present specification provides an apparatus for loading an application instance in an application development framework, comprising:
an acquisition unit configured to acquire configuration elements of respective ones of a plurality of application instances;
a grouping unit configured to group the plurality of application program instances into a predetermined number of groups;
the generating unit is configured to generate a predetermined number of configuration files concurrently, wherein the predetermined number of configuration files correspond to the predetermined number of groups in a one-to-one manner, and each configuration file comprises configuration elements of each application program instance in the group corresponding to the configuration file; and
and the loading unit is configured to load the application program instances simultaneously based on the preset number of configuration files respectively.
In one embodiment, the application program instances have different names, wherein the grouping unit includes a calculating subunit configured to calculate hash values of the names of the application program instances; an assigning subunit configured to, for each application instance, assign the application instance to one of a predetermined number of groups based on a value of at least one predetermined bit in the hash value of its name.
In one embodiment, the obtaining unit is further configured to obtain the configuration elements of the respective application program instances by reading a plurality of scripts pre-stored in the database.
In one embodiment, the obtaining unit is further configured to obtain the configuration elements of the respective application program instances by reading a plurality of scripts pre-stored in the database, grouping the plurality of scripts, and concurrently performing syntax checking and compiling on the plurality of groups of scripts.
Another aspect of the present specification provides a computer readable storage medium having a computer program stored thereon, which, when executed in a computer, causes the computer to perform any one of the above methods.
Another aspect of the present specification provides a computing device comprising a memory and a processor, wherein the memory stores executable code, and the processor implements any one of the above methods when executing the executable code.
According to the scheme for loading the application program examples when the framework is started, the multiple application program examples are loaded in parallel by using multiple threads, the loading time is greatly shortened, the starting time is greatly shortened, the scripts can be quickly updated by the multiple threads when the scripts are updated, fault isolation and old script backup are realized, the safety is improved, and the possibility of online faults is reduced.
Drawings
The embodiments of the present specification may be made more clear by describing the embodiments with reference to the attached drawings:
fig. 1 illustrates a core container 100 included in an application development framework according to an embodiment of the present description;
FIG. 2 illustrates a method of loading an application instance in an application development framework in accordance with an embodiment of the present description;
FIG. 3 schematically illustrates the process shown in FIG. 2;
fig. 4 illustrates an apparatus 400 for loading an application instance in an application development framework according to an embodiment of the present description.
Detailed Description
The embodiments of the present specification will be described below with reference to the accompanying drawings.
Fig. 1 illustrates a core container 100 included in an application development framework according to an embodiment of the present specification. The application development framework is, for example, a Spring framework, which is an open source framework, and one of the main advantages of the framework is its hierarchical structure, which allows the user to select which component to use. The core container 100 is a control Inversion (IOC) container in which multiple application instances (beans) are produced and managed in a factory mode (beans). As shown in fig. 1, four components are included in the core container 100: an application instance component 11, a core component 12, a context component 13, and a SpEL component 14. Among other things, the application instance component 11 solves the following problems, for example: definition of an application instance, creation of an application instance, and parsing of an application instance. The core component 12 defines the access patterns of the resources. The core component 12 and the application instance component 11 provide the most basic part of the overall framework, including controlling the reversal dependency injection. The context component 13 builds on the core component and the application instance component 11, and provides a runtime environment for the Spring framework to save the state of each object (i.e., application instance). The SpEL component 14 provides a powerful expression language for manipulating objects at runtime. In the scheme of loading application instances in a framework according to the embodiment of the present specification, that is, the scheme executed by the core container 100, specifically, after the core container 100 reads configuration elements of a plurality of (e.g., N) application instances, the configuration elements of each application instance are allocated to a predetermined number (e.g., M) of xml files in the application instance component 11, for example, based on a hash algorithm, so that the configuration elements are registered in a concurrent hash mapping table (ConcurrentHashMap) in the context component 13 based on the M xml files.
It is to be understood that, in the above description, although a Spring framework is taken as an example for illustration, in this embodiment, the Spring framework is not limited to the Spring framework, and may be an application development framework supporting concurrent loading of application program instances for any underlying layer. Hereinafter, the Spring frame will be explained as an example.
The above loading scheme is described in detail below.
Fig. 2 illustrates a method for loading an application instance in an application development framework according to an embodiment of the present specification, including:
step S202, obtaining respective configuration elements of a plurality of application program instances;
step S204, dividing the plurality of application program instances into a predetermined number of groups;
step S206, a preset number of configuration files are generated concurrently, wherein the preset number of configuration files correspond to the preset number of groups one to one, and each configuration file comprises configuration elements of each application program instance in the group corresponding to the configuration file; and
and step S208, loading the application program instances simultaneously based on the preset number of configuration files respectively.
The application development framework typically performs the loading of application program instances at startup, and thus, the method may be performed at startup of the framework. In the case that the framework acquires the configuration elements of the application program instances through the script, when the script is updated, the framework is triggered to reload the application program instances corresponding to the script. For example, the framework may periodically observe each script, and at each observation time, obtain a plurality of scripts currently updated, and reload instances corresponding to the plurality of updated scripts, so that the method may also be executed after at least one script is updated.
First, in step S202, configuration elements of respective ones of a plurality of application instances are acquired.
The configuration elements of an application instance include various elements such as the name (Id) of the application instance, the class (class) to which the application instance belongs, configuration parameters of the application instance (i.e., object), and the like. The configuration elements may correspond to various elements in an xml configuration file. It is known to those skilled in the art that the name of an application instance uniquely identifies the application instance, i.e., the names of the various application instances are different from one another.
The configuration elements for each of the plurality of application instances may be obtained in a variety of ways. In one embodiment, the configuration elements of the application program instances can be obtained by reading a plurality of scripts pre-stored in the database. The script is, for example, a Groovy language script, and the script is stored in a database in a text form in advance. Each script is preset with various configuration elements of the corresponding application program instance. For example, when the framework is started, the framework reads the script texts from the database, performs syntax check on the script texts, and compiles the script texts after the check is passed, so that various configuration element values of the application program instances in the script texts can be acquired. In one embodiment, after reading, for example, N scripts from the database, the framework may group the N scripts as described below in a grouping method and open N threads to concurrently syntax and compile multiple sets of scripts, thereby speeding up the process.
It is understood that the manner of obtaining the configuration elements of the application instance is not limited to the manner of reading the script, but also includes other manners available to those skilled in the art, for example, by pre-storing other files in a database, by annotating in a class, and the like.
Step S204, the plurality of application program instances are divided into a predetermined number of groups.
In one embodiment, the plurality of application instances may be divided into a predetermined number of groups based on a hashing algorithm. The method specifically comprises the following steps of firstly, obtaining hash values of names of all application program instances.
The hash values corresponding to the respective names may be obtained by various hash algorithms, such as MD4 algorithm, MD5 algorithm, SHA1 algorithm, and the like, which basically ensure that the respective names are mapped to different hash values having the same number of bits based on their algorithm principle, and the respective hash values mapped respectively by the respective names are approximately uniform with respect to the distribution of values at predetermined bits therein. For example, the hash value is a hexadecimal value, and for a predetermined 1 bit, for example, the 1 st bit, of the hash value, the possible values at this bit include 16 values of 1, 2, …, and F, as described above, the configuration elements of N application program instances can be obtained by reading N scripts, that is, N ids can be obtained, and the distribution of the values in the 1 st bit of each of the N hash values mapped by the hash algorithm and corresponding to the N ids respectively in 1, 2, …, and F is substantially uniform. It will be appreciated that for predetermined bits of the hash value, such as bits 1 and 2, the distribution of the values of the respective hash values over the predetermined two bits is also substantially uniform.
In one embodiment, multiple threads may be started to obtain respective hash values for the names of the N application instances, respectively, to speed up the process.
Then, for each application instance, the application instance is assigned to one of a predetermined number of groups based on a value of at least one predetermined bit in the hash value of its name.
The predetermined number is determined based on a number of bits of the predetermined bits. For example, the predetermined bit is 1 bit, for example, the 1 st bit as described above, which has 16 values, so that the predetermined number is 16, and the respective hash values can be divided into 16 groups by the value of the bit, that is, each group corresponds to one of 1 to F, that is, each application instance is allocated to a corresponding one of the 16 groups. It is to be understood that the hash value is not limited to being represented as a hexadecimal number, nor is the predetermined bit limited to being a 1-bit. For example, the hash values are binary numbers, for example, the hash values are grouped by taking values of three predetermined bits in each hash value, and since the values of the three predetermined bits include 8 taking modes, that is, 0 to 7, in this case, the hash values are grouped into 8 groups. It is understood that the three predetermined bits may be consecutive three bits in the hash value or may be scattered three bits.
By grouping the plurality of hash values in this manner, in a case where it is not determined in advance what the total number of the plurality of hash values is, it is still possible to group the plurality of hash values into a predetermined number M of groups on average. Therefore, the method is applicable to a scenario in which application instances are loaded in a framework in the embodiment of the present specification, because the total number of applications that need to be loaded when the framework is started is constantly changed, and usually constantly increased, or because the total number of application instances that need to be loaded due to script update is also changed, accordingly, the total number of calculated hash values corresponding to each application instance is also constantly changed, and thus, by the above-mentioned grouping method based on the hash algorithm, a plurality of application instances whose total number is uncertain can be substantially uniformly grouped into M groups.
It is to be understood that, in the embodiment of the present specification, the grouping method for the plurality of application program instances is not limited to the above-described hash algorithm-based method, and the grouping may be performed by any grouping method as long as the plurality of application program instances are finally grouped into a group of a predetermined number (M), so that each group may be concurrently subjected to a subsequent loading process by M threads after the grouping, so that a loading time may be saved, so that, for example, at the time of framework startup, a framework startup time may be shortened, or after a script is updated, a corresponding application program instance may be updated more quickly. It will be appreciated that the approach in which multiple application instances are grouped evenly results in greater time savings, faster start-up, or faster instance update. For example, the grouping method can also be that M is respectively modulo by the sorting sequence numbers of N application program instances, and the grouping is carried out according to the modulo remainder.
Step S206, a predetermined number of configuration files are generated concurrently, wherein the predetermined number of configuration files correspond to the predetermined number of groups one to one, and each configuration file comprises the configuration elements of the application program instances in the group corresponding to the configuration file.
After the N application instances are evenly grouped into M groups as described above, one profile may be generated for each group, i.e., M profiles are generated. Each configuration file comprises the configuration elements of the application program instances in the corresponding group. That is, the configuration elements of the application instances included in the corresponding group are merged in each configuration file, for example, the configuration elements of the application instances may be arranged in the configuration file in a random order. In this way, the number of profiles is greatly reduced compared to the prior art, for example, 16 profiles are formed in the above case of grouping by 1 bit of a 16-ary hash value. The configuration file is, for example, an xml file, and it is understood that the configuration file is not limited to being an xml file, but may be a configuration file specifically used in any application development framework.
Meanwhile, for the M groups, the M threads can be started to concurrently generate the corresponding configuration files, so that the process is accelerated.
And step S208, loading the application program instances simultaneously based on the preset number of configuration files respectively.
After the M configuration files are generated as described above, the loading of the application instance may be performed by the M threads based on the respective configuration files, respectively. Specifically, in one of the threads, an xml file may be first converted into an xml file stream, each instance in the xml file stream may be converted into a corresponding interface object (BeanDefinition object), each element in the corresponding instance may be included in the interface object, a corresponding application instance may be created based on each interface object, and the application instance may be registered in a concurrent hash mapping table in a Spring framework. The concurrent hash mapping table can guarantee thread security under high concurrency, and therefore implementation of the multithreading scheme of the embodiment of the specification can be supported. Therefore, multithreading loading is carried out based on the Spring framework, the loading efficiency is greatly improved, the starting time or the instance updating time is greatly reduced, and meanwhile fault isolation can be carried out on different threads.
FIG. 3 schematically illustrates the process shown in FIG. 2, and as shown in FIG. 3, at step S302, configuration elements of respective ones of a plurality of application instances are obtained; in step S304, a plurality of application program instances are grouped, so that configuration elements of each of, for example, three groups of application program instances in the graph can be acquired; in step S306, three configuration files are concurrently generated from the three sets of configuration elements; and, in step S308, concurrently loading the application program instance based on the three configuration files. Thus, efficiency is greatly improved through concurrent execution of multiple threads.
Fig. 4 illustrates an apparatus 400 for loading an application instance in an application development framework according to an embodiment of the present description, including:
an obtaining unit 41 configured to obtain configuration elements of respective ones of the plurality of application instances;
a grouping unit 42 configured to group the plurality of application program instances into a predetermined number of groups;
a generating unit 43, configured to concurrently generate a predetermined number of configuration files, where the predetermined number of configuration files correspond to the predetermined number of groups in a one-to-one manner, and each configuration file includes configuration elements of each application instance in the group corresponding to the configuration file; and
a loading unit 44 configured to concurrently load the application program instances based on the predetermined number of configuration files, respectively.
In one embodiment, the application program instances have different names, wherein the grouping unit 42 includes a calculating subunit 421 configured to calculate hash values of the names of the application program instances; an assigning subunit 422 configured to, for each application instance, assign the application instance to one of a predetermined number of groups based on a value of at least one predetermined bit in the hash value of its name.
In an embodiment, the obtaining unit 41 is further configured to obtain the configuration elements of the respective application program instances by reading a plurality of scripts pre-stored in the database.
In one embodiment, the obtaining unit 41 is further configured to obtain the configuration elements of the respective application program instances by reading a plurality of scripts pre-stored in the database, grouping the plurality of scripts, and concurrently performing syntax checking and compiling on the plurality of groups of scripts.
Another aspect of the present specification provides a computer readable storage medium having a computer program stored thereon, which, when executed in a computer, causes the computer to perform any one of the above methods.
Another aspect of the present specification provides a computing device comprising a memory and a processor, wherein the memory stores executable code, and the processor implements any one of the above methods when executing the executable code.
According to the scheme for loading the application program examples when the framework is started, the multiple application program examples are loaded in parallel by using multiple threads, the loading time is greatly shortened, the starting time is greatly shortened, the corresponding application program examples can be quickly updated by the multiple threads when the scripts are updated, fault isolation and old script backup are realized, the safety is improved, and the possibility of online faults is reduced.
It is to be understood that the terms "first," "second," and the like, herein are used for descriptive purposes only and not for purposes of limitation, to distinguish between similar concepts.
The embodiments in the present specification are described in a progressive manner, and the same and similar parts among the embodiments are referred to each other, and each embodiment focuses on the differences from the other embodiments. In particular, for the system embodiment, since it is substantially similar to the method embodiment, the description is simple, and for the relevant points, reference may be made to the partial description of the method embodiment.
The foregoing description has been directed to specific embodiments of this disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.
It will be further appreciated by those of ordinary skill in the art that the elements and algorithm steps of the examples described in connection with the embodiments disclosed herein may be embodied in electronic hardware, computer software, or combinations of both, and that the components and steps of the examples have been described in a functional general in the foregoing description for the purpose of illustrating clearly the interchangeability of hardware and software. Whether these functions are performed in hardware or software depends on the particular application of the solution and design constraints. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.
The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied in hardware, a software module executed by a processor, or a combination of the two. A software module may reside in Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.
The above-mentioned embodiments are intended to illustrate the objects, technical solutions and advantages of the present invention in further detail, and it should be understood that the above-mentioned embodiments are merely exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (12)
1. A method of loading an application instance in an application development framework, comprising:
the method comprises the steps of grouping a plurality of scripts by reading the plurality of scripts pre-stored in a database, and concurrently carrying out syntax check and compilation on the plurality of groups of scripts to obtain respective configuration elements of a plurality of application program instances;
dividing the plurality of application instances into a predetermined number of groups;
concurrently generating a predetermined number of configuration files, wherein the predetermined number of configuration files correspond to the predetermined number of groups one to one, and each configuration file comprises configuration elements of each application program instance in the group corresponding to the configuration file; and
and respectively based on the preset number of configuration files, concurrently loading the application program instances.
2. The method of claim 1, wherein the respective application instances have names that are different from each other, wherein dividing the plurality of application instances into a predetermined number of groups comprises computing a hash value of the name of each application instance; for each application instance, the application instance is assigned to one of a predetermined number of groups based on a value of at least one predetermined bit in the hash value of its name.
3. The method of claim 1, wherein the application development framework is a Spring framework.
4. The method of claim 3, wherein the configuration file is an xml file.
5. The method of claim 1, wherein the method is performed at startup of the application development framework or after at least one of the plurality of scripts is updated.
6. An apparatus for loading an application instance at startup of an application development framework, comprising:
the acquisition unit is configured to read a plurality of scripts pre-stored in the database, group the scripts, and concurrently perform syntax check and compilation on the plurality of groups of scripts to acquire configuration elements of a plurality of application program instances;
a grouping unit configured to group the plurality of application program instances into a predetermined number of groups;
the generating unit is configured to generate a predetermined number of configuration files concurrently, wherein the predetermined number of configuration files correspond to the predetermined number of groups in a one-to-one manner, and each configuration file comprises configuration elements of each application program instance in the group corresponding to the configuration file; and
and the loading unit is configured to load the application program instances simultaneously based on the preset number of configuration files respectively.
7. The apparatus according to claim 6, wherein the respective application instances have names different from each other, wherein the grouping unit includes a calculating subunit configured to calculate hash values of the names of the respective application instances; an assigning subunit configured to, for each application instance, assign the application instance to one of a predetermined number of groups based on a value of at least one predetermined bit in the hash value of its name.
8. The apparatus of claim 6, wherein the application development framework is a Spring framework.
9. The apparatus of claim 8, wherein the configuration file is an xml file.
10. The apparatus of claim 6, wherein the apparatus is deployed at startup of the application development framework or after at least one script of the plurality of scripts is updated.
11. A computer-readable storage medium, on which a computer program is stored which, when executed in a computer, causes the computer to carry out the method of any one of claims 1-5.
12. A computing device comprising a memory and a processor, wherein the memory has stored therein executable code that, when executed by the processor, implements the method of any of claims 1-5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910487751.3A CN110262848B (en) | 2019-06-05 | 2019-06-05 | Method and device for loading application program instance in application development framework |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910487751.3A CN110262848B (en) | 2019-06-05 | 2019-06-05 | Method and device for loading application program instance in application development framework |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110262848A CN110262848A (en) | 2019-09-20 |
| CN110262848B true CN110262848B (en) | 2022-03-04 |
Family
ID=67916943
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910487751.3A Active CN110262848B (en) | 2019-06-05 | 2019-06-05 | Method and device for loading application program instance in application development framework |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110262848B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111382326B (en) * | 2020-03-17 | 2023-06-30 | 北京三快在线科技有限公司 | Instance group creation method, device, server and storage medium |
| CN111654532B (en) * | 2020-05-08 | 2023-08-01 | 国云科技股份有限公司 | Centralized management system, method and device for configuration files |
| CN111984294B (en) * | 2020-08-20 | 2024-04-16 | 中国银行股份有限公司 | Service system updating method and device based on Groovy dynamic loading technology |
| CN114647464B (en) * | 2022-05-19 | 2022-09-06 | 恒生电子股份有限公司 | Application parallel starting processing method and device and electronic equipment |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101216779A (en) * | 2007-01-05 | 2008-07-09 | 中兴通讯股份有限公司 | Method for accomplishing multi-instance and thread serialized affair processing method |
| CN102185768A (en) * | 2011-04-29 | 2011-09-14 | 华为数字技术有限公司 | Configuration business deploying method and device |
| CN106487598A (en) * | 2016-11-15 | 2017-03-08 | 国家数字交换系统工程技术研究中心 | The many examples of isomery redundancy Snmp agreement realize system and its implementation |
| CN108363566A (en) * | 2018-01-30 | 2018-08-03 | 中国平安人寿保险股份有限公司 | File configuration method, intelligent terminal and storage medium in a kind of project development process |
| CN108664315A (en) * | 2017-03-30 | 2018-10-16 | 北京京东尚科信息技术有限公司 | Method, electronic equipment and the readable storage medium storing program for executing of multithreading dynamic processing business |
| CN109165088A (en) * | 2018-09-06 | 2019-01-08 | 华泰证券股份有限公司 | It is a kind of based on elastic-job frame can single machine elasticity dilatation task sharding method |
-
2019
- 2019-06-05 CN CN201910487751.3A patent/CN110262848B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101216779A (en) * | 2007-01-05 | 2008-07-09 | 中兴通讯股份有限公司 | Method for accomplishing multi-instance and thread serialized affair processing method |
| CN102185768A (en) * | 2011-04-29 | 2011-09-14 | 华为数字技术有限公司 | Configuration business deploying method and device |
| CN106487598A (en) * | 2016-11-15 | 2017-03-08 | 国家数字交换系统工程技术研究中心 | The many examples of isomery redundancy Snmp agreement realize system and its implementation |
| CN108664315A (en) * | 2017-03-30 | 2018-10-16 | 北京京东尚科信息技术有限公司 | Method, electronic equipment and the readable storage medium storing program for executing of multithreading dynamic processing business |
| CN108363566A (en) * | 2018-01-30 | 2018-08-03 | 中国平安人寿保险股份有限公司 | File configuration method, intelligent terminal and storage medium in a kind of project development process |
| CN109165088A (en) * | 2018-09-06 | 2019-01-08 | 华泰证券股份有限公司 | It is a kind of based on elastic-job frame can single machine elasticity dilatation task sharding method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110262848A (en) | 2019-09-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110262848B (en) | Method and device for loading application program instance in application development framework | |
| US9934385B2 (en) | System and method for implementing application policies among development environments | |
| US9256419B2 (en) | Dynamic software updates | |
| CN103631720A (en) | Method and device for generating test case | |
| Kusano et al. | CCmutator: A mutation generator for concurrency constructs in multithreaded C/C++ applications | |
| Albarghouthi et al. | Parallelizing top-down interprocedural analyses | |
| CN110543427B (en) | Test case storage method and device, electronic equipment and storage medium | |
| JP2015219924A (en) | PLC program management device | |
| CN109918113A (en) | Multiple/hot update method of IOS application hot repair, server and storage medium | |
| Nguyen et al. | Unbounded Lazy-CSeq: A Lazy Sequentialization Tool for C Programs with Unbounded Context Switches: (Competition Contribution) | |
| CN104268050A (en) | Simple method for testing bandwidth of internal memory | |
| Mayan et al. | Test case optimization using hybrid search technique | |
| CN115757149A (en) | Automatic testing method, system, electronic equipment and storage medium | |
| Kähkönen et al. | LCT: A parallel distributed testing tool for multithreaded Java programs | |
| US8438000B2 (en) | Dynamic generation of tests | |
| CN111026670A (en) | Test case generation method, test case generation device, and storage medium | |
| US8856745B2 (en) | System and method for using a shared standard expectation computation library to implement compliance tests with annotation based standard | |
| US9489284B2 (en) | Debugging method and computer program product | |
| Bonichon et al. | LLVM-based code generation for B | |
| CN113708971A (en) | Openstack cloud platform deployment method and related device | |
| CN111078548B (en) | Test case analysis method and device, storage medium and verification platform | |
| CN108958823A (en) | The method for modifying basic input output system setting value | |
| Diepenbeck et al. | Towards automatic scenario generation from coverage information | |
| KR101506656B1 (en) | System for quality management of application and method therefor | |
| Elmsheuser et al. | Large scale software building with CMake in ATLAS |
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 | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20201009 Address after: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Applicant after: Innovative advanced technology Co.,Ltd. Address before: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Applicant before: Advanced innovation technology Co.,Ltd. Effective date of registration: 20201009 Address after: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Applicant after: Advanced innovation technology Co.,Ltd. Address before: A four-storey 847 mailbox in Grand Cayman Capital Building, British Cayman Islands Applicant before: Alibaba Group Holding Ltd. |
|
| TA01 | Transfer of patent application right | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20240221 Address after: Guohao Times City # 20-01, 128 Meizhi Road, Singapore Patentee after: Advanced Nova Technology (Singapore) Holdings Ltd. Country or region after: Singapore Address before: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Patentee before: Innovative advanced technology Co.,Ltd. Country or region before: United Kingdom |
|
| TR01 | Transfer of patent right |