CN113900657A

CN113900657A - Method for reading data rule, electronic device and storage medium

Info

Publication number: CN113900657A
Application number: CN202111161448.8A
Authority: CN
Inventors: 王锦胤; 刘国强
Original assignee: Zijincheng Credit Investigation Co ltd
Current assignee: Zijincheng Credit Investigation Co ltd
Priority date: 2021-09-30
Filing date: 2021-09-30
Publication date: 2022-01-07

Abstract

The application discloses a method for reading data rules, electronic equipment and a storage medium. The method comprises the steps of generating a Java file based on a configuration rule; performing pre-compiling based on the Java file to obtain a class file; loading the class file to a JVM virtual machine; and reading the rule of the JVM virtual machine based on the acquired request. The method and the device solve the problems that in the traditional mode, an operator puts the configuration into the database and then reads the database when requesting to enter, certain pressure is caused on the database when the flow is large, and meanwhile, the extra system network overhead is increased; after the system reads the configuration, the configuration of the database is adapted, and the situation that the rules are all circulated may occur, which may cause the technical problem of unnecessary logical operation.

Description

Method for reading data rule, electronic device and storage medium

Technical Field

The invention belongs to the technical field of Java, and particularly relates to a method for reading data rules, electronic equipment and a storage medium.

Background

In the conventional method, as shown in fig. 2, after an operator puts a configuration into a database, the operator reads the database when requesting to enter the configuration, and when the traffic is large, a certain pressure is applied to the database, and at the same time, the additional overhead of the system network is also increased. After the system reads the configuration, the configuration of the database is adapted, and it may happen that the rules are all looped. Resulting in unnecessary logical operations.

In summary, the prior art has the following technical problems:

the system reads the configuration causing unnecessary logic operations.

Disclosure of Invention

In order to solve the above technical problem, the present invention provides a method for reading data rules, comprising the steps of:

generating a Java file based on the configuration rule;

performing pre-compiling based on the Java file to obtain a class file;

loading the class file to a JVM virtual machine;

and reading the rule of the JVM virtual machine based on the acquired request.

Preferably, the generating a Java file based on the configuration rule includes:

acquiring configured information;

extracting rules based on the configured information;

the Java file is generated based on the rule.

Preferably, the pre-compiling based on the Java file to obtain a class file includes:

expanding the Java file, and writing codes in the Java file into the created class file;

converting the code into assembly code;

converting the assembly code into machine code;

an executable class file is generated.

Preferably, the expanding the Java file and writing the code therein into the created class file includes:

reading a source program of the Java file, wherein the source program comprises a pseudo instruction and a special symbol;

carrying out preliminary conversion on the pseudo instructions and the special symbols, wherein the preliminary conversion comprises macro replacement, determining annotations and then carrying out conditional compilation;

and generating new source code based on the conditional compiling result and providing the new source code to a compiler.

Preferably, the converting the code into the assembly code includes:

the compiler saves a function address character table in a class file;

and reading the function address in the function address character table when the function is called according to the instruction.

Preferably, the generating an executable class file includes:

reading a function address from a function address character table of the current class file by a compiler;

the function address read is padded behind the instruction.

Preferably, the loading the class file to the JVM virtual machine includes:

obtaining the class file for verification, and creating a class object;

allocating a memory based on the static variable of the class object, and assigning a default value;

replacing the default value with a class memory address;

the memory address of the class is initialized.

Preferably, the obtaining the class file for verification and creating a class object includes:

acquiring a static storage structure of a binary byte stream of a class;

verifying whether the byte stream and the byte code conform to the specification of a Class file format;

analyzing the program semantics of the data flow and the control flow and judging whether the execution is possible;

converting the static storage structure into a runtime data structure of a method area;

a class object of the class is generated as a data access entry for a method region class.

Preferably, the rule for reading the JVM virtual machine based on the obtained request includes:

acquiring a request;

reading a rule in the JVM virtual machine based on the request;

and operating the rule.

A system for reading data rules, comprising:

the Java file generation module is used for generating a Java file based on the configuration rule;

the pre-compiling module is used for performing pre-compiling based on the Java file to obtain a class file;

the class loading module is used for loading the class file to the JVM virtual machine;

and the rule reading module is used for reading the rule of the JVM virtual machine based on the acquired request.

Preferably, the Java file generating module is configured to:

acquiring configured information;

extracting rules based on the configured information;

the Java file is generated based on the rule.

Preferably, the Java file generating module includes:

the information configuration unit is used for acquiring information input by an operator;

and the information extraction unit is used for extracting the configuration information from the acquired information input by the operator.

Preferably, the pre-compiling module is configured to:

converting the code into assembly code;

converting the assembly code into machine code;

an executable class file is generated.

Preferably, the pre-compiling module is configured to:

the compiler saves a function address character table in a class file;

Preferably, the pre-compiling module is configured to:

the function address read is padded behind the instruction.

Preferably, the class loading module is configured to:

obtaining the class file for verification, and creating a class object;

replacing the default value with a class memory address;

the memory address of the class is initialized.

Preferably, the class loading module is configured to:

acquiring a static storage structure of a binary byte stream of a class;

Preferably, the rule reading module is configured to:

acquiring a request;

reading a rule in the JVM virtual machine based on the request;

and operating the rule.

Preferably, the rule reading module includes:

a request acquisition unit for acquiring user input information;

and the request extracting unit is used for extracting the request from the acquired user input information.

An electronic device comprising a memory and a processor, the memory storing a computer program, wherein the computer program is executed in the processor to perform a method that may implement any of the above.

A storage medium storing a computer program, wherein the computer program is executed in a processor to implement the method of any one of the above.

According to the method, a Java file with rules is generated based on the configuration rules through a Java pre-compiling technology, then the Java file is pre-compiled into a class file recognized by the JVM virtual machine, the rules in the JVM virtual machine are directly operated when a request comes, and the technical effects of avoiding reading a database and improving the performance of a system are achieved.

Drawings

FIG. 1 is a schematic flow chart illustrating a method for reading data rules according to the present application;

FIG. 2 is a flow chart illustrating a prior art method for reading data.

Detailed Description

In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that in the description of the present invention, unless otherwise explicitly specified or limited, the term "storage medium" may be various media that can store a computer program, such as ROM, RAM, a magnetic or optical disk, or the like. The term "processor" may be a chip or a circuit having a data Processing function, such as a CPLD (Complex Programmable Logic Device), an FPGA (Field-Programmable Gate array), an MCU (Microcontroller Unit), a PLC (Programmable Logic Controller), and a CPU (Central Processing Unit). The term "electronic device" may be any device having data processing and storage functions and may generally include fixed and mobile terminals. Fixed terminals such as desktop computers and the like. Mobile terminals such as mobile phones, PADs, and mobile robots, etc. Furthermore, the technical features mentioned in the different embodiments of the invention described later can be combined with each other as long as they do not conflict with each other.

In the following, the present invention proposes some preferred embodiments to teach those skilled in the art to implement.

Example one

The present embodiment provides a method for reading data rules, as shown in fig. 1, including the steps of:

s100, generating a Java file based on a configuration rule;

s200, performing pre-compiling based on the Java file to obtain a class file;

s300, loading the class file to a JVM virtual machine;

s400, reading the rule of the JVM virtual machine based on the acquired request.

In a further embodiment, the generating a Java file based on the configuration rule includes:

s110, acquiring configuration information;

s120, extracting rules based on the configured information;

and S130, generating the Java file based on the rule.

In a further embodiment, the pre-compiling based on the Java file to obtain a class file includes:

s210, expanding the Java file, and writing codes in the Java file into the created class file;

s220, converting the codes into assembly codes;

s230, converting the assembly code into a machine code;

and S240, generating an executable class file.

In a further embodiment, the expanding the Java file and writing the code therein into the created class file includes:

s211, reading a source program of the Java file, wherein the source program comprises a pseudo instruction and a special symbol;

s212, carrying out primary conversion on the pseudo instructions and the special symbols, wherein the primary conversion comprises macro replacement, determining annotations, and then carrying out conditional compilation;

and S213, generating a new source code based on the conditional compiling result and providing the new source code to a compiler.

In a further embodiment, the converting the code into assembly code comprises:

s221, the compiler saves a function address character table in the class file;

s222, reading the function address in the function address character table when the function is called according to the instruction.

In a further embodiment, the generating an executable class file comprises:

s241, reading a function address from a function address character table of the current class file by a compiler;

and S242, filling the read function address behind the instruction.

In a further embodiment, the loading the class file to the JVM virtual machine includes:

s310, acquiring the class file for verification, and creating a class object;

s320, allocating a memory based on the static variable of the class object, and assigning a default value;

s330, replacing the default value with a class memory address;

s340, giving an initial value to the class memory address.

In a further embodiment, the obtaining the class file for verification and creating the class object includes:

s311, acquiring a static storage structure of the binary byte stream of the class;

s312, verifying whether the byte stream and the byte code meet the specification of a Class file format or not;

s313, analyzing the program semantics of the data flow and the control flow, and judging whether the execution is possible;

s314, converting the static storage structure into a runtime data structure of the method area;

s315, generating the class object of the class as a data access entrance of the method area.

