CN112199092A - Application development method and device and electronic equipment - Google Patents
Application development method and device and electronic equipment Download PDFInfo
- Publication number
- CN112199092A CN112199092A CN202010984048.6A CN202010984048A CN112199092A CN 112199092 A CN112199092 A CN 112199092A CN 202010984048 A CN202010984048 A CN 202010984048A CN 112199092 A CN112199092 A CN 112199092A
- Authority
- CN
- China
- Prior art keywords
- component
- registration class
- class
- registration
- code 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 53
- 230000006870 function Effects 0.000 claims description 23
- 238000004590 computer program Methods 0.000 claims description 9
- 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 5
- 238000010276 construction Methods 0.000 description 3
- 230000015572 biosynthetic process Effects 0.000 description 2
- 238000005034 decoration Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 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
- 230000001502 supplementing effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/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 an application development method, an application development device and electronic equipment, wherein the method comprises the following steps: and obtaining the custom annotation of each code file from the server. And compiling the custom annotation to generate a registration class corresponding to the custom annotation. And 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 application 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, due to the continuous increase of services, the software code amount of a project is larger and larger. At this time, the high coupling between the software codes also causes difficult version maintenance of the project engineering, and local software code changes often cause the whole project engineering to need to be completely compiled again. In the prior art, codes are divided according to different services, different services are placed in independent functional modules for development, so that each functional module forms an independent code file, and target applications are formed by calling functional modules of components mutually, thereby reducing the coupling among software codes.
However, when the prior art is adopted to develop applications, it is found that since the formation of a target application needs to be realized by calling the functional modules of the component with each other, a dependency relationship exists among the functional modules, and the problem of coupling between codes still exists, so that when one functional module is changed, other functional modules may be recoded to ensure that the functional module is called to complete the development of a large project, thereby increasing the workload of developers, prolonging the construction time of the whole project, and lowering the development efficiency.
Disclosure of Invention
The present application aims to solve at least 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 probability of occurrence of recoding in the development process, and further improve the development efficiency of applications.
The embodiment of the application provides an application development method, which comprises the following steps:
and obtaining the custom annotation of each code file from the server.
And compiling the custom annotation to generate a registration class corresponding to the custom annotation.
And 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:
and analyzing the custom annotation, generating a description class of the code file, acquiring path information and type information of the code file in the description class, and generating a registration class.
Further, according to each registration class in each routing library, calling each corresponding code file from the server, including:
and acquiring an acquisition path of each code file according to the path information in each registration class, and calling 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 a routing library corresponding to the component when matching is successful, including:
the registration class is matched with the configuration rules in the component and added to the dependency base formed by the component when the matching is successful.
And when an application starting instruction is received, 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 registration class in each routing library, calling each corresponding code file from the server to each component, and compiling each component added with the code file 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:
and responding to the function calling request, searching the registration class matched with the function calling request from each routing library, and calling the corresponding code file from the server to the corresponding component according to the searched registration class for compiling to form an 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 apparatus, 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 to generate 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 to form the target application.
Further, the matching module is specifically configured to:
the registration class is matched with the configuration rules in the component and added to the dependency base formed by the component when the matching is successful.
And when an application starting instruction is received, 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: 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 program to realize the development method of the application according to the embodiment.
Further, the present application provides a computer-readable storage medium, which stores computer-executable instructions for causing a computer to execute the method for developing an application according to the above embodiment.
Compared with the prior art, the embodiment generates the corresponding registration class by performing the custom annotation on each code file and compiling the annotation, matches the registration class with the component configuration rule to add the registration class to the routing library corresponding to the component, and calls each code file 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 among the functional modules is avoided, the technical problem of coupling among 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.
In the embodiment, the description class of the code file is generated by analyzing the custom annotation, and the corresponding registration class is generated according to the path information and the type information of the code file in the description class, so that the grouping and the quick search of the code file are realized. And the path of the code file is obtained through the path information in the registration class, and then the code file is called through the path, so that the technical problem that the code file is difficult to search due to the coupling of the codes in the code file is effectively solved.
Drawings
The present application is further described with reference to the following figures and examples;
fig. 1 is an application environment diagram of a development method of an application in one embodiment.
FIG. 2 is a flowchart illustrating a method for developing an application according to an embodiment.
Fig. 3 is a flowchart illustrating a method for developing an application according to another embodiment.
Fig. 4 is a flowchart illustrating a method for developing an application according to still another embodiment.
Fig. 5 is a flowchart illustrating a method for developing an application according to still another embodiment.
Fig. 6 is a schematic structural diagram of a development apparatus 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, preferred embodiments of which are illustrated in the accompanying drawings, which are for the purpose of visually supplementing the description with figures and detailed description, so as to enable a person skilled in the art to visually and visually understand each and every feature and technical solution of the present application, but not to limit the scope of the present application.
When the prior art is adopted for application development, it is found that the formation of a target application needs to be realized by calling the functional modules of the component mutually, so that a dependency relationship exists among the functional modules, the coupling problem among codes still exists, and when one functional module is changed, other functional modules can be recoded to ensure that the functional module is called to complete the development of a large 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.
To solve the above problem, as shown in fig. 1, it is an application environment diagram of a development method of an application in one embodiment. 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 as a stand-alone server 120 or as a server farm comprising a plurality of servers 120. The terminal 110 obtains the custom annotation of each code file from the server 120, compiles the custom annotation to generate a registration class corresponding to the custom annotation, 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 calls each corresponding code file from the server 120 to each component according to each registration class in each routing library to form the target application.
Hereinafter, the development method of the application provided in the embodiments of the present application will be described and explained in detail through several specific embodiments.
In one embodiment, as shown in FIG. 2, a method for developing an application is provided. Referring to fig. 2, the method for developing the application specifically includes the following steps:
and S11, obtaining the self-defined annotation of each code file from the server.
In one embodiment, the custom annotation of each code file is specifically a user's specification of the functions implemented by each code file and the path and category of each code file. The self-defined annotation made to each code file is only one and unique, and functions like a mark.
And S12, compiling the custom annotation to generate a registration class corresponding to the custom annotation.
In one embodiment, the custom annotations are compiled through APT techniques to generate externally exposed registry classes with specific rules.
And S13, 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.
In one embodiment, corresponding configuration rules are specified according to business requirements, each configuration rule corresponds to one component, and each component corresponds to one routing library. The terminal matches the specific rule in the generated registration class with the specified configuration rule, and if the matching is successful, the registration class is added into the routing library corresponding to the component corresponding to the configuration rule.
In this embodiment, the components are divided according to different channels, for example, Google and Facebook are divided into two different components. The configuration rules corresponding to the components are divided according to functions, for example, the login configuration rule and the payment configuration rule under Facebook are divided according to the login function and the payment function.
And S14, 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, when the terminal needs to call each code file, the terminal scans the registered class in the router, specifies a configuration rule according to the function of the target application to be formed by the terminal, finds out the corresponding registered class according to the configuration rule, and calls the code file corresponding to the registered class. The calling code file can call one or more than one code file at a time, and corresponding configuration rules are only required to be specified according to the functions of the target application.
In one embodiment, according to each registration class in each routing library, calling each corresponding code file from the server to each component to form the target application, includes:
and responding to the function calling request, searching the registration class matched with the function calling request from each routing library, and calling the corresponding code file from the server to the corresponding component according to the searched registration class for compiling to form an 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 rule of the component, the method further comprises:
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 option box. Specifically, the configuration rule is selected through the pull-down option frame, the registration class is traversed in the routing library according to the selected configuration rule, and the successfully paired registration class is displayed on the terminal.
The technical problem that calling a code file corresponding to a registration class in a routing library in a scanning traversal mode is low in efficiency and not beneficial to the condition that a target application needs to call a plurality of codes exists. In order to solve the above technical problem, another embodiment is provided as shown in fig. 3.
In another embodiment, as shown in FIG. 3, a method for developing an application is provided. Referring to fig. 3, the method for developing the application specifically includes the following steps:
and S21, obtaining the self-defined annotation of each code file from the server.
In one embodiment, the custom annotation of each code file is specifically a user's specification of the functions implemented by each code file and the path and category of each code file. The custom annotation is added on top of the implementation class of each code file. The self-defined annotation made to each code file is only one and unique, and functions like a mark.
And S22, analyzing the custom annotation, generating a description class of the code file, acquiring the path information and the type information of the code file in the description class, and generating a registration class.
And S23, 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.
This step is the same as the above embodiment, and the detailed analysis may refer to the above embodiment, and is not repeated herein to avoid repetition.
And 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 the embodiment, the path information and the type information in the code file are extracted by analyzing the path information and the type information of the code file and generating a description class of the code file. When the target application calls each code file, the acquisition path of each code file is acquired only according to the path information in the registration class, and then the registration class is called directly according to the path, so that the corresponding code file is quickly searched, meanwhile, the grouping and warehousing process of the registration class is simplified, and the efficiency is improved.
The existing registration type warehousing process needs manual registration and is added to a routing route one by one, and the technical problems of low efficiency and difficult unified management exist. In order to solve the above technical problem, a further embodiment is provided as shown in fig. 4.
In yet another embodiment, as shown in FIG. 4, a method for developing an application is provided. Referring to fig. 4, the method for developing the application specifically includes the following steps:
and S31, obtaining the self-defined annotation of each code file from the server.
In one embodiment, the custom annotation of each code file is specifically a user's specification of the functions implemented by each code file and the path and category of each code file. The self-defined annotation made to each code file is only one and unique, and functions like a mark.
And S32, compiling the custom annotation to generate a registration class corresponding to the custom annotation.
This step is the same as the above embodiment, and the detailed analysis may refer to the above embodiment, and is not repeated herein to avoid repetition.
And S33, matching the registration class with the configuration rule in the component, and adding the registration class to a dependency base formed by the component when the matching is successful. And when an application starting instruction is received, adding the registration class into the corresponding routing library according to the dependency library to which the registration class belongs.
In one embodiment, a respective dependent library, i.e., a proprietary library, is established for all components. And intercepting the registration class with the custom annotation through the Gradle, matching the registration class with different specified configuration rules, and adding the corresponding registration class into the dependency library of the corresponding component after matching. And when the terminal receives the starting instruction, the registration class is added into the corresponding routing library according to the dependency library to which the registration class belongs.
In the embodiment, the registration class is intercepted and added into the dependency library corresponding to the component, and the registration class is added into the routing library according to the starting instruction and the dependency library, so that unified management of the registration class is realized, manual adding one by one is not needed, and convenience is improved.
And S34, calling corresponding code files from the server to the components according to the registration classes in the routing libraries to form the target application.
This step is the same as the above embodiment, and the detailed analysis may refer to the above embodiment, and is not repeated herein to avoid repetition.
The code file for application development sets a corresponding compiling mode, so that 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 for developing an application is provided. Referring to fig. 5, the method for developing the application specifically includes the following steps:
and S41, obtaining the self-defined annotation of each code file from the server.
In one embodiment, the custom annotation of each code file is specifically a user's specification of the functions implemented by each code file and the path and category of each code file. The self-defined annotation made to each code file is only one and unique, and functions like a mark.
And S42, compiling the custom annotation to generate a registration class corresponding to the custom annotation.
And S43, 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.
And S44, calling corresponding code files from the server to the components according to the registration classes in the routing libraries, and compiling the components added with the code files according to the detected compiling mode to form the target application.
In this embodiment, the component may be compiled according to different compiling manners, so that the target application may run on different types of terminals. The compiling mode of the components in the embodiment of the present application is not limited.
In one embodiment, according to each registration class in each routing library, calling each corresponding code file from the server to each component to form the target application, includes:
and responding to the function calling request, searching the registration class matched with the function calling request from each routing library, and calling the corresponding code file from the server to the corresponding component according to the searched registration class for compiling to form an 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 an apparatus for developing an application, including:
and the obtaining module 101 is configured to obtain the custom annotation of each code file from the server.
And the compiling module 102 is used for compiling the custom annotation to generate a registration class corresponding to the custom annotation.
In one embodiment, the compiling module 102 is further configured to: and analyzing the custom annotation, generating a description class of the code file, acquiring path information and type information of the code file in the description class, and generating a registration class.
And the matching module 103 is configured to match the registration class with the configuration rule of the component, and add the registration class to the routing library corresponding to the component when matching is successful.
In one embodiment, the matching module 103 is further configured to: the registration class is matched with the configuration rules in the component and added to the dependency base formed by the component when the matching is successful.
And when an application starting instruction is received, 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 configured to call, according to each registration class in each routing library, each corresponding code file from the server to each component to form the target application.
In one embodiment, the invoking module 104 is further configured to: and acquiring an 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 invoking module 104 is further configured to: and according to each registration class in each routing library, calling each corresponding code file from the server to each component, and compiling each component added with the code file according to the detected compiling mode to form the target application.
In another embodiment, the invoking module 104 is further configured to: and responding to the function calling request, searching the registration class matched with the function calling request from each routing library, and calling the corresponding code file from the server to the corresponding component according to the searched registration class for compiling to form an executable program. The executable program is run.
In one embodiment, a computer apparatus is provided, as shown in fig. 7, which includes a processor, a memory, a network interface, an input device, and a display screen connected by a system bus. Wherein the memory includes a non-volatile 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 the processor, causes the processor to implement a development method of an application. The internal memory may also have stored therein a computer program that, when executed by the processor, causes the processor to perform a method of developing an application. Those skilled in the art will appreciate that the architecture shown in fig. 7 is merely a block diagram of some of the structures associated with the disclosed aspects and is not intended to limit the computing devices to which the disclosed aspects apply, as particular computing devices may include more or less components than those shown, or may combine certain components, or have a different arrangement of components.
In one embodiment, the apparatus for developing an application provided in the present application may be implemented in the form of a computer program, and the computer program may be run on a computer device as shown in fig. 7. The memory of the computer device may store therein the individual program modules constituting the development means of 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: memory, a processor and a computer program stored on the memory and executable on the processor, the processor executing the program when executing the steps of the method of developing the application. The steps of the development method applied here may be steps in the development methods of the applications of the respective embodiments described above.
In one embodiment, a computer-readable storage medium is provided, which stores computer-executable instructions for causing a computer to perform the steps of the method for developing an application described above. The steps of the development method applied here may be steps in the development methods of the applications of the respective embodiments described above.
The foregoing is a preferred embodiment of the present application, and it should be noted that, for those skilled in the art, various modifications and decorations can be made without departing from the principle of the present application, and these modifications and decorations are also regarded as the protection scope of the present application.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium, and when executed, can include the processes 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 (RAM), or the like.
Claims (10)
1. A method for developing an application, comprising:
obtaining the self-defined annotation of each code file from a server;
compiling the user-defined annotation to generate a registration class corresponding to the user-defined annotation;
matching the registration class with a configuration rule of a component, and adding the registration class to 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 target application.
2. The method for developing an application according to claim 1, wherein the compiling the custom annotation to generate the registration class corresponding to the custom annotation comprises:
and analyzing the custom annotation, generating a description class of the code file, acquiring the path information and the type information of the code file in the description class, and generating the registration class.
3. The method for developing an application according to claim 2, wherein said calling each corresponding code file from the server according to each registration class in each routing library includes:
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.
4. The method for developing an application according to claim 1, wherein the 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 matching is successful includes:
matching the registration class with configuration rules in the components, and adding the registration class to a dependency base formed by the components when matching is successful;
and when an application starting instruction is received, adding the registration class into a corresponding routing library according to the dependency library to which the registration class belongs.
5. The method according to claim 1, wherein the invoking, from the server, each corresponding code file into each component according to each registration class in each routing library to form a target application comprises:
and according to each registration class in each routing library, calling each corresponding code file from the server to each component, and compiling each component added with the code file according to the detected compiling mode to form the target application.
6. The method for developing an application according to claim 1 or 5, wherein the invoking, from the server, corresponding code files into the components to form a target application according to the registration classes in the routing libraries comprises:
responding to a function calling request, searching a registration class matched with the function calling request from each routing library, and calling the corresponding code file from the server to the corresponding component according to the searched registration class for compiling to form an executable program;
and running the executable program.
7. The method for developing an application according to claim 1, further comprising, before said matching the registry class with the configuration rule 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 the component is added.
8. An apparatus for developing an application, comprising:
the acquisition module is used for acquiring the custom annotation of each code file from the server;
the compiling module is used for compiling the user-defined annotation to generate a registration class corresponding to the user-defined annotation;
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;
and the calling module is used for calling each corresponding code file from the server to each component according to each registration class in each routing library to form a target application.
9. The apparatus for developing an application according to claim 8, wherein the matching module is specifically configured to:
matching the registration class with configuration rules in the components, and adding the registration class to a dependency base formed by the components when matching is successful;
and when an application starting instruction is received, adding the registration class into a corresponding routing library according to the dependency library to which the registration class belongs.
10. An electronic device, comprising: memory, processor and computer program stored on the memory and executable on the processor, characterized in that the processor implements a method for developing an application according to any of claims 1 to 7 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 true CN112199092A (en) | 2021-01-08 |
| CN112199092B 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) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112925562A (en) * | 2021-02-19 | 2021-06-08 | 京东方科技集团股份有限公司 | Application generation method and device based on android system 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 |
|---|
| STOFFE: "Annotation processor generated code", HTTPS://INTELLIJ-SUPPORT.JETBRAINS.COM/HC/EN-US/COMMUNITY/POSTS/206814065-ANNOTATION-PROCESSOR-GENERATED-CODE * |
| 已注销: "Android组件化专题 - 路由框架原理", HTTPS://JUEJIN.CN/POST/6844903743922634760 * |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112925562A (en) * | 2021-02-19 | 2021-06-08 | 京东方科技集团股份有限公司 | Application generation method and device based on android system and storage medium |
| WO2022174613A1 (en) * | 2021-02-19 | 2022-08-25 | 京东方科技集团股份有限公司 | Application generation method and device based on android system, and storage medium |
| CN112925562B (en) * | 2021-02-19 | 2024-09-17 | 京东方科技集团股份有限公司 | Android system-based application generation method, android system-based application generation device and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112199092B (en) | 2024-03-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109814854B (en) | Project framework generation method, device, computer equipment and storage medium | |
| US11200033B2 (en) | Application programming interface (API) based object oriented software development and textual analysis | |
| CN111124906A (en) | Tracking method, compiling method and device based on dynamic embedded points and electronic equipment | |
| US20130332449A1 (en) | Generating data processing code from a directed acyclic graph | |
| CN111414350A (en) | Service generation method and device | |
| CN112769706B (en) | Componentized routing method and system | |
| CN110990008B (en) | Page updating method and device, storage medium and electronic equipment | |
| CN114115904B (en) | Information processing method, device, server and storage medium | |
| CN104408118A (en) | Database establishing method and device | |
| CN112199092B (en) | Application development method and device and electronic equipment | |
| CN115809288A (en) | Data conversion method, device, equipment and storage medium | |
| CN111488286A (en) | Method and device for independently developing Android module | |
| CN113495723B (en) | Method, device and storage medium for calling functional component | |
| CN113468446B (en) | Method, system and equipment for supporting identification of third party two-dimensional code data | |
| CN114996758A (en) | Data desensitization method and device and electronic equipment | |
| CN113190236A (en) | HQL script checking method and device | |
| CN114253595A (en) | Code warehouse management method and device, computer equipment and storage medium | |
| CN112579275A (en) | Task execution method, device, equipment and storage medium | |
| CN112580038A (en) | Anti-virus data processing method, device and equipment | |
| CN111158695B (en) | Interface positioning method, device, computer equipment and storage medium | |
| CN114003317B (en) | Inline implementation method and device, electronic equipment, storage medium and program product | |
| CN113821750B (en) | Page data processing method and system, electronic equipment and readable storage medium | |
| CN116450682B (en) | Model generation method, device, equipment and medium based on data combination | |
| CN115357163A (en) | Interface skipping method and device, electronic equipment and computer readable storage medium | |
| CN115729826A (en) | Method and device for generating form verification rule, storage medium and electronic equipment |
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 |