CN116303759A - A method, device, and storage medium for synchronizing entity object information - Google Patents

Abstract

The invention discloses a method for synchronizing entity object information, which comprises the following steps: an original model is defined, which is a field/variable type including a base table, a page query, and a business meaning. An enhancement model is defined, which is the field/variable that needs to be added. Acquiring field/variable definition grammar tree nodes of the original model, scanning annotation of the enhancement model by an annotation processor, modifying the field/variable definition grammar tree nodes of the original model according to the attribute in the annotation of the enhancement model, and adding the modified field/variable definition grammar tree nodes into class definition grammar tree nodes of the enhancement model. The invention can solve the problem of field repetition of entity model, and when the field changes due to the change of business, other entity objects can synchronize the change of the original model field during compiling. The repeated codes and inconsistent fields can be reduced to a great extent, and meanwhile, the definition of the codes and the maintainability and expandability of the items can be improved.

Description

A method, device, and storage medium for synchronizing entity object information

technical field

The invention belongs to the technical field of computer development, and in particular relates to an entity object information synchronization method, device and storage medium.

Background technique

With the continuous deepening of programming industrialization, various programming architectures emerge in an endless stream (such as MVC, MVP, DDD, etc.), along with these programming architectures, when developing Java projects, when the code is layered, POJO will exist like VO , BO, PO, DO, DTO, DP and other entity objects. There are roughly two traditional development processes: first define the fields under the table corresponding to the entity object PO, and then copy these field codes to entity objects such as VO, BO, and DTO. By defining the base entity object, other entity objects inherit the base entity object, but due to the limitation of Java single inheritance, there will still be repeated field definitions.

These entity objects have a large number of repeated fields to some extent. When business changes cause fields to be added, modified, or deleted, multiple entity objects need to be modified synchronously. Otherwise, it will lead to problems such as inconsistent field types or inconsistent field names, which are especially prominent in the continuous change of requirements. If the consistency of the model data is not maintained, bugs will appear in the dirty data during use. This type of bug is usually hidden and difficult to troubleshoot.

At present, there is no perfect technical solution to solve the above problems. For example, starting from the data, MapStruct can solve the problem of data conversion by specifying the source model field and the target model field when the fields of two objects are inconsistent. However, it still cannot solve the problems of duplication of fields in the entity model itself and possible inconsistencies in the fields.

Contents of the invention

The technical purpose of the present invention is to provide a method, device and storage medium for synchronizing entity object information, so as to solve the technical problem of a large number of repeatedly defined fields in entity objects.

In order to solve the above problems, the technical solution of the present invention is:

A method for synchronizing entity object information, comprising the steps of:

Define the original model, which includes basic tables, paging queries, and field/variable types with business meanings;

Define the enhanced model, which is the field/variable that needs to be added;

Obtain the field/variable definition syntax tree node of the original model, scan the annotation of the enhanced model through the annotation processor, modify the field/variable definition syntax tree node of the original model according to the attributes in the enhanced model annotation, and define the modified field/variable A syntax tree node is added to the class definition syntax tree node of the augmented model.

Specifically, basic table field/variable types include creating user, updating user, creation time, and update time; paging query field/variable types include page number, page size, and fuzzy search keywords; field/variable types with business meaning include Name, unique key, encoding, and tombstone flag.

Preferably, before using the annotation processor, three annotations are predefined, namely @Mode l, @Mode l Fi e l d and @EnhanceMode l;

When defining the original model, use @Model l to annotate the class of the original model, and use @Mode l Field to annotate the field of the original model;

When defining an enhanced model, use @EnhanceMode l to annotate the class of the enhanced model; if the enhanced model's own field needs a field name or table field name, use @Mode l Field to annotate the enhanced model's own field.

Among them, defining the enhanced model specifically includes the following steps: defining the field/variable type of copying part of the original model; defining the field of ignoring part of the original model; defining whether to copy the swagger annotation of the field of the original model; defining whether to copy the JSR303 annotation of the field of the original model ; Field annotations defining the copied part of the original model are not copied.

