Dependency Implementation Method, Device, and Equipment Based on Rust Language Features

Abstract

The present invention relates to the field of software technology, and particularly relates to a method, device, and equipment for implementing dependencies based on the characteristics of the Rust language. The method specifically includes respectively determining the characteristics corresponding to the target service and the dependent service; respectively generating data structures corresponding to the target service and the dependent service, and placing all the data structures in a container; generating specific implementation classes for the target service and the dependent service, wherein the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are further restricted to implement the characteristics of the dependent service; based on the specific implementation classes, through the methods of injection and projection, enabling the container to implement the characteristics corresponding to the target service and the dependent service, so as to perform the target service through the container. In this way, for the Rust language, it is possible to simply and efficiently implement services with dependency relationships, and at the same time improve the maintainability of large-scale project development.

Description

Technical Field

[0001] The present invention relates to the field of software technology, and in particular, to a method, device, and equipment for implementing dependencies based on the characteristics of the Rust language. Background Art

[0002] In the software field, for web projects and some large projects, there are often dependency relationships between multiple services. For example, a service method in Service A needs to rely on one or more services in other services, such as Service B. At this time, we say that Service A depends on Service B. As a non-object-oriented language, Rust is a memory-safe and efficient programming language, but it lacks an official or community dependency injection library, resulting in the need to implement services with dependency relationships in a cumbersome and complex way, which requires high system performance and poor maintainability. Summary of the Invention

[0003] In view of this, the purpose of the present invention is to provide a method, device, and equipment for implementing dependencies based on the characteristics of the Rust language, so as to overcome the problems of high system performance requirements and poor maintainability when the Rust language currently implements services with dependency relationships.

[0004] To achieve the above purpose, the present invention adopts the following technical solutions:

[0005] In the first aspect, the present application provides a method for implementing dependencies based on the characteristics of the Rust language, including:

[0006] Determine the characteristics corresponding to the target service and the dependent service respectively, where the dependent service is the service on which the target service depends;

[0007] Generate data structures corresponding to the target service and the dependent service respectively, and place all the data structures in a container, where the data structures store the data of the corresponding services;

[0008] Generate specific implementation classes for the target service and the dependent service, where the specific implementation classes are used to implement the characteristics of the corresponding services, where the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are also restricted to implement the characteristics of the dependent service;

[0009] Based on the specific implementation classes, through the methods of injection and projection, make the container implement the characteristics corresponding to the target service and the dependent service, so as to perform the target service through the container.

[0010] Further, in some embodiments of the present application, the generating specific implementation classes for the target service and the dependent service includes:

[0011] Generate program code for a specific implementation class corresponding to the target service, where the program code is used to obtain a data structure corresponding to the target service to implement the service methods defined in the features corresponding to the target service;

[0012] Generate program code for a specific implementation class corresponding to the dependent service, where the program code is used to obtain a data structure corresponding to the dependent service to implement the service methods defined in the features corresponding to the dependent service.

[0013] Further, in some embodiments of the present application, it further includes: generating injection methods and projection methods for each of the specific implementation classes.

[0014] Further, in some embodiments of the present application, based on the specific implementation class, by means of injection and projection, enabling the container to implement the features corresponding to the target service and the dependent service, so as to perform the target service through the container, includes:

[0015] Using the injection method of the specific implementation class corresponding to the target service, converting the container into the structure of the specific implementation class of the target service, and based on the specific implementation class of the target service, implementing and performing at least some of the service methods defined in the features corresponding to the target service.

[0016] Further, in some embodiments of the present application, based on the specific implementation class, by means of injection and projection, enabling the container to implement the features corresponding to the target service and the dependent service, and performing the target service through the container, includes:

[0017] Using the injection method of the specific implementation class of the target service, converting the container into the structure of the specific implementation class of the target service, and based on this specific implementation class, performing the part of the service methods defined in the features of the target service that do not depend on the dependent service;

