Report Development Method Based on JAVA Application

Abstract

The present invention provides a report development method based on JAVA application, which belongs to the field of Java compilation and solves the problem of high difficulty in Java development. The method is specifically as follows: step S1: obtaining a word element and a token of a Java program; step S2: constructing an AST syntax tree according to the word element and the token of the Java program; step S3: adding a report to the Java program; extracting unprocessed annotations in the Java program; extracting analysis nodes in the AST syntax tree, creating an annotation processor according to the syntax structure of the analysis node, and modifying the AST syntax tree; step S4: using the modified AST syntax tree as user output; converting the Java program into a bytecode file; the present invention constructs an AST tree by performing lexical and grammatical analysis on the Java program, and adjusts the AST tree and compiles the Java program according to the annotations in the Java program, so that the Java program runs in a more efficient and stable manner.

Description

Technical Field

[0001] The invention discloses a report development method based on JAVA application and relates to the field of Java compilation. Background Art

[0002] The existing reporting methods for JAVA applications have the following shortcomings:

[0003] High development threshold: Although Java report development tools provide rich functions and flexibility, their development threshold is relatively high; developers need to have certain Java programming skills and report design experience to fully utilize the advantages of these tools.

[0004] Performance issues: Java is an interpreted language, and its execution efficiency may be lower than that of compiled languages. If there are data processing logic errors in the compiled Java language project or the data processing logic is inconsistent with the user's preset logic, it will cause runtime errors or slow running speed.

[0005] Steep learning curve: For beginners, mastering Java report development tools requires a long time of learning and practice. This is because these tools usually have complex functions and flexible configuration options, which is a huge learning cost for developers. Summary of the invention

[0006] In view of the deficiencies in the prior art, the present invention aims to provide a report development method based on JAVA application, aiming to solve the problem of high difficulty in Java development.

[0007] In order to achieve the above object, the present invention is implemented by the following technical scheme: a report development method based on JAVA application includes:

[0008] Step S1: Obtain the source file of the Java program, and use the Java compiler to extract the character sequence set in the source file; perform lexical analysis based on the character sequence set to obtain the word unit and token of the Java program;

[0009] Step S2: Taking the lexers and tokens of the Java program as the input of the syntax analyzer, matching and combining the lexers and tokens of the Java program using context-free grammar based on Java syntax rules, and constructing an AST syntax tree;

[0010] Step S3: Using JasperReports as a reporting tool, add a report to the Java program; extract all annotations in the Java program, and determine whether there are annotation processors corresponding to all annotations in the Java program; if some or all of them are not, the annotations without annotation processors are regarded as unprocessed annotations; extract the operator nodes, expression nodes, and assignment nodes corresponding to the unprocessed annotations in the AST syntax tree as analysis nodes, create an annotation processor according to the syntax structure of the analysis node, and modify the AST syntax tree; if all of them are present, do not process them;

[0011] Step S4: The modified or unmodified AST syntax tree is used as user output; according to the modified or unmodified AST syntax tree, a Java compiler is used to convert the Java program into a bytecode file.

[0012] Furthermore, the specific steps of step S1 are as follows:

[0013] Step S11: Obtain the Java SE document from the Oracle official website; obtain the source file of the Java program, and extract the ordered character sequences such as identifiers, keywords, operators, variables, and constants in the source file based on the Java SE document using a Java compiler as a character sequence set;

[0014] Step S12: define enumeration TokenType: used to represent the Token type corresponding to different ordered character sequences in the character sequence set;

[0015] Define the Token class: used to store the type and value of Token; use the constructor Token(TokenType type,String value) to initialize the type and value of Token;

[0016] Rewrite the toString() method and modify the return value of the toString() method to:

[0017] String.format("(%s,'%s')",type,value), used to output the Token information corresponding to different ordered character sequences in the form of a finite state automaton;

[0018] Step S13: define Lexer class;

[0019] In the Lexer class, define a string variable input to store the input string, which is the code of the Java program.

[0020] Define an integer variable position to store the scanning position, that is, the scanning position of the Java program code;

[0021] Define an integer variable length to store the length of the string, that is, the length of the Java program code;

[0022] Define the constructor Lexer(String input) to initialize the Lexer object, set the scan position to 0; set the input string to: hello world, and set the string length to 11;

[0023] Step S14: define the implementation method of the Lexer class;

[0024] Step S15: Summarize the output of the toString() method to obtain all the tokens of the Java program and the tokens corresponding to all the tokens, and then go to step S2.

[0025] Furthermore, the specific steps of step S14 are as follows:

[0026] Step S141: obtaining the first ordered character sequence of the Java program as the first character; defining a StringBuilder object: for receiving the string value of the first character; determining the character type of the first character, calling a corresponding parsing method, and parsing the syntax element of the first character;

[0027] Step S142: If the character type of the first character is a Java identifier (such as a variable name, function name, class name, etc.), call the parseIdentifier() method;

[0028] Step S143: if the character type of the first character is an integer, call the parseInteger() method; if the character type of the first character is a floating point number, call the parseFloat() method; if the character type of the first character is a large number, call the parseBigNumber() method;

[0029] Step S144: If the character type of the first character is an operator, call the parseOperator() method;

[0030] Step S145: If the character type of the first character is a bracket, call the parseParenthesis() method;

[0031] Step S146: If the character type of the first character is a Java keyword, no parsing is performed;

[0032] Step S147: call the getNextToken() method to obtain the token of the next non-empty ordered character sequence, and repeat steps S141 to S146 until every ordered character sequence in the Java program is parsed.

[0033] Furthermore, the specific steps of step S2 are as follows:

[0034] Step S21: Using Backus-Naur Form (BNF) or Extended Backus-Naur Form (EBNF) as the grammatical rules for Java grammar analysis;

[0035] Step S22: define a lexical analysis parser implementation method: parse method, used to parse the nodes of the class object in the Java program;

[0036] Step S23: define the implementation method of the secondary lexical analysis parser: parseMethod method, used to parse nodes of non-class objects or member objects in a class in a Java program;

[0037] Step S24: define ASTNode class: used to record all nodes of the AST tree output by steps S22 to S23;

[0038] Step S25: Summarize the output of the ASTNode class to obtain the AST tree of the Java program and proceed to step S3.