Specifically, the execution of the annotation processor includes the following steps

Scan the list of TypeE l element with @EnhanceMode annotation, traverse the list of TypeE l element, and process the classes with @EnhanceMode l annotation in turn;

Obtain the TypeE l element of the original model based on the from attribute under @Enhance Model l, and obtain the Var i ab l eE l element list of the original model field from the TypeE element; filter and ignore according to the ignoreFi e l ds attribute under @Enhance Model l field; according to the enab l eSwagger attribute under @EnhanceMode l, judge whether to ignore swagger related annotations; according to the enab l eJSR attribute under @EnhanceMode l, judge whether to ignore JSR303 annotations; according to d i sab l eAnnotat i on under @EnhanceMode l Attribute, ignoring some specified annotations; according to the @Mode lField annotation defined on the field, a field name static variable and a table field name static variable are generated.

Among them, if there is a field with the same name between the original model and the enhanced model during the process of adding the modified field/variable definition syntax tree node to the class definition syntax tree node of the enhanced model, it is judged that if the enhanced model has the same field name, then Use the field of the enhanced model directly; if the enhanced model does not have the same field name, it will cause a compilation error, and the definition of the field is redundant for the enhanced model.

Further preferably, the method of synchronizing entity object information by using an external plug-in of I nte l l i J IDEA is supported, and the steps are as follows: obtain the original model through the from attribute; obtain the field with @Mode l F i e l d in the original model; add the field with @Mode l The original model field of F i e l d is added to the enhanced model; add the field name static variable and the table field name static variable.

An electronic device, the electronic device includes a processor and a memory, the memory stores computer instructions that can run on the processor, and the processor is used to call the computer instructions in the memory to execute the above entity object information synchronization method.

A storage medium is used to store computer instructions, wherein when the computer instructions are running, the device where the storage medium is located is controlled to execute the above entity object information synchronization method.

Compared with the prior art, the present invention has the following advantages and positive effects due to the adoption of the above technical scheme:

The present invention can solve the duplication of fields in the entity model, and when the field changes due to business changes, the developer only needs to focus on the original model and does not need to care about other entity objects. Other entity objects can synchronize the field changes of the original model at compile time, realizing the Fields from the original model are quickly copied into the augmented model. It can greatly reduce repeated code and field inconsistency, and at the same time improve the clarity of the code, and improve the maintainability and scalability of the project. In addition, it can be applied to Java projects developed by all IntelliJ IDEs. It is easy to use and can be used by adding a few annotations.

Description of drawings

Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiment. The drawings are only for the purpose of illustrating a preferred embodiment and are not to be considered as limiting the invention.

Fig. 1 is a flow frame diagram of a method for synchronizing entity object information of the present invention;

Fig. 2 is the flowchart of the definition model of the present invention;

Fig. 3 is a flow frame diagram of the implementation of the annotation processor of the present invention;

Fig. 4 is the plug-in implementation flowchart of the present invention;

Fig. 5 is a schematic diagram of the business model of the present invention;

Fig. 6 is a schematic diagram of another business model of the present invention.

Detailed ways

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the specific implementation manners of the present invention will be described below with reference to the accompanying drawings. Obviously, the accompanying drawings in the following description are only some embodiments of the present invention, and those skilled in the art can obtain other accompanying drawings based on these drawings and obtain other implementations.

In order to make the drawing concise, each drawing only schematically shows the parts related to the present invention, and they do not represent the actual structure of the product. In addition, to make the drawings concise and easy to understand, in some drawings, only one of the components having the same structure or function is schematically shown, or only one of them is marked. Herein, "a" not only means "only one", but also means "more than one".

A method, device, and storage medium for synchronizing entity object information proposed by the present invention will be further described in detail below in conjunction with the accompanying drawings and specific embodiments. Advantages and features of the present invention will be apparent from the following description and claims.

Example

Referring to FIG. 1 to FIG. 5 , this embodiment provides a method for synchronizing entity object information, so that the enhanced model can automatically copy the fields of the original model. When the fields of the original model change, the changes can be synchronized without modifying the enhanced model. Including the following steps:

First, referring to Figure 1 and Figure 2, the original model needs to be defined. When defining the original model, use @Model l to annotate the class of the original model, and use @Model F i e l d to mark the fields of the original model. After adding @Mode lField, when the enhanced model depends on the original model, in addition to copying the field, at the same time, the field name and table field name static variables will be generated. The original model is a defined base class, itself a POJO whose fields can be copied by the enhanced model. Specifically, the fields in the original model can be some basic table field types, including but not limited to: id, createUser (create user), updateUser (update user), createDate (creation time), updateDate (update time), etc. It can also include pageNo (page number), pageSize (page size), searchKey (fuzzy search keyword) and so on when querying data in pages. At the same time, it can also be some basic types with business meanings, including but not limited to: name (name), key (unique key), code (encoding), del eteF lag (logic deletion flag), etc. In this embodiment, the original model can be any POJO type, as long as the developer thinks there are situations where attributes can be reused by other POJOs, they can be defined as the original model.

Next, refer to Figure 1 and Figure 2 to define the enhanced model. The enhanced model is the field/variable that needs to be added. It is also a POJO itself, but the abstract syntax tree (AST) can be modified through the annotation processor (APT) tool to copy the original model. The defined fields are added to the enhanced model, and the original fields of the enhanced model are not affected by compilation. When defining an enhanced model, use @EnhanceMode l to annotate the class of the enhanced model; if the enhanced model's own field needs a field name or table field name, use @Mode l Field to annotate the enhanced model's own field.

Specifically, it includes the following steps: define the field/variable type of copying part of the original model; define the field that ignores part of the original model; define whether to copy the swagger annotation of the field of the original model; define whether to copy the JSR303 annotation of the field of the original model; define the copy part of the original Model field annotations are not copied.

@EnhanceMode l attribute explanation is shown in Table 1

Table 1

Referring to Figure 1 and Figure 3, when the project is being compiled, the annotation processor APT scans the annotations of the enhanced model in the code, and according to the attributes in the annotations of the enhanced model, first obtains the field/variable definition syntax tree nodes of the original model, and then follows The definition of the annotation attribute modifies the field/variable definition syntax tree node of the original model, and finally adds the modified syntax tree node to the class definition syntax tree node of the enhanced model. The newly added fields after APT processing support annotations such as Lombok and MapStruct. For example, after adding @Getter and @Setter annotations of Lombok, the newly added fields will also generate corresponding getter() and setter() methods. MapStruct is the same, adding @ After Mapper annotations, new field conversions will also be generated during object data conversion.

The original model and the enhanced model can come from different modules, as long as they can be depended on by maven. If the modified field/variable definition syntax tree node is added to the class definition syntax tree node of the enhanced model, the original model and If there are fields with the same name between the enhanced models, it is judged that if the enhanced models have the same field name, the fields of the enhanced model will be used directly instead of copying the fields from the original model. If the enhanced model does not have the same field name, but the dependent original models have the same field name, a compilation error occurs, and the user can redundantly define the field for the enhanced model.

Specifically, referring to Figure 3, APT can be used to scan, compile and process annotations at compile time. The detailed steps are as follows: Scan the list of TypeE l lems with @EnhanceMode annotations, traverse the list of TypeE l lems, and process the classes with @EnhanceMode l annotations sequentially; based on the from attribute under @EnhanceMode l, obtain the TypeE element of the original model, from TypeE l Obtain the Var i ab l eE l element list of the original model field in ment; filter the ignored fields according to the ignoreFi e l ds attribute under @EnhanceMode l; judge whether to ignore swagger related according to the enab l eSwagger attribute under @EnhanceMode l Annotation; judge whether to ignore the JSR303 annotation according to the enable JSR attribute under @EnhanceMode l; ignore some specified annotations according to the d i sab l eAnnotation attribute under @EnhanceMode l; generate the field name according to the @Mode l Field annotation defined on the field Static variables and table field names Static variables.

