CN114371850A - Management method for project construction compiling and code development - Google Patents
Management method for project construction compiling and code development Download PDFInfo
- Publication number
- CN114371850A CN114371850A CN202111625112.2A CN202111625112A CN114371850A CN 114371850 A CN114371850 A CN 114371850A CN 202111625112 A CN202111625112 A CN 202111625112A CN 114371850 A CN114371850 A CN 114371850A
- Authority
- CN
- China
- Prior art keywords
- configuration
- file
- project
- master
- configuration file
- 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.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/447—Target code generation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a management method for project construction compiling and code development, which comprises the following steps: creating a custom built. Directly referencing the configuration attribute of the main configuration file in the gradle file of the project or module, and providing a corresponding interface for the configuration attribute needing to be called by the service layer logic code according to the debugging environment and the releasing environment; when a project is reconstructed, the configuration attribute of the main configuration file is referred and obtained through a buildConfig file generated by the logic code of the service layer; other gradle files that reference the configuration attributes of the master configuration file are dynamically changed as the configuration attributes of the master configuration file are modified. The invention reduces the possible repeated codes and avoids the errors possibly caused by modifying the codes at multiple positions by calling the configuration information of the main configuration file in the business logic development codes.
Description
Technical Field
The invention belongs to the technical field of computer software development, and particularly relates to a management method for project construction compiling and code development.
Background
With the continuous development of the current software industry, the development projects at the enterprise level become more huge, and the construction and management technology of the projects is also popular. Version update iteration of project management tools such as management of a dependency library and project construction management is rapid, and even the version update of an IDE is eliminated. Currently, a gradle tool is ascending the top 20 of the ranking of world open source items, and the application development of the Android system with the highest market share is constructed by default by using the gradle. Developers are also continually in need of more flexible and convenient construction and project management methods.
The traditional Android project management mode is that a gradle file such as buildconfig is used for configuring the version, dependence, confusion, packaging and the like of a project, and a config class is required to be written separately when a code is developed and the environment is required to be configured. However, when the configuration attribute of the conventional Android project is modified or the development environment is configured and modified, the attribute values in each project or module need to be modified individually by packaging once, and for some repeatedly configured parts, the mode undoubtedly increases the workload of codes and is not beneficial to the management of the whole project.
Disclosure of Invention
The invention aims to provide a management method for project construction compiling and code development, which aims to solve the problem that a plurality of files are required to be modified by packaging at one time in the project construction process.
In a first aspect of the present invention, a management method for project building compilation and code development is provided, including:
creating a custom built.
Directly referencing the configuration attribute of the main configuration file in a built file of a project or module, and providing a corresponding interface for the configuration attribute to be called of a logic code of a service layer according to two environments of debugging and releasing;
when a project is reconstructed, the configuration attribute of the main configuration file is referred and obtained by a buildConfig file generated by the logic code of the service layer;
and other build files which refer to the configuration attributes of the main configuration file are dynamically changed according to the modification of the configuration attributes of the main configuration file.
Further, the main configuration file is encapsulated with various configuration attributes in a self-defining mode, wherein the configuration attributes comprise project version information, development environment URL configuration information, a third-party dependency base and other self-defining configuration contents.
And further, the build file of the module refers to and acquires the configuration attribute of the main configuration file through rootProject, wherein after the configuration attribute is acquired and referred to, the main module or other non-main modules are selected according to different service requirements.
Furthermore, when the configuration information of the debugging and releasing version needs to be modified, the master module is selected, and the configuration information of the version needing to be debugged and released in the master module is modified in a user-defined mode by calling the configuration attribute of the master configuration file.
Further, when specific service function logic needs to be implemented, selecting another non-master module, transmitting the configuration attribute of the master configuration file to the buildConfig of the other non-master module, transmitting the configuration attribute to the service layer by the buildConfig, and referencing the configuration attribute by a logic code of the service layer.
Furthermore, the master module provides service templates and logic code specifications for other modules, and other non-master modules implement specific functions according to the templates and logic code specifications provided by the master module.
Further, when the master module is selected, if the master module needs to perform logic code specification adjustment, the configuration attribute of the master configuration file is referred and acquired through the buildConfig file.
Further, the buildConfig file injects the configuration attributes of the main configuration file into a buildConfig.
In a second aspect of the present invention, there is provided a computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the method of any one of the above first aspects when executing the computer program.
In a third aspect of the invention, there is provided a computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements the method of any one of the first aspects of the claims.
Compared with the prior art, the project construction compiling and code development management method provided by the invention has the following technical effects:
1. according to the invention, the configuration file generated by the construction tool during the project compiling is modified, so that developers can conveniently manage and customize configuration information such as packaging and development environment in a unified manner, and meanwhile, the development efficiency is improved by simplifying the code configuration flow.
2. The invention directly calls the configuration information in the service logic development code, reduces the possible repeated codes and also avoids the errors possibly caused by modifying the codes at a plurality of places.
3. The invention can directly modify the code logic according to different compiling requirements or development environments when the project is constructed by the configuration file, thereby realizing the code compiling of the guide service logic at the construction layer.
Drawings
FIG. 1 is a flow chart of a management method for project building compilation and code development in an embodiment of the invention;
FIG. 2 is a flow chart of configuration management of a management method of project building compilation and code development in an embodiment of the present invention;
fig. 3 is a call relation diagram of a specific code implementation effect in the embodiment of the present invention.
Fig. 4 is a schematic structural diagram of a computer device according to a second embodiment of the present invention.
Detailed Description
The following examples are only for illustrating the technical solutions of the present invention more clearly, and the protection scope of the present invention is not limited thereby. As certain terms are used throughout the description and claims to refer to particular components. As one skilled in the art will appreciate, manufacturers may refer to a component by different names. The present specification and claims do not intend to distinguish between components that differ in name but not function. The following description is of the preferred embodiment for carrying out the invention, and is made for the purpose of illustrating the general principles of the invention and not for the purpose of limiting the scope of the invention. The scope of the present invention is defined by the appended claims.
The invention is described in further detail below with reference to the figures and specific embodiments.
In a real Project, a plurality of modules in a Project often occur, if each Module has the same dependency, such as the v4 package, then it is troublesome to modify the build files in the modules each time the v4 package is upgraded, and it is very likely that a Module is forgotten. Therefore, it is necessary to manage modules uniformly in a Project. The original purpose of the unified access version management of the gradle is to solve the problem that each referenced module can automatically take effect only by modifying one place of one item, so that the advantage of taking effect by modifying each place in one place is achieved, and meanwhile, the consistency of the version of the reference library of the gradle can be kept.
The invention relates to all projects taking gradle as a construction tool, such as an Android native project developed by using Android Studio, wherein the gradle is a very advanced and powerful project construction tool, a specific language (DSL) based on Groovy field is used for declaring project setting, various complicated configurations based on XML (such as Ant and Maven) are abandoned, and the gradle is completely compatible with Maven and ivy. Through the gradle, differences, dependence, compiling, packaging and deployment … in the development group management project can be helped to define construction logic meeting the needs of the user, and the construction logic is written into the build.
Example one
Fig. 1 is a flowchart illustrating a management method for project building compilation and code development according to an embodiment of the present invention, and referring to fig. 1, the method includes:
and step S1, creating a custom build.
In a project constructed by a gradle, in order to realize the unified management of configuration information, a user-defined configuration file is created as a main configuration file of project development, the main configuration file is encapsulated with attribute information of various configurations in a user-defined manner, and configuration attributes contained in the main configuration file are applicable to the whole development system, and the method mainly comprises the following steps: development project version information, Android version information, development environment URL configuration information, third party dependency base information and other configuration contents which can be customized. The encapsulation of the part can be realized by writing a gradle script (supporting groovy and kotlin codes), and can be written in the form of creating a function or attribute by "array ═ key: value" or def.
Step S2, directly referencing the configuration attribute of the main configuration file in the build file of the project or module, and providing a corresponding interface for the configuration attribute to be called by the logic code of the service layer according to the debugging environment and the releasing environment;
each project provides a build.gradle file of the module, and if modular development is used, each module also provides a build.gradle file of the module, wherein the management ranges of the configuration information of the build.gradle and the module are different. The configuration attribute of the main configuration file is introduced into the build/gram file of the project or module which needs to refer to the configuration attribute in advance, and the interface and the configuration attribute which need to be called under the two environments of debugging and publishing are set in advance when the project is compiled, so that the configuration information of the main configuration file can be directly referred to in the build/gram file of the project or module, and an interface is provided for the configuration attribute which needs to be called by the service layer code according to the two environments of testing and publishing.
Step S3, when reconstructing the project, the buildConfig file generated by the logic code of the business layer refers to and acquires the configuration attribute of the master configuration file. The BuildConfig is a configuration file automatically generated by the android in the compiling process, different variables can be generated in different compiling modes, and the variables are used for facilitating development under different compiling environments. The gram is built once when a project is created, and then the project needs to be built again each time the build. When the configuration parameters are customized in the build.grade, the configuration parameters are configured in a buildConfigField mode, and Gradle provides a customized BuildConfig field, so that different development environments can be configured in a program through the field.
Step S4, other build files referencing the configuration attributes of the main configuration file are dynamically modified according to the modification of the configuration attributes of the main configuration file.
When the configuration attribute needs to be modified, only one position of the configuration attribute of the main configuration file needs to be modified, and the rest parts which refer to the configuration attribute can be automatically modified. Configuration files generated by the construction tool during project compiling are modified, so that developers can conveniently manage and customize configuration information such as packaging and development environment in a unified mode, and meanwhile, the development efficiency is improved by simplifying a code configuration flow.
In the item of the componentized development, the build.gradle file of each module acquires the content in the main configuration file through rootProject, and the configuration information of the build.gradle file of each module completely refers to and refers to the configuration attribute of the customized main configuration file.
Referring to fig. 2, after the configuration attributes are obtained and referenced, a master module or other non-master modules are selected according to different service requirements. The master module is a basic module, basically does not realize specific functions, provides service templates and logic code specifications for other non-master modules, and realizes specific functions according to the templates and the logic code specifications provided by the master module.
When the configuration information (such as a package name) of the debugging and publishing version needs to be modified, the master module is selected, and the configuration information of the version needing debugging and publishing in the master module is modified in a user-defined mode by calling the configuration attribute of the master configuration file. Calling the configuration attribute of the main configuration file in the build type code block in the main module of the project to customize the package names of the debugging and releasing versions, so that the package names meet the specific requirements of the development environment. Aiming at the problem that only information such as test or release, construction time, developers and the like can be added in the packet name dynamically in the existing interface, the method and the system allow the developers to add more fields which are dynamically modified according to the service requirements, and are more flexible to realize. build types are located in android { } code blocks of the module level build. Creating an item, default generating two versions of debug and release in a buildtype code block of a module, and generating a corresponding APK for each build type (build type), where for example, a general debug type APK is default buildconfig, debug is true, and a release type buildconfig, debug is false.
When specific service function logic needs to be realized, selecting other non-master modules, transmitting the configuration attribute of the master configuration file to the buildConfig of the other non-master modules, transmitting the configuration attribute to the service layer by the buildConfig, and referring the configuration attribute by the logic code of the service layer. According to the method and the device, the configuration information is directly called in the business logic development code, so that possible repeated codes are reduced, and errors possibly caused by modifying the codes at multiple positions are avoided.
When the master module is selected, if the master module needs to perform logic code specification adjustment, the configuration attributes of the master configuration file are referred and acquired through the buildConfig file in the same way. Therefore, compared with a non-module, the main module has more custom configuration processes of debugging and releasing versions, and has the same reference flow when service code logic needs to be configured.
And the buildConfig file injects the configuration attribute of the main configuration file into a buildConfig. The configuration attributes of the main configuration files of the items are embedded into different codes needing to call the configuration information in respective modes, and then dynamic logic management can be carried out on the configuration attributes in respective codes through simple processing logic, and meanwhile, the fact that the global construction configuration and related code logic can be changed by only modifying one code is achieved.
The information in the configuration file can be referred to in development to complete the functions of using different code logics according to different development environments, dynamically generating the code logics according to the configuration, such as the name of an installation package, and the like, and repeated codes in project configuration can be reduced.
One specific implementation and effect of the embodiment of the present invention will be described below by taking the method of the embodiment of the present invention as an example of the project packaging and development environment configuration part.
Referring to fig. 3, similar configurations are required for the project at two positions of the packaging and configuration development environment, the method in the embodiment of the present invention customizes the configuration closure in the main configuration file and creates a required attribute code, and the value of the code dynamically controls the finally dynamically generated package name and the configuration information used for configuring the development environment. Other modules, such as two modules of app and appbase in the project, one is a project main module and relates to configuration in the aspect of packaging construction; one is a library module, which relates to java code of the basic environment configuration in the project.
The implementation of modifying the packaged custom packet name is to introduce a code value in a config file into the original packaging configuration and generate a final packet name format through a judgment logic, so that the code acquisition and the judgment logic can be further packaged. The method includes the steps that a java code module configuring a development environment realizes construction files created indirectly through gradles during construction, code attributes are firstly introduced into build.gradl files in the module in the same mode as the above, then different processing is carried out on codes in a buildtype code block aiming at two construction environments of debugging and releasing, corresponding name values are obtained, and the types, names and values of the attributes which can be called by a code end are set through buildconfigField. At this time, after the project is resynchronized and constructed, the attribute is created in the newly generated buildconfig file in the built.gradle folder of the corresponding module in the form of public static final, and the attribute can be directly referred to in other service codes.
After the project is built and the code value is set in the main buildconfig file in fig. 3, the codes in the other three parts in fig. 3 dynamically change the code logic at the same time according to the change of the configuration, so that the code logic meets the current development and packaging requirements. When the configuration needs to be modified later, all modifications can be completed only by modifying the value of one code, so that the problems that the modification operation on a plurality of files is complicated and errors are easy to occur in the prior art are solved.
As long as the business logic code and the code in the gradle configuration file have the same or similar logic, the method in the patent can be used for reconstruction, and a unified management scheme is constructed to reduce the code amount and the later modification and maintenance cost.
The method involved in the patent can theoretically give more processing logic to the processing of the configuration file and further transfer the processing logic to other configuration files or project codes, but because the method involves increasing the codes of the configuration file, the method does not suggest that a large amount of more complex processing logic is migrated from the project codes to the configuration file for processing, which may cause a certain reduction in the readability of the codes, generate unnecessary multi-layer calling, and increase the total time consumption for synchronizing, compiling, building and packaging projects to a certain extent. When the method is used, the codes are conveniently modified by a developer in the later period without influencing the readability of the codes, and the codes are reconstructed according to the requirements of business scenes.
Example two
Fig. 4 is a schematic structural diagram of a computer apparatus according to a second embodiment of the present invention, as shown in fig. 4, the computer apparatus includes a processor 40, a memory 41, an input device 42, and an output device 43; the number of processors 40 in the computer device may be one or more, and one processor 40 is taken as an example in fig. 4; the processor 40, the memory 41, the input device 42 and the output device 43 in the computer apparatus may be connected by a bus or other means, and the connection by the bus is exemplified in fig. 4.
The memory 41 is used as a computer-readable storage medium, and may be used to store a software program, a computer-executable program, and a module, such as a program instruction/module corresponding to the application rapid building method based on the MVVM framework in the embodiment of the present invention. The processor 40 executes various functional applications and data processing of the computer device by running software programs, instructions and modules stored in the memory 41, namely, implements the management method of project building compilation and code development described above: creating a custom built. Directly referencing the configuration attribute of the main configuration file in a built file of a project or module, and providing a corresponding interface for the configuration attribute to be called of a logic code of a service layer according to two environments of debugging and releasing; when a project is reconstructed, the configuration attribute of the main configuration file is referred and obtained by a buildConfig file generated by the logic code of the service layer; and other build files which refer to the configuration attributes of the main configuration file are dynamically changed according to the modification of the configuration attributes of the main configuration file.
The memory 41 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function; the storage data area may store data created according to the use of the terminal, and the like. Further, the memory 41 may include high speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid state storage device. In some examples, memory 41 may further include memory located remotely from processor 40, which may be connected to a computer device over a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
The input device 42 is operable to receive input numeric or character information and to generate key signal inputs relating to user settings and function controls of the computer apparatus. The output device 43 may include a display device such as a display screen.
EXAMPLE III
The third embodiment of the present invention further provides a computer storage medium storing a computer program, where the computer program is used to execute the management method for project building, compiling and code development according to the first embodiment of the present invention when executed by a computer processor: creating a custom built. Directly referencing the configuration attribute of the main configuration file in a built file of a project or module, and providing a corresponding interface for the configuration attribute to be called of a logic code of a service layer according to two environments of debugging and releasing; when a project is reconstructed, the configuration attribute of the main configuration file is referred and obtained by a buildConfig file generated by the logic code of the service layer; and other build files which refer to the configuration attributes of the main configuration file are dynamically changed according to the modification of the configuration attributes of the main configuration file.
Computer storage media for embodiments of the invention may employ any combination of one or more computer-readable media. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a Read-only memory (ROM), an Erasable Programmable Read-only memory (EPROM) or flash memory), an optical fiber, a portable compact disc Read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, Radio Frequency (RF), etc., or any suitable combination of the foregoing. Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).
In the description herein, reference to the description of the term "one embodiment," "some embodiments," "an example," "a specific example," or "some examples," etc., means that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the application. In this specification, the schematic representations of the terms used above do not necessarily refer to the same embodiment or example. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples.
Although embodiments of the present application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting the present application, and that variations, modifications, substitutions and alterations may be made to the above embodiments by those of ordinary skill in the art within the scope of the present application.
Claims (10)
1. A management method for project building compilation and code development is characterized by comprising the following steps:
creating a custom built.
Directly referencing the configuration attribute of the main configuration file in a built file of a project or module, and providing a corresponding interface for the configuration attribute to be called of a logic code of a service layer according to two environments of debugging and releasing;
when a project is reconstructed, the configuration attribute of the main configuration file is referred and obtained by a buildConfig file generated by the logic code of the service layer;
and dynamically changing other build files which refer to the configuration attributes of the main configuration file according to the modification of the configuration attributes of the main configuration file.
2. The method of claim 1, wherein the master configuration file is custom encapsulated with a plurality of configuration attributes including project version information, development environment URL configuration information, third party dependency libraries, and other custom configuration content.
3. The management method according to claim 2, wherein the build.granule file of the module refers to and acquires the configuration attributes of the master configuration file by rootProject, wherein after the configuration attributes are acquired and referred to, the master module or other non-master module is selected according to different service requirements.
4. The management method as claimed in claim 3, wherein when the configuration information of the debugging and publishing version needs to be modified, the master module is selected, and the configuration information of the version needing to be debugged and published in the master module is customized and modified by calling the configuration attribute of the master configuration file.
5. The management method according to claim 3, wherein when a specific service function logic needs to be implemented, another non-master module is selected, the configuration attribute of the master configuration file is passed to the buildConfig of the other non-master module, and is passed to the service layer by the buildConfig, and the configuration attribute is referred to by a logic code of the service layer.
6. The management method of claim 4, wherein the master module provides service templates and logic code specifications for other modules, and other non-master modules implement specific functions according to the templates and logic code specifications provided by the master module.
7. The management method according to claim 6, wherein when the master module is selected, if the master module needs to perform logic code specification adjustment, the configuration attributes of the master configuration file are referred and acquired through the buildConfig file.
8. The management method according to claim 5 or 7, wherein the buildConfig file injects the configuration attributes of the main configuration file into a buildConfig.
9. Computer program for performing one of the methods according to any one of claims 1 to 8 when the computer program runs on a computer, a processor or a programmable hardware component.
10. A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the steps of the method of any of claims 1 to 8 are implemented when the computer program is executed by the processor.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111625112.2A CN114371850A (en) | 2021-12-28 | 2021-12-28 | Management method for project construction compiling and code development |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111625112.2A CN114371850A (en) | 2021-12-28 | 2021-12-28 | Management method for project construction compiling and code development |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114371850A true CN114371850A (en) | 2022-04-19 |
Family
ID=81142287
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111625112.2A Pending CN114371850A (en) | 2021-12-28 | 2021-12-28 | Management method for project construction compiling and code development |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114371850A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115086206A (en) * | 2022-06-14 | 2022-09-20 | 工银科技有限公司 | Client software debugging method and device |
| CN116204199A (en) * | 2022-12-27 | 2023-06-02 | 北京君航微金信息科技有限公司 | Command line-based project management method, system, equipment and storage medium |
-
2021
- 2021-12-28 CN CN202111625112.2A patent/CN114371850A/en active Pending
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115086206A (en) * | 2022-06-14 | 2022-09-20 | 工银科技有限公司 | Client software debugging method and device |
| CN116204199A (en) * | 2022-12-27 | 2023-06-02 | 北京君航微金信息科技有限公司 | Command line-based project management method, system, equipment and storage medium |
| CN116204199B (en) * | 2022-12-27 | 2023-12-12 | 北京君航微金信息科技有限公司 | Command line-based project management method, system, equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10795660B1 (en) | Live code updates | |
| CN109597814B (en) | Online rapid delivery system of background management information system | |
| US9135227B2 (en) | Methods and systems for enabling the provisioning and execution of a platform-independent application | |
| CN110673853B (en) | Compiling method, device and system | |
| CN111740948B (en) | Data packet issuing method, dynamic updating method, device, equipment and medium | |
| CN114371850A (en) | Management method for project construction compiling and code development | |
| CN111309291B (en) | Modularized embedded software architecture, customization method and customization system thereof | |
| CN106844153B (en) | Application program operation monitoring method and device and terminal | |
| CN101645009A (en) | Web service integrated development system and method | |
| WO2019005228A1 (en) | Automated source code adaption to inject features between platform versions | |
| CN102455931B (en) | Method and system for developing Android platform engineering | |
| CN112835584B (en) | Method for realizing component expansion and management based on REACTNATIVE | |
| CN113312046A (en) | Sub-application page processing method and device and computer equipment | |
| CN112083968A (en) | Plug-in loading method and device in host | |
| CN117149301A (en) | MDF-based micro front end resource sharing method, system and storage medium | |
| CN114281347A (en) | Method for converting Taro small program code into APP | |
| CN113127000B (en) | Compiling method, compiling device, compiling equipment and compiling storage medium for application program component | |
| CN112988175A (en) | Cross-platform application installation package generation method, device, medium and electronic equipment | |
| KR101416096B1 (en) | A highly compatible plug-in system for developing hybrid web applications | |
| CN114721647B (en) | Object-oriented programming method based on codeless application development | |
| CN108804088B (en) | Protocol processing method and device | |
| US9448818B2 (en) | Defining classes as singleton classes or non-singleton classes | |
| CN114816475A (en) | Method, device, equipment and medium for updating embedded operating system | |
| US20110321009A1 (en) | Implementing encryption via aspect oriented programming | |
| CN113821271B (en) | Connector expansion method and system of business application integration platform |
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 |