CN112199092B - Application development method and device and electronic equipment - Google Patents
Application development method and device and electronic equipment Download PDFInfo
- Publication number
- CN112199092B CN112199092B CN202010984048.6A CN202010984048A CN112199092B CN 112199092 B CN112199092 B CN 112199092B CN 202010984048 A CN202010984048 A CN 202010984048A CN 112199092 B CN112199092 B CN 112199092B
- Authority
- CN
- China
- Prior art keywords
- class
- registration
- code file
- component
- matching
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 49
- 230000006870 function Effects 0.000 claims description 23
- 238000004590 computer program Methods 0.000 claims description 8
- 230000008878 coupling Effects 0.000 description 7
- 238000010168 coupling process Methods 0.000 description 7
- 238000005859 coupling reaction Methods 0.000 description 7
- 238000010586 diagram Methods 0.000 description 6
- 230000008569 process Effects 0.000 description 5
- 238000004458 analytical method Methods 0.000 description 3
- 238000010276 construction Methods 0.000 description 3
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000001419 dependent effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 239000013589 supplement Substances 0.000 description 1
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
-
- 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
- G06F8/33—Intelligent editors
-
- 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)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a development method and device of an application and electronic equipment, wherein the method comprises the following steps: custom annotations for each code file are obtained from the server. Compiling the custom annotation to generate a registration class corresponding to the custom annotation. Matching the registration class with the configuration rule of the component, and adding the registration class into a routing library corresponding to the component when the matching is successful. And calling corresponding code files from the server to the components according to the registration classes in the routing libraries to form the target application.
Description
Technical Field
The present invention relates to the field of software development technologies, and in particular, to a method and an apparatus for developing an application, and an electronic device.
Background
In the development process of android system application, the software code amount of the project is increased due to the continuous growth of the business. The high coupling between the software codes also causes the version maintenance of the project engineering to be difficult, and local software code changes often cause the whole project engineering to need to be fully compiled again. In the prior art, codes are divided according to different services, different services are placed into independent functional modules for development, each functional module forms an independent code file, and the functional modules of the components are called mutually to form a target application, so that the coupling between software codes is reduced.
However, when the prior art is adopted to develop the application, it is found that the target application needs to be formed by calling the functional modules of the components mutually, so that the dependency relationship exists between the functional modules, the coupling problem between codes still exists, and when one functional module is changed, other functional modules can be recoded to ensure that the functional modules can be called to complete the development of a large-scale project, so that the workload of developers is increased, the construction time of the whole project is too long, and the development efficiency is low.
Disclosure of Invention
The application aims at least solving one of the technical problems in the prior art, and provides an application development method, an application development device and an electronic device, which reduce the coupling between codes, so as to reduce the occurrence probability of recoding in the development process and further improve the development efficiency of the application.
The embodiment of the application provides a development method of an application, which comprises the following steps:
custom annotations for each code file are obtained from the server.
Compiling the custom annotation to generate a registration class corresponding to the custom annotation.
Matching the registration class with the configuration rule of the component, and adding the registration class into a routing library corresponding to the component when the matching is successful.
And calling corresponding code files from the server to the components according to the registration classes in the routing libraries to form the target application.
Further, compiling the custom annotation to generate a registration class corresponding to the custom annotation, including:
analyzing the custom annotation, and after generating the description class of the code file, acquiring path information and type information of the code file in the description class to generate a registration class.
Further, according to each registration class in each routing library, each corresponding code file is called from the server, including:
and acquiring the acquisition path of each code file according to the path information in each registration class, so as to call each corresponding code file from the server according to the acquisition path.
Further, matching the registration class with the configuration rule of the component, and adding the registration class to the routing library corresponding to the component when the matching is successful, including:
matching the registration class with the configuration rules in the component, and adding the registration class to a dependency library formed by the component when the matching is successful.
And when receiving an application starting instruction, adding the registration class into the corresponding routing library according to the dependency library to which the registration class belongs.
Further, according to each registration class in each routing library, calling each corresponding code file from the server to each component to form a target application, including:
and according to each registered class in each routing library, after each corresponding code file is called from the server to each component, each component added with the code file is compiled according to the detected compiling mode to form the target application.
Further, according to each registration class in each routing library, calling each corresponding code file from the server to each component to form a target application, including:
responding to the function call request, searching the registration class matched with the function call request from each routing library, calling the corresponding code file from the server to the corresponding component according to the searched registration class, and compiling to form the executable program.
The executable program is run.
Further, before matching the registration class with the configuration rule of the component, the method further includes:
and responding to the component editing operation, and editing the configuration rule of the component according to the component editing operation after adding the component.
Further, an embodiment of the present application further provides an application development device, including:
and the acquisition module is used for acquiring the custom annotation of each code file from the server.
And the compiling module is used for compiling the custom annotation and generating a registration class corresponding to the custom annotation.
And the matching module is used for matching the registration class with the configuration rule of the component and adding the registration class into the routing library corresponding to the component when the matching is successful.
And the calling module is used for calling corresponding code files from the server to the components according to the registration classes in the routing libraries so as to form the target application.
Further, the matching module is specifically configured to:
matching the registration class with the configuration rules in the component, and adding the registration class to a dependency library formed by the component when the matching is successful.
And when receiving an application starting instruction, adding the registration class into the corresponding routing library according to the dependency library to which the registration class belongs.
Further, an embodiment of the present application provides an electronic device, including: a memory, a processor, and a computer program stored on the memory and executable on the processor, which when executed implements the development method of the application as described in the above embodiments.
Further, the present application provides a computer-readable storage medium storing computer-executable instructions for causing a computer to execute the development method of the application described in the above embodiments.
Compared with the prior art, the method and the device have the advantages that the user-defined annotation is carried out on each code file, the corresponding registration class is generated by compiling the annotation, the registration class is matched with the component configuration rule to be added into the routing library corresponding to the component, and each code file is called according to the registration class in the routing library to form the target application. The application development process does not need to call the functional modules of the components, so that the dependency relationship between the functional modules is avoided, the technical problem of coupling between codes in each code file is effectively solved, the workload of developers is reduced, the project construction time is shortened, and the development efficiency is improved.
The embodiment generates the description class of the code file by analyzing the custom annotation, and generates the corresponding registration class according to the path information and the type information of the code file in the description class, thereby realizing grouping and quick searching of the code file. And the path information in the registration class is used for acquiring the path of the code file, and the code file is called through the path, so that the technical problem of difficulty in searching the code file due to the coupling of codes in the code file is effectively solved.
Drawings
The present application is further described below with reference to the drawings and examples;
FIG. 1 is an application environment diagram of a development method of an application in one embodiment.
FIG. 2 is a flow diagram of a development method applied in one embodiment.
Fig. 3 is a flow chart of a development method applied in another embodiment.
Fig. 4 is a flow chart of a development method applied in yet another embodiment.
Fig. 5 is a flow chart of a development method applied in yet another embodiment.
Fig. 6 is a schematic structural diagram of a development device applied in one embodiment.
FIG. 7 is a block diagram of a computer device in one embodiment.
Detailed Description
Reference will now be made in detail to the present embodiments of the present application, examples of which are illustrated in the accompanying drawings, wherein the purpose of the accompanying drawings is to supplement the description of the written description section with figures, so that one can intuitively and intuitively understand each technical feature and overall technical scheme of the present application, but not to limit the scope of protection of the present application.
When the prior art is adopted to develop the application, the fact that the target application is formed by calling the functional modules of the components mutually is found out, so that the dependency relationship exists among the functional modules, the problem of coupling among codes still exists, and when one functional module is changed, other functional modules can be recoded to ensure that the functional modules can be called to complete the development of a large-scale project, so that the workload of developers is increased, the construction time of the whole project is too long, and the development efficiency is low.
In order to solve the above-described problems, as shown in fig. 1, an application environment diagram of a development method applied in one embodiment is shown. Referring to fig. 1, the development system of the application includes a terminal 110 and a server 120. The terminal 110 and the server 120 are connected through a network. The terminal 110 may specifically be a desktop terminal 110 or a mobile terminal 110, and the mobile terminal may be at least one of a mobile phone, a tablet computer, a notebook computer, and the like. The server 120 may be implemented by a single server 120 or a server group formed by a plurality of servers 120. The terminal 110 obtains the custom annotations of the code files from the server 120, compiles the custom annotations, generates a registration class corresponding to the custom annotations, matches the registration class with the configuration rule of the component, adds the registration class to the routing library corresponding to the component when the matching is successful, and invokes the corresponding code files from the server 120 to the components according to the registration classes in the routing libraries to form the target application.
In the following, a method for developing an application provided in the embodiment of the present application will be described and illustrated in detail by means of several specific embodiments.
As shown in FIG. 2, in one embodiment, a method of development of an application is provided. Referring to fig. 2, the development method of the application specifically includes the following steps:
s11, acquiring the custom annotation of each code file from the server.
In one embodiment, the custom annotations for each code file are specifically descriptions of the functions implemented by each code file and the path and class of each code file by the user. The self-defined annotation made to each code file is only one and only, and functions like a mark.
S12, compiling the custom annotation to generate a registration class corresponding to the custom annotation.
In one embodiment, custom annotations are compiled by APT techniques to generate externally exposed registration classes with specific rules.
S13, matching the registration class with the configuration rule of the component, and adding the registration class into a routing library corresponding to the component when the matching is successful.
In one embodiment, corresponding configuration rules are specified according to service requirements, each configuration rule corresponding to a component, and each component corresponding to a routing library. The terminal matches the specific rule in the generated registration class with the appointed configuration rule, and adds the registration class into the routing library corresponding to the component corresponding to the configuration rule if the matching is successful.
In this embodiment, the components are divided by different channels, such as Google and Facebook, into two different components. The configuration rules corresponding to the components are divided according to functions, for example, login configuration rules and payment configuration rules under Facebook are divided according to login functions and payment functions.
S14, according to each registration class in each routing library, each corresponding code file is called from the server to each component to form the target application.
In one embodiment, when the terminal needs to call each code file, the registered class is scanned in the router, a configuration rule is specified according to the function of the target application to be formed by the terminal, a corresponding registered class is found according to the configuration rule, and the code file corresponding to the registered class is called. The calling code file can be called one at a time or multiple at a time, and the corresponding configuration rule is only required to be specified according to the function of the target application.
In one embodiment, invoking corresponding code files from a server into components to form a target application according to registration classes in the routing libraries comprises:
responding to the function call request, searching the registration class matched with the function call request from each routing library, calling the corresponding code file from the server to the corresponding component according to the searched registration class, and compiling to form the executable program.
The executable program is run.
In this embodiment, the code file is called only when the application is started by storing the registration class, so that the memory pressure of the device is saved.
In one embodiment, before matching the registration class with the configuration rules of the component, further comprising:
and responding to the component editing operation, and editing the configuration rule of the component according to the component editing operation after adding the component.
In one embodiment, the rule configuration may be performed by way of a drop down tab. Specifically, a configuration rule is selected through a drop-down option frame, the registration class is traversed in the routing library according to the selected configuration rule, and the registration class successfully paired is displayed on the terminal.
The code files corresponding to the registration classes are called in the routing library in a scanning traversing mode, so that the technical problem that the efficiency is too low and the condition that a target application needs to call a plurality of codes is not facilitated. In order to solve the above technical problem, another embodiment as shown in fig. 3 is provided.
In another embodiment, as shown in FIG. 3, a method of application development is provided. Referring to fig. 3, the development method of the application specifically includes the following steps:
s21, obtaining the custom annotation of each code file from the server.
In one embodiment, the custom annotations for each code file are specifically descriptions of the functions implemented by each code file and the path and class of each code file by the user. The custom annotations are added at the top of the implementation class for each code file. The self-defined annotation made to each code file is only one and only, and functions like a mark.
S22, analyzing the self-defined annotation, and after generating the description class of the code file, acquiring path information and type information of the code file in the description class to generate a registration class.
S23, matching the registration class with the configuration rule of the component, and adding the registration class into a routing library corresponding to the component when the matching is successful.
The steps are the same as those of the above embodiments, and specific analyses may refer to the above embodiments, so that repetition is avoided and details are not repeated here.
S24, acquiring the acquisition path of each code file according to the path information in each registration class, and calling each corresponding code file from the server to each component according to the acquisition path to form the target application.
In this embodiment, the path information and the type information in the code file are extracted by parsing the path information and the type information with the code file to generate a description class of the code file. When the target application calls each code file, the acquisition path of each code file is only required to be acquired according to the path information in the registration class, and then the registration class is directly called according to the path, so that the quick searching of the corresponding code file is realized, meanwhile, the grouping and warehousing process of the registration class is simplified, and the efficiency is improved.
In the existing registration type warehousing process, manual registration is needed and the registration types are added into a route one by one, so that the technical problems of low efficiency and difficulty in unified management exist. In order to solve the above technical problem, a further embodiment as shown in fig. 4 is provided.
In yet another embodiment, as shown in FIG. 4, a method of development of an application is provided. Referring to fig. 4, the development method of the application specifically includes the following steps:
s31, obtaining the custom annotation of each code file from the server.
In one embodiment, the custom annotations for each code file are specifically descriptions of the functions implemented by each code file and the path and class of each code file by the user. The self-defined annotation made to each code file is only one and only, and functions like a mark.
S32, compiling the custom annotation to generate a registration class corresponding to the custom annotation.
The steps are the same as those of the above embodiments, and specific analyses may refer to the above embodiments, so that repetition is avoided and details are not repeated here.
S33, matching the registration class with the configuration rules in the components, and adding the registration class into a dependency library formed by the components when the matching is successful. And when receiving an application starting instruction, adding the registration class into the corresponding routing library according to the dependency library to which the registration class belongs.
In one embodiment, the corresponding dependent libraries, i.e., proprietary libraries, are built for all components. The registration class with the custom annotation is intercepted through Gradle, and is matched with different appointed configuration rules according to the registration class, and the corresponding registration class is added into the dependency library of the corresponding component after matching. And when the terminal receives the starting instruction, adding the registration class into the corresponding routing library according to the dependency library to which the registration class belongs.
In the embodiment, the registration classes are intercepted and added to the dependency library corresponding to the component, and then added to the routing library according to the starting instruction and the dependency library, so that unified management of the registration classes is realized, the registration classes are not added one by one manually, and convenience is improved.
S34, according to each registration class in each routing library, each corresponding code file is called from the server to each component to form the target application.
The steps are the same as those of the above embodiments, and specific analyses may refer to the above embodiments, so that repetition is avoided and details are not repeated here.
Because the code file developed by the application can set the corresponding compiling mode, the technical problem that the application cannot adapt to different types of terminals exists. In order to solve the above technical problem, still another embodiment as shown in fig. 5 is provided.
In yet another embodiment, as shown in FIG. 5, a method of development of an application is provided. Referring to fig. 5, the development method of the application specifically includes the following steps:
s41, acquiring the custom annotation of each code file from the server.
In one embodiment, the custom annotations for each code file are specifically descriptions of the functions implemented by each code file and the path and class of each code file by the user. The self-defined annotation made to each code file is only one and only, and functions like a mark.
S42, compiling the custom annotation to generate a registration class corresponding to the custom annotation.
S43, matching the registration class with the configuration rule of the component, and adding the registration class into a routing library corresponding to the component when the matching is successful.
S44, according to each registration class in each routing library, after each corresponding code file is called from the server to each component, each component added with the code file is compiled according to the detected compiling mode to form the target application.
In this embodiment, the component may be compiled according to different compiling modes, so that the target application may run on different types of terminals. The compiling manner of the component in the embodiment of the present application is not limited.
In one embodiment, invoking corresponding code files from a server into components to form a target application according to registration classes in the routing libraries comprises:
responding to the function call request, searching the registration class matched with the function call request from each routing library, calling the corresponding code file from the server to the corresponding component according to the searched registration class, and compiling to form the executable program.
The executable program is run.
In this embodiment, the code file is called only when the application is started by storing the registration class, so that the memory pressure of the device is saved.
In one embodiment, as shown in fig. 6, there is provided a development apparatus of an application, including:
the obtaining module 101 is configured to obtain, from a server, a custom annotation of each code file.
And the compiling module 102 is used for compiling the custom annotation and generating a registration class corresponding to the custom annotation.
In one embodiment, the compiling module 102 is further configured to: analyzing the custom annotation, and after generating the description class of the code file, acquiring path information and type information of the code file in the description class to generate a registration class.
And the matching module 103 is used for matching the registration class with the configuration rule of the component, and adding the registration class into the routing library corresponding to the component when the matching is successful.
In one embodiment, the matching module 103 is further configured to: matching the registration class with the configuration rules in the component, and adding the registration class to a dependency library formed by the component when the matching is successful.
And when receiving an application starting instruction, adding the registration class into the corresponding routing library according to the dependency library to which the registration class belongs.
And the calling module 104 is used for calling corresponding code files from the server to the components according to the registration classes in the routing libraries to form the target application.
In one embodiment, the calling module 104 is further configured to: and acquiring the acquisition path of each code file according to the path information in each registration class, and calling each corresponding code file from the server to each component according to the acquisition path to form the target application.
In another embodiment, the calling module 104 is further configured to: and according to each registered class in each routing library, after each corresponding code file is called from the server to each component, each component added with the code file is compiled according to the detected compiling mode to form the target application.
In yet another embodiment, the calling module 104 is further configured to: responding to the function call request, searching the registration class matched with the function call request from each routing library, calling the corresponding code file from the server to the corresponding component according to the searched registration class, and compiling to form the executable program. The executable program is run.
In one embodiment, a computer apparatus is provided, as shown in FIG. 7, comprising a processor, a memory, a network interface, an input device, and a display screen connected by a system bus. The memory includes a nonvolatile storage medium and an internal memory. The non-volatile storage medium of the computer device stores an operating system, and may also store a computer program that, when executed by a processor, causes the processor to implement a method of developing an application. The internal memory may also store a computer program that, when executed by the processor, causes the processor to perform a method of developing an application. It will be appreciated by those skilled in the art that the structure shown in fig. 7 is merely a block diagram of some of the structures associated with the present application and is not limiting of the computer device to which the present application may be applied, and that a particular computer device may include more or fewer components than shown, or may combine certain components, or have a different arrangement of components.
In one embodiment, the development apparatus of the application provided in the present application may be implemented in the form of a computer program, which may be run on a computer device as shown in fig. 7. The memory of the computer device may store various program modules that make up the development apparatus for the application. The computer program constituted by the respective program modules causes the processor to execute the steps in the development method of the application of the respective embodiments of the present application described in the present specification.
In one embodiment, there is provided an electronic device including: the system comprises a memory, a processor and a computer program stored on the memory and capable of running on the processor, wherein the processor executes the steps of the development method of the application. The steps of the development method applied here may be the steps in the development method applied to the respective embodiments described above.
In one embodiment, a computer-readable storage medium storing computer-executable instructions for causing a computer to perform the steps of the development method of the application described above is provided. The steps of the development method applied here may be the steps in the development method applied to the respective embodiments described above.
While the foregoing is directed to the preferred embodiments of the present application, it will be appreciated by those skilled in the art that changes and modifications may be made without departing from the principles of the present application, such changes and modifications are also intended to be within the scope of the present application.
Those skilled in the art will appreciate that implementing all or part of the above-described methods in accordance with the embodiments may be accomplished by way of a computer program stored on a computer readable storage medium, which when executed may comprise the steps of the embodiments of the methods described above. The storage medium may be a magnetic disk, an optical disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), or the like.
Claims (8)
1. A method of developing an application, comprising:
obtaining custom notes of each code file from a server;
analyzing the custom annotation, generating a description class of the code file, and acquiring path information and type information of the code file in the description class to generate a registration class;
matching the registration class with the configuration rule of the component, and adding the registration class into a routing library corresponding to the component when the matching is successful;
calling corresponding code files from the server to the components according to the registration classes in the routing libraries to form target applications;
and according to each registered class in each routing library, calling each corresponding code file from the server, wherein the code file comprises:
and acquiring an acquisition path of each code file according to the path information in each registration class, so as to call each corresponding code file from the server according to the acquisition path.
2. The method for developing an application according to claim 1, wherein said matching the registration class with the configuration rule of the component, and adding the registration class to the routing library corresponding to the component when the matching is successful, comprises:
matching the registration class with configuration rules in the components, and adding the registration class into a dependency library formed by the components when the matching is successful;
and when receiving an application starting instruction, adding the registration class into a corresponding routing library according to the dependency library to which the registration class belongs.
3. The method according to claim 1, wherein the calling, from the server, the corresponding code files into the components to form the target application according to the registration classes in the routing libraries, comprises:
and according to each registered class in each routing library, calling corresponding code files from the server to each component, and then compiling each component added with the code files according to the detected compiling mode to form a target application.
4. A method of developing an application according to claim 1 or 3, wherein said calling corresponding code files from said server into said components to form a target application according to said registration classes in said routing libraries comprises:
responding to a function call request, searching a registration class matched with the function call request from each routing library, calling the corresponding code file from the server to the corresponding component according to the searched registration class, and compiling to form an executable program;
and running the executable program.
5. The method of claim 1, further comprising, prior to said matching the registration class with the configuration rules of the component:
and responding to the component editing operation, and editing the configuration rule of the component according to the component editing operation after adding the component.
6. An application development apparatus, comprising:
the acquisition module is used for acquiring the custom annotation of each code file from the server;
the compiling module is used for analyzing the custom annotation, and after generating the description class of the code file, acquiring path information and type information of the code file in the description class to generate a registration class;
the matching module is used for matching the registration class with the configuration rule of the component and adding the registration class into a routing library corresponding to the component when the matching is successful;
a calling module, configured to call, from the server, each corresponding code file into each component according to each registered class in each routing library to form a target application, where, from the server, each corresponding code file is called according to each registered class in each routing library, including: and acquiring an acquisition path of each code file according to the path information in each registration class, so as to call each corresponding code file from the server according to the acquisition path.
7. The application development device according to claim 6, wherein the matching module is specifically configured to:
matching the registration class with configuration rules in the components, and adding the registration class into a dependency library formed by the components when the matching is successful;
and when receiving an application starting instruction, adding the registration class into a corresponding routing library according to the dependency library to which the registration class belongs.
8. An electronic device, comprising: memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the development method of an application according to any one of claims 1 to 5 when executing the program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010984048.6A CN112199092B (en) | 2020-09-17 | 2020-09-17 | Application development method and device and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010984048.6A CN112199092B (en) | 2020-09-17 | 2020-09-17 | Application development method and device and electronic equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112199092A CN112199092A (en) | 2021-01-08 |
| CN112199092B true CN112199092B (en) | 2024-03-15 |
Family
ID=74015451
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010984048.6A Active CN112199092B (en) | 2020-09-17 | 2020-09-17 | Application development method and device and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112199092B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112925562B (en) * | 2021-02-19 | 2024-09-17 | 京东方科技集团股份有限公司 | Android system-based application generation method, android system-based application generation device and storage medium |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108563432A (en) * | 2018-03-14 | 2018-09-21 | 广东能龙教育股份有限公司 | Android application program componentization rapid development method through route configuration |
| CN109254808A (en) * | 2018-07-18 | 2019-01-22 | 平安科技（深圳）有限公司 | Interface call method, device and computer readable storage medium |
| CN109828784A (en) * | 2019-02-03 | 2019-05-31 | 普信恒业科技发展（北京）有限公司 | A kind of task grasping means and device |
| WO2019153544A1 (en) * | 2018-02-12 | 2019-08-15 | 平安科技（深圳）有限公司 | Annotation backend check method and apparatus, computer device and storage medium. |
| CN110308900A (en) * | 2019-06-27 | 2019-10-08 | 广州华多网络科技有限公司 | Generation method, device, computer equipment and the storage medium of page route documents |
| CN110865889A (en) * | 2018-08-27 | 2020-03-06 | 北京高绎信息技术有限公司 | Method and apparatus for transferring events between components |
| CN114168111A (en) * | 2021-12-07 | 2022-03-11 | 北京五八信息技术有限公司 | Method, device, product and storage medium for realizing modular routing |
-
2020
- 2020-09-17 CN CN202010984048.6A patent/CN112199092B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2019153544A1 (en) * | 2018-02-12 | 2019-08-15 | 平安科技（深圳）有限公司 | Annotation backend check method and apparatus, computer device and storage medium. |
| CN108563432A (en) * | 2018-03-14 | 2018-09-21 | 广东能龙教育股份有限公司 | Android application program componentization rapid development method through route configuration |
| CN109254808A (en) * | 2018-07-18 | 2019-01-22 | 平安科技（深圳）有限公司 | Interface call method, device and computer readable storage medium |
| CN110865889A (en) * | 2018-08-27 | 2020-03-06 | 北京高绎信息技术有限公司 | Method and apparatus for transferring events between components |
| CN109828784A (en) * | 2019-02-03 | 2019-05-31 | 普信恒业科技发展（北京）有限公司 | A kind of task grasping means and device |
| CN110308900A (en) * | 2019-06-27 | 2019-10-08 | 广州华多网络科技有限公司 | Generation method, device, computer equipment and the storage medium of page route documents |
| CN114168111A (en) * | 2021-12-07 | 2022-03-11 | 北京五八信息技术有限公司 | Method, device, product and storage medium for realizing modular routing |
Non-Patent Citations (2)
| Title |
|---|
| Android组件化专题 - 路由框架原理;已注销;https://juejin.cn/post/6844903743922634760;全文 * |
| Annotation processor generated code;Stoffe;https://intellij-support.jetbrains.com/hc/en-us/community/posts/206814065-Annotation-processor-generated-code;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112199092A (en) | 2021-01-08 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109814854B (en) | Project framework generation method, device, computer equipment and storage medium | |
| CN111124906A (en) | Tracking method, compiling method and device based on dynamic embedded points and electronic equipment | |
| CN112422484B (en) | Method, apparatus, and storage medium for determining scenario for processing security event | |
| CN113076253A (en) | Test method and test device | |
| CN111143446A (en) | Data structure conversion processing method and device of data object and electronic equipment | |
| CN111008022B (en) | Relationship diagram generation method, device, computer equipment and storage medium | |
| CN111124872A (en) | Branch detection method and device based on difference code analysis and storage medium | |
| CN110688096B (en) | Method and device for constructing application program containing plug-in, medium and electronic equipment | |
| CN112769706B (en) | Componentized routing method and system | |
| CN113760722A (en) | Test system and test method | |
| CN112199092B (en) | Application development method and device and electronic equipment | |
| CN113254399A (en) | Log query method and device, electronic equipment and medium | |
| CN111240772A (en) | Data processing method and device based on block chain and storage medium | |
| CN111488286B (en) | Method and device for independently developing Android modules | |
| CN112817600A (en) | Program annotation compiling method and corresponding device, equipment and medium | |
| CN112767155A (en) | Intelligent contract security transaction sequence generation method, device, medium and equipment | |
| CN109857716B (en) | System interaction log recording method and device, storage medium and server | |
| CN110018831B (en) | Program processing method, program processing apparatus, and computer-readable storage medium | |
| CN111158777A (en) | Component calling method and device and computer readable storage medium | |
| CN113741868B (en) | Service computing task processing method, device, computer equipment and storage medium | |
| CN115934537A (en) | Interface test tool generation method, device, equipment, medium and product | |
| CN115756598A (en) | Component detection method, system and device applied to low-code platform | |
| CN111475226B (en) | Electronic device, micro-service calling method, and computer-readable storage medium | |
| CN113190236A (en) | HQL script checking method and device | |
| CN112579275A (en) | Task execution method, device, equipment and storage medium |
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 |