Preferably, referring to Figure 4, since APT scans, compiles, and processes Java annotations during compilation, when using Intel l iJ IDEA to write code, it cannot recognize and process @Mode l, @Mode lField, @EnhanceModel, etc. annotation. In order to support developers to develop normally in Intel l l i J IDEA, this patent provides a plug-in and publishes it to the plug-in market. Developers only need to download and install the plug-in on their own Intel l l i J IDEA. After installing the plug-in in I nte ll i J IDEA, the processing logic steps of the plug-in are as follows: get the original model through the from attribute; get the fields with @Mode l F ie l d in the original model; add the original with @Mode l Fie l d Model fields to augmented models; add field name static variables as well as table field name static variables. At the same time, in order to support developers to see the corresponding POJO fields and variables in the structure tool window of Inte ll i J IDEA, we have implemented the StructureViewExtension interface of Inte ll i JI DEA, and the processing logic is consistent with the above plug-in processing logic .

Referring to Figure 5 and Figure 6, an example is given to illustrate the actual application of this embodiment. For example, in the e-commerce industry, during the use of parameters, multiple services such as commodities, orders, and instances need to be sent, so there are a large number of repeated parameters. Moreover, due to the need for entity object conversion between different fields, there are also a large number of parameter assignment operations. As shown in Figure 5, large fields such as product detailed descriptions are stored separately to improve query performance. In such a scenario, the product details must include fields for basic product information and extended product information. As shown in FIG. 6 , when querying data, in addition to fields derived from commodity basic information and commodity extended information, pagination basic information may also be required. Therefore, the fields supporting the enhanced model in this embodiment can come from multiple original models.

First, define the original model to determine which product fields can be used as original model field information:

1. Commodity basic information: Commodity has commodity id (itemI d), commodity title (t it l e), and commodity price (price) information, and these basic information may be stored in the commodity table.

2. Product extension information: In order to improve query performance, some large fields such as product description are stored separately, and these information may be stored in the product extension table.

Therefore, developers can define two original models of items, namely: ItemBasic and ItemExtra.

In addition, users need paging information when querying, so the original paging model BasePage needs to be defined.

Then define and process the enhanced model. Developers need to use the corresponding DTO entity object when developing commodity business, which is defined as ItemDTO. And ItemDTO needs the field information under ItemBasic and ItemExtra, does not need the corresponding swagger annotation information on the field, JSR303 corresponding annotation information, and @Length annotation information, and does not need the extraField information under ItemExtra. When the user initiates a query request, the defined ItemQuery query entity needs not only the field information under ItemBasic and ItemExtra, but also the corresponding paging information. When developing the order business, the DTO entity object OrderDTO of the order may need field information under ItemBasic, but it also has some field information, such as order number, order name, etc.

As in the above example, when the field needs to be changed, you need to change t it l e to name; or if the demand changes, the product needs to add a unique number itemNo, and the order also needs to record the product number synchronously. In this embodiment, it is only necessary to modify the original model ItemBasic to change t it l e to name, and add an itemNo field, and the enhanced model will automatically synchronize field changes.

In this embodiment, the fields generated by the enhanced model support Lombok and MapStruct functions at the same time, so developers can also apply when defining the annotations of Lombok and MapStruct in the enhanced model. Applicable to Lombok: Add the @Data annotation to the ItemDeta ilQuery enhanced model. MapStruct is applicable: the field fields generated by the enhanced model can also use MapStruct to assign attributes, and secondly, if there is an inconsistency in the field names, the static variables can be generated through this embodiment to obtain the field names.

If there is a demand now, when the user places an order, because there is no place to enter the order name, he wants to assign the product name to the order name. When MapStruct performs data conversion, it needs to be completed by writing code. When writing code, you can obtain the field name through ItemDTO.itemName_field and OrderDTO.orderName_field.

Further, this embodiment also provides an electronic device, the electronic device includes a processor and a memory, the memory stores computer instructions that can be run on the processor, and the processor is used to invoke the computer instructions in the memory to execute the above entity Object information synchronization method.