In a further embodiment, the reading the rule of the JVM virtual machine based on the obtained request includes:

s410, acquiring a request;

s420, reading rules in the JVM virtual machine based on the request;

and S430, operating the rule.

From the above description, it can be seen that the present invention achieves the following technical effects:

1. by means of a Java precompilation technology, a Java file with rules is generated based on configuration rules, then the Java file is precompiled into a class file recognized by a JVM virtual machine, the rules in the JVM virtual machine are directly operated when a request comes in, reading of a database is avoided, and system performance is improved.

Example two

The present embodiment provides a system for reading data rules, including:

In a further embodiment, the Java file generating module is configured to:

acquiring configured information;

extracting rules based on the configured information;

the Java file is generated based on the rule.

In a further embodiment, the Java file generating module includes:

In a further embodiment, the pre-compilation module is to:

converting the code into assembly code;

converting the assembly code into machine code;

an executable class file is generated.

In a further embodiment, the pre-compiling module is configured to:

the compiler saves a function address character table in a class file;

In a further embodiment, the pre-compiling module is configured to:

the function address read is padded behind the instruction.

In a further embodiment, the class loading module is configured to:

obtaining the class file for verification, and creating a class object;

replacing the default value with a class memory address;

the memory address of the class is initialized.

In a further embodiment, the class loading module is configured to:

acquiring a static storage structure of a binary byte stream of a class;

In a further embodiment, the rule reading module is configured to:

acquiring a request;

reading a rule in the JVM virtual machine based on the request;

and operating the rule.

In a further embodiment, the rule reading module includes:

a request acquisition unit for acquiring user input information;

EXAMPLE III

In this embodiment, a C language program is used, and a method for reading data rules is provided based on a C language, as shown in fig. 1, including the steps of:

s100, generating a C language file based on a configuration rule;

s200, performing pre-compiling based on the C language file to obtain a class file;

s300, loading the class file to a JVM virtual machine;

s110, acquiring configuration information;

s120, extracting rules based on the configured information;

and S130, generating a C language file based on the rule.

In a further embodiment, the pre-compiling based on the C language file to obtain a class file includes:

s210, expanding the C language file, and writing codes in the C language file into a created class file;

s220, converting the codes into assembly codes;

s230, converting the assembly code into a machine code;

and S240, generating an executable class file.

In a further embodiment, the expanding the C language file and writing the code therein into the created class file includes:

s211, reading a source program of the C language file, wherein the source program comprises a pseudo instruction and a special symbol;

In a further embodiment, the pseudo-instruction is a line of code beginning with # number for translating source code of a C language file.

In a further embodiment, the pseudo-instructions include macro definition instructions, conditional compilation instructions, header files containing instructions and special symbols.

In a further embodiment, the preliminary conversion of the pseudo-instruction and the special symbol includes:

expanding macro definition to replace characters;

processing a conditional compilation instruction;

delete all annotations;

adding a line number and a file mark;

the compiler directives are preserved.

In a further embodiment, the converting the code into assembly code comprises:

s221, the compiler saves a function address character table in the class file;

In a further embodiment, the converting the code into assembly code comprises:

and performing lexical, syntactic and semantic analysis on the codes, and optimizing to generate corresponding assembly codes.

In a further embodiment, the generating an executable class file comprises:

and S242, filling the read function address behind the instruction.

s310, acquiring the class file for verification, and creating a class object;

s330, replacing the default value with a class memory address;

s340, giving an initial value to the class memory address.

s410, acquiring a request;

s420, reading rules in the JVM virtual machine based on the request;

and S430, operating the rule.

Example four

The embodiment is directly initialized by skipping the loading process when a special case is met in class loading.

Based on this embodiment, a method for reading data rules is provided, as shown in fig. 1, including the steps of:

s100, generating a Java file based on a configuration rule;

s200, performing pre-compiling based on the Java file to obtain a class file;

s300, loading the class file to a JVM virtual machine;

s110, acquiring configuration information;

s120, extracting rules based on the configured information;

and S130, generating the Java file based on the rule.

s220, converting the codes into assembly codes;

s230, converting the assembly code into a machine code;

and S240, generating an executable class file.

In a further embodiment, the converting the code into assembly code comprises:

s221, the compiler saves a function address character table in the class file;

In a further embodiment, the generating an executable class file comprises:

and S242, filling the read function address behind the instruction.

s310, acquiring the class file for verification, and creating a class object;

s330, replacing the default value with a class memory address;

s340, giving an initial value to the class memory address.

when the static variables and the static non-literal constants of the classes are read and set, initializing the static variables and the static non-literal constants;

when the class is subjected to reflection calling, if the class is not initialized, the initialization of the class needs to be triggered first;