[0018] And then converting the converted container into the structure of the specific implementation class of the dependent service through the projection method of the specific implementation class of the dependent service, and based on the specific implementation class of the dependent service, performing the part of the service methods defined in the features of the target service that depend on the dependent service.

[0019] Further, in some embodiments of the present application, it further includes:

[0020] Using the injection method of the specific implementation class of the dependent service, converting the container into the structure of the specific implementation class of the dependent service, and based on the specific implementation class of the dependent service, implementing and performing the service methods defined in the features of the dependent service.

[0021] Second aspect, the present application provides a dependency implementation device based on Rust language features, including:

[0022] A definition module, configured to respectively determine the features corresponding to the target service and the dependent service, where the dependent service is the service on which the target service depends;

[0023] A first generation module, configured to respectively generate data structures corresponding to the target service and the dependent service, and place all the data structures in a container, where the data structures store data of the corresponding services;

[0024] A second generation module, configured to generate specific implementation classes for the target service and the dependent service, where the specific implementation classes are used to implement the features of the corresponding services, where the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are further restricted to implement the features of the dependent service;

[0025] An operation module, configured to enable the container to implement the features corresponding to the target service and the dependent service based on the specific implementation classes through the methods of injection and projection, so as to perform the target service through the container.

[0026] Third aspect, the present application provides a dependency implementation device based on Rust language features, including a processor and a memory, and the processor is connected to the memory:

[0027] Wherein, the processor is configured to call and execute a program stored in the memory;

[0028] The memory is configured to store the program, and the program is at least used to execute the above-mentioned dependency implementation method based on Rust language features.

[0029] The present invention relates to the technical field of software, and specifically relates to a dependency implementation method, device and device based on Rust language features. The method specifically includes respectively determining the features corresponding to the target service and the dependent service; respectively generating data structures corresponding to the target service and the dependent service, and placing all the data structures in a container; generating specific implementation classes for the target service and the dependent service, where the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are further restricted to implement the features of the dependent service; based on the specific implementation classes, through the methods of injection and projection, enabling the container to implement the features corresponding to the target service and the dependent service, so as to perform the target service through the container. In this way, for the Rust language, the business with dependency relationships can be simply and efficiently implemented, and at the same time, the maintainability of large-scale project development is improved. Description of the Drawings

[0030] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the accompanying drawings required for the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0031] Figure 1 It is a schematic flowchart of a dependency implementation method based on Rust language features provided by an embodiment of the present invention.

[0032] Figure 2 It is a schematic structural diagram of a dependency implementation device based on Rust language features provided by an embodiment of the present invention.

[0033] Figure 3 It is a schematic structural diagram of a dependency implementation device based on Rust language features provided by an embodiment of the present invention. Detailed implementation manners

[0034] To make the objectives, technical solutions and advantages of the present invention clearer, the following will describe the technical solutions of the present invention in detail. Obviously, the described embodiments are only some embodiments of the present invention, rather than all embodiments. Based on the embodiments of the present invention, all other implementation manners obtained by those of ordinary skill in the art without creative efforts fall within the scope protected by the present invention.

[0035] Figure 1 It is a schematic flowchart of a dependency implementation method based on Rust language features provided by an embodiment of the present invention. Please refer to Figure 1 , this embodiment may include the following steps:

[0036] S101. Determine the features corresponding to the target service and the dependent service respectively.

[0037] Among them, the dependent service is the service that the target service depends on.

[0038] Specifically, it should be noted first that since the concept of features is involved, this application is a solution for the Rust language. Of course, for other languages, it can be applied based on the essence of features, that is, memory layout conversion. This application will not describe it in detail. In the Rust language, a trait is an abstract concept used to define shared behaviors, which is similar to the principle of an interface in an object-oriented language. In the Rust language, traits are used to define method signatures and other information (but do not include the program code for implementing specific methods), such as which business methods are included in the target service or the dependent service.

