CN117311799B - Configuration method of software project page - Google Patents
Configuration method of software project page Download PDFInfo
- Publication number
- CN117311799B CN117311799B CN202311621937.6A CN202311621937A CN117311799B CN 117311799 B CN117311799 B CN 117311799B CN 202311621937 A CN202311621937 A CN 202311621937A CN 117311799 B CN117311799 B CN 117311799B
- Authority
- CN
- China
- Prior art keywords
- configuration
- page
- software project
- annotation
- component
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 84
- 238000009877 rendering Methods 0.000 claims abstract description 26
- 230000008859 change Effects 0.000 claims abstract description 6
- 230000008569 process Effects 0.000 claims description 24
- 230000004044 response Effects 0.000 claims description 6
- 238000004590 computer program Methods 0.000 description 9
- 238000010586 diagram Methods 0.000 description 4
- 230000006399 behavior Effects 0.000 description 3
- 238000013461 design Methods 0.000 description 3
- 238000011161 development Methods 0.000 description 3
- 230000006870 function Effects 0.000 description 3
- 238000007726 management method Methods 0.000 description 3
- XVOCEQLNJQGCQG-UNAVROQCSA-N (2s)-2-[[(2s)-2-[[(2s)-1-[(2s)-6-amino-2-[[(2s)-1-[(2s)-2-amino-5-(diaminomethylideneamino)pentanoyl]pyrrolidine-2-carbonyl]amino]hexanoyl]pyrrolidine-2-carbonyl]amino]-3-phenylpropanoyl]amino]-n-[(2s)-1-[[(2s)-1-[[(2s)-1-[[(2s)-1-[[(2s)-1-amino-4-methyl- Chemical compound C([C@@H](C(=O)N[C@@H](CC=1C2=CC=CC=C2NC=1)C(=O)N[C@@H](CC(C)C)C(=O)N[C@@H](CC(C)C)C(N)=O)NC(=O)[C@H](CC=1C2=CC=CC=C2NC=1)NC(=O)[C@H](CCC(N)=O)NC(=O)[C@H](CC=1C=CC=CC=1)NC(=O)[C@H]1N(CCC1)C(=O)[C@H](CCCCN)NC(=O)[C@H]1N(CCC1)C(=O)[C@@H](N)CCCN=C(N)N)C1=CC=CC=C1 XVOCEQLNJQGCQG-UNAVROQCSA-N 0.000 description 2
- 238000010276 construction Methods 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 230000000903 blocking effect Effects 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 239000003607 modifier Substances 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 238000012797 qualification Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 230000002194 synthesizing effect Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- 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/38—Creation or generation of source code for implementing user interfaces
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Human Computer Interaction (AREA)
- Stored Programmes (AREA)
Abstract
The application provides a configuration method of a software project page, which is characterized in that abstract classes are fetched and scanned to obtain subclasses of the abstract classes; reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters; generating a configuration file of the software project page according to the configuration item parameters; and rendering the configuration file to a configuration page of the software project page, and generating the software project page. The configuration method of the software project page simplifies the configuration steps and parameter definition setting of the software project page, can dynamically change the attribute in the system, realizes zero codes of the system configuration page, and improves user experience.
Description
Technical Field
The application relates to the technical field of software programming, in particular to a configuration method of a software project page.
Background
With the advent of the internet big data age, the business demands have changed faster and faster, the scale and complexity of application systems have been continuously increased, and the demands of users for obtaining convenient, high-quality and diversified services have been increasing. Accordingly, programmers often are involved in the task of configuring a wide variety of different software project pages during the course of work.
In the course of conception and implementation of the present application, the applicant has found at least the following problems: some existing software project pages are complicated in configuration steps, parameter definition and setting are complex, so that a user cannot dynamically change the attribute in the system, the requirement of the system for configuring the page zero code cannot be met, and the user experience is poor.
Disclosure of Invention
In order to alleviate the above problems, the present application provides a method for configuring a software project page, including:
invoking and scanning an abstract class to obtain a subclass of the abstract class;
reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters;
generating a configuration file of the software project page according to the configuration item parameters;
and rendering the configuration file to a configuration page of the software project page, and generating the software project page.
Optionally, the step of retrieving and scanning the abstract class, and acquiring the subclass of the abstract class includes, before:
defining component annotations, wherein the component annotations are configured corresponding to the project components of the software project surface;
based on the component annotations, abstract classes are defined, and the abstract classes are configured corresponding to classes storing system configuration attributes.
Optionally, in the process of defining the component annotation, the component annotation is configured in one-to-one correspondence with the item component of the software item plane.
Optionally, in the process of defining the component annotation, the attribute of the item component of the software item page is abstracted to the attribute of the annotation.
Optionally, the abstract class is fetched and scanned, and the abstract class is scanned according to a preset path in the process of obtaining the subclass of the abstract class.
Optionally, before the step of scanning the abstract class according to the preset path, the preset path is set through a preset configuration item in a configuration file.
Optionally, in the process of reading the annotation of the field attribute annotation of the subclass, reading the annotation of the field attribute annotation of the subclass by using a reflection reading mode.
Optionally, the annotation comprises an annotation type and an annotation attribute; and in the process of reading the notes marked by the field attributes of the subclasses and configuring the corresponding configuration item parameters, the configuration item parameters are respectively and correspondingly configured according to the note types and the note attributes.
Optionally, the step of rendering the configuration file to a configuration page of the software project page, and generating the software project page includes:
and generating a configuration file according to the description of the annotation in response to receiving a request for the configuration file of the page to be rendered, wherein the configuration file is used for indicating the component type, the position layout of the component and the display size of the component of the configuration page.
Optionally, the step of rendering the configuration file to the configuration page of the software project page, after generating the software project page, includes:
and updating and storing the configuration item parameters in response to the change of the configuration item parameters.
As described above, the configuration method of the software project page provided by the application acquires the subclass of the abstract class by calling and scanning the abstract class; reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters; generating a configuration file of the software project page according to the configuration item parameters; rendering the configuration file to a configuration page of the software project page to generate the software project page; the software project page configuration steps and parameter definition setting are simplified, and the user experience is improved.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the application and together with the description, serve to explain the principles of the application. In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the description of the embodiments will be briefly described below, and it will be obvious to those skilled in the art that other drawings can be obtained from these drawings without inventive effort.
Fig. 1 is a flowchart of a configuration method of a software project page according to an embodiment of the present application.
Fig. 2 is a schematic flow chart of a java generation configuration file according to an embodiment of the present application.
Fig. 3 is a schematic diagram of a configuration page rendering flow according to an embodiment of the present application.
Fig. 4 is a schematic diagram of a process for implementing software project page configuration by using an intelligent terminal according to an embodiment of the present application.
The realization, functional characteristics and advantages of the present application will be further described with reference to the embodiments, referring to the attached drawings. Specific embodiments thereof have been shown by way of example in the drawings and will herein be described in more detail. These drawings and the written description are not intended to limit the scope of the inventive concepts in any way, but to illustrate the concepts of the present application to those skilled in the art by reference to specific embodiments.
Detailed Description
Reference will now be made in detail to exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, the same numbers in different drawings refer to the same or similar elements, unless otherwise indicated. The implementations described in the following exemplary examples are not representative of all implementations consistent with the present application. Rather, they are merely examples of apparatus and methods consistent with some aspects of the present application as detailed in the accompanying claims.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, the element defined by the phrase "comprising one … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element, and furthermore, elements having the same name in different embodiments of the present application may have the same meaning or may have different meanings, a particular meaning of which is to be determined by its interpretation in this particular embodiment or by further combining the context of this particular embodiment.
It should be noted that, in this document, step numbers such as S10 and S20 are adopted, and the purpose of the present invention is to more clearly and briefly describe the corresponding content, and not to constitute a substantial limitation on the sequence, and those skilled in the art may execute S20 first and then execute S10 when implementing the present invention, which is within the scope of protection of the present application.
It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the present application.
The following provides a detailed description of what is presented in connection with the various figures.
First embodiment
Fig. 1 is a flowchart of a configuration method of a software project page according to an embodiment of the present application.
As shown in fig. 1, in an embodiment, a method for configuring a software project page includes:
s10: and invoking and scanning the abstract class to acquire the subclass of the abstract class.
The object-oriented software is the basis of a modern software design mode, and the object-oriented software development mode is reasonably utilized, so that the expandability and reusability of codes can be enhanced, the development efficiency can be improved, and the maintenance cost can be reduced. Illustratively, in object-oriented software development, classes have inheritance relationships. In the integrated relationship, if a class a inherits another class B, we call a subclass of B. Inheritance is the ability of a child to inherit the characteristics and behavior of a parent class, such that the child has the same behavior and data structure as the parent class. Inheritance may be in the form of single inheritance or multiple inheritance. Alternatively, in a software development of the Java language, when one class does not explicitly use two integrated keywords (extensions\entities), then the inherited Obiect class may be defaulted.
S20: and reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters.
Illustratively, the Annotation (Annomination), which may be a special "Annotation" placed before the class, method, field, parameter of Java source code, is a tag, label. The annotated content is often ignored directly by the compiler, can be packaged into class files by the compiler, and performs the corresponding processing. Alternatively, each functional method may be individually packaged into a functional component by way of notes or labels for the code blocks of the respective associated modules.
Illustratively, many components may be used in the page presentation, e.g., some input components such as AInput (for simple input), AButton (for drawing a button), assuming the front-end project developed using AntD. And each of its components may be annotated with a corresponding annotation in the design annotation.
S30: and generating a configuration file of the software project page according to the configuration item parameters.
In the Java development process, it is often necessary to use configuration files to save some configuration information, such as database connection information, log configuration, etc.
Fig. 2 is a schematic flow chart of a java generation configuration file according to an embodiment of the present application.
Referring to FIG. 2, for example, a Properties object may be created for holding configuration items. Properties class is a class in Java for operating configuration files, inherits from the Hashtable class, and can save key value pairs into files. Second, a setProperty method may be used to add a configuration item to the configuration file, where a key of a first parameter corresponding to the configuration item may be used and a value of a second parameter corresponding to the configuration item may be used. Finally, the configuration items may be written to the file using a store method, wherein an output stream (such as a file output stream or other output stream) and a string may be used for specifying annotation information for the configuration file.
S40: and rendering the configuration file to a configuration page of the software project page, and generating the software project page.
Optionally, after receiving the configuration file, the rendering thread generates a rendering task and transfers the rendering task to the message queue of the rendering main thread. Under the action of an event circulation mechanism, the rendering main thread takes out the rendering task in the message queue, and starts the rendering flow.
Fig. 3 is a schematic diagram of a configuration page rendering flow according to an embodiment of the present application.
Taking HTML page rendering as an example, as shown in fig. 3, the whole rendering flow is illustratively divided into a plurality of sub-phases, respectively: HTML parsing, style computation, layout, layering, drawing, blocking, rasterizing, and synthesizing a picture. Each stage has definite input and output, and the output of the previous stage becomes the input of the next stage, so that the whole rendering process is formed, and the display of the final page is realized.
According to the configuration method of the software project page, abstract classes are fetched and scanned to obtain subclasses of the abstract classes; reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters; generating a configuration file of the software project page according to the configuration item parameters; rendering the configuration file to a configuration page of the software project page to generate the software project page; the software project page configuration steps and parameter definition settings are simplified, the attribute in the system can be dynamically changed, and the user experience is improved.
Optionally, the step of retrieving and scanning the abstract class, and acquiring the subclass of the abstract class includes, before:
defining component annotations, wherein the component annotations are configured corresponding to the project components of the software project surface;
based on the component annotations, abstract classes are defined, and the abstract classes are configured corresponding to classes storing system configuration attributes.
Illustratively, a user may create a dynamic configuration item and inherit the abstract class of Abstract ConfigItem. In this embodiment, this is taken as an example to describe that the abstract class of the abstract is a configuration item, and in other embodiments, the abstract class inherited herein may be another abstract class, which is not limited in this application. When the project runs, the specified components are used for accepting the content of the configuration item according to the notes on the created configuration item class, and finally, the configuration page is generated. Annotations provide a secure annotation-like mechanism for associating any information or metadata (metadata) with program elements (classes, method member variables, etc.). The elements (class, method, member variables) of the program are given more visual and clear descriptions, the description information is irrelevant to the business logic of the program and is used by a specified tool or framework, and the notes are applied to declarative sentences of packages, types, construction methods, member variables, parameters and local variables like a modifier.
Illustratively, java annotations are meta-information attached to code, and are used for analyzing and using tools in compiling and running, so that the java annotations serve as description and configuration functions. The annotation does not and cannot affect the actual logic of the code, only plays an auxiliary role. Alternatively, annotations may be used to generate documents, track dependencies of code, perform format checks on the compilation process, and so forth.
Illustratively, @ Component is a generic annotation that is used to correspondingly mark a Component in a class Spring. The class labeled @ Component will be automatically scanned and added to the Spring's container through which an instance of the Component can be obtained. Component has three derivative notes: the @ Controller, @ Service, and @ restore, which are used to mark the Controller, business layer, and data access layer components, respectively. These annotations act as @ components and can better distinguish the types of components.
Illustratively, the generic class is a well-established functional class, and can directly generate instantiation objects, and the generic class can contain contents such as a construction method, a generic method, a static method, constants, variables and the like. And abstract class refers to adding components of abstract methods inside the structure of common class. Alternatively, the class having the abstract method is an abstract class, and the abstract class is declared by using an abstract keyword. Alternatively, the abstract method may be public or protected, default to public. Alternatively, abstract classes have subclasses, and one subclass can inherit one abstract class using extensions inheritance. The subclass may overwrite all abstract methods among abstract classes (if the subclass does not implement the abstract method of the parent class, then the subclass must also be defined as an abstract class).
An interface is illustratively a special abstract class. An interface is a declaration of a series of methods, is a collection of method features, and an interface has only the features of a method without implementation of a method, so that the methods can be implemented by different classes in different places, and the implementations can have different behaviors (functions).
Optionally, in the process of defining the component annotation, the component annotation is configured in one-to-one correspondence with the item component of the software item plane.
Illustratively, many components may be used in the page presentation, e.g., some input components such as AInput (for simple input), AButton (for drawing a button), assuming the front-end project developed using AntD. And each component can be annotated in a one-to-one correspondence in the design annotation; and the configurations may also be in a one-to-one correspondence, e.g., the AButton component may have size attributes that control its size, then there may also be size attributes in the annotation.
Optionally, in the process of defining the component annotation, the attribute of the item component of the software item page is abstracted to the attribute of the annotation.
For example, after the front-end component is abstracted into the annotation in the system, in order to configure the specific style of the front-end component, the attribute of the front-end component may be abstracted, for example, the AButton component has the size attribute which can control the size of the front-end component, and then the size attribute is correspondingly provided in the annotation. For example: the Input primary key (Input has an attribute of an inputtable length-length, whether encryption-password) may define an annotation (@ Input (length, password)).
Optionally, the abstract class is fetched and scanned, and the abstract class is scanned according to a preset path in the process of obtaining the subclass of the abstract class.
Optionally, in the setting of the project structure, the preset path may perform the scanning task according to all codes under the address of the path of the scanned file, so as to avoid performing full-project scanning and further reducing the performance index. In scanning the code, it may be monitored whether component annotations of the design are available in the code. Illustratively, an abstract class (Abstract ConfigItem) of a class is defined for storing system configuration attributes, and the system at startup scans for subclasses of the Abstract ConfigItem abstract class under a specified path. And using the notes marked by the attribute of each field of the reflection reading subclass, and generating a configuration item page configuration file according to the notes.
Optionally, before the step of scanning the abstract class according to the preset path, the preset path is set through a preset configuration item in a configuration file.
The preset scan path belongs to a static configuration, and may be specified before a specific development work starts, or may be specified by a specific developer, or may be specified by a configuration item' tip.
Optionally, in the process of reading the annotation of the field attribute annotation of the subclass, reading the annotation of the field attribute annotation of the subclass by using a reflection reading mode.
Illustratively, the Annotation essence is a special interface inheriting the animation, and its concrete implementation class is a dynamic proxy class generated by Java runtime. And we get the annotation by reflection, returned is the dynamic proxy object SProxy1 generated by Java runtime. Invoking the method of custom annotation (interface) through proxy object will eventually invoke the invoke method of AnnotationlnvocationHandler. The method will season out the corresponding value from the Map of memberValues. And the source of memberValues is the Java constant pool. Alternatively, java may read the definition of a class by its full name of the class (i.e., package name + filename), and may read the notes on a specific object instance and its configured properties.
Optionally, the annotation includes an annotation type and an annotation attribute. And in the process of reading the notes marked by the field attributes of the subclasses and configuring the corresponding configuration item parameters, the configuration item parameters are respectively and correspondingly configured according to the note types and the note attributes.
Illustratively, the annotation types refer to one and the same annotation, and as described above, the software item has a plurality of components (AInput, AButton, etc.) at the present end, and a corresponding number of annotations at the corresponding backend. The properties of the AInput notes of the back end of the software item may be consistent with the properties of the front end AInput component. The software item currently determines how to display the component by the component attribute, for example, the size attribute determines the size of the component.
Optionally, the step of rendering the configuration file to a configuration page of the software project page, and generating the software project page includes:
and generating a configuration file according to the description of the annotation in response to receiving a request for the configuration file of the page to be rendered, wherein the configuration file is used for indicating the component type, the position layout of the component and the display size of the component of the configuration page.
For example, the software item current end may request a configuration file of a page to be rendered, and the management back end of the software item may generate the configuration file according to the description of the annotation and send the configuration file to the front end. The configuration file content will describe the type of component, the name of the page, and information such as the location layout of the component, the size of the component, etc.
Optionally, the step of rendering the configuration file to the configuration page of the software project page, after generating the software project page, includes:
and updating and storing the configuration item parameters in response to the change of the configuration item parameters.
As described above, the configuration method of the software project page provided by the application acquires the subclass of the abstract class by calling and scanning the abstract class; reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters; generating a configuration file of the software project page according to the configuration item parameters; rendering the configuration file to a configuration page of the software project page to generate the software project page; the software project page configuration steps and parameter definition settings are simplified, the attribute in the system can be dynamically changed, the zero code of the system configuration page is realized, and the user experience is improved.
Illustratively, a user may configure the configuration item at system runtime, persisting the configuration item content. For example: the relevant qualifications of the applet may require attributes of applet appId, applet key appscreen, which are received through a normal input component and a password input component, respectively, both are noted with annotation @ AInput, and @ AInput of appscreen needs to be configured as a pattern of password — @ AInput (password=true). After the configuration is completed, the system runs, and the specifically used user can see the rendered 2 AInput components on the page where the WeChat applet is configured to qualify, and fill in the applet's appId and the applet's key appScreen. After which the user clicks on save, the system will persist the configuration in the database. The content of the configuration item is cached in the running process, so that the efficiency of reading the configuration item by the system can be optimized.
Second embodiment
The application also provides an intelligent terminal, which comprises a processor and a memory;
the memory stores a computer program which, when executed by the processor, implements the steps of the configuration method of the software project page as described above.
Fig. 4 is a schematic diagram of a process for implementing software project page configuration by using an intelligent terminal according to an embodiment of the present application.
As shown in fig. 4, in an embodiment, the intelligent terminal implements the steps of the configuration method of the software project page by the following procedures:
1. and defining annotations corresponding to the user interface components one by one when configuring the system attributes, and abstracting the attributes of the components of the user interface into the attributes of the annotations. For example, entering a primary key (Input, which has the property of: length-whether encrypted-password) may define an annotation as (@ Input (password)).
2. An abstract class (abstract ConfigItem) of a class for storing system configuration attributes is defined, and a subclass of the abstract class of the abstract ConfigItem under a specified path is scanned at system start-up. And using the notes marked by the attribute of each field of the reflection reading subclass, and generating a configuration item page configuration file according to the notes.
3. The client reads the configuration item page configuration file and renders the configuration item page configuration file into a system attribute configuration page.
The embodiment provides a scheme for quickly generating a management system user interface according to service code configuration items and matching with notes, and can automatically generate a management system attribute configuration page according to the note types in the software codes and the attributes on the notes. According to the system service requirement, the user can dynamically change the attribute in the system, and the requirement of the system configuration page zero code is realized.
Third embodiment
The present application also provides a storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the configuration method of a software project page as described above.
As described above, the configuration method of the software project page provided by the application acquires the subclass of the abstract class by calling and scanning the abstract class; reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters; generating a configuration file of the software project page according to the configuration item parameters; rendering the configuration file to a configuration page of the software project page to generate the software project page; the software project page configuration steps and parameter definition settings are simplified, the attribute in the system can be dynamically changed, and the user experience is improved.
The embodiments of the intelligent terminal and the storage medium provided in the present application may include all technical features of any one of the embodiments of the interaction method, and the expansion and explanation contents of the description are substantially the same as those of each embodiment of the method, which are not repeated herein.
The present embodiments also provide a computer program product comprising computer program code which, when run on a computer, causes the computer to perform the method in the various possible implementations as above.
The embodiments also provide a chip including a memory for storing a computer program and a processor for calling and running the computer program from the memory, so that a device on which the chip is mounted performs the method in the above possible embodiments.
It can be understood that the above scenario is merely an example, and does not constitute a limitation on the application scenario of the technical solution provided in the embodiments of the present application, and the technical solution of the present application may also be applied to other scenarios. For example, as one of ordinary skill in the art can know, with the evolution of the system architecture and the appearance of new service scenarios, the technical solutions provided in the embodiments of the present application are equally applicable to similar technical problems.
The foregoing embodiment numbers of the present application are merely for describing, and do not represent advantages or disadvantages of the embodiments.
The steps in the method of the embodiment of the application can be sequentially adjusted, combined and deleted according to actual needs.
The units in the device of the embodiment of the application can be combined, divided and pruned according to actual needs.
In this application, the same or similar term concept, technical solution, and/or application scenario description will generally be described in detail only when first appearing, and when repeated later, for brevity, will not generally be repeated, and when understanding the content of the technical solution of the present application, etc., reference may be made to the previous related detailed description thereof for the same or similar term concept, technical solution, and/or application scenario description, etc., which are not described in detail later.
In this application, the descriptions of the embodiments are focused on, and the details or descriptions of one embodiment may be found in the related descriptions of other embodiments.
The technical features of the technical solutions of the present application may be arbitrarily combined, and for brevity of description, all possible combinations of the technical features in the above embodiments are not described, however, as long as there is no contradiction between the combinations of the technical features, they should be considered as the scope of the present application.
From the above description of the embodiments, it will be clear to those skilled in the art that the above-described embodiment method may be implemented by means of software plus a necessary general hardware platform, but of course may also be implemented by means of hardware, but in many cases the former is a preferred embodiment. Based on such understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art in the form of a software product stored in a storage medium (e.g. ROM/RAM, magnetic disk, optical disk) as above, including several instructions for causing a terminal device (which may be a mobile phone, a computer, a server, a controlled terminal, or a network device, etc.) to perform the method of each embodiment of the present application.
In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions in accordance with embodiments of the present application are produced in whole or in part. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable devices. The computer instructions may be stored in a storage medium or transmitted from one storage medium to another storage medium, for example, from one website, computer, server, or data center to another website, computer, server, or data center by a wired (e.g., coaxial cable, fiber optic, digital subscriber line), or wireless (e.g., infrared, wireless, microwave, etc.) means. The storage media may be any available media that can be accessed by a computer or a data storage device such as a server, data center, or the like that contains an integration of one or more available media. Usable media may be magnetic media (e.g., floppy disks, storage disks, magnetic tape), optical media (e.g., DVD), or semiconductor media (e.g., solid State Disk (SSD)), among others.
The foregoing description is only of the preferred embodiments of the present application, and is not intended to limit the scope of the claims, and all equivalent structures or equivalent processes using the descriptions and drawings of the present application, or direct or indirect application in other related technical fields are included in the scope of the claims of the present application.
Claims (9)
1. A method for configuring a software project page, comprising:
invoking and scanning an abstract class to obtain a subclass of the abstract class;
reading the notes of the field attribute labels of the subclasses, and configuring corresponding configuration item parameters;
generating a configuration file of the software project page according to the configuration item parameters;
rendering the configuration file to a configuration page of the software project page to generate the software project page;
in the process of reading the annotation of the field attribute label of the subclass, reading the annotation of the field attribute label of the subclass by using a reflection reading mode;
when the annotation is acquired through reflection, a dynamic proxy object SProxy1 generated during Java running is returned;
and calling a method of custom annotation through the proxy object to call an invoke method of AnnotationnvocationHandler, and acquiring a corresponding value from memberValues, wherein the source of the memberValues is a Java constant pool.
2. The method according to claim 1, wherein the step of retrieving and scanning abstract classes and obtaining subclasses of the abstract classes comprises, before:
defining component annotations, wherein the component annotations are configured corresponding to the project components of the software project surface;
based on the component annotations, abstract classes are defined, and the abstract classes are configured corresponding to classes storing system configuration attributes.
3. A method of configuring a software project page according to claim 2, wherein in the defining of component annotations, the component annotations are configured in a one-to-one correspondence with project components of a software project plane.
4. A method of configuring a software project page according to claim 2, wherein in the defining of the component annotations, the properties of the project components of the software project page are abstracted to the annotated properties.
5. The method for configuring a software project page according to claim 1, wherein the abstract class is fetched and scanned, and the abstract class is scanned according to a preset path in the process of obtaining the subclass of the abstract class.
6. The method according to claim 5, wherein the step of scanning the abstract class according to a preset path is preceded by setting the preset path by a preset configuration item in a configuration file.
7. The method of claim 1, wherein the annotation comprises an annotation type and an annotation attribute; and in the process of reading the notes marked by the field attributes of the subclasses and configuring the corresponding configuration item parameters, the configuration item parameters are respectively and correspondingly configured according to the note types and the note attributes.
8. The method of any of claims 1-7, wherein the step of rendering the configuration file to the configuration page of the software project page, generating the software project page comprises:
and generating a configuration file according to the description of the annotation in response to receiving a request for the configuration file of the page to be rendered, wherein the configuration file is used for indicating the component type, the position layout of the component and the display size of the component of the configuration page.
9. A method of configuring a software project page according to any one of claims 1 to 7, wherein the step of rendering the configuration file to the configuration page of the software project page, after which the step of generating the software project page comprises:
and updating and storing the configuration item parameters in response to the change of the configuration item parameters.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311621937.6A CN117311799B (en) | 2023-11-30 | 2023-11-30 | Configuration method of software project page |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311621937.6A CN117311799B (en) | 2023-11-30 | 2023-11-30 | Configuration method of software project page |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117311799A CN117311799A (en) | 2023-12-29 |
| CN117311799B true CN117311799B (en) | 2024-03-19 |
Family
ID=89281577
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311621937.6A Active CN117311799B (en) | 2023-11-30 | 2023-11-30 | Configuration method of software project page |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117311799B (en) |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108846087A (en) * | 2018-06-12 | 2018-11-20 | 恒生电子股份有限公司 | A kind of page rendering method, apparatus, terminal and server |
| WO2020233090A1 (en) * | 2019-05-21 | 2020-11-26 | 深圳壹账通智能科技有限公司 | Application configuration method, apparatus and device based on h5 page, and storage medium |
| CN113485702A (en) * | 2021-06-21 | 2021-10-08 | 上海百秋电子商务有限公司 | Method, device and equipment for configurationally generating front-end page and storage medium |
| CN114489830A (en) * | 2021-12-23 | 2022-05-13 | 阿里巴巴（中国）有限公司 | Configuration page operation method, processing method and computing device |
| CN115268908A (en) * | 2022-07-21 | 2022-11-01 | 中国平安财产保险股份有限公司 | Method, device, equipment and storage medium for self-defining configuration page |
| CN115562753A (en) * | 2022-10-11 | 2023-01-03 | 上海哔哩哔哩科技有限公司 | Data processing method and device |
| CN116028047A (en) * | 2023-02-16 | 2023-04-28 | 浪潮软件科技有限公司 | Page rapid generation method based on custom annotation |
| CN116541105A (en) * | 2023-07-06 | 2023-08-04 | 智慧眼科技股份有限公司 | Annotation-based component loading method, system, terminal and storage medium |
-
2023
- 2023-11-30 CN CN202311621937.6A patent/CN117311799B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108846087A (en) * | 2018-06-12 | 2018-11-20 | 恒生电子股份有限公司 | A kind of page rendering method, apparatus, terminal and server |
| WO2020233090A1 (en) * | 2019-05-21 | 2020-11-26 | 深圳壹账通智能科技有限公司 | Application configuration method, apparatus and device based on h5 page, and storage medium |
| CN113485702A (en) * | 2021-06-21 | 2021-10-08 | 上海百秋电子商务有限公司 | Method, device and equipment for configurationally generating front-end page and storage medium |
| CN114489830A (en) * | 2021-12-23 | 2022-05-13 | 阿里巴巴（中国）有限公司 | Configuration page operation method, processing method and computing device |
| CN115268908A (en) * | 2022-07-21 | 2022-11-01 | 中国平安财产保险股份有限公司 | Method, device, equipment and storage medium for self-defining configuration page |
| CN115562753A (en) * | 2022-10-11 | 2023-01-03 | 上海哔哩哔哩科技有限公司 | Data processing method and device |
| CN116028047A (en) * | 2023-02-16 | 2023-04-28 | 浪潮软件科技有限公司 | Page rapid generation method based on custom annotation |
| CN116541105A (en) * | 2023-07-06 | 2023-08-04 | 智慧眼科技股份有限公司 | Annotation-based component loading method, system, terminal and storage medium |
Non-Patent Citations (4)
| Title |
|---|
| REMAP: Remote mEmory Manager for disAggregated Platforms;Dimitris Theodoropoulos ICS / FORTH, Greece Etc.;2018 IEEE 29th International Conference on Application-specific Systems, Architectures and Processors (ASAP);20180826;全文 * |
| 基于Axure 软件平台的教学课件制作;刘飞;中小学电教;20150720;全文 * |
| 基于Spring与Hibernate的Web应用开发研究;李晓静;魏振钢;;软件导刊(05);全文 * |
| 基于配置文件的web页面自动生成系统;尹航 等;SOFTWARE;20141225;第35卷(第10期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117311799A (en) | 2023-12-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110162296B (en) | Method and device for generating application programming interface document and terminal equipment | |
| CN106980504B (en) | Application program development method and tool and equipment thereof | |
| US5953524A (en) | Development system with methods for runtime binding of user-defined classes | |
| US7779429B2 (en) | Method and machine-readable medium for building distributed software | |
| US7849437B2 (en) | Object oriented web application framework | |
| CN112748908B (en) | Method and device for developing Restful service based on SSM framework | |
| CN110007920B (en) | Method and device for acquiring code dependency relationship and electronic equipment | |
| Zakrzewski | Towards verification of Ethereum smart contracts: a formalization of core of Solidity | |
| US20130339841A1 (en) | Systems and methods of a script generation engine | |
| US6948120B1 (en) | Computer-implemented system and method for hosting design-time controls | |
| US10572278B2 (en) | Smart controls for user interface design and implementation | |
| WO2024045382A1 (en) | Implementation of reflective mechanism in blockchain | |
| CN110321504B (en) | Page processing method and device | |
| US7418659B2 (en) | System and method for declaring a resource within a markup document | |
| CN115328458B (en) | Business application development method and device | |
| CN117311799B (en) | Configuration method of software project page | |
| CN113342399B (en) | Method and device for configuring structure of application program and readable storage medium | |
| Ali | Advanced IOS 4 Programming: Developing Mobile Applications for Apple IPhone, IPad, and IPod Touch | |
| Kapitsaki et al. | Model-driven development of context-aware web applications based on a web service context management architecture | |
| CN110069514B (en) | Message processing method and device | |
| Mügge et al. | Integrating aspect-orientation and structural annotations to support adaptive middleware | |
| CN115883353A (en) | Routing plug-in arranging and executing system based on Spring Cloud Gateway in trusted environment | |
| CN116700827A (en) | Loading method, device and medium for enumeration data | |
| Hollister et al. | Blender “DNA” and Serialization | |
| Ali | iPhone SDK 3 programming: advanced mobile development for Apple iPhone and iPod touch |
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 |