[0039] Furthermore, the specific steps of step S22 are as follows:

[0040] Step S221: corresponding to the private method parse, as the entry of a lexical analysis parser; parse method: no parameters, return type: ASTNode;

[0041] Step S222: Create an object root of ASTNode type, which represents the root node of the AST tree. The initial value of root is empty.

[0042] Take the class with main method as the starting class, and record the first token of the starting class as the first token;

[0043] Traverse the tokens of the entire Java program from the first token until the end-of-file marker EOF is encountered;

[0044] Step S222: Determine whether the Token corresponding to the first word is a class;

[0045] If yes, use the advance() method to get the next non-Java keyword token corresponding to the first token, recorded as the main token; the main token is used as the root node of the AST tree, that is, the value of root is an empty main token;

[0046] If not, then proceed to step S23 to parse the node corresponding to the first word element that is not a class object or a member object in the class until all words in the starting class are parsed;

[0047] Step S223: obtaining a reference class of the starting class as a jump class;

[0048] The first word of the skip class is taken as the starting word, and the type object of the starting word is analyzed, and the process goes to step S224;

[0049] If the starting class does not have a skip class, then obtain the root directory of the Java program; and parse the first non-starting class Java class in the root directory as a skip class;

[0050] Step S224: Check whether the Token of the initial word is class;

[0051] If so, create an ASTNode object MethodName representing the class name to receive the initial token, and add the initial token to the child node of the class node on the AST tree, and then call the advance() method to check the Token of the next token output by the parse method;

[0052] If not, go to step S23.

[0053] Furthermore, the specific steps of step S23 are as follows:

[0054] Step S231: define a private method parseMethod as the entry of the secondary lexical analysis parser; parseMethod method: no parameters, return type: ASTNode;

[0055] Step S232: Obtain the word unit output by the parseMethod method as the current word unit;

[0056] Check whether the token of the current word is a Java keyword and whether the token is void;

[0057] If yes, create an ASTNode object ReturnType representing the return value type to receive the current token, add the current token to the child node of the method node on the AST tree, and then call the advance() method to check the Token of the next token output by the parseMethod method;

[0058] If not, proceed to step S234;

[0059] Step S233: Check whether the Token of the current word is an identifier (i.e., a method name or a variable name);

[0060] If yes, create an ASTNode object MethodName representing the method name to receive the current token, and receive the child node of the expression node added to the AST tree, and then call the advance() method to check the Token of the next token output by the parseMethod method;

[0061] If not, proceed to step S234;

[0062] Step S234: Check whether the Token of the current word is a sub-constant. If so, create an ASTNode object MethodName representing the constant to receive the current word, and receive the child node of the constant node added to the AST tree by the current word, and then call the advance() method to check the Token of the next word output by the parseMethod method;

[0063] If not, proceed to step S235;

[0064] Step S235: Check whether the Token of the current word is an operator. If so, create an ASTNode object MethodName representing the operator to receive the current word, and receive the child node of the operator node added to the AST tree by the current word, and then call the advance() method to check the Token of the next word output by the parseMethod method;

[0065] If not, proceed to step S236;

[0066] Step S236: Check whether the token of the current word is a separator, and whether the token is an English left bracket or an English left curly bracket;

[0067] If so, create an ASTNode object MethodName representing a separator to receive the current token, and receive the child node of the current token added to the separator node on the AST tree, and then create a loop structure to traverse the tokens output by the parseMethod method in sequence until an English right bracket or an English right curly bracket is found; use the tokens output by the loop structure as input to steps S232 to S236 to extract Java keywords, identifiers, and separators;

[0068] If not, a runtime exception is thrown, indicating that the current word is not a method, and the process returns to step S22.

[0069] Furthermore, the specific steps of step S24 are as follows:

[0070] Step S241: define member variables of ASTNode class:

[0071] Define a String type (member) variable type: used to store the node type of the abstract syntax tree;

[0072] Define a generic list (member) variable children: used to store the child node sequence of the node on the AST tree;

[0073] Step S242: Initialize the constructor of the ASTNode class and create an empty child node list;

[0074] Step S243: Use the addChild method to add a child node to the variable children;

[0075] Override the toString method: used to return the class nodes, method nodes, expression nodes, constant nodes, operator nodes and separator nodes on the AST tree as well as the child nodes corresponding to the class nodes, method nodes, expression nodes, constant nodes, operator nodes and separator nodes in the form of strings.

[0076] Furthermore, the specific steps of step S3 are as follows:

[0077] Step S31: Using JasperReports as a reporting tool, add a report to the Java program;

[0078] Step S311: define the public class JasperReportExample;

[0079] Use the try-catch block to catch exceptions that occur in the JasperReportExample class;

[0080] Step S312: Use the compileReport method to compile the report template file of the Java program and generate a JasperReport object;

[0081] Define a variable reportSource of type String: used to store the path of the report template file;

[0082] Step S313: define a generic list variable dataList; call the getData method to obtain the report data in the Java program and receive it with the variable dataList;

[0083] Use the JRBeanCollectionDataSource method to create a data source object and pass the variable dataList to the constructor of the JasperReportExample class;

[0084] Step S314: create an object parameters of the HashMap type for storing the key-value pairs received by the variable dataList;

[0085] Use the fillReport method of JasperFillManager to fill the report, pass the JasperReport object and the variable dataList to the fillReport method, and return the JasperPrint object;

[0086] Step S315: Encapsulate the JasperPrint object in a SimpleExporterInput object and pass it to the setExporterInput method;

[0087] Use the SimpleOutputStreamExporterOutput object to encapsulate the variable reportSource; call the exportReport method to export the report of the Java program;

[0088] Step S32: extract all annotations in the Java program, and determine whether there are annotation processors corresponding to all annotations in the Java program;

[0089] If some or all of them are not present, the annotations without annotation processors are treated as unprocessed annotations; the nodes corresponding to the unprocessed annotations are extracted from the AST syntax tree, the AST syntax tree is modified, and step S33 is entered;

[0090] If all are present, no processing will be done;

[0091] Step S33: extracting the operator nodes, expression nodes and assignment nodes corresponding to the unprocessed annotations in the AST syntax tree as analysis nodes, creating an annotation processor according to the syntax structure of the analysis nodes, and modifying the AST syntax tree;