[0039] It should be noted that the number of business methods defined in the characteristics corresponding to the target business and the dependent business can be multiple, that is, multiple business methods can be defined in the characteristics of the target business, and multiple business methods can also be defined in the characteristics of the dependent business. In this application, the business that depends on other businesses is called the target business, and the business on which the target business depends is called the dependent business. For example, if some business methods in business A need to depend on a certain or certain business methods in business B, then business A can be called the target business and business B can be called the dependent business.

[0040] S102. Generate data structures corresponding to the target business and the dependent business respectively, and place all the data structures in a container.

[0041] Among them, the data structure stores the data of the corresponding business.

[0042] Specifically, in this application, the data of each business is stored through a data structure corresponding to the business. For example, the data can be stored by defining a State structure. It should be noted that in this application, the data structure corresponds to the business one by one, and a data structure only stores the data required by the corresponding business itself, such as private fields, and does not store the data of other businesses.

[0043] S103. Generate specific implementation classes for the target business and the dependent business.

[0044] Among them, the specific implementation class is used to implement the characteristics of the corresponding business, that is, to implement the business methods defined in the characteristics of the corresponding business. The specific implementation class is generated based on generic parameters, and the generic parameters in the specific implementation class of the target business are also restricted to implement the characteristics of the dependent business.

[0045] Specifically, generating specific implementation classes for the target business and the dependent business includes: generating the program code of the specific implementation class corresponding to the target business, and generating the program code of the specific implementation class corresponding to the dependent business.

[0046] It can be understood that the program code of the specific implementation class corresponding to the target business is used to obtain the data structure corresponding to the target business and implement the business methods defined in the characteristics corresponding to the target business; the program code of the specific implementation class corresponding to the dependent business is used to obtain the data structure corresponding to the dependent business and implement the business methods defined in the characteristics corresponding to the dependent business.

[0047] In practical applications, the specific implementation class can be the Implement structure and is generated based on generic parameters. It can be understood that in the Rust language, generics can be used to generate code with generality and reusability without specifying data types. By using generics, functions, structures, enums, or traits can operate on different types of data without writing separate code for each type.

[0048] On this basis, considering the characteristic that the target business needs to depend on other businesses, the conditions or behaviors that the generic parameters must satisfy can be restricted based on the type constraints of the generic parameters, that is, when defining the generic parameters, specify which traits they must implement, so as to successfully pass the compilation check and achieve the purpose of introducing dependencies. In this application, for the generic parameters in the specific implementation class of the target business, when defining them, their implementation of the traits of the dependent business can be restricted, so that when used subsequently, they can successfully pass the compilation check and introduce dependencies at the same time.

[0049] S104. Based on the specific implementation class, through injection and projection, enable the container to implement the traits corresponding to the target business and the dependent business, so as to perform the target business through the container.

[0050] Specifically, the injection method and the projection method of the above specific implementation class can be pre-generated, so that through the injection method and the projection method, the container can implement the traits corresponding to the target business and the dependent business, and thus perform the target business through the container.

[0051] It can be understood that the function of the injection method is to specify a target object (which is the above container during actual operation) and convert it into the structure of this class. The projection method is to convert the structure of this object (such as the object obtained by the container through injection) into the structure of the target class.

[0052] During actual operation, the structure of the container can be converted through the injection method and the projection method, so as to call the corresponding specific implementation class, enable the container to implement the traits corresponding to the target business and the dependent business, and perform the target business through the container.

[0053] The dependency implementation method based on the Rust language features provided by the present invention first determines the features corresponding to the target service and the dependent service respectively; then generates the data structures corresponding to the target service and the dependent service respectively, and places all the data structures in a container; then generates specific implementation classes for the target service and the dependent service, wherein the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are further restricted to implement the features of the dependent service; finally, based on the specific implementation classes, through the methods of injection and projection, the container is enabled to implement the features corresponding to the target service and the dependent service, so as to perform the target service through the container. In this way, for the Rust language, the business with dependency relationships can be simply and efficiently implemented, and the maintainability of large-scale project development is improved at the same time.