when the class is initialized, if the parent class is not initialized, the initialization of the parent class needs to be triggered first;

when the virtual machine is started, the designated execution main class is initialized preferentially;

when the class corresponding to the method handle is not initialized, the initialization is triggered first.

s410, acquiring a request;

s420, reading rules in the JVM virtual machine based on the request;

and S430, operating the rule.

EXAMPLE III

The embodiment of the present invention further includes an electronic device, including a memory and a processor, where the memory stores a computer program, and the computer program is used to implement the method for reading data rules described above when executed in the processor, where the method includes:

s100, generating a Java file based on a configuration rule;

s200, performing pre-compiling based on the Java file to obtain a class file;

s300, loading the class file to a JVM virtual machine;

Example four

In this embodiment, the present invention further provides a readable storage medium, in which a computer program is stored, where the computer program is used to implement the method for reading data rules described above when executed by a processor, and the method includes:

s100, generating a Java file based on a configuration rule;

s200, performing pre-compiling based on the Java file to obtain a class file;

s300, loading the class file to a JVM virtual machine;

The readable storage medium may be a computer storage medium or a communication medium. Communication media includes any medium that facilitates transfer of a computer program from one place to another. Computer storage media may be any available media that can be accessed by a general purpose or special purpose computer. For example, a readable storage medium is coupled to the processor such that the processor can read information from, and write information to, the readable storage medium. Of course, the readable storage medium may also be an integral part of the processor. The processor and the readable storage medium may reside in an Application Specific Integrated Circuits (ASIC). Additionally, the ASIC may reside in user equipment. Of course, the processor and the readable storage medium may also reside as discrete components in a communication device. The readable storage medium may be a read-only memory (ROM), a random-access memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like.

The present invention also provides a program product comprising execution instructions stored in a readable storage medium. The at least one processor of the device may read the execution instructions from the readable storage medium, and the execution of the execution instructions by the at least one processor causes the device to implement the methods provided by the various embodiments described above.

In the above embodiments of the terminal or the server, it should be understood that the Processor may be a Central Processing Unit (CPU), other general-purpose processors, a Digital Signal Processor (DSP), etc. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of a method disclosed in connection with the present invention may be embodied directly in a hardware processor, or in a combination of the hardware and software modules within the processor.

It should be noted that the steps illustrated in the flowcharts of the figures may be performed in a computer system such as a set of computer-executable instructions and that, although a logical order is illustrated in the flowcharts, in some cases, the steps illustrated or described may be performed in an order different than presented herein.

It will be apparent to those skilled in the art that the modules or steps of the present invention described above may be implemented by a general purpose computing device, they may be centralized on a single computing device or distributed across a network of multiple computing devices, and they may alternatively be implemented by program code executable by a computing device, such that they may be stored in a storage device and executed by a computing device, or fabricated separately as individual integrated circuit modules, or fabricated as a single integrated circuit module from multiple modules or steps. Thus, the present invention is not limited to any specific combination of hardware and software.

The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents and improvements made within the spirit and principle of the present invention are intended to be included within the scope of the present invention.

Claims

1. A method of reading data rules, comprising:

generating a Java file based on the configuration rule;

performing pre-compiling based on the Java file to obtain a class file;

loading the class file to a JVM virtual machine;

and reading the rule of the JVM virtual machine based on the acquired request.

2. The method of claim 1, wherein generating the Java file based on the configuration rule comprises:

acquiring configured information;

extracting rules based on the configured information;

the Java file is generated based on the rule.

3. The method of claim 1, wherein said pre-compiling based on said Java file to obtain a class file comprises:

converting the code into assembly code;

converting the assembly code into machine code;

an executable class file is generated.

4. The method of claim 1, wherein said loading the class file into the JVM virtual machine comprises:

obtaining the class file for verification, and creating a class object;

replacing the default value with a class memory address;

the memory address of the class is initialized.

5. The method of claim 1, wherein reading the rules of the JVM virtual machine based on the obtained request comprises:

acquiring a request;

reading a rule in the JVM virtual machine based on the request;

and operating the rule.

6. A system for reading data rules, comprising:

7. The system of claim 6, wherein the Java file generation module is to:

acquiring configured information;

extracting rules based on the configured information;

the Java file is generated based on the rule.

8. The system of claim 6, wherein the rule reading module is to:

acquiring a request;

reading a rule in the JVM virtual machine based on the request;

and operating the rule.

9. An electronic device comprising a memory and a processor, the memory storing a computer program, wherein the computer program is executed in the processor to implement the method of any of claims 1-5.

10. A storage medium storing a computer program, characterized in that the computer program is executed in a processor implementing the method according to any of claims 1-5.