This article Source and Times Chaoyang Database (Protest Database) Training Department Oracle Database.
Prior to Oracle8i, developers can only use PL / SQL to develop stored procedures. In Oracle8i, not only the original PL / SQL development stored procedure can also be used to develop stored procedures using Java language. This article will briefly introduce knowledge about this, including the following:
l Introduction to the stored procedure;
l Java stored procedure
l Development steps for Java stored procedures
l Use the Java development process;
l Use Java development functions;
l Use a Java development package;
l Develop triggers using Java;
l Use the Java development object method;
l Develop JSP using JDeveloper.
Introduction to the stored procedure
The stored procedure is a parameter stored in the database. When creating a stored procedure, the system is compiled and the execution code is stored in the database.
1. Design the policy of stored procedures
l When defining a stored procedure, use it to complete a single, relatively concentrated task.
l When defining a stored procedure, do not define the process that has been provided by other features. For example, do not define the process of mandatory data integrity (use integrity constraints).
2. Advantages of stored procedures
1) Safety
Once the stored procedure can be created, the permissions of the process can be granted other users, allowing him to perform specific database operations without accessing other mode objects (such as tables). For example, you can grant the permissions of the execution process (update table) to other users, but do not grant them directly access the permissions of the table.
2) Performance
l The stored procedure is only sent to the database once, and its network traffic is smaller than the SQL statement or PL / SQL block.
l When the stored procedure is called, the database will run the stored procedure directly without compiling. It is faster than the SQL statement or PL / SQL block.
3) Memory allocation
The stored procedure takes advantage of the ability of Oracle shared memory. After loading the stored procedure into the memory, multiple users can call the stored procedure at the same time, thereby reducing the actual memory requirements for Oracle.
4) Productivity
The stored procedure has improved development productivity. Improve the development of productivity by writing a public collection as a stored procedure. For example, we can write a process for inserting, updating, deleting an AuthS table, and then the application can call these processes directly without having to override the SQL statement. When the method of managing data changes, you only need to modify the process without any modification of the application.
Java stored procedure
In the previous Oracle version, the development stored procedure is done by PL / SQL. In the Oracle8i version, we can use the PL / SQL to develop stored procedures, but also use Java language to develop stored procedures.
1. Comparison of PL / SQL and Java stored procedures
Developing stored procedures using Java language is the following advantages over PL / SQL:
l Java language has more powerful computing power, providing more operational methods. Use JSP will be your best choice when you want to complete a stored procedure for complex operation.
l PL / SQL can only be used for Oracle databases, while Java languages can be applied to more database systems (such as Sybase, DB2, Informix, etc.), so Java stored procedures will have better compatibility and portability. 2. JSP classification
The Java stored procedure includes four types of processes, functions, triggers, and object methods.
3. Call the four ways of JSP
l Call syntax;
l DML statement;
l PL / SQL block, subroutine, package;
l Implied by the trigger.
Development steps for Java stored procedures
Writing Java source code
When developing a Java stored procedure, you should first write Java source code. As shown below:
Precautions:
l When the class is declared in a public manner, the class name must be exactly the same as its file name.
l Only public static methods can be used as a Java stored procedure.
2. Load Java code and class to Oracle8i database
After writing Java source code, the Java code and the corresponding Java class should be loaded into the Oracle8i database. As shown below:
Loading Java code and class to RDBMS have the following methods:
l Using the LoadJava tool, you can quickly load the Java source code (.java), Java binary code (.class), and Java package file (.jar) through this tool.
l Use Create Java, ALTER JAVA to load Java code.
Among them, the former approach is relatively simple, and we recommend you to use this method.
3. Generate call description
After loading the Java class, the call description of the Public Static method should be generated, and finally complete the development of the Java stored procedure. As shown below:
After completing the above steps, the development of the Java stored procedure is completed, and then the Java stored procedure can be called and executed.
Use Java development process
The process is used to perform some kind of operation. It should be noted that the Return value of the Java method corresponding to the process must be empty (VOID). This section is creating JSP for insertion, modifying, and deleting an AuthS table as an example to illustrate how to use Java development processes. As shown below:
The following describes the methods and processes of the above tasks:
Writing Java source code
The list of procedures is as follows (Manipulate_Auths.java):
/ * Import Java class * /
Import java.sql. *;
Import java.io. *;
Import oracle.jdbc.driver. *;
/ * Main class * /
Public class manipulate_auths {
Public Static Void Insert_AUTHS
(String code, String name, int sex, string birthdate, string entry_date_time)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "INSERT INTO AUTHS
(Author_code, name, sex, birthdate, entry_date_time)
"VALUES (?,?,?,?)"; / * Catch and throw exceptions using the try ... catch statement * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
PSTMT.SetString (2, name);
PSTMT.Setint (3, SEX);
Pstmt.setstring (4, birthdate);
PSTMT.SetString (5, entry_date_time);
/ * Perform a dynamic SQL statement * /
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
Public Static void delete_auths (String code)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "DELETE FROM AUTHS Where Author_code =?";
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
/ * Perform a dynamic SQL statement * /
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
Public Static Void Modify_salary (String Code, Float Salry)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "Update Auths Set Salry =? Where author_code =?";
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
Pstmt.setfloat (1, Salary);
PSTMT.SetString (2, CODE);
/ * Perform a dynamic SQL statement * /
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
}
2. Load Java code and class to Oracle8i database
After writing the Java source code, you can load the Java object into the Oracle8i database. Here is the method of completing this task:
3. Release Java, generate call instructions
After loading the Java class, you can issue this Java class and generate a process description of the call to its method. Below is a method of completing this task:
4. Call JSP
After generating a process description of calling a Java method, we can call JSP. For example: use Java development functions
The function is used to return specific data. This section will use the method of using the Java development function by creating an article title for returning the author, as well as a number of types of articles. As shown below:
The method and process of completing the above tasks will be described below.
Writing Java source code
The list is as follows (query_archicle.java):
/ * Import Java class * /
Import java.sql. *;
Import java.io. *;
Import oracle.jdbc.driver. *;
/ * Main class * /
Public class query_Article {
Public static string auths_Article (String Code)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL1 = "SELECT NAME FROM AUTHS WHERE Author_code =?";
String SQL2 = "SELECT TIM ARTICLE WHERE AUTHOR_CODE =?";
/ * Declare and initialize the auths_Article variable * /
String auths_Article = new string ();
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL1);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
/ * Execute the query and save the result to the result set * /
ResultSet Rset = pstmt.executeQuery ();
/ * Cycle acquisition and processing result set data * /
While (RSET.NEXT ())
Auths_Article = Auths_Article Rset.getstring (1);
/ * Close result set * /
Rset.Close ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
Author "The title of the article written is as follows: / n";
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL2);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
/ * Execute the query and save the result to the result set * /
ResultSet Rset = pstmt.executeQuery ();
/ * Cycle acquisition and processing result set data * /
While (RSET.NEXT ()) {
Auths_Article = Auths_Article " RSET.GETSTRING (1) " / n ";
}
/ * Close result set * /
Rset.Close ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
Return auths_article;
}
Public static string query_type_article_number (string code) throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "SELECT Count (*) from Article Where Article_code in"
"(SELECT ARTICLE_CODE from ARTICLE_TYPE WHERE TYPE_CODE =?)";
String article_number = new string ("" "" Code "");
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
/ * Execute the query and save the result to the result set * /
ResultSet Rset = pstmt.executeQuery ();
/ * Cycle acquisition and processing result set data * /
While (RSET.NEXT ())
Article_number = article_number rset.getstring (1) "articles";
/ * Close result set * /
Rset.Close ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
Return article_number;
}
}
2. Load Java code and class to Oracle8i database
After writing the Java source code, you can load the Java object into the Oracle8i database. Here is the method of completing this task:
3. Release Java, generate call instructions
After loading the Java class, you can issue this Java class and generate a function of calling its method. Below is a method of completing this task:
4. Call JSP
These functions can be called after the function description of the calling Java method is generated. E.g:
Use Java development kits
Java class is used in encapsulation Java methods, similar to this, packaged in packages and functions. This section will use the method of using the Java development package by creating a package for managing table Subject. As shown below:
The method and process of completing the above tasks will be described below.
Writing Java source code
The list is as follows (manage_subject.java):
/ * Import Java class * /
Import java.sql. *;
Import java.io. *;
Import oracle.jdbc.driver. *;
/ * Main class * /
Public class manage_subject {
Public static string query_subject ()
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Construct SQL statement * /
String SQL = "SELECT * from Subject";
/ * Statement and initialize the Subject variable * / string subject = new string ();
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Create a Statement object * /
Statement Stmt = conn.createstatement ();
/ * Execute the SQL statement and assign the query results to the result set * /
ResultSet Rset = Stmt.executeQuery (SQL);
/ * Cycle acquisition and processing result set variable * /
While (RSET.NEXT ())
Subject = Subject Rset.getstring (1) "/ n";
/ * Close result set * /
Rset.Close ();
} catch (sqlexception e) {}
Return Subject;
}
Public static void insert_subject (String Subject)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "INSERT INTO SUBJECT VALUES (?)";
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, Subject);
/ * Perform a dynamic SQL statement * /
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
Public static void delete_subject (String Subject)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "DELETE from Subject Where Subject =?";
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, Subject);
/ * Perform a dynamic SQL statement * /
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
Public static void update_subject (String old_subject, string new_subject)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "Update Subject Set Subject =? Where subject =?";
/ * Use the try ... catch statement to capture and throw exception * /
Try {/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.STSTRING (1, new_subject);
Pstmt.setstring (2, Old_Subject);
/ * Perform a dynamic SQL statement * /
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
}
2. Load Java code and class to Oracle8i database
After writing the Java source code, you can load the Java object into the Oracle8i database. Here is the method of completing this task:
3. Release Java, generate call instructions
After loading the Java class, you can issue this Java class and generate a package that calls its method. Below is a method of completing this task:
4. Call JSP
After generating the package that calls the Java method, the functions corresponding to these methods can be called. E.g:
Develop triggers using Java
The trigger is a store program that is triggered when a specific modification is performed, and the stored program is executed. The following is a method of using the Java development trigger using the Java development trigger to describe the triggers that use the Java development trigger. As shown below:
The method and process of completing the above tasks will be described below.
Writing Java source code
The list of procedures is as follows (TRIGGER.JAVA):
/ * Import Java class * /
Import java.sql. *;
Import java.io. *;
Import oracle.jdbc.driver. *;
/ * Main class * /
Public class trigger {
Public static void log_salary (String name, float old_sal, float new_sal)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
String SQL = "INSERT INTO SALARY_AUDIT VALUES (?,?,?)
/ * Use the try ... catch statement to capture and throw exception * /
Try {
PreparedState pstmt = conn.preparestatement (SQL);
PSTMT.SetString (1, name);
PSTMT.SetFloat (2, OLD_SAL);
Pstmt.setfloat (3, new_sal);
PSTMT.ExecuteUpdate ();
PSTMT.Close ();
} catch (sqlexception e) {}
}
}
2. Load Java code and class to Oracle8i database
After writing the Java source code, you can load the Java object into the Oracle8i database. Here is the method of completing this task:
3. Release Java, generate call instructions
After loading the Java class, you can issue this Java class and generate a process description and trigger that calls its method. Below is a method of completing this task:
4. Call JSP
After the trigger is created, the stored program is automatically called when modifying the author salary. E.g:
Using Java development object method
Object Types are a user-defined data structure that encapsulates data types, functions, and processes into the data structure. The object method refers to the functions and processes in the object type. This section will be used as an example to obtain and increase the target wage information, and the method of using the Java development object method will be described. As shown below: The method and process of completing the above tasks below:
Writing Java source code
The list is as follows (Object_type.java):
/ * Import Java class * /
Import java.sql. *;
Import java.io. *;
Import oracle.sql. *;
Import oracle.jdbc.driver. *;
Import oracle.Oracore. *;
Import oracle.jdbc2. *;
Import java.math. *;
/ * Main class, realize SQLDATA interface * /
Public class object_type imports sqldata {
/ * Declare the private variable, which correspond to the properties of the object type * /
PRIVATE STRING CODE;
PRIVATE STRING NAME;
PRIVATE BIGDECIMAL SEX;
PRIVATE BIGDECIMAL SALY;
/ * Method GET_NAME (): Object Type Method for Get Object Name * /
Public string get_name () {
Return Name;
}
/ * Method GET_SAlary (): Object type method for obtaining object wages * /
Public BigDecimal Get_Salary () {
BigDecimal Sal = SALARY;
Return Sal;
}
/ * Method Raise_SAlary (): Object type method for increasing target pay * /
Public void raise_salary (BigDecimal Raise) {
SALARY = Salary.Add (raise);
}
/ * The following block implements interface SQLDATA * /
String SQL_TYPE;
Public string getsqltypename () throws sqlexception {
Return SQL_TYPE;
}
Public void readsql (Sqlinput Stream, String TypeName) throws Sqlexception {
SQL_TYPE = Typename;
Code = stream.readstring ();
Name = stream.readstring ();
SEX = stream.readbigdecimal ();
Salary = stream.readbigdecimal ();
}
Public void Writesql (Sqloutput Stream) throws sqlexception {
Stream.writestring (Code);
Stream.writeString (Name);
Stream.writebigDecimal (SEX);
Stream.writeBigDecimal (Salary);
}
}
2. Load Java code and class to Oracle8i database
After writing the Java source code, you can load the Java object into the Oracle8i database. Here is the method of completing this task:
3. Release Java, generate call instructions
After loading the Java class, the Java class can be released and the corresponding object method that calls its method is generated. Below is a method of completing this task:
4. Calling JSP After creating an object type and an object method, you can call these object methods. E.g:
Develop JSP using JDeveloper
This section is creating JSP for manipulating Article Table as an example to illustrate how JSP is developed using JDeveloper 2.0. As shown below:
Here is just to introduce the process and steps of using JDeveloper development JSP, and about how to use JDeveloper to see the reader to see the relevant manual.
Preparation
1) Select "File-> New Workspace" to create a working group named jsp.jws. As shown below:
2) Select "File-> New Project", start the new project to create the wizard, and display the following dialog:
3) Select "CREATE AN
4) As shown in the figure above, type "article" in the "Project Name" box, type "D: / JSP" in the Items path box, and then click "Next", the following dialog is displayed:
5) Type the information you need in the dialog box above, then click "Next", the following dialog is displayed:
6) Click "Finish" to complete the project's creation process, at this time, the graphical interface is as follows:
2. Write the Java source code
After completing the preparation work, we can write Java source code. Proceed as follows:
1) Select "File-> New", which will pop up the following dialog:
2) As shown in the figure above, select "Class", then click "OK", then the following dialog box is populated:
3) As shown in the figure above, type "article" in the "class name" box, select "public" in "style", and then click "OK", which will increase the node named "article.java". As shown below:
4) Double-click the "Article.java" node and display the editing workspace. As shown below:
5) Then, prepare the Java source code (Article.java) in the editing workspace:
/ * Import Java class * /
Import java.sql. *;
Import java.io. *;
Import oracle.jdbc.driver. *;
/ * Main class * /
Public class article {
Public Static String Query_Article (String Code)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "SELECT Author_code, Title from Article"
"WHERE ARTICLE_CODE =?";
/ * Declare string variable article_info, this variable will be used to store article information * /
String article_info = new string ();
/ * Use the try ... catch statement to capture and throw exception * /
Try {/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
ResultSet Rset = pstmt.executeQuery ();
/ * Cycle acquisition and processing results * /
While (RSET.NEXT ()) {
Article_info = "Author code:" RSET.GETSTRING (1) "/ n";
Article_info = article_info "Article Title:"
RSET.GETSTRING (2);
}
/ * Close result set * /
Rset.Close ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
Return Article_Info;
}
Public static void insert_article (String Article_code,
String author_code, string secrate_level, string pub_date)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "INSERT INTO ARTICLE (Article_code, Author_code,"
"secrate_level, pub_date" value (?,?,?,?)
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, article_code);
PSTMT.SetString (2, Author_code);
PSTMT.SetString (3, secrate_level);
PSTMT.SetString (4, Pub_Date);
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
Public static void delete_Article (String Code)
Throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Construct SQL statement * /
String SQL = "DELETE from ARTICLE WHERE ARTICLE_CODE =?";
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, CODE);
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
Public static void update_article (string code, string secrate_level) throws sqlexception {
/ * Renained to the default connection to the database * /
Connection conn = new oracleDriver (). DefaultConnection ();
/ * Constructive SQL statement * /
String SQL = "Update Article SET SECRATE_LEVEL =?"
"WHERE ARTICLE_CODE =?";
/ * Use the try ... catch statement to capture and throw exception * /
Try {
/ * Prepare dynamic SQL statement * /
PreparedState pstmt = conn.preparestatement (SQL);
/ * Set the dynamic SQL parameter value * /
PSTMT.SetString (1, secrate_level);
PSTMT.SetString (2, CODE);
PSTMT.ExecuteUpdate ();
/ * Close dynamic SQL statement * /
PSTMT.Close ();
} catch (sqlexception e) {}
}
}
3. Configure and issue JSP
Proceed as follows:
1) Select "Project-> Deploy-> New Profile", which will pop up the following dialog:
2) As shown in the figure above, select "Deploy Java Classes and Stored Procedure to Oracle8i", then click "Next", then the following dialog box is displayed:
3) Click "Next", the following dialog box will pop up:
4) Click "Next", the following dialog is displayed:
5) Click "Next", the following dialog is displayed:
6) Clear the "Default Database Package" box, then click "Next", the following dialog is displayed:
7) Click "New" to create a database connection, which will pop up the following dialog:
This dialog is used to configure database connection information, and configure the corresponding parameters according to your database settings. Once the database connection is complete, click the Test Connection test configuration correct. If the configuration is incorrect, modify the configuration parameters.
8) Click "OK", which will pop up the following dialog:
The corresponding database connection information is displayed in this dialog.
9) Click "Next", and then pop up the following dialog:
10) Click "Finish", which will pop up the following dialog box:
11) Click "NO" to exit the configuration, then select the configuration file "profile1.prf" in the main window, click the right mouse button, which will display the following pop-up menu:
12) Select "Properties" from the pop-up menu, and the following dialog is displayed:
13) Select the "Methods" page, the dialog box is as follows:
14) As shown in the figure above, select all the radio box under public, and then click "DONE", the following dialog is displayed:
15) Click Yes, start configuring and distribute JSP, and eventually display the following interface:
16) Click "DONE", and the following message box is displayed: 17) Click "OK" so that we have completed all the processes of the configuration and release JSP. Then we can call JSP to complete the corresponding task.
4. Call JSP
These functions and procedures can be called after the Java-based function and procedure are created. Methods as below:
