CN114647407A - Method, device and storage medium for realizing complex branch logic call - Google Patents

Abstract

The invention provides a method, a device and a storage medium for realizing complex branch logic calling, wherein the method for realizing the complex branch logic calling comprises the following steps: creating a class, creating a Map container in the class, wherein the Map container comprises a plurality of keys; creating a core class by which values are initialized into the Map container, the keys being mapped to the values to form key-value pairs; and calling the corresponding value in the key value pair from the Map container through the core class according to different keys. Therefore, the problems of poor readability and maintainability of codes and high development cost in the prior art are solved, and the problems that each part of logic is encapsulated into different classes, the strategy implementation classes are more and more due to a plurality of branch judgments, the assigned and compared business logic cannot be overlooked, and the development time is multiplied are solved.

Description

A method, device and storage medium for realizing complex branch logic call

technical field

The invention relates to the technical field of software development, in particular to a method, a device and a storage medium for implementing complex branch logic calls.

Background technique

In the existing software development process, in addition to considering generalized design in the technical design and implementation of many products, there will be good openings to prevent differentiated customization requirements, and the technical design will keep scalability. For example, a consumer loan product needs to know the user's provident fund data to comprehensively evaluate the credit score before lending. Then this consumer loan product is a national product, and the provident fund product is different for each province or even city level. In the existing technology , some technicians in the technical design of similar scenarios mostly write if/else statements or swtich (case) on the interface, all code branches are in one interface, so the code length is too long, but The maintainability is extremely poor, which affects the readability. One defect will make all provident fund interfaces unavailable; some technicians encapsulate each part of the logic into different classes through the strategy mode, so the code maintainability is good. Fewer, but the shortcomings are also obvious. If there are many branch judgments, there will be more and more policy implementation classes, and the business logic of overlooking the assignment and comparison cannot be realized. The development is also very troublesome, and the development time increases exponentially. Therefore, there is a need for a method for implementing complex branch logic calls, which solves the problems of poor code readability and maintainability and high development cost in the prior art.

SUMMARY OF THE INVENTION

Therefore, the technical problem to be solved by the present invention is to overcome the problems of poor code readability and maintainability and high development cost in the prior art.

In order to solve the above-mentioned technical problems, the present invention provides a method for realizing complex branch logic call, comprising the steps of: creating a class, and creating a Map container in the class, where the Map container contains several keys;

Create a core class, initialize several values into the Map container through the core class, and map the keys to the values to form key-value pairs;

According to the different keys, the corresponding value in the key-value pair is called from the Map container through the core class.

Optionally, different said values are isolated from each other.

Optionally, each of the keys is mapped to one of the values, respectively.

Optionally, the value is created using a function.

Optionally, the method for initializing several values into the Map container by using the core class includes: using a lambda expression to implement initializing the several values into the Map container.

Optionally, the method of initializing several values into the Map container by using the core class further includes: injecting an http interface into the core class, and calling the core method of the core class to complete the implementation of using a lambda expression. The several values are initialized into the Map container.

Optionally, the core class is created in the class.

In order to solve the above technical problems, the present invention also provides an apparatus for implementing complex branch logic calls, including: a memory; and

a processor coupled to the memory, the processor configured to:

Create a class, create a Map container in the class, and the Map container contains several keys;

Create a core class, initialize several values into the Map container through the core class, and map the keys to the values to form key-value pairs;

According to the different keys, the corresponding value in the key-value pair is called from the Map container through the core class.

Optionally, the processor is further configured to isolate the different values from each other.

In order to solve the above technical problem, the present invention also provides a computer storage medium on which a computer program is stored, wherein the computer program implements the steps of the above method when executed by a machine.

The technical scheme of the present invention has the following advantages:

1. A method for implementing complex branch logic calls provided by the present invention includes the steps of: creating a class, creating a Map container in the class, and the Map container contains several keys; Several values are initialized into the Map container, and the keys are mapped to the values to form key-value pairs; according to the different keys, the corresponding keys in the key-value pairs are called from the Map container through the core class. the value.

By creating multiple method classes (values) in one class to achieve different requirements, the code readability, maintainability and reuse rate are improved, development costs are reduced, development is agile and rapid, and each part is avoided. The logic of the system is encapsulated into different classes. Since there are many branch judgments, there will be more and more policy implementation classes. It is impossible to overlook the business logic of assignment and comparison, and the development time will increase exponentially.

2. Further, different said values are isolated from each other. In this way, it can be avoided that the readability of the code is too long and the maintainability is poor, so the readability, maintainability and reuse rate of the code are improved, the development cost is reduced, and the development is agile and rapid.

3. Further, the value is created using a function. It is more convenient to use functions, and the code of functional programming has a higher signal-to-noise ratio. The code of functional programming is not only concise and elegant, less error-prone, but also more efficient, easy to optimize, improve and parallelize, thereby reducing development costs and making development easier. Quick and agile.

4. Further, the method for initializing several values into the Map container by using the core class includes: implementing the initialization of the several values into the Map container by using a lambda expression. The initialization is realized through a line of code lambda expression, which improves the code readability, maintainability and reuse rate, reduces the development cost, and makes the development agile and rapid.

Description of drawings

In order to illustrate the specific embodiments of the present invention or the technical solutions in the prior art more clearly, the following briefly introduces the accompanying drawings that need to be used in the description of the specific embodiments or the prior art. Obviously, the accompanying drawings in the following description The drawings are some embodiments of the present invention. For those of ordinary skill in the art, other drawings can also be obtained based on these drawings without creative efforts.

1 is a flowchart of a method for implementing complex branch logic calls provided in an embodiment of the present invention;

2 is a schematic diagram of an implementation process of a method for implementing complex branch logic calls provided in an embodiment of the present invention;

FIG. 3 is a block diagram of a module of an apparatus for implementing complex branch logic calls according to an embodiment of the present invention.

Detailed ways

The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are a part of the embodiments of the present invention, but not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

In addition, the technical features involved in the different embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other.

An embodiment of the present invention provides a method for implementing complex branch logic invocation. Referring to FIG. 1, FIG. 1 is a flowchart of a method for implementing complex branch logic invocation provided in an embodiment of the present invention. It should be understood that, The method may also include additional blocks not shown and/or blocks shown may be omitted, and the scope of the present invention is not limited in this regard. It includes the following steps:

At step 101, a class is created in which a Map container is created containing several keys.

Specifically, in some embodiments, the method of the present invention is implemented based on java jdk8, a new class is created using java, and a Map container is created in the class. Map is a container that associates key objects and value objects. Map The container provides a mapping relationship, in which the elements are stored in the form of key-value pairs, which can quickly find the value (value) according to the key (key). The key-value pair in the Map container exists in the form of an object instance of the Entry type. , the key (key) cannot be repeated, the value value can be repeated, a value value can form a corresponding relationship with many keys, and each key can only be mapped to at most one value value. The keys of the Map container cannot be repeated. When the Map container has the same key, the key cannot be repeated. The value corresponding to the following key will overwrite the value corresponding to the previous key. In some embodiments, referring to FIG. 2 , taking the example of calling the provident fund data of each province, the key is used as the Type for distinguishing each province: areaType.

At step 102, a core class is created through which several values are initialized into the Map container, and the keys are mapped to the values to form key-value pairs.

Specifically, the core class can be created in the aforementioned class, or can be created outside the class. In some embodiments, the values are isolated from each other and implemented in different ways. In this way, it can be avoided that the readability of the code is too long and the maintainability is poor, so the readability, maintainability and reuse rate of the code are improved, the development cost is reduced, and the development is agile and rapid.

In some embodiments, referring to FIG. 2 , taking the call of the provident fund data of each province as an example, the value is the logical processing of Zhejiang, the logical processing of Jiangsu, the logical processing of Anhui, the logical processing of Jiangxi, the logical processing of Shanghai, and the like. The core class initializes the value into the Map container.

In some embodiments, the value is created using a function. It is more convenient to use functions, and the code of functional programming has a higher signal-to-noise ratio. The code of functional programming is not only concise and elegant, less error-prone, but also more efficient, easy to optimize, improve and parallelize, thereby reducing development costs and making development easier. Quick and agile.

In some embodiments, the method of initializing a number of values into the Map container by the core class includes using a lambda expression to implement the initialization of the number of values into the Map container. With lambda expressions, you can fully utilize the power of functional programming in Java. Using functional style, you can get better expressiveness, more concise code, fewer assignment operations, and fewer errors, thus improving code readability. It reduces development costs and makes development agile and rapid.

In some embodiments, the method of initializing several values into the Map container through the core class further includes: injecting an http interface into the core class, and calling a core method of the core class to complete the using lambda expression The implementation initializes the several values into the Map container.

At step 103, according to the different keys, the value corresponding to the key-value pair is called from the Map container through the core class.

Specifically, referring to FIG. 2 , taking the example of calling the provident fund data of each province, when calling the provident fund data of Zhejiang, according to the aeraType of Zhejiang, the logic processing of Zhejiang is called from the Map container through the core class, so as to obtain the provident fund data of Zhejiang .

FIG. 3 is a block diagram of a module of an apparatus for implementing complex branch logic calls according to an embodiment of the present invention. The device includes:

a memory 201; and a processor 202 connected to the memory 201, the processor 202 is configured to: create a class, and create a Map container in the class, and the Map container contains several keys; create a core class, through The core class initializes several values into the Map container, and the keys are mapped to the values to form key-value pairs; according to the different keys, the core class calls the keys from the Map container The corresponding stated value in the value pair.

In some embodiments, the processor 202 is further configured to isolate different said values from each other.

In some embodiments, the processor 202 is further configured to map each of the keys to one of the values.

In some embodiments, the processor 202 is further configured to: the value is created using a function.

In some embodiments, the processor 202 is further configured to: the method of initializing a number of values into the Map container by the core class comprises: using a lambda expression to implement the initialization of the number of values into the Map container .

In some embodiments, the processor 202 is further configured to: the method of initializing several values into the Map container through the core class further comprises: injecting an http interface into the core class, calling the core of the core class The method completes the initialization of the number of values into the Map container using the lambda expression implementation.

In some embodiments, the processor 202 is further configured such that the core class is created in the class.

For a specific implementation method, refer to the foregoing method embodiments, and details are not repeated here.

According to various embodiments of the present invention, by creating multiple method classes (values) in one class to achieve different requirements, code readability, maintainability and reuse rate are improved, development costs are reduced, and development Agile and fast, and avoids encapsulating the logic of each part into different classes. Because there are many branch judgments, there will be more and more policy implementation classes. It is impossible to overlook the business logic of assignment and comparison, and the development time increases exponentially. question.

The present invention may be a method, apparatus, system and/or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for carrying out various aspects of the present invention.

A computer-readable storage medium may be a tangible device that can hold and store instructions for use by the instruction execution device. The computer-readable storage medium may be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (non-exhaustive list) of computer readable storage media include: portable computer disks, hard disks, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM) or flash memory), static random access memory (SRAM), portable compact disk read only memory (CD-ROM), digital versatile disk (DVD), memory sticks, floppy disks, mechanically coded devices, such as printers with instructions stored thereon Hole cards or raised structures in grooves, and any suitable combination of the above. Computer-readable storage media, as used herein, are not to be construed as transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (eg, light pulses through fiber optic cables), or through electrical wires transmitted electrical signals.

The computer readable program instructions described herein may be downloaded to various computing/processing devices from a computer readable storage medium, or to an external computer or external storage device over a network such as the Internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer-readable program instructions from a network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in each computing/processing device .

The computer program instructions for carrying out the operations of the present invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state setting data, or instructions in one or more programming languages. Source or object code, written in any combination, including object-oriented programming languages, such as Smalltalk, C++, etc., and conventional procedural programming languages, such as the "C" language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server implement. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (eg, using an Internet service provider through the Internet connect). In some embodiments, custom electronic circuits, such as programmable logic circuits, field programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), can be personalized by utilizing state information of computer readable program instructions. Computer readable program instructions are executed to implement various aspects of the present invention.

Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.

These computer readable program instructions may be provided to the processing unit of a general purpose computer, special purpose computer or other programmable data processing device to produce a machine that causes the instructions when executed by the processing unit of the computer or other programmable data processing device , resulting in means for implementing the functions/acts specified in one or more blocks of the flowchart and/or block diagrams. These computer readable program instructions can also be stored in a computer readable storage medium, these instructions cause a computer, programmable data processing apparatus and/or other equipment to operate in a specific manner, so that the computer readable medium on which the instructions are stored includes An article of manufacture comprising instructions for implementing various aspects of the functions/acts specified in one or more blocks of the flowchart and/or block diagrams.

Computer-readable program instructions can also be loaded onto a computer, other programmable data processing apparatus, or other equipment to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus, or other equipment to produce a computer-implemented process , thereby causing instructions executing on a computer, other programmable data processing apparatus, or other device to implement the functions/acts specified in one or more blocks of the flowcharts and/or block diagrams.

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more functions for implementing the specified logical function(s) executable instructions. In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It is also noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented in dedicated hardware-based systems that perform the specified functions or actions , or can be implemented in a combination of dedicated hardware and computer instructions.

It is noted that all features disclosed in this specification (including any accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless directly stated otherwise. Thus, unless expressly stated otherwise, each feature disclosed is only one example of a group of equivalent or similar features. In the case of use, further, preferably, further and more preferably is a simple beginning of the description of another embodiment on the basis of the foregoing embodiment, which is further, preferably, further or More preferably, the content of the backband is combined with the foregoing embodiment as a complete composition of another embodiment. A further embodiment can be formed by arbitrarily combining several further, better, further or more optimal arrangements of the rear bands of the same embodiment.

It should be understood by those skilled in the art that the embodiments of the present invention shown in the above description and the accompanying drawings are only examples and do not limit the present invention. The objects of the present invention have been fully and effectively achieved. The functional and structural principles of the present invention have been shown and described in the embodiments, and the embodiments of the present invention may be modified or modified in any way without departing from the principles.

Claims (10)

1. A method for implementing a complex branch logic call, comprising the steps of:

creating a class, creating a Map container in the class, wherein the Map container comprises a plurality of keys;

creating a core class by which values are initialized into the Map container, the keys being mapped to the values to form key-value pairs;

and calling the corresponding value in the key value pair from the Map container through the core class according to different keys.

2. The method of claim 1, wherein different values are isolated from each other.

3. The method of claim 1, wherein each of said keys maps to a respective one of said values.

4. The method of claim 1, wherein the value is created using a function.

5. The method of claim 1, wherein initializing values into the Map container by the core class comprises: initializing the number of values into the Map container is accomplished using lambda expressions.

6. The method of claim 5, wherein initializing values into the Map container by the core class further comprises: and injecting an http interface into the core class, and calling a core method of the core class to complete the initialization of the values into the Map container by using the lambda expression.

7. The method of claim 1, wherein the core class is created in the class.

8. An apparatus for implementing complex branch logic calls, comprising:

a memory; and

a processor coupled to the memory, the processor configured to:

creating a class, creating a Map container in the class, wherein the Map container comprises a plurality of keys;

creating a core class by which values are initialized into the Map container, the keys being mapped to the values to form key-value pairs;

and calling the corresponding value in the key value pair from the Map container through the core class according to different keys.

9. The apparatus of claim 8, wherein the processor is further configured to: different said values are isolated from each other.

10. A computer storage medium having a computer program stored thereon, wherein the computer program, when executed by a machine, performs the steps of the method of any of claims 1-7.

Images