CN110825361B - Code modification method, device, equipment and readable storage medium - Google Patents
Code modification method, device, equipment and readable storage medium Download PDFInfo
- Publication number
- CN110825361B CN110825361B CN201911038003.3A CN201911038003A CN110825361B CN 110825361 B CN110825361 B CN 110825361B CN 201911038003 A CN201911038003 A CN 201911038003A CN 110825361 B CN110825361 B CN 110825361B
- Authority
- CN
- China
- Prior art keywords
- target object
- code
- code segment
- name
- modifying
- 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/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
-
- 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
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a code modification method, a code modification device, a code modification equipment and a readable storage medium. The method disclosed by the application comprises the following steps: acquiring a code segment to be modified; adding the code segment to the target object, and modifying the code segment in the target object; the target object has the same name and storage path as the original object in the flash; adding a dependent object corresponding to the code segment to the target object; and adding the target object to a plug-in library in the Flume, modifying configuration information corresponding to the code fragments, and enabling the target object to run in the Flume. According to the method and the device for modifying the code fragments, the code fragments to be modified and the related dependent objects are added to the target objects, so that the target objects can replace the original objects in the Flume to operate in the Flume without redeploying an operation environment, the workload of technicians is reduced, and the modification efficiency of the codes is improved correspondingly. The code modification device, the code modification device and the readable storage medium disclosed by the application also have the technical effects.
Description
Technical Field
The present disclosure relates to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a readable storage medium for modifying codes.
Background
At present, when the source code in the running environment needs to be modified, the whole source code related to the running environment needs to be downloaded to the local, then the part needing to be modified is modified, after the modification is completed, all the source codes are packaged, the running environment is redeployed, and the source code package is uploaded. The deployment operation steps of the running environment are complex, if the running environment is redeployed each time the source code is modified, the workload of technicians is inevitably increased, and the modification efficiency of the code is low.
Therefore, how to improve the code modification efficiency is a problem that needs to be solved by those skilled in the art.
Disclosure of Invention
In view of the foregoing, it is an object of the present application to provide a code modification method, apparatus, device, and readable storage medium, so as to improve the code modification efficiency. The specific scheme is as follows:
in a first aspect, the present application provides a code modification method, including:
acquiring a code segment to be modified;
adding the code segment to the target object, and modifying the code segment in the target object; the target object has the same name and storage path as the original object in the flash;
after the code segment is modified, adding the dependent object corresponding to the code segment to the target object;
adding the target object to a plug-in library in the Flume, and modifying configuration information corresponding to the code segment;
the jume is started to run the target object in the jume.
Preferably, running the target object in the jump comprises:
the target object is run in plug-in manner in the jume.
Preferably, adding the code segment to the target object and modifying the code segment in the target object includes:
the code fragment is added to the target object, the class name of the code fragment is modified to the target name in the target object, and the code fragment is modified.
Preferably, adding a dependent object corresponding to the code fragment to the target object includes:
modifying the name of the dependent object into an object name, wherein the object name corresponds to the target name;
a dependent object having an object name is added to the target object.
Preferably, the code segment is associated with KafkaSource, HDFSEventSink or hbaselink.
Preferably, adding the target object to a plug-in library in the jump comprises:
and compiling and packaging the target object and adding the target object into a plug-in library.
Preferably, the method further comprises:
if the code segment is associated with the HBaseLink, when the code segment is used for writing data into the hbase, the preset identification information is used for marking the data written into the hbase in unit time.
In a second aspect, the present application provides a code modification apparatus comprising:
the acquisition module is used for acquiring the code segment to be modified;
the first modification module is used for adding the code segment to the target object and modifying the code segment in the target object; the target object has the same name and storage path as the original object in the flash;
the second modification module is used for adding the dependent object corresponding to the code segment to the target object after the code segment is modified;
the third modification module is used for adding the target object to a plug-in library in the Flume and modifying configuration information corresponding to the code segment;
and the starting module is used for starting the Flume so as to run the target object in the Flume.
Preferably, the starting module is specifically configured to:
and running the target object in the manner of a plug-in the Flume.
Preferably, the code segment is associated with KafkaSource, HDFSEventSink or hbaselink.
In a third aspect, the present application provides a code modification apparatus comprising:
a memory for storing a computer program;
a processor for executing a computer program to implement the previously disclosed code modification method.
In a fourth aspect, the present application provides a readable storage medium storing a computer program, wherein the computer program, when executed by a processor, implements the previously disclosed code modification method.
As can be seen from the above solution, the present application provides a code modification method, including: acquiring a code segment to be modified; adding the code segment to the target object, and modifying the code segment in the target object; the target object has the same name and storage path as the original object in the flash; after the code segment is modified, adding the dependent object corresponding to the code segment to the target object; adding the target object to a plug-in library in the Flume, and modifying configuration information corresponding to the code segment; the jume is started to run the target object in the jume.
The method comprises the steps of adding a code segment to be modified and a dependent object related to the code segment to a target object, adding the target object to a plug-in library in the Flume after the code segment is modified in the target object, and modifying configuration information corresponding to the code segment; the original object in the jump can be replaced with the target object because the target object has the same name and storage path as the original object in the jump, without affecting the invocation and deployment of the jump. And then the method starts the Flume, and the target object can be operated in the Flume, so that code modification and deployment are realized, and the expansion of the Flume is also realized. The method and the device only need to modify and deploy the code segments needing modification, and after modification is completed, the Flume can directly call the target object containing the modified code, so that the deployment and operation of the code segments are completed. Therefore, the method and the device do not need to process the whole source code package and redeploy the running environment when modifying the source code, reduce the workload of technicians and correspondingly improve the modifying efficiency of the code.
Correspondingly, the code modification device and the readable storage medium have the technical effects.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings that are required to be used in the embodiments or the description of the prior art will be briefly described below, and it is obvious that the drawings in the following description are only embodiments of the present application, and that other drawings may be obtained according to the provided drawings without inventive effort to a person skilled in the art.
FIG. 1 is a flow chart of a code modification method disclosed in the present application;
FIG. 2 is a schematic diagram of a code modification device disclosed herein;
fig. 3 is a schematic diagram of a code modification apparatus disclosed in the present application.
Detailed Description
The following description of the embodiments of the present application will be made clearly and fully with reference to the accompanying drawings, in which it is evident that the embodiments described are only some, but not all, of the embodiments of the present application. All other embodiments, which can be made by one of ordinary skill in the art without undue burden from the present disclosure, are within the scope of the present disclosure.
In the prior art, after each time the source code is modified, the running environment is redeployed, the workload of technicians is inevitably increased, and the modification efficiency of the code is low. Therefore, the code modification scheme can reduce the workload of technicians and improve the code modification efficiency.
Referring to fig. 1, an embodiment of the present application discloses a code modification method, including:
s101, acquiring a code segment to be modified;
s102, adding the code segment to a target object, and modifying the code segment in the target object;
wherein the target object has the same name and storage path as the original object in the flash.
S103, adding the dependent object corresponding to the code segment to the target object after the code segment is modified;
in this embodiment, adding the code segment to the target object and modifying the code segment in the target object includes: the code fragment is added to the target object, the class name of the code fragment is modified to the target name in the target object, and the code fragment is modified.
It should be noted that, since the target object is to replace the original object in the flash, in order to ensure normal operation and integrity, both the dependent object related to the code of the modification part needs to be added to the target object, and the name of the dependent object and the class name of the code fragment are modified at the same time, so as to distinguish the modified code fragment from the code fragment before modification.
Wherein adding the dependent object corresponding to the code fragment to the target object comprises: modifying the name of the dependent object into an object name, wherein the object name corresponds to the target name; a dependent object having an object name is added to the target object.
Specifically, the purpose of modifying the class name and the dependent object name of the code fragment is to: the modified code segment is distinguished from the code segment before modification, but the modified code segment and the dependent object related to the modified code segment still need to be corresponding, so that the modified name of the code segment corresponds to the modified name of the dependent object, that is, the object name corresponds to the target name.
S104, adding the target object to a plug-in library in the Flume, and modifying configuration information corresponding to the code segment;
wherein the configuration information is also differentiated when the modified code segments are different.
S105, starting the jump so as to run the target object in the jump.
In one embodiment, running the target object in a jump includes: the target object is run in plug-in manner in the jume. The modified code is combined with other unmodified codes in the form of plug-in, so that the integrity of a source code package is guaranteed, and code modification is realized rapidly.
In one embodiment, adding the target object to a plug-in library in a Flume includes: and compiling and packaging the target object and adding the target object into a plug-in library. In this embodiment, the target object may be a new package in a new java item, where the java item containing the target object needs to be packaged before the target object is added to the plug-in library in the flash.
According to the scheme provided by the present embodiment, the code segments associated with KafkaSource, HDFSEventSink or hbaselink may be modified accordingly. For example: if the code segment is associated with the HBaseLink, when the code segment is used for writing data into the hbase, the preset identification information is used for marking the data written into the hbase in unit time. I.e. modifying the code segment to be able to mark the code written in hbase data per unit time, which may be 1 second. The preset identification information may be a short UUID.
The rule for generating the short UUID may be: an array of 62 non-repeated characters a to Z, 0 to 9, and a to Z is used as a reference. The Java tool is used for obtaining 36-bit hexadecimal character strings, the "-" segmenter is removed, 32-bit hexadecimal character strings are obtained, 4 bits are taken as a group, 8 groups can be obtained in a splitting mode, 62 modulo is conducted on each group, characters in the reference array are obtained, and therefore short-eight-bit UUIDs are generated. Long-term test verifies that repeated generation of one million character strings continuously does not occur, and the current requirement is met.
It should be noted that S101 to S105 disclosed in this embodiment may be performed under the operation of the user. Such as: the user copies the code to be modified from the original object and copies the code to the newly built project, so that the project can obtain the code segment to be modified. The system comprises a system for collecting, aggregating and transmitting distributed mass logs, wherein the system is used for customizing various data transmitters in a log system and is used for collecting data; meanwhile, the jume provides the ability to simply process data and write to various data recipients (customizable).
As can be seen, in the embodiment of the present application, the code segment to be modified and the dependent object related to the code segment are added to the target object, after the code segment is modified in the target object, the target object is added to the plug-in library in the flash, and the configuration information corresponding to the code segment is modified; the original object in the jump can be replaced with the target object because the target object has the same name and storage path as the original object in the jump, without affecting the invocation and deployment of the jump. And then the method starts the Flume, and the target object can be operated in the Flume, so that code modification and deployment are realized, and the expansion of the Flume is also realized. The method and the device only need to modify and deploy the code segments needing modification, and after modification is completed, the Flume can directly call the target object containing the modified code, so that the deployment and operation of the code segments are completed. Therefore, the method and the device do not need to process the whole source code package and redeploy the running environment when modifying the source code, reduce the workload of technicians and correspondingly improve the modifying efficiency of the code.
If the code segments associated with KafkaSource, HDFSEventSink or hbaselink are modified according to the scheme provided in this embodiment, then there are: and creating a java item, wherein a package (i.e. a target object) consistent with a jar package (i.e. an original object) where the component in the flash is located is created.
When the code segment to be modified is associated with KafkaSource, the name of the package may be: org.apache.fluid.source.kafka, org.apache.fluid.source.kafka may also be considered the storage path of the current package.
When the code fragment to be modified is associated with an HDFSEventSink, the name of the package may be: the org.apache.fluid.sink.hdfs, org.apache.fluid.sink.hdfs may also be considered as a storage path for the current package.
When the code fragment to be modified is associated with hbaselink, the name of the package may be: the org.apache.fluid.sink.hbase, org.apache.fluid.sink.hbase can also be considered as the storage path for the current package.
Copying the class code of the component to be modified from the jar packet, placing the class code of the component to be modified in the package, and modifying the class name of the class code to distinguish the original class code from the modified class code. If the original class code is named as HBaseLink, the modified class code is IotHBaseLink.
The dependent objects related to the components of the original class code are added to the package and renamed. Such as: the original name of the dependent object is HBaseEventSerializer, and the modified name of the dependent object is IotHBaseEventSerializer. Corresponding modifications to the dependent objects may also be required at this point.
The technician can modify the original class code in the package to complete personalized customization. And then marking the modified class code into a jar packet, placing the jar packet under a directory appointed by a plug-in library in the flash, modifying a configuration file at the same time, and running the modified code in a plug-in mode. The modified code implements the modules as: tier.sink.hbase_sink.type=org.apache.fluid.sink.hbase.
The following describes a code modification apparatus provided in an embodiment of the present application, and a code modification apparatus described below and a code modification method described above may be referred to each other.
Referring to fig. 2, an embodiment of the present application discloses a code modification apparatus, including:
an obtaining module 201, configured to obtain a code segment to be modified;
a first modification module 202, configured to add a code segment to a target object and modify the code segment in the target object; the target object has the same name and storage path as the original object in the flash;
the second modification module 203 is configured to add the dependent object corresponding to the code segment to the target object after the code segment is modified;
a third modification module 204, configured to add the target object to a plug-in library in the jump, and modify configuration information corresponding to the code segment;
a starting module 205, configured to start the jump so as to run the target object in the jump.
In one embodiment, the third modification module is specifically configured to:
the target object is run in plug-in manner in the jume.
In one embodiment, the first modification module is specifically configured to:
the code fragment is added to the target object, the class name of the code fragment is modified to the target name in the target object, and the code fragment is modified.
In one embodiment, the second modification module includes:
the modification unit is used for modifying the name of the dependent object into an object name, and the object name corresponds to the target name;
and an adding unit for adding the dependent object having the object name to the target object.
In one embodiment, the code segment is associated with KafkaSource, HDFSEventSink or hbaselink.
In one embodiment, the third modification module is specifically configured to:
and compiling and packaging the target object, and adding the target object into a flight plugin library.
The more specific working process of each module and unit in this embodiment may refer to the corresponding content disclosed in the foregoing embodiment, and will not be described herein.
It can be seen that this embodiment provides a code modification device, which adds a code segment to be modified and a dependent object related to the code segment to a target object, adds the target object to a plug-in library in a flash after the code segment is modified in the target object, and modifies configuration information corresponding to the code segment; the original object in the jump can be replaced with the target object because the target object has the same name and storage path as the original object in the jump, without affecting the invocation and deployment of the jump. And then the method starts the Flume, and the target object can be operated in the Flume, so that code modification and deployment are realized, and the expansion of the Flume is also realized. The method and the device only need to modify and deploy the code segments needing modification, and after modification is completed, the Flume can directly call the target object containing the modified code, so that the deployment and operation of the code segments are completed. Therefore, the method and the device do not need to process the whole source code package and redeploy the running environment when modifying the source code, reduce the workload of technicians and correspondingly improve the modifying efficiency of the code.
The following describes a code modification device provided in the embodiments of the present application, and the code modification device described below and the code modification method and apparatus described above may be referred to each other.
Referring to fig. 3, an embodiment of the present application discloses a code modification apparatus, including:
a memory 301 for storing a computer program;
a processor 302 for executing the computer program to implement the steps of:
acquiring a code segment to be modified; adding the code segment to the target object, and modifying the code segment in the target object; the target object has the same name and storage path as the original object in the flash; after the code segment is modified, adding the dependent object corresponding to the code segment to the target object; adding the target object to a plug-in library in the Flume, and modifying configuration information corresponding to the code segment; the jume is started to run the target object in the jume.
In this embodiment, when the processor executes the computer subroutine stored in the memory, the following steps may be specifically implemented: the target object is run in plug-in manner in the jume.
In this embodiment, when the processor executes the computer subroutine stored in the memory, the following steps may be specifically implemented: the code fragment is added to the target object, the class name of the code fragment is modified to the target name in the target object, and the code fragment is modified.
In this embodiment, when the processor executes the computer subroutine stored in the memory, the following steps may be specifically implemented: modifying the name of the dependent object into an object name, wherein the object name corresponds to the target name; a dependent object having an object name is added to the target object.
In this embodiment, when the processor executes the computer subroutine stored in the memory, the following steps may be specifically implemented: if the code segment is associated with the HBaseLink, when the code segment is used for writing data into the hbase, the preset identification information is used for marking the data written into the hbase in unit time.
The following describes a readable storage medium provided in the embodiments of the present application, and the readable storage medium described below and the code modification method, apparatus and device described above may be referred to with each other.
A readable storage medium storing a computer program, wherein the computer program when executed by a processor implements the code modification method disclosed in the foregoing embodiments. For specific steps of the method, reference may be made to the corresponding contents disclosed in the foregoing embodiments, and no further description is given here.
Reference to "first," "second," "third," "fourth," etc. (if present) herein is used to distinguish similar objects from each other and does not necessarily describe a particular order or sequence. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments described herein may be implemented in other sequences than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed or inherent to such process, method, or apparatus.
It should be noted that the description herein of "first," "second," etc. is for descriptive purposes only and is not to be construed as indicating or implying a relative importance or implying an indication of the number of technical features being indicated. Thus, a feature defining "a first" or "a second" may explicitly or implicitly include at least one such feature. In addition, the technical solutions of the embodiments may be combined with each other, but it is necessary to base that the technical solutions can be realized by those skilled in the art, and when the technical solutions are contradictory or cannot be realized, the combination of the technical solutions should be regarded as not exist and not within the protection scope of the present application.
In this specification, each embodiment is described in a progressive manner, and each embodiment is mainly described in a different point from other embodiments, so that the same or similar parts between the embodiments are referred to each other.
The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. The software modules may be disposed 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 readable storage medium known in the art.
The principles and embodiments of the present application are described herein with specific examples, the above examples being provided only to assist in understanding the methods of the present application and their core ideas; meanwhile, as those skilled in the art will have modifications in the specific embodiments and application scope in accordance with the ideas of the present application, the present description should not be construed as limiting the present application in view of the above.
Claims (6)
1. A code modification method, comprising:
acquiring a code segment to be modified;
adding the code segment to a target object, and modifying the code segment in the target object; the target object and the original object in the flash have the same name and storage path;
after the code segment is modified, adding a dependent object corresponding to the code segment to the target object;
adding the target object to a plug-in library in the Flume, and modifying configuration information corresponding to the code segment;
starting the jump so as to run the target object in the jump;
wherein the running the target object in the jump comprises:
running the target object in a plug-in mode in the Flume;
the adding the code segment to a target object and modifying the code segment in the target object includes:
adding the code segment to the target object, modifying a class name of the code segment to a target name in the target object, and modifying the code segment;
the adding a dependent object corresponding to the code segment to the target object includes:
modifying the name of the dependent object into an object name, wherein the object name corresponds to the target name; a dependent object having the object name is added to the target object.
2. The code modification method of claim 1, wherein the adding the target object to a plug-in library in the jump comprises:
and compiling and packaging the target object and then adding the target object into the plug-in library.
3. A code modification apparatus, comprising:
the acquisition module is used for acquiring the code segment to be modified;
the first modification module is used for adding the code segment to a target object and modifying the code segment in the target object; the target object and the original object in the flash have the same name and storage path;
the second modification module is used for adding the dependent object corresponding to the code segment to the target object after the code segment is modified;
the third modification module is used for adding the target object to a plug-in library in the Flume and modifying configuration information corresponding to the code segment;
a starting module, configured to start the jump so as to run the target object in the jump;
the starting module is specifically configured to:
running the target object in a plug-in mode in the Flume;
the first modification module is specifically configured to:
adding the code segment to the target object, modifying a class name of the code segment to a target name in the target object, and modifying the code segment;
the second modification module is specifically configured to:
modifying the name of the dependent object into an object name, wherein the object name corresponds to the target name; a dependent object having the object name is added to the target object.
4. The code modification apparatus of claim 3, wherein the third modification module is specifically configured to:
and compiling and packaging the target object, and adding the target object into a flight plugin library.
5. A code modification apparatus, comprising:
a memory for storing a computer program;
a processor for executing the computer program to implement the code modification method of any one of claims 1 or 2.
6. A readable storage medium for storing a computer program, wherein the computer program when executed by a processor implements the code modification method of any of claims 1 or 2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911038003.3A CN110825361B (en) | 2019-10-29 | 2019-10-29 | Code modification method, device, equipment and readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911038003.3A CN110825361B (en) | 2019-10-29 | 2019-10-29 | Code modification method, device, equipment and readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110825361A CN110825361A (en) | 2020-02-21 |
| CN110825361B true CN110825361B (en) | 2023-06-16 |
Family
ID=69551082
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911038003.3A Active CN110825361B (en) | 2019-10-29 | 2019-10-29 | Code modification method, device, equipment and readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110825361B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111722866B (en) * | 2020-06-19 | 2022-06-17 | 浪潮电子信息产业股份有限公司 | OpenStack code repairing method, device, equipment and storage medium |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108920250A (en) * | 2018-06-05 | 2018-11-30 | 麒麟合盛网络技术股份有限公司 | The method and device of Application Container |
Family Cites Families (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7707547B2 (en) * | 2005-03-11 | 2010-04-27 | Aptana, Inc. | System and method for creating target byte code |
| US20120026079A1 (en) * | 2010-07-27 | 2012-02-02 | Apple Inc. | Using a display abstraction to control a display |
| CN102053836B (en) * | 2010-12-31 | 2013-04-10 | 广东欧珀电子工业有限公司 | Implementation method of version management tool for Android application development |
| CN106201862B (en) * | 2015-05-25 | 2019-03-15 | 阿里巴巴集团控股有限公司 | Web services method for testing pressure and device |
| CN105915377A (en) * | 2016-04-14 | 2016-08-31 | 北京思特奇信息技术股份有限公司 | Flume and Spark streaming integration method and system |
| CN106886445A (en) * | 2016-06-23 | 2017-06-23 | 阿里巴巴集团控股有限公司 | Java packets generation method and equipment and information extracting method and equipment |
| CN107193615B (en) * | 2017-06-29 | 2020-12-04 | 北京全域医疗技术集团有限公司 | Project code information updating and deploying method and device |
| WO2019139911A1 (en) * | 2018-01-09 | 2019-07-18 | Justdo, Inc. | Scripting language computer program modification methodology, system and software |
| CN109491662A (en) * | 2018-10-31 | 2019-03-19 | 珠海市筑巢科技有限公司 | Code packaging method, computer installation and computer readable storage medium, code packaging system |
| CN110109680A (en) * | 2019-05-14 | 2019-08-09 | 重庆商勤科技有限公司 | Using dispositions method, device and apply dissemination method, server, storage medium |
| CN110210188A (en) * | 2019-06-04 | 2019-09-06 | 武汉神算云信息科技有限责任公司 | Code encryption method, apparatus, equipment and storage medium under Spring frame |
| CN110377290B (en) * | 2019-07-22 | 2023-04-25 | 创新先进技术有限公司 | Method, device and equipment for compiling target engineering |
-
2019
- 2019-10-29 CN CN201911038003.3A patent/CN110825361B/en active Active
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108920250A (en) * | 2018-06-05 | 2018-11-30 | 麒麟合盛网络技术股份有限公司 | The method and device of Application Container |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110825361A (en) | 2020-02-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108229112A (en) | A kind of operation method and device for protecting application program, application program | |
| CN111666096B (en) | Hot updating method and device for target application, storage medium and electronic equipment | |
| CN107678750A (en) | A kind of SDK packaging methods, computing device and SDK packaging systems | |
| CN104462959A (en) | Reinforcement protection method, sever and system for android app | |
| CN103177210A (en) | Method of implanting dynamic stain analysis module in Android | |
| CN109800005B (en) | Client hot update method and device | |
| CN111399840B (en) | Module development method and device | |
| CN108415821A (en) | The generation method and device of test report | |
| CN104754062A (en) | Internet based information popularization method, server and user terminal | |
| CN104346146A (en) | Method and device for cross-platform conversion of application codes | |
| CN107360265A (en) | A kind of equipment exclusive identification code acquisition methods, device and mobile terminal | |
| CN108108169B (en) | Multi-branch construction method and system based on Jenkins | |
| CN108694049B (en) | Method and equipment for updating software | |
| CN110825361B (en) | Code modification method, device, equipment and readable storage medium | |
| CN105404794A (en) | Protection method and device of Java application software | |
| CN110716786B (en) | Page display method, system and storage medium | |
| CN110795353B (en) | Quick application debugging method, device, equipment and storage medium | |
| CN110968296A (en) | Data acquisition method, device, equipment and readable storage medium | |
| CN104036193A (en) | Local cross-domain vulnerability detection method and device for application program | |
| CN103176903B (en) | The test method and equipment of MapReduce distributed system program | |
| CN116775087A (en) | Thermal repair method, device, electronic equipment and storage medium | |
| CN110750310A (en) | Binary and source code switching method based on IOS system componentization development | |
| CN107463423B (en) | Verification method, storage medium, electronic device and system depending on package tool | |
| CN113094664B (en) | System for preventing android application program from being decompiled | |
| CN106897049A (en) | The packaging method and device of a kind of installation kit |
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 |