[0054] It should be noted that in this application, since all the data structures are placed in the container, and all the data structures have the data corresponding to the respective services, all the data required for the services can be accessed through the container.

[0055] In practical applications, it is possible to limit the creation of only one container object in the entire main function. During global operation, by continuously transforming the container into the structure of any class to change its behavior, various services can be implemented, specifically including the following:

[0056] First, at least some of the business methods defined in the features corresponding to the target service can be implemented based on the injection method, specifically the business methods that do not depend on other services.

[0057] Specifically, the injection method of the specific implementation class corresponding to the target service can be called to convert the container into the structure of the specific implementation class, and then the specific implementation class can be called to implement and perform the business methods defined in the features corresponding to the target service that do not depend on other services.

[0058] Second, the business methods defined in the features corresponding to the target service that need to depend on other services can be implemented based on the injection method and the projection method.

[0059] Specifically, the injection method of the specific implementation class corresponding to the target service can be called first to convert the container into the structure of the specific implementation class, and then the specific implementation class can be called to implement and perform some steps of the business methods.

[0060] It should be noted that at this time, the structure of the container is in the form of the specific implementation class of the target service. At the same time, since the generic parameters in the specific implementation class of the target service are further restricted to implement the features of the dependent service, when the specific implementation class in the dependent service wants to be called at this time, it is legal during compilation check and can pass the compilation check smoothly.

[0061] On this basis, the projection method of the specific implementation class of the dependent service is called again to convert the container into the structure of the specific implementation class of the dependent service, and the specific implementation class of the dependent service is called to perform the part that depends on the dependent service in the service methods defined in the characteristics of the target service.

[0062] Thirdly, the service methods defined in the characteristics corresponding to the dependent service can be implemented based on the injection method (for the convenience of description, it is assumed in this application that the service methods defined in the characteristics corresponding to the dependent service do not depend on other services. In actual applications, the dependent service itself may also depend on other services. In this case, the specific implementation principle is the same as the above-mentioned target service principle and will not be elaborated here).

[0063] Specifically, the injection method of the specific implementation class of the corresponding dependent service can be called to convert the container into the structure of this specific implementation class, and this specific implementation class can be called to implement and perform the service methods in the characteristics corresponding to the dependent service.

[0064] The dependent implementation method based on the Rust language characteristics provided by the present invention converts the structure of the container through injection and projection methods, enabling it to implement the characteristics of each related service, statically calls the specific implementation classes of each service, avoiding the runtime overhead of dynamic dispatch, and at the same time, through the characteristic constraints on the generic parameters in the specific implementation class, ensuring that the dependency relationship can be determined during the compilation period, improving the development efficiency of services with dependency relationships, improving runtime performance, and system maintainability.

[0065] Based on the same inventive concept, the present application also provides a dependent implementation device based on the Rust language characteristics. Figure 2 It is a schematic structural diagram of the dependent implementation device based on the Rust language characteristics provided by the embodiment of the present invention, as Figure 2 shown. The device includes:

[0066] A definition module 11 for respectively determining the characteristics corresponding to the target service and the dependent service, where the dependent service is the service on which the target service depends.

[0067] A first generation module 12 for respectively generating data structure bodies corresponding to the target service and the dependent service, and placing all the data structure bodies in a container, where the data structure bodies store the data of the corresponding services.

[0068] A second generation module 13 for generating specific implementation classes for the target service and the dependent service, where the specific implementation classes are used to implement the characteristics of the corresponding services, and the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are also restricted to implement the characteristics of the dependent service.

[0069] The running module 14 is used to enable the container to implement the characteristics corresponding to the target service and the dependent service through injection and projection based on the specific implementation class, so as to perform the target service through the container.

