Dynamic compilation of Java programs

[Reseller Note] For many application systems, dynamic loading and execution classes and code snippets are often required, which facilitates deployment simplicity and system design flexibility. This article provides a comprehensive introduction, which is worth your reference.

In Sun JDK 1.2 and later versions, it contains a group of APIs that can compile and execute Java code at runtime. These APIs are included in the tools. Jar class library. This function allows Java programs to dynamically compile and execute Small code blocks during runtime. In some cases, this function makes the Java application architecture more flexible and open.

This article assumes that the reader has installed and configured Sun JDK 1.2 or later on the computer, and has some knowledge about javac compiler commands.

　　Use a compiler in a Java program
Suppose you want to use the javac command to compile the test. Java file in the/home/mytest directory, and set the class file to be stored in the/home/mytest/classes path. Enter the following command:

Javac-D/home/mytest/classes test. Java

To achieve the same purpose, you can also use a Java compiler API provided by Sun. It is also easy to use. The core code segment is as follows:

1. ...
3. 　　String[] ARGs =New String[] {"-D", "/homemytestclasses", "test. Java "};
5. Int status = javac. Compile (ARGs );
7. ...

The javac compilation tool is installed in the/bin directory of the JDK root directory and is responsible for compiling the source code into the bytecode running on JVM. In fact, we often use the javac compilation tool in the/bin directory to compile Java source files. If you dynamically compile arbitrary Java statements in a Java program, the use of this external javac compiler is not flexible enough. Although you can use the runtime class to execute an external command, if you want to know whether the code is compiled and what error occurs during compilation, use the exec () the method is very difficult to implement.

In Sun's JDK 1.2 and later versions, the/lib path of the JDK installation path contains a tool. jar file, which contains a complete compiler package. Com. Sun. Tools. javac. Main is the main class entry of the compiler. If you are familiar with the use of the javac compiler command line, it is easy to understand how to use this class. The compile (string [] P) method executes the compilation action. The parameter P is a string array used to store the Parameter options of the javac command. An int value is returned for the compiled status, the corresponding values are shown in the following table:

Table status parameters and corresponding values

Exit_ OK 0

Exit_error 1

Exit_cmderr 2

Exit_syserr 3

Exit_abnormal 4

　　Compile and execute Java statements during Program Execution

From the above section, we have basically learned how to dynamically compile a Java file. So how to dynamically compile the specified Java statement during runtime? Here is a tip.

Assume that the Java statements to be dynamically compiled are as follows:

1. 　　System. Out. println ("hello, this runtime code !");

The compiler does not support compiling a single Java statement. The compiled object must be. java is a suffix and has a valid structure class source program file. Therefore, you need to transform this statement into a complete class and put this statement into the main method for testing.

1. 　　Public Class<Temporary class file name> {
3. 　　Public Static VoidMain (String[] ARGs)Throws Exception{
5. 　　System. Out. println ("hello, this runtime code !");
7. }
9. }

In this way, the code to be dynamically compiled has been dynamically assembled into the above Code by the program. The preparation work is not over yet, but it seems that the work tends to be slightly complicated. Because the above Code is still stored in the memory, the compiler seems more interested in a hard disk file. We need to reference the java. Io. File class (JDK 1.2 or above) and create a temporary file to store the content of the above Code. The static method createtempfile () of the Java. Io. File class ensures that the created file names are non-duplicated, which increases the flexibility of this program. Flexibility depends on the policies applied to the system architecture.

System. getproperty ("user. dir") is used to obtain the current path, which serves as the directory for storing temporary files.

1. File file;
3. File = file. createtempfile ("javaruntime", ". Java ",NewFile (System. Getproperty ("user. dir ")));
5. 　　StringFilename = file. getname ();
7. 　　StringClassname = getclassname (filename );
9. 　　// Output code to a file
11. Printwriter out =NewPrintwriter (NewFileoutputstream (File ));
13. Out. println ("Public Class"+ Classname +" {"};
15. Out. println ("... code ..");
17. Out. println ("}");
19. 　　// Close the file stream
21. Out. Flush ();
23. Out. Close ();

We agree that the temporary file name to be created will be suffixed with "javaruntime" (which can be any name), and the suffix will end with ". Java. A Java source file to be compiled has been dynamically generated. Next, create a main instance from the com. Sun. Tools. javac package and call the javac. Compile () method to compile the temporary file:

1. PrivateStaticCom. Sun. Tools. javac. Main javac =NewCom. Sun. Tools. javac. Main ();
3. 　　String[] ARGs =New String[] {"-D ",System. Getproperty ("user. dir"), filename };
5. Int status = javac. Compile (ARGs );

Assuming that the temporary file has passed the compiler syntax verification and other verification, the compilation is successful (the value of status is equal to 0, see the previous table), and a Java class file will be added to the running directory of the current program. We will simulate the execution of the Code to be dynamically compiled by executing this Java class file.

