CN110413336B - Development project starting method, device, server and storage medium - Google Patents
Development project starting method, device, server and storage medium Download PDFInfo
- Publication number
- CN110413336B CN110413336B CN201910528779.7A CN201910528779A CN110413336B CN 110413336 B CN110413336 B CN 110413336B CN 201910528779 A CN201910528779 A CN 201910528779A CN 110413336 B CN110413336 B CN 110413336B
- Authority
- CN
- China
- Prior art keywords
- shielded
- components
- files
- target module
- determining
- 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
- 238000011161 development Methods 0.000 title claims abstract description 85
- 238000000034 method Methods 0.000 title claims abstract description 57
- 230000000977 initiatory effect Effects 0.000 claims abstract description 23
- 238000004590 computer program Methods 0.000 claims description 14
- 230000006870 function Effects 0.000 description 32
- 230000002829 reductive effect Effects 0.000 description 25
- 235000010627 Phaseolus vulgaris Nutrition 0.000 description 22
- 244000046052 Phaseolus vulgaris Species 0.000 description 22
- 238000013507 mapping Methods 0.000 description 8
- 230000008569 process Effects 0.000 description 6
- 238000012546 transfer Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 5
- 230000000873 masking effect Effects 0.000 description 5
- 238000012217 deletion Methods 0.000 description 4
- 230000037430 deletion Effects 0.000 description 4
- 230000000670 limiting effect Effects 0.000 description 4
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 235000006719 Cassia obtusifolia Nutrition 0.000 description 2
- 235000014552 Cassia tora Nutrition 0.000 description 2
- 244000201986 Cassia tora Species 0.000 description 2
- 238000004422 calculation algorithm Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000005538 encapsulation Methods 0.000 description 2
- 238000003780 insertion Methods 0.000 description 2
- 230000037431 insertion Effects 0.000 description 2
- 230000002427 irreversible effect Effects 0.000 description 2
- 238000002955 isolation Methods 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 238000012544 monitoring process Methods 0.000 description 2
- 239000010453 quartz Substances 0.000 description 2
- 230000002441 reversible effect Effects 0.000 description 2
- VYPSYNLAJGMNEJ-UHFFFAOYSA-N silicon dioxide Inorganic materials O=[Si]=O VYPSYNLAJGMNEJ-UHFFFAOYSA-N 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- 238000003491 array Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44568—Immediately runnable code
- G06F9/44578—Preparing or optimising for loading
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
A development project initiation method, the method comprising: receiving a starting instruction aiming at a target module in a development project; determining files to be shielded and/or components to be shielded which are irrelevant to the target module; shielding the file to be shielded and/or the component to be shielded; determining related files and/or related components related to the target module according to the files and/or components to be shielded; and loading the related file and/or the related component to start the target module. The invention also provides a development project starting device, a server and a storage medium. The invention can reduce the starting time of the project and improve the development efficiency of the project.
Description
Technical Field
The present invention relates to the field of project development technologies, and in particular, to a method and apparatus for starting a development project, a server, and a storage medium.
Background
During the development of a project, a developer will typically be responsible for a certain module or function of the project. With the continuous development of the project, the project is bigger and bigger, and the modules or functions of the project are also bigger and bigger, so that the content loaded during the project starting is bigger and bigger, and the project starting speed is slower and slower.
In practice, it is found that a developer usually only needs to take a few seconds to modify a certain file of a module in charge of the developer, but the starting time of the whole project needs about 6 minutes, while for the developer, only care about the modification time of a certain module in charge of the developer, and not care about the starting time of the whole project, if the starting time of the whole project greatly exceeds the modification time of the module in charge of the developer, the time of the developer is wasted, and meanwhile, the efficiency of project development is reduced.
Disclosure of Invention
In view of the foregoing, it is desirable to provide a method, apparatus, server, and storage medium for starting a development project, which can reduce the starting time of the project and improve the development efficiency of the project.
A first aspect of the present invention provides a development project starting method, the method comprising:
receiving a starting instruction aiming at a target module in a development project;
determining files to be shielded and/or components to be shielded which are irrelevant to the target module;
shielding the file to be shielded and/or the component to be shielded;
determining related files and/or related components related to the target module according to the files and/or components to be shielded;
And loading the related file and/or the related component to start the target module.
In one possible implementation manner, after the shielding the file to be shielded and/or the component to be shielded, the method further includes:
acquiring the rest files and/or components;
judging whether the target module can be started by loading the residual files and/or components according to the dependency relationship between the residual files and/or components;
if the target module cannot be started by loading the rest files and/or components, determining files to be restored and/or components to be restored which need to be restored from the files to be shielded and/or components to be shielded;
restoring the file to be restored and/or the component to be restored;
the method comprises the steps that according to the files to be shielded and/or the components to be shielded, relevant files and/or relevant components relevant to the target module are determined to comprise;
and determining related files and/or related components related to the target module according to the files and/or components to be shielded and the files and/or components to be restored.
In one possible implementation manner, the determining the file to be shielded and/or the component to be shielded, which are not related to the target module, includes:
Acquiring a deployment descriptor file;
determining a server program irrelevant to the target module from the deployment descriptor file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the server program.
In one possible implementation manner, the determining the file to be shielded and/or the component to be shielded, which are not related to the target module, includes:
acquiring an enterprise-level Java component configuration description file;
determining all components unrelated to the target module from the enterprise-level Java component configuration description file;
determining a base component and a common component from all the components;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding all components except the base component and the common component.
In one possible implementation manner, the determining the file to be shielded and/or the component to be shielded, which are not related to the target module, includes:
acquiring a database operation statement configuration file;
determining a database operation statement irrelevant to the target module from the database operation statement configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
And shielding the database operation statement.
In one possible implementation manner, the determining the file to be shielded and/or the component to be shielded, which are not related to the target module, includes:
acquiring a configuration file related to a timer in the development project;
determining a timer unrelated to the target module from the configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
a timer independent of the target module is masked.
In one possible implementation manner, the determining the file to be shielded and/or the component to be shielded, which are not related to the target module, includes:
acquiring a route configuration file;
determining a binding address unrelated to the target module from the routing configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
the binding address is masked.
A second aspect of the present invention provides a development project initiation apparatus including:
the receiving module is used for receiving a starting instruction aiming at a target module in a development project;
the first determining module is used for determining files to be shielded and/or components to be shielded which are irrelevant to the target module;
The shielding module is used for shielding the file to be shielded and/or the component to be shielded;
the second determining module is used for determining related files and/or related components related to the target module according to the files and/or the components to be shielded;
and the loading module is used for loading the related files and/or the related components so as to start the target module.
A third aspect of the present invention provides a server comprising a processor and a memory, the processor being adapted to implement the development project initiation method when executing a computer program stored in the memory.
A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the development project initiation method.
By the technical scheme, the starting instruction aiming at the target module in the development project can be received; further, determining files to be shielded and/or components to be shielded which are irrelevant to the target module; further, shielding the file to be shielded and/or the component to be shielded; still further, according to the file to be shielded and/or the component to be shielded, determining related files and/or related components related to the target module; and loading files and/or components related to the target module to start the target module. Therefore, in the invention, before the target module in the development project is started, the content loaded during the project starting can be reduced by shielding the files to be shielded and/or the components to be shielded which are irrelevant to the target module, so that the starting time of the project can be reduced, and meanwhile, the development efficiency of the project is improved.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings that are required to be used in the embodiments or the description of the prior art will be briefly described below, and it is obvious that the drawings in the following description are only embodiments of the present invention, and that other drawings can be obtained according to the provided drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flow chart of a preferred embodiment of a development project initiation method of the present disclosure.
FIG. 2 is a functional block diagram of a preferred embodiment of a development project initiation apparatus according to the present invention.
FIG. 3 is a schematic diagram of a server for implementing a development project initiation method according to a preferred embodiment of the present invention.
Detailed Description
In order that the above-recited objects, features and advantages of the present invention will be more clearly understood, a more particular description of the invention will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. It should be noted that, without conflict, the embodiments of the present invention and features in the embodiments may be combined with each other.
The following description of the embodiments of the present invention will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. The terminology used herein in the description of the invention is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention.
In order that the above-recited objects, features and advantages of the present invention will become more readily apparent, a more particular description of the invention will be rendered by reference to the appended drawings and appended detailed description.
The development project starting method of the embodiment of the invention is applied to a server, and can also be applied to a hardware environment formed by the server and electronic equipment connected with the server through a network, and the method is executed by the server and the electronic equipment together. Networks include, but are not limited to: a wide area network, a metropolitan area network, or a local area network.
A server may refer to a computer system that provides services to other devices (e.g., electronic devices) in a network. If a personal computer can provide file transfer protocol (File Transfer Protocol, FTP) service to the outside, the server can also be called. In a narrow sense, a server is dedicated to some high-performance computers, and can provide services to the outside through a network, and compared with a common personal computer, the server has higher requirements on stability, security, performance and the like, so that the server is different from the common personal computer in terms of hardware such as a CPU, a chipset, a memory, a disk system, a network and the like.
Referring to fig. 1, fig. 1 is a flowchart of a development project starting method according to a preferred embodiment of the present invention. The sequence of steps in the flowchart may be changed and some steps may be omitted according to different needs.
S11, the server receives a starting instruction aiming at a target module in the development project.
In the development process of the project, the project is often split into different modules according to functions, so that different developers can develop the modules respectively responsible for the different modules at the same time, and the development efficiency of the project is improved.
In this specification, a module, also called a component, refers to a collection of program statements (i.e., a collection of program code and data structures) that can be named individually and that perform a function independently. It has two basic features: external features and internal features.
The external features refer to interfaces (namely, the mode of calling the module by other modules or programs, including input and output parameters and referenced global variables) and functions of the module, wherein the interfaces are connected with the external environment by the module; internal features refer to features that the internal environment of a module has (i.e., the module's local data and program code).
The target module may be understood as a certain module in a development project that a certain developer needs to be responsible for.
S12, the server determines files to be shielded and/or components to be shielded which are irrelevant to the target module.
Typically, an item contains a number of modules, and when a module needs to be started, not all files and/or components need to be loaded.
The files and/or components to be shielded refer to files and/or components irrelevant to the target module, and in order to accelerate the starting time of the module, the files and/or components irrelevant to the target module need to be shielded.
The Component (Component) is a simple package of data and methods, is a reusable part in a program, and is generally packaged in the process of software development, and after the package, the reusable part can be directly called without re-writing the code.
Optionally, the determining the file to be shielded and/or the component to be shielded which are irrelevant to the target module includes:
acquiring a deployment descriptor file;
determining a server program irrelevant to the target module from the deployment descriptor file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the server program.
The deployment descriptor file refers to a web xml file, and is used for configuring information to be loaded when a web (network) project is started.
The server-side program Servlet (Server Applet) is called a Servlet or a service connector, and is written by Java, and has a main function of interactively browsing and modifying data to generate dynamic web content.
Specifically, the deployment descriptor file specifies the existence of the server program and binds specific classes and access paths.
Among them, class (Class) is the basis for Object-oriented programming (OOP, object-Oriented Programming) to implement information encapsulation. A class is a user-defined type, also known as class type. Each class contains a data description and a set of functions that operate on data or transfer messages. An instance of a class is called an object.
In this alternative embodiment, a deployment descriptor file may be obtained first, after a server-side program unrelated to the target module is determined from the deployment descriptor file, the server-side program may be masked, and only the program related to the target module in the deployment descriptor file is left, so that the content loaded when the target module is started may be reduced, so as to reduce the starting time.
Optionally, the determining the file to be shielded and/or the component to be shielded which are irrelevant to the target module includes:
Acquiring an enterprise-level Java component configuration description file;
determining all components unrelated to the target module from the enterprise-level Java component configuration description file;
determining a base component and a common component from all the components;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding all components except the base component and the common component.
Wherein the enterprise-level Java component is EJB (Enterprise JavaBean), and the EJB is a component model of a J2EE (Java 2 Platform, enterprise Edition) server, and the EJB includes a session Bean (Session Bean), an entity Bean (Entity Bean), and a message driver Bean (Message Driven Bean). J2EE is a Java platform designed for large enterprise host-level computing types.
Wherein session beans are used in J2EE applications to complete some server-side business operations, such as accessing databases, invoking other EJB components; entity beans are domain model objects for implementing O/R mapping (object/relation mapping) responsible for mapping records in a database into entity objects; the message driven Bean is a new enterprise Bean introduced in EJB2.0, in effect an asynchronous stateless session Bean, and the client does not need to wait after invoking the message driven Bean and returns immediately.
Wherein the base component includes, but is not limited to: system class, run time class, date class, math class, random class, etc.
Wherein, the public components refer to auxiliary components which are accumulated by developers in daily life, well packaged, independent in function and commonly used, and the scope of the public components can include but is not limited to: collection class (including synchronization, ordering, etc.), device auxiliary class (including sound, photo collection, clipboard, computer hardware information, keyboard, mouse, etc.), encryption class (including Base64, md5 (Message-Digest Algorithm), SHA1 (Secure Hash Algorithm1 ), reversible and irreversible encryption, etc.), and thread class, etc. The common components can help developers save a lot of development time. Wherein Base64 is a method of representing binary data based on 64 printable characters; md5 is a widely used cryptographic hash function that generates a 128 bit (16 byte) hash value to ensure that the information transfer is complete and consistent; SHA1 is a cryptographic hash function that always treats a message as a bit string.
In this alternative embodiment, an enterprise-level Java component configuration profile may be obtained first, and after all components unrelated to the target module are determined from the enterprise-level Java component configuration profile, a base component and a common component are determined from all components, and further, components of all components except the base component and the common component are shielded, so that component content loaded when the target module is started can be reduced, and starting time is reduced.
Optionally, the determining the file to be shielded and/or the component to be shielded which are irrelevant to the target module includes:
acquiring a database operation statement configuration file;
determining a database operation statement irrelevant to the target module from the database operation statement configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the database operation statement.
The database operation statement is called SQL for short and is used for accessing data, inquiring, updating and managing a relational database system; and is also an extension of the database script file.
Specifically, in the development process, the database operation sentences required by the development project are usually packaged, and the specified database operation sentences can be called only by providing specific parameters without repeatedly writing the database operation sentences. However, for a module, there are many times when there is no need to perform excessive operations on the database, for example, a search function is implemented by a module, and only query operations on the database, such as other database operation sentences, are not used, for example, insertion, deletion, update, etc. These unused database operation statements do not need to be loaded, but rather can be masked, and the masking does not have any impact on the target module. Therefore, in this alternative embodiment, a database operation sentence configuration file may be acquired first, after the database operation sentence irrelevant to the target module is determined from the database operation sentence configuration file, the database operation sentence irrelevant to the target module may be masked, and only the database operation sentence relevant to the target module in the database operation sentence configuration file is reserved, so that the content of the database operation sentence loaded when the target module is started may be reduced, so as to reduce the starting time.
Optionally, the determining the file to be shielded and/or the component to be shielded which are irrelevant to the target module includes:
acquiring a configuration file related to a timer in the development project;
determining a timer unrelated to the target module from the configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
a timer independent of the target module is masked.
Specifically, the timer is a function of setting a preset time value and then executing a preset program code after the preset time value or at intervals of the preset time value.
For example, when the user logs in successfully, a timer is triggered, the timer is used for monitoring the non-operation duration of the user on a certain page, and when the non-operation duration of the user on the page exceeds a time value preset by the timer, the login state of the user is logged out. At this time, the user needs to perform a login operation again.
Specifically, there are mainly two kinds of timers in Java development: timer and quantiz Timer.
The Timer is a Timer tool provided in JDK (Java Development Kit ), and when in use, a single thread is started outside the main thread to execute a specified scheduled task, which can be specified to be executed once or repeatedly. Quartz is an open source job scheduling framework written entirely in Java, providing a simple yet powerful mechanism for job scheduling in Java applications.
In this alternative embodiment, the configuration file related to the timer in the development project may be acquired first, the timer unrelated to the target module may be masked after the timer unrelated to the target module is determined from the configuration file, and only the timer related to the target module in the configuration file is left, so that the content of the timer loaded when the target module is started may be reduced, so as to reduce the starting time.
Optionally, the determining the file to be shielded and/or the component to be shielded which are irrelevant to the target module includes:
acquiring a route configuration file;
determining a binding address unrelated to the target module from the routing configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
the binding address is masked.
Where the routing refers to mapping addresses (URLs) to specific methods in specific classes of Java, or to specific JSP (Java Server Pages, java service page) files. Wherein, JSP is to insert Java program segments (script) and JSP tags (tags) into a conventional web page HTML (HyperText Markup Language ) file (HTML), so as to form a JSP file, and the suffix name is (.jsp).
Wherein the binding address refers to an address mapped to a specific method in a specific class. Different addresses may bundle different functions of different modules.
Specifically, other modules than the target module that are address bound do not need to be loaded. Therefore, in this alternative embodiment, the routing configuration file may be acquired first, after the binding address irrelevant to the target module is determined from the routing configuration file, the binding address may be masked, and by masking the binding address, a method of calling other modules with address binding may be avoided, so that loading of contents of other modules when the target module is started may be avoided, loading of contents when the target module is started may be reduced, and starting time may be reduced.
S13, the server shields the files to be shielded and/or the components to be shielded.
Wherein, the shielding way includes but is not limited to: deletion, annotation, and quarantine. The annotation refers to annotating the code of the component to be shielded, and the annotated code is not compiled by a compiler; the isolation refers to moving the file to be shielded to a directory which cannot be scanned by the development project, so as to ensure that the file cannot be loaded by the target module.
S14, according to the files to be shielded and/or the components to be shielded, the server determines related files and/or related components related to the target module.
Specifically, the files to be shielded and/or the components to be shielded are removed from all files and/or components, and the remaining files and/or components are related files and/or related components related to the target module.
As an alternative embodiment, after step S13, the method further includes:
acquiring the rest files and/or components;
judging whether the target module can be started by loading the residual files and/or components according to the dependency relationship between the residual files and/or components;
if the target module cannot be started by loading the rest files and/or components, determining files to be restored and/or components to be restored which need to be restored from the files to be shielded and/or components to be shielded;
restoring the file to be restored and/or the component to be restored;
step S14, according to the files to be shielded and/or the components to be shielded, determining that related files and/or related components related to the target module comprise;
and determining related files and/or related components related to the target module according to the files and/or components to be shielded and the files and/or components to be restored.
In particular, there may be some kind of dependency between files, components and between components. For example, in Java development, if a first class invokes a method and/or data of a second class, the first class may have a dependency on the second class, and if the second class is masked, the first class may be in error in operation. Therefore, further judgment is made on the remaining files and/or components according to the dependency relationship between the remaining files and/or components.
The files and/or components to be restored refer to files and/or components with a dependency relationship with the files and/or components related to the target module in the files and/or components to be shielded. There may be methods and/or data etc. in the files and/or components to be restored that need to be called by the files and/or components related to the target module.
In this alternative embodiment, a remaining file and/or component may be obtained, then, according to a dependency relationship between the remaining file and/or component, it is determined whether loading the remaining file and/or component can start the target module, if loading the remaining file and/or component cannot start the target module, a file and/or component to be restored, which needs to be restored, is determined from the files and/or components to be shielded that are shielded, and finally, the file and/or components to be restored are restored. The remaining files and/or components and the files to be restored and/or components to be restored together are related files and/or related components related to the target module. The files and/or components to be restored, i.e. the files and/or components associated with the target module, are necessary at the time of the boot-up load.
S15, the server loads the relevant files and/or the relevant components so as to start the target module.
Specifically, the files and/or components loaded when the target module is started are filtered, that is, files and/or components irrelevant to the target module are not required to be loaded when the target module is started, and only files and/or components relevant to the target module are required to be loaded, so that the content loaded when the target module is started is reduced.
In the method flow described in FIG. 1, a launch instruction for a target module in a development project may be received; further, determining files to be shielded and/or components to be shielded which are irrelevant to the target module; further, shielding the file to be shielded and/or the component to be shielded; still further, according to the file to be shielded and/or the component to be shielded, determining related files and/or related components related to the target module; and loading files and/or components related to the target module to start the target module. Therefore, in the invention, before the target module in the development project is started, the content loaded during the project starting can be reduced by shielding the files to be shielded and/or the components to be shielded which are irrelevant to the target module, so that the starting time of the project can be reduced, and meanwhile, the development efficiency of the project is improved.
While the invention has been described with reference to specific embodiments, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention.
Referring to fig. 2, fig. 2 is a functional block diagram of a development project initiation apparatus according to a preferred embodiment of the present invention.
In some embodiments, the development project initiation apparatus is run in a server. The development project initiation means may comprise a plurality of functional modules consisting of program code segments. Program code for each of the program segments in the development project initiation apparatus may be stored in a memory and executed by at least one processor to perform some or all of the steps in the development project initiation method described in fig. 1.
In this embodiment, the development project initiation apparatus may be divided into a plurality of functional modules according to the functions performed by the development project initiation apparatus. The functional module may include: the device comprises a receiving module 201, a first determining module 202, a shielding module 203, a second determining module 204 and a loading module 205. The module referred to in the present invention refers to a series of computer program segments capable of being executed by at least one processor and of performing a fixed function, stored in a memory. In some embodiments, the function of each module will be described in detail in the following embodiments.
A receiving module 201, configured to receive a start instruction for a target module in a development project;
in the development process of the project, the project is often split into different modules according to functions, so that different developers can develop the modules respectively responsible for the different modules at the same time, and the development efficiency of the project is improved.
In this specification, a module, also called a component, refers to a collection of program statements (i.e., a collection of program code and data structures) that can be named individually and that perform a function independently. It has two basic features: external features and internal features.
The external features refer to interfaces (namely, the mode of calling the module by other modules or programs, including input and output parameters and referenced global variables) and functions of the module, wherein the interfaces are connected with the external environment by the module; internal features refer to features that the internal environment of a module has (i.e., the module's local data and program code).
The target module may be understood as a certain module in a development project that a certain developer needs to be responsible for.
A first determining module 202, configured to determine a file to be shielded and/or a component to be shielded, which are not related to the target module;
typically, an item contains a number of modules, and when a module needs to be started, not all files and/or components need to be loaded.
The files and/or components to be shielded refer to files and/or components irrelevant to the target module, and in order to accelerate the starting time of the module, the files and/or components irrelevant to the target module need to be shielded.
The Component (Component) is a simple package of data and methods, is a reusable part in a program, and is generally packaged in the process of software development, and after the package, the reusable part can be directly called without re-writing the code.
A shielding module 203, configured to shield the file to be shielded and/or the component to be shielded;
wherein, the shielding way includes but is not limited to: deletion, annotation, and quarantine. The annotation refers to annotating the code of the component to be shielded, and the annotated code is not compiled by a compiler; the isolation refers to moving the file to be shielded to a directory which cannot be scanned by the development project, so as to ensure that the file cannot be loaded by the target module.
A second determining module 204, configured to determine, according to the file to be masked and/or the component to be masked, a related file and/or a related component related to the target module;
Specifically, the files to be shielded and/or the components to be shielded are removed from all files and/or components, and the remaining files and/or components are related files and/or related components related to the target module.
And if the residual files and/or components are loaded and cannot start the target module, recovering the files and/or components to be recovered from the files and/or components to be recovered, wherein the residual files and/or components and the files and/or components to be recovered are related files and/or related components related to the target module.
And the loading module 205 is configured to load the related file and/or the related component to start the target module.
Specifically, the files and/or components loaded when the target module is started are filtered, that is, files and/or components irrelevant to the target module are not required to be loaded when the target module is started, and only files and/or components relevant to the target module are required to be loaded, so that the content loaded when the target module is started is reduced.
As an optional embodiment, the development project starting apparatus further includes:
An obtaining module, configured to obtain remaining files and/or components after the shielding module 203 shields the files and/or components to be shielded;
the judging module is used for judging whether the target module can be started by loading the residual files and/or components according to the dependency relationship among the residual files and/or components;
the third determining module is used for determining a file to be restored and/or a component to be restored, which need to be restored, from the files to be shielded and/or the components to be shielded which are shielded if the target module cannot be started by loading the rest files and/or the components;
the recovery module is used for recovering the file to be recovered and/or the component to be recovered;
the second determining module 204 determines, according to the file to be masked and/or the component to be masked, a related file and/or a related component related to the target module, including:
and determining related files and/or related components related to the target module according to the files and/or components to be shielded and the files and/or components to be restored.
In particular, there may be some kind of dependency between files, components and between components. For example, in Java development, if a first class invokes a method and/or data of a second class, the first class may have a dependency on the second class, and if the second class is masked, the first class may be in error in operation. Therefore, further judgment is made on the remaining files and/or components according to the dependency relationship between the remaining files and/or components.
The files and/or components to be restored refer to files and/or components with a dependency relationship with the files and/or components related to the target module in the files and/or components to be shielded. There may be methods and/or data etc. in the files and/or components to be restored that need to be called by the files and/or components related to the target module.
In this alternative embodiment, a remaining file and/or component may be obtained, then, according to a dependency relationship between the remaining file and/or component, it is determined whether loading the remaining file and/or component can start the target module, if loading the remaining file and/or component cannot start the target module, a file and/or component to be restored, which needs to be restored, is determined from the files and/or components to be shielded to be restored, and finally, the file and/or component to be restored, which is to be restored, is restored, that is, the file and/or component to be restored related to the target module, is essential when loading is started.
As an alternative embodiment, the first determining module 202 includes:
The first acquisition sub-module is used for acquiring the deployment descriptor file;
a first determining sub-module, configured to determine a server program unrelated to the target module from the deployment descriptor file;
the shielding module 203 specifically shields the file to be shielded and/or the component to be shielded by:
and shielding the server program.
The deployment descriptor file refers to a web xml file, and is used for configuring information to be loaded when a web (network) project is started.
The server-side program Servlet (Server Applet) is called a Servlet or a service connector, and is written by Java, and has a main function of interactively browsing and modifying data to generate dynamic web content.
Specifically, the deployment descriptor file specifies the existence of the server program and binds specific classes and access paths.
Among them, class (Class) is the basis for Object-oriented programming (OOP, object-Oriented Programming) to implement information encapsulation. A class is a user-defined type, also known as class type. Each class contains a data description and a set of functions that operate on data or transfer messages. An instance of a class is called an object.
In this alternative embodiment, a deployment descriptor file may be obtained first, after a server-side program unrelated to the target module is determined from the deployment descriptor file, the server-side program may be masked, and only the program related to the target module in the deployment descriptor file is left, so that the content loaded when the target module is started may be reduced, so as to reduce the starting time.
As an alternative embodiment, the first determining module 202 includes:
the second acquisition submodule is used for acquiring the enterprise-level Java component configuration description file;
a second determination submodule for determining all components irrelevant to the target module from the enterprise-level Java component configuration description file;
the second determining sub-module is further used for determining a basic component and a public component from all the components;
the shielding module 203 specifically shields the file to be shielded and/or the component to be shielded by:
and shielding all components except the base component and the common component.
Wherein the enterprise-level Java component is EJB (Enterprise JavaBean), and the EJB is a component model of a J2EE (Java 2 Platform, enterprise Edition) server, and the EJB includes a session Bean (Session Bean), an entity Bean (Entity Bean), and a message driver Bean (Message Driven Bean). J2EE is a Java platform designed for large enterprise host-level computing types.
Wherein session beans are used in J2EE applications to complete some server-side business operations, such as accessing databases, invoking other EJB components; entity beans are domain model objects for implementing O/R mapping (object/relation mapping) responsible for mapping records in a database into entity objects; the message driven Bean is a new enterprise Bean introduced in EJB2.0, in effect an asynchronous stateless session Bean, and the client does not need to wait after invoking the message driven Bean and returns immediately.
Wherein the base component includes, but is not limited to: system class, run time class, date class, math class, random class, etc.
Wherein, the public components refer to auxiliary components which are accumulated by developers in daily life, well packaged, independent in function and commonly used, and the scope of the public components can include but is not limited to: collection class (including synchronization, ordering, etc.), device auxiliary class (including sound, photo collection, clipboard, computer hardware information, keyboard, mouse, etc.), encryption class (including Base64, md5 (Message-Digest Algorithm), SHA1 (Secure Hash Algorithm1 ), reversible and irreversible encryption, etc.), and thread class, etc. The common components can help developers save a lot of development time. Wherein Base64 is a method of representing binary data based on 64 printable characters; md5 is a widely used cryptographic hash function that generates a 128 bit (16 byte) hash value to ensure that the information transfer is complete and consistent; SHA1 is a cryptographic hash function that always treats a message as a bit string.
In this alternative embodiment, an enterprise-level Java component configuration profile may be obtained first, and after all components unrelated to the target module are determined from the enterprise-level Java component configuration profile, a base component and a common component are determined from all components, and further, components of all components except the base component and the common component are shielded, so that component content loaded when the target module is started can be reduced, and starting time is reduced.
As an alternative embodiment, the first determining module 202 includes:
the third acquisition sub-module is used for acquiring the database operation statement configuration file;
a third determining sub-module for determining a database operation statement unrelated to the target module from the database operation statement configuration file;
the shielding module 203 specifically shields the file to be shielded and/or the component to be shielded by:
and shielding the database operation statement.
The database operation statement is called SQL for short and is used for accessing data, inquiring, updating and managing a relational database system; and is also an extension of the database script file.
Specifically, in the development process, the database operation sentences required by the development project are usually packaged, and the specified database operation sentences can be called only by providing specific parameters without repeatedly writing the database operation sentences. However, for a module, there are many times when there is no need to perform excessive operations on the database, for example, a search function is implemented by a module, and only query operations on the database, such as other database operation sentences, are not used, for example, insertion, deletion, update, etc. These unused database operation statements do not need to be loaded, but rather can be masked, and the masking does not have any impact on the target module. Therefore, in this alternative embodiment, a database operation sentence configuration file may be acquired first, after the database operation sentence irrelevant to the target module is determined from the database operation sentence configuration file, the database operation sentence irrelevant to the target module may be masked, and only the database operation sentence relevant to the target module in the database operation sentence configuration file is reserved, so that the content of the database operation sentence loaded when the target module is started may be reduced, so as to reduce the starting time.
As an alternative embodiment, the first determining module 202 includes:
a fourth obtaining sub-module, configured to obtain a configuration file related to the timer in the development project;
a fourth determining sub-module for determining a timer independent of the target module from the configuration file;
the shielding module 203 specifically shields the file to be shielded and/or the component to be shielded by:
a timer independent of the target module is masked.
Specifically, the timer is a function of setting a preset time value and then executing a preset program code after the preset time value or at intervals of the preset time value.
For example, when the user logs in successfully, a timer is triggered, the timer is used for monitoring the non-operation duration of the user on a certain page, and when the non-operation duration of the user on the page exceeds a time value preset by the timer, the login state of the user is logged out. At this time, the user needs to perform a login operation again.
Specifically, there are mainly two kinds of timers in Java development: timer and quantiz Timer.
The Timer is a Timer tool provided in JDK (Java Development Kit ), and when in use, a single thread is started outside the main thread to execute a specified scheduled task, which can be specified to be executed once or repeatedly. Quartz is an open source job scheduling framework written entirely in Java, providing a simple yet powerful mechanism for job scheduling in Java applications.
In this alternative embodiment, the configuration file related to the timer in the development project may be acquired first, the timer unrelated to the target module may be masked after the timer unrelated to the target module is determined from the configuration file, and only the timer related to the target module in the configuration file is left, so that the content of the timer loaded when the target module is started may be reduced, so as to reduce the starting time.
As an alternative embodiment, the first determining module 202 includes:
a fifth obtaining sub-module, configured to obtain a routing configuration file;
a fifth determining sub-module for determining a binding address independent of the target module from the routing configuration file;
the shielding module 203 specifically shields the file to be shielded and/or the component to be shielded by:
the binding address is masked.
Where the routing refers to mapping addresses (URLs) to specific methods in specific classes of Java, or to specific JSP (Java Server Pages, java service page) files. Wherein, JSP is to insert Java program segments (script) and JSP tags (tags) into a conventional web page HTML (HyperText Markup Language ) file (HTML), so as to form a JSP file, and the suffix name is (.jsp).
Wherein the binding address refers to an address mapped to a specific method in a specific class. Different addresses may bundle different functions of different modules.
Specifically, other modules than the target module that are address bound do not need to be loaded. Therefore, in this alternative embodiment, the routing configuration file may be acquired first, after the binding address irrelevant to the target module is determined from the routing configuration file, the binding address may be masked, and by masking the binding address, a method of calling other modules with address binding may be avoided, so that loading of contents of other modules when the target module is started may be avoided, loading of contents when the target module is started may be reduced, and starting time may be reduced.
In the development project initiation apparatus described in fig. 2, an initiation instruction for a target module in a development project may be received; further, determining files to be shielded and/or components to be shielded which are irrelevant to the target module; further, shielding the file to be shielded and/or the component to be shielded; still further, according to the file to be shielded and/or the component to be shielded, determining related files and/or related components related to the target module; and loading files and/or components related to the target module to start the target module. Therefore, in the invention, before the target module in the development project is started, the content loaded during the project starting can be reduced by shielding the files to be shielded and/or the components to be shielded which are irrelevant to the target module, so that the starting time of the project can be reduced, and meanwhile, the development efficiency of the project is improved.
Fig. 3 is a schematic structural diagram of a server according to a preferred embodiment of the present invention for implementing a development project starting method. The server 3 comprises a memory 31, at least one processor 32, a computer program 33 stored in the memory 31 and executable on the at least one processor 32, and at least one communication bus 34.
It will be appreciated by those skilled in the art that the schematic diagram shown in fig. 3 is merely an example of the server 3 and is not limiting of the server 3, and may include more or less components than illustrated, or may combine certain components, or different components, e.g. the server 3 may also include input and output devices, network access devices, etc.
The at least one processor 32 may be a central processing unit (Central Processing Unit, CPU), but may also be other general purpose processors, digital signal processors (Digital Signal Processor, DSP), application specific integrated circuits (Application Specific Integrated Circuit, ASIC), off-the-shelf programmable gate arrays (Field-Programmable Gate Array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, or the like. The processor 32 may be a microprocessor or the processor 32 may be any conventional processor or the like, the processor 32 being a control center of the server 3, the various interfaces and lines being used to connect the various parts of the entire server 3.
The memory 31 may be used to store the computer program 33 and/or modules/units, and the processor 32 may implement the various functions of the server 3 by running or executing the computer program and/or modules/units stored in the memory 31 and invoking data stored in the memory 31. The memory 31 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 (such as a sound playing function, an image playing function, etc.) required for at least one function, and the like; the storage data area may store data (such as audio data, phonebook, etc.) created according to the use of the server 3, and the like. In addition, the memory 31 may include a high-speed random access memory, and may also include a nonvolatile memory such as a hard disk, a memory, a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash Card (Flash Card), at least one disk storage device, a Flash memory device, or other volatile solid-state storage device.
In connection with fig. 1, the memory 31 in the server 3 stores a plurality of instructions to implement a development project initiation method, the processor 32 being executable to implement:
Receiving a starting instruction aiming at a target module in a development project;
determining files to be shielded and/or components to be shielded which are irrelevant to the target module;
shielding the file to be shielded and/or the component to be shielded;
determining related files and/or related components related to the target module according to the files and/or components to be shielded;
and loading the related file and/or the related component to start the target module.
In an alternative embodiment, after the masking of the file to be masked and/or the component to be masked, the processor 32 may execute the plurality of instructions to implement:
acquiring the rest files and/or components;
judging whether the target module can be started by loading the residual files and/or components according to the dependency relationship between the residual files and/or components;
if the target module cannot be started by loading the rest files and/or components, determining files to be restored and/or components to be restored which need to be restored from the files to be shielded and/or components to be shielded;
restoring the file to be restored and/or the component to be restored;
the method comprises the steps that according to the files to be shielded and/or the components to be shielded, relevant files and/or relevant components relevant to the target module are determined to comprise;
And determining related files and/or related components related to the target module according to the files and/or components to be shielded and the files and/or components to be restored.
In an alternative embodiment, the determining the file to be shielded and/or the component to be shielded, which are independent of the target module, includes:
acquiring a deployment descriptor file;
determining a server program irrelevant to the target module from the deployment descriptor file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the server program.
In an alternative embodiment, the determining the file to be shielded and/or the component to be shielded, which are independent of the target module, includes:
acquiring an enterprise-level Java component configuration description file;
determining all components unrelated to the target module from the enterprise-level Java component configuration description file;
determining a base component and a common component from all the components;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding all components except the base component and the common component.
In an alternative embodiment, the determining the file to be shielded and/or the component to be shielded, which are independent of the target module, includes:
Acquiring a database operation statement configuration file;
determining a database operation statement irrelevant to the target module from the database operation statement configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the database operation statement.
In an alternative embodiment, the determining the file to be shielded and/or the component to be shielded, which are independent of the target module, includes:
acquiring a configuration file related to a timer in the development project;
determining a timer unrelated to the target module from the configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
a timer independent of the target module is masked.
In an alternative embodiment, the determining the file to be shielded and/or the component to be shielded, which are independent of the target module, includes:
acquiring a route configuration file;
determining a binding address unrelated to the target module from the routing configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
the binding address is masked.
Specifically, the specific implementation method of the above instructions by the processor 32 may refer to the description of the relevant steps in the corresponding embodiment of fig. 1, which is not repeated herein.
In the server 3 depicted in fig. 3, a start instruction for a target module in a development project may be received; further, determining files to be shielded and/or components to be shielded which are irrelevant to the target module; further, shielding the file to be shielded and/or the component to be shielded; still further, according to the file to be shielded and/or the component to be shielded, determining related files and/or related components related to the target module; and loading files and/or components related to the target module to start the target module. Therefore, in the invention, before the target module in the development project is started, the content loaded during the project starting can be reduced by shielding the files to be shielded and/or the components to be shielded which are irrelevant to the target module, so that the starting time of the project can be reduced, and meanwhile, the development efficiency of the project is improved.
The modules/units integrated by the server 3 may be stored in a computer readable storage medium if implemented in the form of software functional units and sold or used as separate products. Based on such understanding, the present invention may implement all or part of the flow of the method of the above embodiment, or may be implemented by a computer program to instruct related hardware, where the computer program may be stored in a computer readable storage medium, and when the computer program is executed by a processor, the computer program may implement the steps of each of the method embodiments described above. Wherein the computer program comprises computer program code which may be in source code form, object code form, executable file or some intermediate form etc. The computer readable medium may include: any entity or device capable of carrying the computer program code, a recording medium, a U disk, a removable hard disk, a magnetic disk, an optical disk, a computer Memory, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), an electrical carrier signal, a telecommunications signal, a software distribution medium, and so forth. It should be noted that the computer readable medium contains content that can be appropriately scaled according to the requirements of jurisdictions in which such content is subject to legislation and patent practice, such as in certain jurisdictions in which such content is subject to legislation and patent practice, the computer readable medium does not include electrical carrier signals and telecommunication signals.
In the several embodiments provided in the present invention, it should be understood that the disclosed systems, devices, and methods may be implemented in other manners. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the modules is merely a logical function division, and there may be other manners of division when actually implemented.
The modules described as separate components may or may not be physically separate, and components shown as modules may or may not be physical units, may be located in one place, or may be distributed over multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of this embodiment.
In addition, each functional module in the embodiments of the present invention may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units can be realized in a form of hardware or a form of hardware and a form of software functional modules.
It will be evident to those skilled in the art that the invention is not limited to the details of the foregoing illustrative embodiments, and that the present invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. The present embodiments are, therefore, to be considered in all respects as illustrative and not restrictive, the scope of the invention being indicated by the appended claims rather than by the foregoing description, and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein. Any reference signs in the claims shall not be construed as limiting the claim concerned. Furthermore, it is evident that the word "comprising" does not exclude other elements or steps, and that the singular does not exclude a plurality. A plurality of units or means recited in the system claims can also be implemented by means of software or hardware by means of one unit or means. The terms second, etc. are used to denote a name, but not any particular order.
Finally, it should be noted that the above-mentioned embodiments are merely for illustrating the technical solution of the present invention and not for limiting the same, and although the present invention has been described in detail with reference to the preferred embodiments, it should be understood by those skilled in the art that modifications and equivalents may be made to the technical solution of the present invention without departing from the spirit and scope of the technical solution of the present invention.
Claims (9)
1. A method of initiating a development project, the method comprising:
receiving a starting instruction aiming at a target module in a development project;
determining files to be shielded and/or components to be shielded which are irrelevant to the target module;
shielding the file to be shielded and/or the component to be shielded, wherein the shielding mode comprises the following steps: delete, annotate, and isolate;
acquiring the rest files and/or components; judging whether the target module can be started by loading the residual files and/or components according to the dependency relationship between the residual files and/or components; if the target module cannot be started by loading the rest files and/or components, determining files to be restored and/or components to be restored which need to be restored from the files to be shielded and/or components to be shielded; restoring the file to be restored and/or the component to be restored;
Determining related files and/or related components related to the target module according to the files and/or components to be shielded, including: determining related files and/or related components related to the target module according to the files and/or components to be shielded and the files and/or components to be restored;
and loading the related file and/or the related component to start the target module.
2. The method of claim 1, wherein the determining files and/or components to be shielded that are independent of the target module comprises:
acquiring a deployment descriptor file;
determining a server program irrelevant to the target module from the deployment descriptor file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the server program.
3. The method of claim 1, wherein the determining files and/or components to be shielded that are independent of the target module comprises:
acquiring an enterprise-level Java component configuration description file;
determining all components unrelated to the target module from the enterprise-level Java component configuration description file;
Determining a base component and a common component from all the components;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding all components except the base component and the common component.
4. The method of claim 1, wherein the determining files and/or components to be shielded that are independent of the target module comprises:
acquiring a database operation statement configuration file;
determining a database operation statement irrelevant to the target module from the database operation statement configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
and shielding the database operation statement.
5. The method of claim 1, wherein the determining files and/or components to be shielded that are independent of the target module comprises:
acquiring a configuration file related to a timer in the development project;
determining a timer unrelated to the target module from the configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
a timer independent of the target module is masked.
6. The method of claim 1, wherein the determining files and/or components to be shielded that are independent of the target module comprises:
Acquiring a route configuration file;
determining a binding address unrelated to the target module from the routing configuration file;
the shielding of the files to be shielded and/or the components to be shielded comprises:
the binding address is masked.
7. A development project initiation apparatus, characterized in that the apparatus comprises a module implementing the development project initiation method according to any one of claims 1 to 6, the development project initiation apparatus comprising:
the receiving module is used for receiving a starting instruction aiming at a target module in a development project;
the first determining module is used for determining files to be shielded and/or components to be shielded which are irrelevant to the target module;
the shielding module is used for shielding the file to be shielded and/or the component to be shielded, wherein the shielding mode comprises the following steps: delete, annotate, and isolate;
the second determining module is configured to determine, according to the file to be masked and/or the component to be masked, a related file and/or a related component related to the target module, and includes: determining related files and/or related components related to the target module according to the files and/or components to be shielded and the files and/or components to be restored;
And the loading module is used for loading the related files and/or the related components so as to start the target module.
8. A server comprising a processor and a memory, the processor being configured to execute a computer program stored in the memory to implement the development project initiation method of any one of claims 1 to 6.
9. A computer readable storage medium storing at least one instruction which when executed by a processor implements the development project initiation method of any one of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910528779.7A CN110413336B (en) | 2019-06-18 | 2019-06-18 | Development project starting method, device, server and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910528779.7A CN110413336B (en) | 2019-06-18 | 2019-06-18 | Development project starting method, device, server and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110413336A CN110413336A (en) | 2019-11-05 |
| CN110413336B true CN110413336B (en) | 2024-03-15 |
Family
ID=68359265
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910528779.7A Active CN110413336B (en) | 2019-06-18 | 2019-06-18 | Development project starting method, device, server and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110413336B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114675899A (en) * | 2021-05-24 | 2022-06-28 | 腾讯云计算（北京）有限责任公司 | Application starting method, device, equipment and storage medium |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101625647A (en) * | 2009-08-06 | 2010-01-13 | 青岛海信电器股份有限公司 | Method for accelerating starting speed of embedded software system |
| US8930940B2 (en) * | 2011-08-19 | 2015-01-06 | Yongyong Xu | Online software execution platform |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8302072B2 (en) * | 2000-06-05 | 2012-10-30 | National Instruments Corporation | System and method for programmatically generating a graphical program based on a sequence of motion control, machine vision, and data acquisition (DAQ) operations |
-
2019
- 2019-06-18 CN CN201910528779.7A patent/CN110413336B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101625647A (en) * | 2009-08-06 | 2010-01-13 | 青岛海信电器股份有限公司 | Method for accelerating starting speed of embedded software system |
| US8930940B2 (en) * | 2011-08-19 | 2015-01-06 | Yongyong Xu | Online software execution platform |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110413336A (en) | 2019-11-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US20070067418A1 (en) | Object oriented web application framework | |
| US8887150B2 (en) | Methods for dynamic mobile application behavior modification subject to a behavior policy | |
| US20050262499A1 (en) | System and method for external override of annotations | |
| CN110187902B (en) | Project transformation method, device, equipment and storage medium based on spring boot | |
| CN113419817B (en) | Front-end application nesting method, device, equipment and storage medium | |
| CN113938321B (en) | Extensible operation and maintenance management system, method, electronic equipment and readable storage medium | |
| WO2008034234A1 (en) | File indexing framework and symbolic name maintenance framework | |
| CN109828759B (en) | Code compiling method, device, computer device and storage medium | |
| CN110413336B (en) | Development project starting method, device, server and storage medium | |
| CN112416612A (en) | Service calling method and device, computer equipment and readable storage medium | |
| CN109739487B (en) | Business logic processing method and device and computer readable storage medium | |
| CN112114871A (en) | Code sharing method, device, server, terminal and medium | |
| CN117008920A (en) | Engine system, request processing method and device, computer equipment and storage medium | |
| US11182508B1 (en) | Enhanced version retention systems and methods | |
| CN110941443A (en) | Method and device for modifying file name in SDK and electronic equipment | |
| CN107643892B (en) | Interface processing method, device, storage medium and processor | |
| US10802810B2 (en) | Consuming persistent library bundles | |
| US11017032B1 (en) | Document recovery utilizing serialized data | |
| CN113760481A (en) | Distributed timed task scheduling system and method | |
| EP4018305A1 (en) | Methods and apparatuses for providing a function as a service platform | |
| US20110004889A1 (en) | Dynamic Distributed Evaluator | |
| CN114780073A (en) | Generation method and device of programming language class library, electronic equipment and storage medium | |
| CN117520019B (en) | Component communication method and device | |
| CN113886428A (en) | Business method based dynamic SQL generation method and device | |
| CN116360824A (en) | Hot update method of application program, terminal device 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 |