[0092] Step S34: Summarize the Java programs added and modified in steps S31 to S33 as input for lexical analysis of the Java programs, and re-execute step S2 until all annotations in the Java programs have their corresponding annotation processors.

[0093] Furthermore, the specific steps of step S33 are as follows:

[0094] Step S331: extract the operator node corresponding to the unprocessed annotation as the target node;

[0095] Adjust the AST syntax tree according to the target node;

[0096] Step S332: extract the class node corresponding to the target node, recorded as target node a1;

[0097] According to the target node a1, find the method corresponding to the target node a1 in the Java program and record it as the target method;

[0098] According to the target node a1, find the class corresponding to the target node a1 in the Java program and record it as the target class;

[0099] Check whether there is an inheritance keyword extends in the target class;

[0100] If yes, create an annotation processor according to the parent class of the target class and go to step S333;

[0101] If not, check whether the target class contains the implementation keyword implements, and go to step S334;

[0102] Step S333: Create an annotation processor according to the parent class inherited by the target class;

[0103] Step S3331: Create a file named: avax.target class name.target method name.target node name in the META-INF / services directory of the Java program;

[0104] Step S3332: Find a method or symbol with the same name as the target method or target node in the parent class inherited by the target class;

[0105] Step S3333: Record the method in the parent class with the same name as the target method as the reference method; record the symbol in the parent class with the same name as the target node as the reference symbol;

[0106] Step S3334: overload the target method in the target class according to the reference method;

[0107] Get the definition method of the reference symbol in the parent class as the exported method; import the exported method into the function body of the target method in the target class;

[0108] Step S334: If the target class has the keyword implements, then in the interface implemented by the target class, find a method or symbol with the same name as the target method or target node, and repeat the same steps in step S333 to create an annotation processor;

[0109] If the keyword implements is not implemented in the target class, go to step S335.

[0110] Furthermore, the subsequent steps of step S334 are as follows:

[0111] Step S335: Count the number of all classes in the Java program and the number of all methods corresponding to each class;

[0112] The number of all classes in the Java program is denoted as cl; the number of all methods corresponding to each class is denoted as me1, me2~me cl ;

[0113] Among them, me1 represents the total number of methods corresponding to the first class in the Java program; me2 represents the total number of methods corresponding to the second class in the Java program; and so on. cl Indicates the total number of methods corresponding to the cl-th class in the Java program;

[0114] Step S336: Assume that the total number of word units corresponding to the i-th class in the Java program is: lea(i);

[0115] Suppose the number of terms in the jth method corresponding to the i-th class in the Java program is: leb(i, j);

[0116] Let the number of symbols in the jth method corresponding to the i-th class in the Java program that are identical to the target symbol be: lec(i, j);

[0117] Define the TF-IDF value of the jth method corresponding to the i-th class in the Java program that has the same TF-IDF as the target symbol, denoted as TF-IDF(i, j) value;

[0118] Where i and j are both positive integers, the value range of i is: 1~cl, the value range of j is: me1~me cl ;

[0119] The calculation formula of TF-IDF(i, j) is as follows:

[0120] Calculate the inverse document frequency IDF(i, j) of the jth method corresponding to the i-th class in the Java program with the same target symbol. The calculation formula of IDF(i, j) is as follows:

[0121]

[0122] Calculate the inverse document frequency TF-IDF(i, j) of the jth method corresponding to the i-th class in the Java program with the same target symbol. The calculation formula of TF-IDF(i, j) is as follows:

[0123]

[0124] Step S337: According to the TF-IDF(i, j) calculation formula defined in step S336, the TF-IDF value of each method corresponding to each class in the Java program is calculated to obtain TF-IDF(1, 1), TF-IDF(1, 2) ~ TF-IDF(1, me1) ~ TF-IDF(cl, me cl );

[0125] Among them, TF-IDF(1,1) represents the TF-IDF value of the first method corresponding to the first class in the Java program; TF-IDF(1,2) represents the TF-IDF value of the second method corresponding to the first class in the Java program; and so on, TF-IDF(1,me1) represents the TF-IDF value of the me1th method corresponding to the first class in the Java program; TF-IDF(cl,me cl ) indicates the me corresponding to the cl-th class in the Java program cl TF-IDF value of each method;

[0126] Press TF-IDF(1,1)~TF-IDF(cl,me cl ) Arrange the methods in the Java program in descending order to obtain a priority method sequence;

[0127] The method corresponding to the first TF-IDF value in the priority method sequence is used as the reference method, and the same steps as in step S333 are repeated according to the reference method to create an annotation processor;

[0128] Step S338: Repeat the same steps of creating annotation processors for operator nodes corresponding to unprocessed annotations, and create annotation processors for expression nodes and assignment nodes corresponding to unprocessed annotations.

[0129] Compared with the prior art, the present invention has the following beneficial effects:

[0130] Seamless integration and platform compatibility: Due to the cross-platform characteristics of Java, the present invention can be integrated into various J2EE application systems. This compatibility enables the report module to run on different operating systems and hardware platforms without requiring extensive modifications to the report code.

[0131] Strong code processing capability: The present invention can efficiently process large amounts of data, generate complex reports and charts, and provide support for users to modify Java projects.

[0132] Expanding Java functions: The present invention can support operator overloading in JAVA applications, automatically analyze the dependencies between data based on the AST tree, and rearrange the execution order, thereby reducing the burden on developers. BRIEF DESCRIPTION OF THE DRAWINGS

[0133] Other features, objects and advantages of the present invention will become more apparent from the detailed description of non-limiting embodiments made with reference to the following drawings:

[0134] Figure 1 It is a schematic diagram of the method of the present invention;

[0135] Figure 2 This is a Java compilation schematic diagram of the present invention;

[0136] Figure 3 This is a logical diagram for adjusting the AST number nodes of the present invention. DETAILED DESCRIPTION

[0137] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the present invention is further described in detail below with reference to the accompanying drawings and specific embodiments.

[0138] See also Figure 1 and Figure 2 , the report development methods based on JAVA applications include:

[0139] It should be noted that the "Java program" in the present invention refers to a program compiled in Java using the present invention (the report development method based on JAVA application).

[0140] Step S1: Obtain the source file of the Java program, and use the Java compiler to extract the character sequence set in the source file; perform lexical analysis based on the character sequence set to obtain the word unit and token of the Java program;

[0141] The specific steps of step S1 are as follows:

[0142] Step S11: Obtain the Java SE document from Oracle's official website (i.e., the standard Java grammar rule document)

[0143] Obtain a source file of a Java program, and use a Java compiler to extract identifiers (an ordered combination of letters (AZ, az), numbers (0-9), underscores (_), and dollar signs ($)), keywords (such as class, int, extends, etc.), operators (such as +, -, *, / , %), variables, constants, and other ordered character sequences in the source file as a character sequence set based on a Java SE document;

[0144] Step S12: define enumeration TokenType: used to represent the Token type corresponding to different ordered character sequences in the character sequence set;

[0145] Define the Token class: used to store the type and value of Token; use the constructor Token(TokenType type,String value) to initialize the type and value of Token.

[0146] Rewrite the toString() method and modify the return value of the toString() method to:

[0147] String.format("(%s,'%s')",type,value), used to output the Token information corresponding to different ordered character sequences in the form of "finite state automaton";

[0148] Step S13: define Lexer class;

[0149] In the Lexer class, define a string variable input to store the input string, which is the code of the Java program.

[0150] Define an integer variable position to store the scanning position, that is, the scanning position of the Java program code;

[0151] Define an integer variable length to store the length of the string, that is, the length of the Java program code;

[0152] Define the constructor Lexer(String input) to initialize the Lexer object, set the scan position to 0; set the input string to: hello world, and set the string length to 11;

[0153] It should be noted that in the Lexer constructor, only "setting the scan position to 0" is necessary, and the input string and string length are set according to the preferences of the user or relevant technicians, such as the "hello world" mentioned above.

[0154] Step S14: Define the implementation method of the Lexer class:

[0155] Step S141: obtaining the first ordered character sequence of the Java program as the first character; defining a StringBuilder object: for receiving the string value of the first character; determining the character type of the first character, calling a corresponding parsing method, and parsing the syntax element of the first character;

[0156] Step S142: If the character type of the first character is a Java identifier (such as a variable name, function name, class name, etc.), call the parseIdentifier() method;

[0157] Step S143: if the character type of the first character is an integer, call the parseInteger() method; if the character type of the first character is a floating point number, call the parseFloat() method; if the character type of the first character is a large number, call the parseBigNumber() method;

[0158] Step S144: If the character type of the first character is an operator, call the parseOperator() method;

[0159] Step S145: If the character type of the first character is a bracket, call the parseParenthesis() method;

[0160] Step S146: If the character type of the first character is a Java keyword, no parsing is performed;

[0161] Step S147: call the getNextToken() method to obtain the token of the next non-empty ordered character sequence, and repeat steps S141 to S146 until each ordered character sequence in the Java program is parsed;

[0162] Step S15: Summarize the output of the toString() method to obtain all the tokens of the Java program and the tokens corresponding to all the tokens.

[0163] Step S2: Take the lexers and tokens of the Java program as the input of the syntax analyzer, match and combine the lexers and tokens of the Java program using the "context-free grammar" based on the Java syntax rules, and construct an AST syntax tree;

[0164] The specific steps of step S2 are as follows:

[0165] Step S21: Using Backus-Naur Form (BNF) or Extended Backus-Naur Form (EBNF) as the grammatical rules for Java grammar analysis;

[0166] Step S22: define a lexical analysis parser implementation method: parse method, used to parse the nodes of the class object in the Java program;

[0167] Step S221: corresponding to the private method parse, as the entry of a lexical analysis parser; parse method: no parameters, return type: ASTNode;

[0168] Step S222: Create an object root of ASTNode type, which represents the root node of the AST tree. The initial value of root is empty.

[0169] Take the class with main method as the starting class, and record the first token of the starting class as the first token;

[0170] Traverse the tokens of the entire Java program from the first token until the end-of-file marker EOF is encountered;

[0171] Step S222: Determine whether the Token corresponding to the first word is a class;

[0172] If yes, use the advance() method to get the next non-Java keyword token corresponding to the first token, recorded as the main token; the main token is used as the root node of the AST tree, that is, the value of root is an empty main token;

[0173] If not, then proceed to step S23 to parse the node corresponding to the first word element that is not a class object or a member object in the class until all words in the starting class are parsed;

[0174] Step S223: obtaining a reference class of the starting class as a jump class;

[0175] The first word of the skip class is taken as the starting word, and the type object of the starting word is analyzed, and the process goes to step S224;

[0176] If the starting class does not have a skip class, the root directory of the Java program is obtained; the first non-starting class Java class in the root directory is parsed as a skip class (entering step S224);

[0177] Step S224: Check whether the Token of the initial word is class;

[0178] If so, create an ASTNode object MethodName representing the class name to receive the initial token, and add the initial token to the child node of the class node on the AST tree, and then call the advance() method to check the Token of the next token output by the parse method;

[0179] If not, proceed to step S23;

[0180] Step S23: define the implementation method of the secondary lexical analysis parser: parseMethod method, used to parse nodes of non-class objects or member objects in a class in a Java program;

[0181] Step S231: define a private method parseMethod as the entry of the secondary lexical analysis parser; parseMethod method: no parameters, return type: ASTNode;

[0182] Step S232: Obtain the word unit output by the parseMethod method as the current word unit;

[0183] Check whether the token of the current word is a Java keyword and whether the token is void;

[0184] If yes, create an ASTNode object ReturnType representing the return value type to receive the current token, add the current token to the child node of the method node on the AST tree, and then call the advance() method to check the Token of the next token output by the parseMethod method;

[0185] If not, proceed to step S234;

[0186] Step S233: Check whether the Token of the current word is an identifier (i.e., a method name or a variable name);

[0187] If yes, create an ASTNode object MethodName representing the method name to receive the current token, and receive the child node of the expression node added to the AST tree, and then call the advance() method to check the Token of the next token output by the parseMethod method;

[0188] If not, proceed to step S234;