Java provides the ability to load classes at runtime, dynamically identifying and calling class constructor methods, class fields, and class methods. Java. Lang. Reflect. method implements the member interface. You can call the interface method to obtain the name and modifier of the method class. Methods such as getruturntype (), getparametertypes (), and getexeptiontypess () return the construction information of the represented method. Another important feature of method is that you can call invoke () to execute this method (for detailed usage, you can view the java. Lang. Reflect package documentation ). The following code creates a java. Lang. Reflect. method class method and calls the getmethod () method to obtain the ing of the assembled main method. The Code is as follows:

1. 　　Try{
3. 　　// Access this class
5. 　　ClassCLS =Class. Forname (classname );
7. 　　// Call the main method
9. Method main = Cls. getmethod ("Main ",New Class[] {String[].Class});
11. Main. Invoke (Null,New Object[] {New String[0]});
13. }Catch(SecurityexceptionSe ){
15. Debug ("Access to the information is denied:" + Se. tostring ());
17. }Catch(NosuchmethodexceptionNME ){
19. Debug ("a matching method is not found orIfThen name is or:
21. "+ NME. tostring ());
23. }Catch(InvocationtargetexceptionITE ){
25. Debug ("ExceptionIn Main: "+ ite. gettargetexception ());
27. }Catch(ExceptionE ){
29. Debug (E. tostring ());
31. }

The running result parameters are as follows:

Hello, This runtime code!

　　Demonstration procedure

The following is a simple Java program, which explains how to use sun's javac compiler to dynamically compile Java statements. To run this program, you must install JDK 1.2 or later on your computer and specify the location of the tools. jar file in classpath or during running.

Program structure:

◆ Compile () compiles Java code and returns the generated temporary file;

◆ Run () run the compiled class file;

◆ Debug () Outputs debugging information;

◆ Getclassname () obtains the class name from a Java source file;

◆ Readline () reads the Java code entered by the user from the console.

1. Import java. Io.File;
3. ...
5. PublicClassRuntimecode {
7. 　　/** Compiler */ 
9. 　　Private StaticCom. Sun. Tools. javac. Main javac =NewCom. Sun. Tools. javac. Main ();
11. 　　/** Wait for the user to enter the javacode and then compile and execute the Code */ 
13. 　　Public Static VoidMain (String[] ARGs)Throws Exception{
15. ...
17. Run (compile (CODE ));
19. }
21. 　　/** Compile javacode and return the temporary file object */ 
23. 　　Private Synchronized StaticFile compile (StringCode)
25. 　　ThrowsIoexception,Exception{
27. File file;
29. 　　// Create a temporary code file in the user's current file directory
31. File = file. createtempfile ("javaruntime", ". Java ",
33. 　　NewFile (System. Getproperty ("user. dir ")));
35. 　　// Delete this temporary Java source file when the VM exits
37. File. deleteonexit ();
39. 　　// Get the file name and Class Name
41. 　　StringFilename = file. getname ();
43. 　　StringClassname = getclassname (filename );
45. 　　// Output code to a file
47. Printwriter out =NewPrintwriter (NewFileoutputstream (File ));
49. Out. println ("/**");
51. ...
53. // Close the file stream
55. Out. Flush ();
57. Out. Close ();
59. // Compile the code file
61. String [] ARGs = new string [] {"-D", system. getproperty ("user. dir"), filename };
63. // Return the compiled status code
65. Int status = javac. Compile (ARGs );
67. // Process the compilation status
69. ...
71. }
73. /** Execute the compiled class file */ 
75. 　　Private Static Synchronized VoidRun (File file)
77. ...
79. 　　// Delete this temporarily compiled class file when the VM exits
81. 　　NewFile (file. getparent (), classname + ".Class"). Deleteonexit ();
83. 　　Try{
85. 　　// Access this class
87. 　　ClassCLS =Class. Forname (classname );
89. 　　// Map the main method
91. Method main = Cls. getmethod ("Main ",New Class[] {String[].Class});
93. 　　// Execute the main method
95. Main. Invoke (Null,New Object[] {New String[0]});
97. }Catch(SecurityexceptionSe ){
99. ...
101. }
103. }
105. 　　/** Print debugging information */ 
107. 　　Private Static VoidDebug (StringMSG ){
109. 　　System. Err. println (MSG );
111. }
113. 　　/** Obtain the class name based on the name of a Java source file */ 
115. 　　Private Static StringGetclassname (StringFilename ){
117. 　　ReturnFilename. substring (0, filename.Length()-5 );
119. }
121. 　　/** Obtain the Java code segment entered by the user from the console */ 
123. ...
125. }

Compile and run the above Code. Enter the following code at the prompt of please input Java code:

For (INT I = 0; I <10; I ++) {system. Out. println ("This is:" + I );}

The running result is as follows:

Please input Java code:

For (INT I = 0; I <10; I ++) {system. Out. println ("This is:" + I );}

Wait ....

--------------------

This is: 0

This is: 1

This is: 2

This is: 3

This is: 4

This is: 5

This is: 6

This is: 7

This is: 8

This is: 9

Summary

On the Application System Platform of large and medium-sized enterprises, the dynamic code compilation technology combined with the OO programming model can ensure the scalability and scalability of the system without the crash of the system. If you are a Java programmer, slightly adjusting the above Code can also help debug small sections of Java code.