CN110990054B - Configuration processing method and device of open source framework - Google Patents
Configuration processing method and device of open source framework Download PDFInfo
- Publication number
- CN110990054B CN110990054B CN201911225649.2A CN201911225649A CN110990054B CN 110990054 B CN110990054 B CN 110990054B CN 201911225649 A CN201911225649 A CN 201911225649A CN 110990054 B CN110990054 B CN 110990054B
- Authority
- CN
- China
- Prior art keywords
- carrier class
- configuration file
- intermediate carrier
- attribute
- class
- 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
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- 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
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a configuration processing method and device of an open source framework, and relates to the technical field of application development. The method comprises the following steps: injecting the information in the configuration file into an intermediate carrier class of the configuration file; after the application program is started, acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class; and copying the value corresponding to the attribute in the intermediate carrier class to the attribute corresponding to the target carrier class of the configuration file. By applying the embodiment of the invention, the open-source framework can support constant configuration, and the working efficiency of developers is improved.
Description
Technical Field
The invention relates to the technical field of application development, in particular to a configuration processing method and device of an open-source framework.
Background
In the development process of the application program, the initial building and development of the application program can be simplified through a preset open source framework such as spring boot. The open source framework can be configured in a specific mode and inherits the principle of convention superior to configuration, so that developers do not need to customize various complicated configurations.
The open source framework in the current application does not support injecting the value corresponding to the attribute in the configuration file into the constant attribute.
That is, the open-source framework in the prior art cannot support constant configuration, which may result in a reduction in development efficiency of developers.
Disclosure of Invention
The present invention is directed to provide a method and an apparatus for processing configuration of an open-source framework, which improve the development efficiency of developers, in view of the above-mentioned deficiencies in the prior art.
In order to achieve the above purpose, the embodiment of the present invention adopts the following technical solutions:
in a first aspect, an embodiment of the present invention provides a method for processing configuration of an open source framework, where the method includes:
injecting information in the configuration file into an intermediate carrier class of the configuration file;
after the application program is started, acquiring the intermediate carrier class to be copied and the attributes in the intermediate carrier class;
and copying the values corresponding to the attributes in the intermediate carrier class to the attributes corresponding to the target carrier class of the configuration file.
Further, the obtaining the intermediate carrier class to be copied and the attribute in the intermediate carrier class includes:
and setting an interface according to a preset annotation and the attribute in the reflection mechanism, and acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class.
Further, the copying the value corresponding to the attribute in the intermediate bearer class to the attribute corresponding to the target bearer class of the configuration file includes:
if the attribute in the object carrier class of the configuration file is modified by a preset termination modifier, removing the termination modifier in the attribute of the object carrier class by using a reflection mechanism;
copying values corresponding to the attributes in the intermediate carrier class to corresponding attributes in the target carrier class by using the reflection mechanism;
and after the copying is finished, adding the termination modifier in the attribute of the target carrier class.
Further, the method further comprises:
monitoring the configuration file by adopting a file monitor;
if the configuration file is monitored to be modified, updating the information in the intermediate carrier class of the configuration file according to the monitored modification information of the configuration file;
and copying the updated information in the intermediate carrier class to the target carrier class of the configuration file.
Further, the updating the information in the intermediate bearer class of the configuration file according to the monitored modification information of the configuration file includes:
using a preset updating annotation to identify the intermediate carrier class to be updated;
and updating the information in the intermediate carrier class with the updated annotation by adopting a context updating interface according to the monitored modification information.
Further, the copying the updated information in the intermediate bearer class to the target bearer class of the configuration file includes:
and copying the updated information in the intermediate carrier class to the target carrier class of the configuration file by using a constant loading interface.
Further, before the information in the configuration file is injected into the intermediate carrier class of the configuration file, the method further includes:
and modifying the information in the target carrier class of the configuration file by using the static constant modifier.
In a second aspect, an embodiment of the present invention further provides a configuration processing apparatus based on a standalone version open source framework, where the apparatus includes:
the injection module is used for injecting the information in the configuration file into the intermediate carrier class of the configuration file;
the acquisition module is used for acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class after the application program is started;
and the first copying module is used for copying the values corresponding to the attributes in the intermediate carrier class to the attributes corresponding to the target carrier class of the configuration file.
Further, the obtaining module is specifically configured to:
and setting an interface according to a preset annotation and the attribute in the reflection mechanism, and acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class.
Further, the first copy module is specifically configured to:
if the attribute in the target carrier class is modified by a preset termination modifier, removing the termination modifier in the attribute of the target carrier class by using a reflection mechanism;
copying values corresponding to the attributes in the intermediate carrier class to corresponding attributes in the target carrier class by using the reflection mechanism;
and after the copying is finished, adding the termination modifier in the attribute of the target carrier class.
Further, the apparatus further comprises:
the monitoring module is used for monitoring the configuration file by adopting a file monitor;
the updating module is used for updating the information in the intermediate carrier class of the configuration file according to the monitored modification information of the configuration file if the configuration file is monitored to be modified;
and the second copying module is used for copying the updated information in the intermediate carrier class to the target carrier class of the configuration file.
Further, the update module is specifically configured to:
using a preset updating annotation to identify the intermediate carrier class to be updated;
and updating the information in the intermediate carrier class with the updated annotation by adopting a context updating interface according to the monitored modification information.
Further, the second copy module is specifically configured to:
and copying the updated information in the intermediate carrier class to a target carrier class of the configuration file by using a constant loading interface.
Further, before the injection module, the method further includes:
and the modifying module is used for modifying the information in the target carrier class of the configuration file by using the static constant modifier.
The embodiment of the present invention further provides a configuration processing device, which includes a memory and a processor, where the memory stores a computer program that can run on the processor, and the processor implements the steps of the configuration processing method of any open source framework when executing the computer program.
The embodiment of the invention also provides a storage medium, wherein a computer program is stored on the storage medium, and when being executed by a processor, the computer program executes the steps of the configuration processing method of any open source framework.
The invention has the beneficial effects that:
the method and the device for configuration processing of the open source framework provided by the embodiment of the invention firstly inject the information in the configuration file into the intermediate carrier class of the configuration file, then obtain the intermediate carrier class to be copied and the attributes in the intermediate carrier class after the application program is started, and finally copy the values corresponding to the attributes in the intermediate carrier class into the corresponding attributes in the target carrier class of the configuration file. By adopting the configuration processing method of the open-source framework provided by the embodiment of the invention, when the value corresponding to the attribute in the configuration file needs to be injected into the constant attribute, the value corresponding to the attribute in the configuration file can be transited into the target carrier class by using the intermediate carrier class, so that the open-source framework can support the injection of the value corresponding to the attribute in the configuration file into the constant attribute, that is, the open-source framework can support the constant configuration, and the development efficiency of developers is improved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present invention and therefore should not be considered as limiting the scope, and those skilled in the art can also obtain other related drawings based on the drawings without inventive efforts.
Fig. 1 is a schematic flowchart of a configuration processing method of an open source framework according to an embodiment of the present invention;
fig. 2 is a schematic flowchart of another configuration processing method of an open source framework according to an embodiment of the present invention;
fig. 3 is a schematic structural diagram of a configuration processing apparatus of an open source framework according to an embodiment of the present invention;
fig. 4 is a schematic structural diagram of a configuration processing apparatus of an open source framework according to an embodiment of the present invention;
fig. 5 is a schematic structural diagram of a configuration processing device according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention.
The method for configuring an open-source framework provided in the following embodiments of the present application may be used in a development process of an application program of the open-source framework, where the open-source framework may be, for example, a spring boot, and the method may be implemented by a computer device, and the computer device may be a device having an open-source framework and used for developing the application program, such as any one of a laptop, a desktop, and a tablet. Fig. 1 is a schematic flowchart of a configuration processing method of an open source framework according to an embodiment of the present invention, as shown in fig. 1, the method includes:
s101, injecting the information in the configuration file into an intermediate carrier class of the configuration file.
Specifically, the configuration file may be a configuration file of a preset application to be developed. The configuration file may be a configuration file established according to the development requirement of the application program, and the configuration file at least includes: the function configuration parameters of the application program are configuration parameters required for realizing preset functions of the application program.
In the configuration file, the function configuration parameters may exist in the form of one key value, the left side is a key value, the right side is a value, for example, the key values are key1 and key2, respectively, and the corresponding value values are value1 and value2, respectively.
Specifically, the intermediate carrier class is identified in advance by a configuration attribute (@ configuration properties) annotation, and then the information in the configuration file is injected into the intermediate carrier class by the configuration attribute annotation. The intermediate carrier class may be used to inject information in the configuration file. Taking the open source framework as the spring boot as an example, the intermediate carrier class may be an intermediate constant class (mcb).
For example, the intermediate carrier class has attributes key1 and key2, the configuration file has a key value and a value, the key values are key1 and key2, respectively, the corresponding value values are value1 and value2, respectively, and the value1 and value2 in the configuration file can be injected into the corresponding attributes key1 and key2 in the intermediate carrier class by using configuration attribute annotation (@ configuration properties).
S102, after the application program is started, acquiring an intermediate carrier class to be copied and the attribute in the intermediate carrier class.
Specifically, the application startup event (application startup event) monitor may be used to monitor the application startup event, and if the startup event is monitored to be completed, it may be determined that the application startup is completed, and then the intermediate carrier class to be copied and the attribute in the intermediate carrier class are acquired.
In this step, an interface may be set according to the preset annotation and the attribute in the reflection mechanism, and the intermediate carrier class to be copied and the attribute in the intermediate carrier class are obtained. Specifically, if the open source frame is a spring boot, the preset annotation may be, for example, a Constant annotation (@ Constant), and in the target carrier class, the information to be copied may be identified by using the Constant annotation, and then the corresponding intermediate carrier class and intermediate carrier class attribute fields (mcb fields) are obtained according to the preset annotation and an attribute setting interface (set (Object obj, object value) api) in the Java reflection mechanism, where a field name in the information to be copied and a corresponding intermediate carrier class attribute field name (field name) are to be consistent. The target carrier class may be a system Constant (Constant) class in a foreground and background service code of the application to be developed. When the attributes to be copied are too many, unnecessary hard coding can be reduced in the object carrier class, and the reading property and the observability of the application program code are enhanced.
S103, copying the value corresponding to the attribute in the intermediate carrier class to the attribute corresponding to the target carrier class of the configuration file.
Specifically, if the attribute in the target carrier class is an inaccessible level, the attribute may be set to an access level, if the attribute of the target carrier class is modified by a preset termination modifier final, the termination modifier in the attribute of the target carrier class may be removed by using an attribute modifier (modifiers) provided in a Java reflection mechanism, then a value corresponding to the attribute of the intermediate carrier class is copied to the attribute corresponding to the target carrier class by using the Java reflection mechanism, and after the copying is completed, the termination modifier final is added to the attribute of the target carrier class.
According to the configuration processing method of the open source framework, when the value corresponding to the attribute in the configuration file needs to be injected into the constant attribute, the value corresponding to the attribute in the configuration file can be transited to the target carrier class by using the intermediate carrier class, so that the open source framework can support the injection of the value corresponding to the attribute in the configuration file into the constant attribute, namely, the open source framework can support the constant configuration, and the development efficiency of developers is improved.
Fig. 2 is a schematic flowchart of another configuration processing method of an open source framework according to an embodiment of the present invention, and as shown in fig. 2, after step S103 in fig. 1, the method further includes:
s201, monitoring the configuration file by adopting a file monitor.
The file listener may be a pre-registered file listener for the profile. If the open source framework is a stand-alone spring boot, the file listener may be, for example, a file change listening adapter (filealterationlistenerdadaptor) provided by the common-io component package, or a listener constituted by other third-party components.
In the method, the file monitor can be adopted to monitor the modification of the configuration file so as to monitor whether the configuration file is modified, and if the configuration file is modified, the modification information of the configuration file can be monitored.
S202, if the configuration file is monitored to be modified, updating the information in the intermediate carrier class of the configuration file according to the monitored modification information of the configuration file.
Specifically, the modification information of the configuration file at least includes: the target value of the modified attribute in the configuration file. And under the condition that the monitored configuration file is modified, updating the value of the corresponding attribute in the intermediate carrier class according to the modification information of the configuration file. For example, if it is monitored that value2 corresponding to key2 in the configuration file is modified and is modified to value3, the value corresponding to attribute key2 in the intermediate carrier class of the configuration file may be updated, and the values corresponding to other attributes are not updated.
Further, in an embodiment, in this step, the information in the intermediate bearer class of the configuration file is updated according to the monitored modification information of the configuration file. The following may be specifically adopted:
specifically, the preset update annotation may be used to identify the intermediate carrier class to be updated, and then the context update interface is used to update the information in the intermediate carrier class with the update annotation according to the monitored modification information.
For example, taking a spring boot of a single version as an example, first, an intermediate carrier class to be updated may be identified by using a preset update annotation (@ RefreshScope), where the identified intermediate carrier class may be an intermediate carrier class to which an attribute frequently used by developing an application belongs, then, according to monitored modification information, information in the intermediate carrier class having the identification update annotation may be updated by using a context update interface (context. Refresh ()) provided by a component package printing-closed-content, and finally, the updated information in the intermediate carrier class is copied to a target carrier class of a configuration file by using a constant load interface (loadconstantfromconfigugfilfiles ()).
S203, copying the updated information in the intermediate carrier class to the target carrier class of the configuration file.
Specifically, a constant load (ConstantLoader) interface may be utilized to copy the information in the updated intermediate carrier class to the target carrier class of the configuration file. Taking Spring Boot of a stand-alone version as an example, the constant load (ConstantLoader) interface may be a constant load interface (loadConstantsFromConfigFiles ()).
Further, in another embodiment, before the information in the configuration file is injected into the intermediate carrier class of the configuration file, the method may further include:
and modifying the information in the target carrier class of the configuration file by using a static constant modifier.
Specifically, taking a single-machine version of spring boot as an example, before the application program starts, the information in the object carrier class may be modified in advance by using a static constant modifier (static final), which may ensure that the information is not modified at will by anyone or any thread when the application program runs.
The following describes a device, an apparatus, and a storage medium for executing the processing method for updating configuration based on a standalone version open source framework provided in the present application, and specific implementation procedures and technical effects thereof are referred to above, and will not be described again below.
Fig. 3 is a schematic structural diagram of a configuration processing apparatus of an open source framework according to an embodiment of the present invention, where the apparatus includes:
an injection module 301, configured to inject information in a configuration file into an intermediate carrier class of the configuration file;
an obtaining module 302, configured to obtain the intermediate carrier class to be copied and an attribute in the intermediate carrier class after the application is started;
a first copying module 303, configured to copy the value corresponding to the attribute in the intermediate bearer class to the attribute corresponding to the destination bearer class of the configuration file.
Further, the obtaining module 302 is specifically configured to:
if the attribute in the target carrier class is modified by a preset termination modifier, removing the termination modifier in the attribute of the target carrier class by using a reflection mechanism;
copying the value corresponding to the attribute in the intermediate carrier class to the attribute corresponding to the target carrier class by using the reflection mechanism;
after the copying is completed, the termination modifier is added to the attribute of the target carrier class.
Further, the first copy module 303 is specifically configured to:
if the attribute in the target carrier class is modified by a preset termination modifier, removing the termination modifier in the attribute of the target carrier class by using a reflection mechanism;
copying the value corresponding to the attribute in the intermediate carrier class to the attribute corresponding to the target carrier class by using the reflection mechanism;
after the copying is completed, the termination modifier is added to the attribute of the target carrier class.
Fig. 4 is a schematic structural diagram of another configuration processing apparatus of an open source framework according to an embodiment of the present invention, as shown in fig. 4, after the first copy module 303 in fig. 3, the apparatus further includes:
a monitoring module 401, configured to monitor the configuration file by using a file monitor;
an updating module 402, configured to update information in the intermediate bearer class of the configuration file according to modification information of the monitored configuration file if it is monitored that the configuration file is modified;
a second copying module 403, configured to copy the updated information in the intermediate carrier class to the target carrier class of the configuration file.
Further, the updating module 402 is specifically configured to:
using a preset updating annotation to identify the intermediate carrier class to be updated;
and updating the information in the intermediate carrier class with the updated annotation by adopting a context updating interface according to the monitored modification information.
Further, the second copy module 403 is specifically configured to:
and copying the updated information in the intermediate carrier class to the target carrier class of the configuration file by using a constant loading interface.
Further, before the injection module 301, the apparatus further comprises:
and the modifying module is used for modifying the information in the target carrier class of the configuration file by using the static constant modifier.
The above-mentioned apparatus is used for executing the method provided by the foregoing embodiment, and the implementation principle and technical effect are similar, which are not described herein again.
These above modules may be one or more integrated circuits configured to implement the above methods, such as: one or more Application Specific Integrated Circuits (ASICs), or one or more microprocessors (DSPs), or one or more Field Programmable Gate Arrays (FPGAs), among others. For another example, when one of the above modules is implemented in the form of a Processing element scheduler code, the Processing element may be a general-purpose processor, such as a Central Processing Unit (CPU) or other processor capable of calling program code. For another example, these modules may be integrated together and implemented in the form of a system-on-a-chip (SOC).
Fig. 5 is a configuration processing apparatus provided in an embodiment of the present invention, including: memory 501, processor 502.
The memory 501 is used for storing a computer program that is executable on the processor 502, and the processor 502 is used for implementing the above-described method embodiments when executing the computer program. The specific implementation and technical effects are similar, and are not described herein again.
Optionally, the present invention also provides a storage medium, for example a computer-readable storage medium, comprising a program, which when executed by a processor is adapted to perform the above-described method embodiments.
In the embodiments provided in the present invention, it should be understood that the disclosed apparatus and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.
The integrated unit implemented in the form of a software functional unit may be stored in a computer-readable storage medium. The software functional unit is stored in a storage medium and includes several instructions to enable a computer device (which may be a personal computer, a server, or a network device) or a processor (processor) to execute some steps of the methods according to the embodiments of the present invention. And the aforementioned storage medium includes: a U disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.
Claims (8)
1. A configuration processing method of an open source framework is characterized by comprising the following steps:
injecting information in a configuration file into an intermediate carrier class of the configuration file;
after the application program is started, acquiring the intermediate carrier class to be copied and the attributes in the intermediate carrier class;
copying the values corresponding to the attributes in the intermediate carrier class to the attributes corresponding to the target carrier class of the configuration file;
the obtaining of the intermediate carrier class to be copied and the attributes in the intermediate carrier class includes:
setting an interface according to a preset annotation and an attribute in a reflection mechanism, and acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class;
copying the values corresponding to the attributes in the intermediate carrier class to the attributes corresponding to the target carrier class of the configuration file, including:
if the attribute in the target carrier class is modified by a preset termination modifier, removing the termination modifier in the attribute of the target carrier class by using a reflection mechanism;
copying values corresponding to the attributes in the intermediate carrier class to corresponding attributes in the target carrier class by using the reflection mechanism;
and after the copying is finished, adding the termination modifier in the attribute of the target carrier class.
2. The method of claim 1, wherein the method further comprises:
monitoring the configuration file by adopting a file monitor;
if the configuration file is monitored to be modified, updating the information in the intermediate carrier class of the configuration file according to the monitored modification information of the configuration file;
and copying the updated information in the intermediate carrier class to a target carrier class of the configuration file.
3. The method as claimed in claim 2, wherein said updating the information in the intermediate bearer class of the configuration file according to the monitored modification information of the configuration file comprises:
using a preset updating annotation to identify the intermediate carrier class to be updated;
and updating the information in the intermediate carrier class with the updated annotation by adopting a context updating interface according to the monitored modification information.
4. The method of claim 2, wherein the copying the updated information in the intermediate carrier class to the target carrier class of the configuration file comprises:
and copying the updated information in the intermediate carrier class to a target carrier class of the configuration file by using a constant loading interface.
5. The method of any of claims 1-4, wherein prior to injecting the information in the configuration file into the intermediate carrier class of the configuration file, further comprising:
and modifying the information in the target carrier class of the configuration file by using the static constant modifier.
6. An open source framework configuration processing apparatus, the apparatus comprising:
the injection module is used for injecting the information in the configuration file into the intermediate carrier class of the configuration file;
the acquisition module is used for acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class after the application program is started;
a first copying module, configured to copy a value corresponding to an attribute in the intermediate carrier class to an attribute corresponding to a target carrier class of the configuration file;
the acquisition module is specifically configured to:
setting an interface according to a preset annotation and an attribute in a reflection mechanism, and acquiring the intermediate carrier class to be copied and the attribute in the intermediate carrier class;
the first copy module is specifically configured to:
if the attribute in the target carrier class is modified by a preset termination modifier, removing the termination modifier in the attribute of the target carrier class by using a reflection mechanism;
copying values corresponding to the attributes in the intermediate carrier class to corresponding attributes in the target carrier class by using the reflection mechanism;
and after the copying is finished, adding the termination modifier in the attribute of the target carrier class.
7. A configuration processing device, comprising a memory, a processor, a computer program being stored in the memory and being executable on the processor, the processor implementing the steps of the method according to any of the preceding claims 1 to 5 when executing the computer program.
8. A storage medium, characterized in that the storage medium has stored thereon a computer program which, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911225649.2A CN110990054B (en) | 2019-12-03 | 2019-12-03 | Configuration processing method and device of open source framework |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911225649.2A CN110990054B (en) | 2019-12-03 | 2019-12-03 | Configuration processing method and device of open source framework |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110990054A CN110990054A (en) | 2020-04-10 |
| CN110990054B true CN110990054B (en) | 2023-03-21 |
Family
ID=70089868
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911225649.2A Active CN110990054B (en) | 2019-12-03 | 2019-12-03 | Configuration processing method and device of open source framework |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110990054B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114090105A (en) * | 2021-02-02 | 2022-02-25 | 京东科技信息技术有限公司 | System building method and device |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101911018A (en) * | 2008-01-11 | 2010-12-08 | 国际商业机器公司 | Computer configuration virtual topology discovery |
| CN108133139A (en) * | 2017-11-28 | 2018-06-08 | 西安交通大学 | A kind of Android malicious application detecting system compared based on more running environment behaviors |
| CN110222318A (en) * | 2019-06-05 | 2019-09-10 | 卡斯柯信号(成都)有限公司 | Data generating tool development approach based on XML |
| CN110377336A (en) * | 2019-06-17 | 2019-10-25 | 平安普惠企业管理有限公司 | Interface document generation method, device, computer equipment and storage medium |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140016142A1 (en) * | 2012-07-13 | 2014-01-16 | Konica Minolta Laboratory U.S.A., Inc. | Printing the identity of unsupported formatting attributes |
-
2019
- 2019-12-03 CN CN201911225649.2A patent/CN110990054B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101911018A (en) * | 2008-01-11 | 2010-12-08 | 国际商业机器公司 | Computer configuration virtual topology discovery |
| CN108133139A (en) * | 2017-11-28 | 2018-06-08 | 西安交通大学 | A kind of Android malicious application detecting system compared based on more running environment behaviors |
| CN110222318A (en) * | 2019-06-05 | 2019-09-10 | 卡斯柯信号(成都)有限公司 | Data generating tool development approach based on XML |
| CN110377336A (en) * | 2019-06-17 | 2019-10-25 | 平安普惠企业管理有限公司 | Interface document generation method, device, computer equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110990054A (en) | 2020-04-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10545775B2 (en) | Hook framework | |
| US10613970B1 (en) | Method and system for managing deployment of software application components based on software performance data | |
| US20200192662A1 (en) | Semantic-aware and self-corrective re-architecting system | |
| US10552210B2 (en) | Method and apparatus for migrating virtual machine | |
| US8806437B2 (en) | Automated testing process | |
| WO2019042311A1 (en) | Software project setup task configuration method and device using jenkins | |
| US20120174068A1 (en) | Testing Software Code | |
| US9483384B2 (en) | Generation of software test code | |
| CN107368353B (en) | Method and device for realizing hot addition of virtual machine memory | |
| Farooq et al. | Runtimedroid: Restarting-free runtime change handling for android apps | |
| US11983519B2 (en) | Abort installation of firmware bundles | |
| WO2020177519A1 (en) | Debugging method executed on smart terminal and software debugging device | |
| CN110990054B (en) | Configuration processing method and device of open source framework | |
| CN106603125B (en) | Method and device for data interaction with Bluetooth equipment | |
| CN106293790B (en) | application program upgrading method and device based on Firefox operating system | |
| US20140279974A1 (en) | Versioning for configurations of reusable artifacts | |
| WO2019136861A1 (en) | Method and device for implementing hook function based on high-level programming language | |
| CN112835639A (en) | Hook implementation method, device, equipment, medium and product | |
| US9489179B2 (en) | Application programming interface tracing mechanism | |
| CN111522535A (en) | Data source aggregation method and device, storage medium and computer equipment | |
| US10558639B2 (en) | Objects comparison manager | |
| CN103677846A (en) | SQLite database development kit and development method thereof | |
| CN109783156B (en) | Application starting control method and device | |
| CN113535354A (en) | Method and device for adjusting parallelism of Flink SQL operator | |
| US20140074795A1 (en) | Reconstruction of system definitional and state information |
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 |