[0189] Step S234: Check whether the Token of the current word is a sub-constant. If so, create an ASTNode object MethodName representing the constant to receive the current word, and receive the child node of the constant node added to the AST tree by the current word, and then call the advance() method to check the Token of the next word output by the parseMethod method;

[0190] If not, proceed to step S235;

[0191] Step S235: Check whether the Token of the current word is an operator. If so, create an ASTNode object MethodName representing the operator to receive the current word, and receive the child node of the operator node added to the AST tree by the current word, and then call the advance() method to check the Token of the next word output by the parseMethod method;

[0192] If not, proceed to step S236;

[0193] Step S236: Check whether the token of the current word is a separator, and whether the token is an English left bracket (“(”) or an English left curly bracket (“{”);

[0194] If so, create an ASTNode object MethodName representing a separator to receive the current token, and receive the child node of the current token added to the separator node on the AST tree, and then create a loop structure to traverse the tokens output by the parseMethod method in sequence until an English right bracket (") or an English right curly bracket (}) is found; use the tokens output by the loop structure as input to steps S232 to S236 to extract Java keywords, identifiers, and separators therein;

[0195] If not, a runtime exception is thrown, indicating that the current word is not a method, and the process returns to step S22;

[0196] Step S24: define the ASTNode class: used to record all nodes of the AST tree (abstract syntax tree) output by steps S22 to S23;

[0197] Step S241: define member variables of ASTNode class:

[0198] Define a String type (member) variable type: used to store the node type of the abstract syntax tree;

[0199] Define a generic list (member) variable children: used to store the child node sequence of the node on the AST tree;

[0200] Step S242: Initialize the constructor of the ASTNode class and create an empty child node list;

[0201] Step S243: Use the addChild method to add a child node to the variable children;

[0202] Override the toString method: used to return the class nodes, method nodes, expression nodes, constant nodes, operator nodes and separator nodes on the AST tree and the child nodes corresponding to the class nodes, method nodes, expression nodes, constant nodes, operator nodes and separator nodes in the form of strings;

[0203] Step S25: Summarize the output of the ASTNode class to obtain the AST tree of the Java program.

[0204] Step S3: Using JasperReports as a reporting tool, add a report to the Java program; extract all annotations in the Java program, and determine whether there are annotation processors corresponding to all annotations in the Java program; if some or all of them are not, the annotations without annotation processors are regarded as unprocessed annotations; extract the operator nodes, expression nodes, and assignment nodes corresponding to the unprocessed annotations in the AST syntax tree as analysis nodes, create an annotation processor according to the syntax structure of the analysis node, and modify the AST syntax tree; if all of them are present, do not process them;

[0205] See also Figure 3 , the specific steps of step S3 are as follows:

[0206] Step S31: Using JasperReports as a reporting tool, add a report to the Java program;

[0207] Step S311: define the public class JasperReportExample;

[0208] Use the try-catch block to catch exceptions that occur in the JasperReportExample class;

[0209] Step S312: Use the compileReport method to compile the report template file of the Java program and generate a JasperReport object (ie, .jasper file);

[0210] Define a variable reportSource of type String: used to store the path of the report template file (.jrxml);

[0211] Step S313: define a generic list variable dataList; call the getData method to obtain the report data in the Java program and receive it with the variable dataList;

[0212] Use the JRBeanCollectionDataSource method to create a data source object and pass the variable dataList to the constructor of the JasperReportExample class;

[0213] Step S314: create an object parameters of the HashMap type for storing the key-value pairs received by the variable dataList;

[0214] Use the fillReport method of JasperFillManager to fill the report, pass the JasperReport object and the variable dataList to the fillReport method, and return the JasperPrint object;

[0215] Step S315: Encapsulate the JasperPrint object in a SimpleExporterInput object and pass it to the setExporterInput method;

[0216] Use the SimpleOutputStreamExporterOutput object to encapsulate the variable reportSource; call the exportReport method to export the report of the Java program;

[0217] Step S32: extract all annotations in the Java program, and determine whether there are annotation processors corresponding to all annotations in the Java program;

[0218] If some or all of them are not present, the annotations without annotation processors are treated as unprocessed annotations; the nodes corresponding to the unprocessed annotations are extracted from the AST syntax tree, the AST syntax tree is modified, and step S33 is entered;

[0219] If all are present, no processing will be done;

[0220] Step S33: extracting the operator nodes, expression nodes and assignment nodes corresponding to the unprocessed annotations in the AST syntax tree as analysis nodes, creating an annotation processor according to the syntax structure of the analysis nodes, and modifying the AST syntax tree;

[0221] Step S331: extract the operator node corresponding to the unprocessed annotation as the target node;

[0222] Adjust the AST syntax tree according to the target node;

[0223] Step S332: extract the class node corresponding to the target node, recorded as target node a1;

[0224] According to the target node a1, find the method corresponding to the target node a1 in the Java program and record it as the target method;

[0225] According to the target node a1, find the class corresponding to the target node a1 in the Java program and record it as the target class;

[0226] Check whether there is an inheritance keyword extends in the target class;

[0227] If yes, create an annotation processor according to the parent class of the target class and go to step S333;

[0228] If not, check whether the target class contains the implementation keyword implements, and go to step S334;

[0229] Step S333: Create an annotation processor according to the parent class inherited by the target class;

[0230] Step S3331: Create a file named "avax.target class name.target method name.target node name" in the META-INF / services directory of the Java program;

[0231] Step S3332: Find a method or symbol with the same name as the target method or target node in the parent class inherited by the target class;

[0232] Step S3333: Record the method in the parent class with the same name as the target method as the reference method; record the symbol in the parent class with the same name as the target node as the reference symbol;

[0233] Step S3334: overload the target method in the target class according to the reference method;

[0234] Get the definition method of the reference symbol in the parent class as the exported method; import the exported method into the function body of the target method in the target class;

[0235] Step S334: If the target class has the keyword implements, then in the interface implemented by the target class, find a method or symbol with the same name as the target method or target node, and repeat the same steps in step S333 to create an annotation processor;

[0236] If the target class does not have the keyword implements, then go to step S335;

[0237] Step S335: Count the number of all classes in the Java program and the number of all methods corresponding to each class;

[0238] The number of all classes in the Java program is denoted as cl; the number of all methods corresponding to each class is denoted as me1, me2~me cl ;

[0239] Among them, me1 represents the total number of methods corresponding to the first class in the Java program; me2 represents the total number of methods corresponding to the second class in the Java program; and so on. cl Indicates the total number of methods corresponding to the cl-th class in the Java program;

[0240] Step S336: Assume that the total number of word units corresponding to the i-th class in the Java program is: lea(i);

[0241] Suppose the number of terms in the jth method corresponding to the i-th class in the Java program is: leb(i, j);

[0242] Let the number of symbols in the jth method corresponding to the i-th class in the Java program that are identical to the target symbol be: lec(i, j);

[0243] Define the TF-IDF value of the jth method corresponding to the i-th class in the Java program that has the same TF-IDF as the target symbol, denoted as TF-IDF(i, j) value;

[0244] Where i and j are both positive integers, the value range of i is: 1~cl, the value range of j is: me1~me cl ;

[0245] The calculation formula of TF-IDF(i, j) is as follows:

[0246] Calculate the inverse document frequency IDF(i, j) of the jth method corresponding to the i-th class in the Java program with the same target symbol. The calculation formula of IDF(i, j) is as follows:

[0247]

[0248] Calculate the inverse document frequency TF-IDF(i, j) of the jth method corresponding to the i-th class in the Java program with the same target symbol. The calculation formula of TF-IDF(i, j) is as follows:

[0249]

[0250] Step S337: According to the TF-IDF(i, j) calculation formula defined in step S336, the TF-IDF value of each method corresponding to each class in the Java program is calculated to obtain TF-IDF(1, 1), TF-IDF(1, 2) ~ TF-IDF(1, me1) ~ TF-IDF(cl, me cl );

[0251] Among them, TF-IDF(1,1) represents the TF-IDF value of the first method corresponding to the first class in the Java program; TF-IDF(1,2) represents the TF-IDF value of the second method corresponding to the first class in the Java program; and so on, TF-IDF(1,me1) represents the TF-IDF value of the me1th method corresponding to the first class in the Java program; TF-IDF(cl,me cl ) indicates the me corresponding to the cl-th class in the Java program cl TF-IDF value of each method;

[0252] Press TF-IDF(1,1)~TF-IDF(cl,mecl ) Arrange the methods in the Java program in descending order to obtain a priority method sequence;

[0253] The method corresponding to the first TF-IDF value in the priority method sequence is used as the reference method, and the same steps as in step S333 are repeated according to the reference method to create an annotation processor;

[0254] Step S338: repeat the same steps of creating annotation processors for operator nodes corresponding to unprocessed annotations (i.e., steps S331 to S337), and create annotation processors for expression nodes and assignment nodes corresponding to unprocessed annotations;

[0255] Step S34: Summarize the Java programs added and modified in steps S31 to S33 as input for lexical analysis of the Java programs, and re-execute step S2 until all annotations in the Java programs have their corresponding annotation processors.

[0256] Step S4: Use the modified AST syntax tree (or unmodified AST syntax tree) as user output; and use a Java compiler to convert the Java program into a bytecode file (i.e., a .class file) according to the (modified or unmodified) AST syntax tree.

[0257] It should be noted that the above scheme only lists the implementation logic of the present invention, and the code part is only a simple demonstration of necessary functions and cannot be used directly; when users or relevant technical personnel use the code of this scheme, please rewrite or overload the above code part in combination with the actual Java project.

[0258] The above formulas are all dimensionless and numerical calculations. The formula is a formula for the most recent real situation obtained by collecting a large amount of data and performing software simulation. The preset parameters in the formula are set by technical personnel in this field according to actual conditions. For example, if there are weight coefficients and proportional coefficients, their set sizes are to quantify each parameter to obtain a specific value, which is convenient for subsequent comparison. Regarding the size of the weight coefficient and the proportional coefficient, it is sufficient as long as it does not affect the proportional relationship between the parameter and the quantized value.

[0259] Finally, it should be noted that the above-described embodiments are only specific implementations of the present invention, which are used to illustrate the technical solutions of the present invention, rather than to limit them. The protection scope of the present invention is not limited thereto. Although the present invention is described in detail with reference to the above-described embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solutions recorded in the above-described embodiments within the technical scope disclosed by the present invention, or can easily think of changes, or make equivalent replacements for some of the technical features therein; and these modifications, changes or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention shall be based on the protection scope of the claims.

Claims

1. A report development method based on JAVA application, characterized in that: The method comprises: Step S1: Obtain the source file of the Java program, and use the Java compiler to extract the character sequence set in the source file; perform lexical analysis based on the character sequence set to obtain the word unit and token of the Java program; Step S2: Taking the lexers and tokens of the Java program as the input of the syntax analyzer, matching and combining the lexers and tokens of the Java program using context-free grammar based on Java syntax rules, and constructing an AST syntax tree; Step S3: Using JasperReports as a reporting tool, add a report to the Java program; extract all annotations in the Java program, and determine whether there are annotation processors corresponding to all annotations in the Java program; if some or all of them are not, the annotations without annotation processors are regarded as unprocessed annotations; extract the operator nodes, expression nodes, and assignment nodes corresponding to the unprocessed annotations in the AST syntax tree as analysis nodes, create an annotation processor according to the syntax structure of the analysis node, and modify the AST syntax tree; if all of them are present, do not process them; Step S4: using the modified or unmodified AST syntax tree as user output; using a Java compiler to convert the Java program into a bytecode file according to the modified or unmodified AST syntax tree; The specific steps of step S2 are as follows: Step S21: Using Backus-Naur Form or Extended Backus-Naur Form as the grammar rule for Java grammar analysis; Step S22: define a lexical analysis parser implementation method: parse method, used to parse the nodes of the class object in the Java program; Step S23: define the implementation method of the secondary lexical analysis parser: parseMethod method, used to parse nodes of non-class objects or member objects in a class in a Java program; Step S24: define ASTNode class: used to record all nodes of the AST tree output by steps S22 to S23; Step S25: Summarize the output of the ASTNode class to obtain the AST tree of the Java program and proceed to step S3.

2. The report development method based on JAVA application according to claim 1, characterized in that: The specific steps of step S1 are as follows: Step S11: obtaining a Java SE document; obtaining a source file of a Java program, and extracting an ordered character sequence of identifiers, keywords, operators, variables, and constants in the source file based on the Java SE document using a Java compiler as a character sequence set; Step S12: define enumeration TokenType: used to represent the Token type corresponding to different ordered character sequences in the character sequence set; Define the Token class: used to store the type and value of the Token; Use the constructor Token(TokenType type,String value) to initialize the type and value of Token; Rewrite the toString() method and modify the return value of the toString() method to: String.format("(%s, '%s')", type, value), used to output the Token information corresponding to different ordered character sequences in the form of a finite state automaton; Step S13: define Lexer class; In the Lexer class, define a string variable input to store the input string, which is the code of the Java program. Define an integer variable position to store the scanning position, that is, the scanning position of the Java program code; Define an integer variable length to store the length of the string, that is, the length of the Java program code; Define the constructor Lexer(String input) to initialize the Lexer object, set the scan position to 0; set the input string to: hello world, and set the string length to 11; Step S14: define the implementation method of the Lexer class; Step S15: Summarize the output of the toString() method to obtain all the tokens of the Java program and the tokens corresponding to all the tokens, and then go to step S2.

3. The report development method based on JAVA application according to claim 2, characterized in that: The specific steps of step S14 are as follows: Step S141: obtaining the first ordered character sequence of the Java program as the first character; defining a StringBuilder object: for receiving the string value of the first character; determining the character type of the first character, calling a corresponding parsing method, and parsing the syntax element of the first character; Step S142: If the character type of the first character is a Java identifier, call the parseIdentifier() method; Step S143: if the character type of the first character is an integer, call the parseInteger() method; if the character type of the first character is a floating point number, call the parseFloat() method; if the character type of the first character is a large number, call the parseBigNumber() method; Step S144: If the character type of the first character is an operator, call the parseOperator() method; Step S145: If the character type of the first character is a bracket, call the parseParenthesis() method; Step S146: If the character type of the first character is a Java keyword, no parsing is performed; Step S147: call the getNextToken() method to obtain the token of the next non-empty ordered character sequence, and repeat steps S141 to S146 until every ordered character sequence in the Java program is parsed.

4. The report development method based on JAVA application according to claim 1, characterized in that: The specific steps of step S22 are as follows: Step S221: corresponding to the private method parse, as the entry of a lexical analysis parser; parse method: no parameters, return type: ASTNode; Create an object root of type ASTNode, which represents the root node of the AST tree. The initial value of root is empty. Take the class with main method as the starting class, and record the first token of the starting class as the first token; Traverse the tokens of the entire Java program from the first token until the end-of-file marker EOF is encountered; Step S222: Determine whether the Token corresponding to the first word is a class; If yes, use the advance() method to get the next non-Java keyword token corresponding to the first token, recorded as the main token; the main token is used as the root node of the AST tree, that is, the value of root is an empty main token; If not, then proceed to step S23 to parse the node corresponding to the first word element that is not a class object or a member object in the class until all words in the starting class are parsed; Step S223: obtaining a reference class of the starting class as a jump class; The first word of the skip class is taken as the starting word, and the type object of the starting word is analyzed, and the process goes to step S224; If the starting class does not have a skip class, then obtain the root directory of the Java program; and parse the first non-starting class Java class in the root directory as a skip class; Step S224: Check whether the Token of the initial word is class; If so, create an ASTNode object MethodName representing the class name to receive the initial token, and add the initial token to the child node of the class node on the AST tree, and then call the advance() method to check the Token of the next token output by the parse method; If not, go to step S23.

5. The report development method based on JAVA application according to claim 1, characterized in that: The specific steps of step S23 are as follows: Step S231: define a private method parseMethod as the entry of the secondary lexical analysis parser; parseMethod method: no parameters, return type: ASTNode; Step S232: Obtain the word unit output by the parseMethod method as the current word unit; Check whether the token of the current word is a Java keyword and whether the token is void; If yes, create an ASTNode object ReturnType representing the return value type to receive the current token, add the current token to the child node of the method node on the AST tree, and then call the advance() method to check the Token of the next token output by the parseMethod method; If not, proceed to step S234; Step S233: Check whether the Token of the current word is an identifier; If yes, create an ASTNode object MethodName representing the method name to receive the current token, and receive the current token added to the child node of the expression node on the AST tree, and then call the advance() method to check the Token of the next token output by the parseMethod method; If not, proceed to step S234; Step S234: Check whether the Token of the current word is a sub-constant. If so, create an ASTNode object MethodName representing the constant to receive the current word, and receive the child node of the constant node added to the AST tree by the current word, and then call the advance() method to check the Token of the next word output by the parseMethod method; If not, proceed to step S235; Step S235: Check whether the Token of the current word is an operator. If so, create an ASTNode object MethodName representing the operator to receive the current word, and receive the child node of the operator node added to the AST tree by the current word, and then call the advance() method to check the Token of the next word output by the parseMethod method; If not, proceed to step S236; Step S236: Check whether the token of the current word is a separator, and whether the token is an English left bracket or an English left curly bracket; If so, create an ASTNode object MethodName representing a separator to receive the current token, and receive the child node of the current token added to the separator node on the AST tree, and then create a loop structure to traverse the tokens output by the parseMethod method in sequence until an English right bracket or an English right curly bracket is found; use the tokens output by the loop structure as input to steps S232 to S236 to extract Java keywords, identifiers, and separators; If not, a runtime exception is thrown, indicating that the current word is not a method, and the process returns to step S22.

6. The report development method based on JAVA application according to claim 1, characterized in that: The specific steps of step S24 are as follows: Step S241: define member variables of ASTNode class: Define a String type variable type: used to store the node type of the abstract syntax tree; Define a generic list variable children: used to store the child node sequence of the node on the AST tree; Step S242: Initialize the constructor of the ASTNode class and create an empty child node list; Step S243: Use the addChild method to add a child node to the variable children; Override the toString method: used to return the class nodes, method nodes, expression nodes, constant nodes, operator nodes and separator nodes on the AST tree as well as the child nodes corresponding to the class nodes, method nodes, expression nodes, constant nodes, operator nodes and separator nodes in the form of strings.

7. The report development method based on JAVA application according to claim 1, characterized in that: The specific steps of step S3 are as follows: Step S31: Using JasperReports as a reporting tool, add a report to the Java program; Step S311: define the public class JasperReportExample; Use the try-catch block to catch exceptions that occur in the JasperReportExample class; Step S312: Use the compileReport method to compile the report template file of the Java program and generate a JasperReport object; Define a variable reportSource of type String: used to store the path of the report template file; Step S313: define a generic list variable dataList; call the getData method to obtain the report data in the Java program and receive it with the variable dataList; Use the JRBeanCollectionDataSource method to create a data source object and pass the variable dataList to the constructor of the JasperReportExample class; Step S314: create an object parameters of the HashMap type for storing the key-value pairs received by the variable dataList; Use the fillReport method of JasperFillManager to fill the report, pass the JasperReport object and the variable dataList to the fillReport method, and return the JasperPrint object; Step S315: Encapsulate the JasperPrint object in a SimpleExporterInput object and pass it to the setExporterInput method; Use the SimpleOutputStreamExporterOutput object to encapsulate the variable reportSource; call the exportReport method to export the report of the Java program; Step S32: extract all annotations in the Java program, and determine whether there are annotation processors corresponding to all annotations in the Java program; If some or all of them are not present, the annotations without annotation processors are treated as unprocessed annotations; the nodes corresponding to the unprocessed annotations are extracted from the AST syntax tree, the AST syntax tree is modified, and step S33 is entered; If all are present, no processing will be done; Step S33: extracting the operator nodes, expression nodes and assignment nodes corresponding to the unprocessed annotations in the AST syntax tree as analysis nodes, creating an annotation processor according to the syntax structure of the analysis nodes, and modifying the AST syntax tree; Step S34: Summarize the Java programs added and modified in steps S31 to S33 as input for lexical analysis of the Java programs, and re-execute step S2 until all annotations in the Java programs have their corresponding annotation processors.

8. The report development method based on JAVA application according to claim 7, characterized in that: The specific steps of step S33 are as follows: Step S331: extract the operator node corresponding to the unprocessed annotation as the target node; Adjust the AST syntax tree according to the target node; Step S332: extract the class node corresponding to the target node, recorded as target node a1; According to the target node a1, find the method corresponding to the target node a1 in the Java program and record it as the target method; According to the target node a1, find the class corresponding to the target node a1 in the Java program and record it as the target class; Check whether there is an inheritance keyword extends in the target class; If yes, create an annotation processor according to the parent class of the target class and go to step S333; If not, check whether the target class contains the implementation keyword implements, and go to step S334; Step S333: Create an annotation processor according to the parent class inherited by the target class; Step S3331: Create a file named: avax.target class name.target method name.target node name in the META-INF / services directory of the Java program; Step S3332: Find a method or symbol with the same name as the target method or target node in the parent class inherited by the target class; Step S3333: Record the method in the parent class with the same name as the target method as the reference method; record the symbol in the parent class with the same name as the target node as the reference symbol; Step S3334: overload the target method in the target class according to the reference method; Get the definition method of the reference symbol in the parent class as the export method; Import the exported method into the function body of the target method in the target class; Step S334: If the target class has the keyword implements, then in the interface implemented by the target class, find a method or symbol with the same name as the target method or target node, and repeat the same steps in step S333 to create an annotation processor; If the keyword implements is not implemented in the target class, go to step S335.

9. The report development method based on JAVA application according to claim 8, characterized in that: The subsequent steps of step S334 are as follows: Step S335: Count the number of all classes in the Java program and the number of all methods corresponding to each class; The number of all classes in the Java program is denoted as cl; the number of all methods corresponding to each class is denoted as me1, me2~me cl ; Among them, me1 represents the total number of methods corresponding to the first class in the Java program; me2 represents the total number of methods corresponding to the second class in the Java program; and so on. cl Indicates the total number of methods corresponding to the cl-th class in the Java program; Step S336: Assume that the total number of word units corresponding to the i-th class in the Java program is: lea(i); Suppose the number of tokens in the jth method corresponding to the i-th class in the Java program is: leb(i, j); Let the number of symbols in the jth method corresponding to the i-th class in the Java program that are the same as the target symbol: lec(i, j); Define the TF-IDF value of the jth method corresponding to the i-th class in the Java program that has the same TF-IDF as the target symbol, denoted as TF-IDF(i, j) value; Where i and j are both positive integers, the value range of i is: 1~cl, the value range of j is: me1~me cl ; The calculation formula of TF-IDF(i, j) is as follows: Calculate the inverse document frequency IDF(i, j) of the jth method corresponding to the i-th class in the Java program that has the same symbol as the target. The calculation formula of IDF(i, j) is as follows: ； Calculate the inverse document frequency TF-IDF(i, j) of the jth method corresponding to the i-th class in the Java program with the same target symbol. The calculation formula of TF-IDF(i, j) is as follows: ； Step S337: According to the TF-IDF (i, j) calculation formula defined in step S336, the TF-IDF value of each method corresponding to each class in the Java program is calculated to obtain TF-IDF (1, 1), TF-IDF (1, 2) ~ TF-IDF (1, me1) ~ TF-IDF (cl, me cl ); Among them, TF-IDF (1, 1) represents the TF-IDF value of the first method corresponding to the first class in the Java program; TF-IDF (1, 2) represents the TF-IDF value of the second method corresponding to the first class in the Java program; and so on, TF-IDF (1, me1) represents the TF-IDF value of the me1th method corresponding to the first class in the Java program; TF-IDF (cl, me cl ) indicates the me corresponding to the cl-th class in the Java program cl TF-IDF value of each method; Press TF-IDF (1, 1) ~ TF-IDF (cl, me cl ) Arrange the methods in the Java program in descending order to obtain a priority method sequence; The method corresponding to the first TF-IDF value in the priority method sequence is used as the reference method, and the same steps as in step S333 are repeated according to the reference method to create an annotation processor; Step S338: Repeat the same steps of creating annotation processors for operator nodes corresponding to unprocessed annotations, and create annotation processors for expression nodes and assignment nodes corresponding to unprocessed annotations.

Images