[0070] Regarding the device in the above embodiments, the specific ways in which each module performs operations have been described in detail in the embodiments related to the method, and will not be elaborated here.

[0071] Based on the same inventive concept, the present application also provides a dependency implementation device based on Rust language features. Figure 3 It is a schematic structural diagram of the dependency implementation device based on Rust language features provided by an embodiment of the present invention, as Figure 3 shown. The device includes a processor 21 and a memory 22, and the processor 21 is connected to the memory 22. Among them, the processor 21 is used to call and execute the program stored in the memory 22; the memory 22 is used to store the program, and this program is at least used to execute the dependency implementation method based on Rust language features in the above embodiments.

[0072] The specific implementation of the dependency implementation device based on Rust language features provided by the embodiments of the present application can refer to the implementation manner of the dependency implementation method based on Rust language features in any of the above embodiments, and will not be elaborated here.

[0073] It can be understood that the same or similar parts in the above embodiments can be referred to each other, and the content not detailed in some embodiments can be seen in the same or similar content in other embodiments.

[0074] It should be noted that in the description of the present invention, terms such as "first" and "second" are only used for descriptive purposes and cannot be understood as indicating or implying relative importance. In addition, in the description of the present invention, unless otherwise specified, the meaning of "a plurality" refers to at least two.

[0075] Any process or method description shown in the flowchart or described in other ways herein can be understood as representing a module, segment, or part of executable instructions including one or more steps for implementing a specific logical function or process, and the scope of the preferred embodiments of the present invention includes additional implementations, where the functions can be executed in a substantially simultaneous manner or in a reverse order according to the involved functions, rather than in the order shown or discussed, which should be understood by those skilled in the technical field of the embodiments of the present invention.

[0076] It should be understood that each part of the present invention can be implemented by hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented by software or firmware stored in a memory and executed by a suitable instruction execution system. For example, if implemented by hardware, as in another embodiment, any one or a combination of the following techniques well known in the art can be used: discrete logic circuits with logic gate circuits for implementing logical functions on data signals, application specific integrated circuits with appropriate combinational logic gate circuits, programmable gate arrays (PGAs), field programmable gate arrays (FPGAs), and the like.

[0077] Those of ordinary skill in the art can understand that all or part of the steps carried by the methods of the above embodiments can be completed by instructing relevant hardware through a program, and the program can be stored in a computer-readable storage medium. When the program is executed, it includes one or a combination of the steps of the method embodiments.

[0078] In addition, in each embodiment of the present invention, each functional unit can be integrated into a processing module, or each unit can exist physically alone, or two or more units can be integrated into one module. The above integrated module can be implemented in the form of hardware or in the form of a software functional module. When the above integrated module is implemented in the form of a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0079] The above-mentioned storage medium can be a read-only memory, a magnetic disk, an optical disc, or the like.

[0080] In the description of this specification, the description with reference to terms such as "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials, or characteristics described in connection with the embodiment or example are included in at least one embodiment or example of the present invention. In this specification, the schematic representations of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials, or characteristics described can be combined in any one or more embodiments or examples in a suitable manner.

[0081] Although the embodiments of the present invention have been shown and described above, it can be understood that the above embodiments are exemplary and should not be construed as limiting the present invention. Those of ordinary skill in the art can make changes, modifications, substitutions, and variations to the above embodiments within the scope of the present invention.

Claims