In addition, this embodiment also provides a storage medium, which is used to store computer instructions, wherein when the computer instructions are running, the device where the storage medium is located is controlled to execute the above entity object information synchronization method.

The embodiments of the present invention have been described in detail above with reference to the accompanying drawings, but the present invention is not limited to the above embodiments. Even if various changes are made to the present invention, if these changes fall within the scope of the claims of the present invention and equivalent technologies, they still fall within the protection scope of the present invention.

Claims (9)

1. A method for synchronizing entity object information, comprising the steps of: Define the original model, which includes basic tables, pagination queries, and field/variable types with business meanings; Define an enhanced model, the enhanced model is the fields/variables that need to be added; Obtaining the field/variable definition syntax tree nodes of the original model, scanning the annotations of the enhanced model through the annotation processor, and modifying the field/variable definition syntax tree nodes of the original model according to the attributes in the enhanced model annotations, The modified field/variable definition syntax tree node is added to the class definition syntax tree node of the enhanced model. 2. The entity object information synchronization method according to claim 1, wherein: Basic table field/variable types include create user, update user, create time and update time; Paging query field/variable types include page number, page size and fuzzy search keywords; Field/variable types with business meaning include names, unique keys, encodings, and tombstone flags. 3. The method for synchronizing entity object information according to claim 1, further preferably, before using the annotation processor, three annotations are predefined, namely @Model, @ModelField and @EnhanceModel; When defining the original model, use @Model to annotate the class of the original model, and use @ModelField to mark the field of the original model; When defining the enhanced model, use @EnhanceModel to annotate the enhanced model class; if the enhanced model’s own field needs a field name or table field name, then use @ModelField in the enhanced model’s own field Annotate above. 4. The method for synchronizing entity object information according to claim 3, wherein said defining an enhanced model specifically comprises the following steps Define the field/variable types of the original model as described in the copying section; Define the fields of the original model as described in the Ignore section; Define whether to copy the swagger annotation of the field of the original model; Define whether to copy the JSR303 annotation of the field of the original model; Field annotations that define the original model as described in the Copy section are not copied. 5. The method for synchronizing entity object information according to claim 4, wherein the annotation processor comprises the following steps when executing Scan the TypeElement list with @EnhanceMode annotation, traverse the TypeElement list, and process the classes with @EnhanceModel annotation in turn; Obtain the TypeElement of the original model based on the from attribute under @Enhance Model, and obtain the VariableElement list of the original model field from TypeElement; filter the ignored fields according to the ignoreFields attribute under @Enhance Model; according to the enableSwagger attribute under @EnhanceModel, Determine whether to ignore swagger-related annotations; judge whether to ignore JSR303 annotations according to the enableJSR attribute under @EnhanceModel; ignore some specified annotations according to the disableAnnotation attribute under @EnhanceModel; generate field name static variables and table fields according to the @ModelField annotation defined on the field named static variable. 6. The entity object information synchronization method according to claim 1, wherein, if the modified field/variable definition syntax tree node is added to the class definition syntax tree node of the enhanced model, there is There is a field with the same name between the original model and the enhanced model, and it is judged that if the enhanced model has the same field name, then directly use the field of the enhanced model; if the enhanced model does not have the same field name, compile Error, the definition of this field is redundant for the augmented model. 7. The method for synchronizing entity object information according to claim 3, wherein, further preferably, it is supported to adopt an external plug-in of IntelliJ IDEA to realize the method for synchronizing entity object information, and the steps are as follows: obtain the original model through the from attribute; Obtain the field with @ModelField in the original model; add the original model field with @ModelField to the enhanced model; add a field name static variable and a table field name static variable. 8. An electronic device, characterized in that the electronic device comprises a processor and a memory, the memory is stored with computer instructions that can run on the processor, and the processor is used to call the The computer instruction executes the method for synchronizing entity object information according to any one of claims 1-7. 9. A storage medium, characterized in that the storage medium is used to store computer instructions, wherein, when the computer instructions are running, the device where the storage medium is located is controlled to execute as described in any one of claims 1-7. Entity object information synchronization method.

Images