1. A dependency implementation method based on Rust language features, characterized in that: include: Determine the characteristics corresponding to the target service and the dependent service respectively, wherein the dependent service is the service on which the target service depends; Generating data structures corresponding to the target business and the dependent business respectively, and placing all the data structures in a container, wherein the data structures store data corresponding to the business; Generate specific implementation classes for the target service and the dependent service, the specific implementation classes are used to implement the characteristics of the corresponding services, wherein the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target service are also restricted to implement the characteristics of the dependent service; Based on the specific implementation class, the container is enabled to realize the characteristics corresponding to the target business and the dependent business by injection and projection, so as to perform the target business through the container; It also includes: generating an injection method and a projection method for each of the specific implementation classes; The step of enabling the container to realize the characteristics corresponding to the target business and the dependent business by injection and projection based on the specific implementation class so as to perform the target business through the container includes: Using the injection method of the specific implementation class corresponding to the target business, the container is converted into the structure of the specific implementation class of the target business, and based on the specific implementation class of the target business, at least part of the business methods defined in the characteristics corresponding to the target business are implemented and performed; and using the injection method of the specific implementation class of the target business to convert the container into the structure of the specific implementation class of the target business, and based on the specific implementation class, performing the part of the business method defined in the characteristics of the target business that does not depend on the dependent business; and then converting the converted container into the structure of the specific implementation class of the dependent business through the projection method of the specific implementation class of the dependent business, and based on the specific implementation class of the dependent business, performing the part of the business method defined in the characteristics of the target business that needs to depend on the dependent business.

2. The method for implementing dependency based on Rust language characteristics according to claim 1, characterized in that: The generating of specific implementation classes for the target business and the dependent business includes: Generate a program code of a specific implementation class corresponding to the target business, the program code is used to obtain a data structure corresponding to the target business to implement a business method defined in a characteristic corresponding to the target business; Generate a program code of a specific implementation class corresponding to the dependent business, and the program code is used to obtain a data structure corresponding to the dependent business to implement a business method defined in a characteristic corresponding to the dependent business.

3. The method for implementing dependency based on Rust language characteristics according to claim 1, characterized in that: Also includes: The container is converted into the structure of the specific implementation class of the dependent business by using the injection method of the specific implementation class of the dependent business, and based on the specific implementation class of the dependent business, the business method defined in the characteristics of the dependent business is implemented and performed.

4. A dependency implementation device based on Rust language characteristics, characterized in that: include: A definition module, used to respectively determine characteristics corresponding to a target service and a dependent service, wherein the dependent service is a service on which the target service depends; A first generating module, used to generate data structures corresponding to the target business and the dependent business respectively, and place all the data structures in a container, wherein the data structures store data corresponding to the business; A second generation module is used to generate specific implementation classes for the target business and the dependent business, the specific implementation classes are used to implement the characteristics of the corresponding business, wherein the specific implementation classes are generated based on generic parameters, and the generic parameters in the specific implementation class of the target business are also limited to implement the characteristics of the dependent business; and generate injection methods and projection methods for each of the specific implementation classes; An operation module, used to enable the container to implement the characteristics corresponding to the target business and the dependent business through injection and projection based on the specific implementation class, so as to perform the target business through the container; The step of enabling the container to realize the characteristics corresponding to the target business and the dependent business by injection and projection based on the specific implementation class so as to perform the target business through the container includes: Using the injection method of the specific implementation class corresponding to the target business, the container is converted into the structure of the specific implementation class of the target business, and based on the specific implementation class of the target business, at least part of the business methods defined in the characteristics corresponding to the target business are implemented and performed; and using the injection method of the specific implementation class of the target business to convert the container into the structure of the specific implementation class of the target business, and based on the specific implementation class, performing the part of the business method defined in the characteristics of the target business that does not depend on the dependent business; and then converting the converted container into the structure of the specific implementation class of the dependent business through the projection method of the specific implementation class of the dependent business, and based on the specific implementation class of the dependent business, performing the part of the business method defined in the characteristics of the target business that needs to depend on the dependent business.

5. A dependency implementation device based on Rust language features, characterized in that: The invention comprises a processor and a memory, wherein the processor is connected to the memory: Wherein, the processor is used to call and execute the program stored in the memory; The memory is used to store the program, and the program is at least used to execute the dependency implementation method based on Rust language characteristics as described in any one of claims 1-3.

Images