SoFunction
Updated on 2025-04-05

Methods to dynamically load DLL/SO files in JAVA Web Project

introduction

In JAVA Web Project, we often need to call some third-party libraries or implement some functions that JAVA itself does not support. At this time, we may consider using JNI (Java Native Interface) to call DLL (Windows Dynamic Link Library) or SO (Linux Dynamic Link Library) files. However, putting these files into the bin directory of %JAVA_HOME%\jre\bin\​ or applying middleware (such as Tomcat, Weblogic) is not an elegant and portable solution. Therefore, this article will introduce how to dynamically load DLL/SO files in a JAVA web project.

1. Create a listening class

In order to automatically load the DLL/SO file when the application middleware is started, we can create an implementation​​ServletContextListener​​The listening class of the interface. This class will be executed when the web application starts​​contextInitialized​Method.

import ;
import ;
 
public class DllLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // Write code to load DLL/SO files here    }
 
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // Clean up resources if needed    }
}

2. Dynamically add library file path to system variables

In the contextInitialized method, we need to dynamically add the path where the DLL/SO file is located to the system environment variable. Note that you cannot use the method settings directly here because the JVM will cache this value when starting. We need to use the reflection mechanism to modify this value.

private void addDirToPath(String s) {
    try {
        Field field = ("sys_paths");
        (true);
        String[] path = (String[]) (null);
        String[] tem = new String[ + 1];
        (path, 0, tem, 0, );
        tem[] = s;
        (null, tem);
    } catch (Exception e) {
        ();
    }
}

In​contextInitialized​Call this method in the method and pass in the path where the DLL/SO file is located. Suppose we put DLL/SO files in the web application​WEB-INF​Under folder:

@Override
public void contextInitialized(ServletContextEvent sce) {
    String path = ().getRealPath("WEB-INF/lib"); // Modify the path according to actual situation    addDirToPath(path);
    (path + "/your_library.dll"); // Load the DLL file and modify the file name and extension according to the actual situation}

3. Configure the listening class in

In order for our listening class to be automatically executed at the start of the application, we need to​​Configure it in the file:

<listener>
    <listener-class>com.your_package.DllLoaderListener</listener-class> <!-- Modify package name and class name according to actual situation -->
</listener>

4. Restart the application middleware and test it

Finally, restart your application middleware (such as Tomcat, Weblogic) and test whether your JAVA Web project can successfully call the methods in the DLL/SO file. If everything works fine, you should be able to see the corresponding output in the console or in the log.

Notes and FAQ solutions:

  1. Ensure that the operating system and Java version support dynamic loading of DLL/SO: Most modern operating systems and Java versions support this feature, but you may encounter problems in certain specific environments. If you encounter problems, please consult the relevant documentation or seek community help.
  2. deal with​UnsatisfiedLinkError​​Exception: If you encounter when loading or calling a DLL/SO file​UnsatisfiedLinkError​​Exception, please check the following points:
  • Whether the DLL/SO file exists and the path is correct.
  • Is the DLL/SO file compatible with your operating system and Java version?
  • Whether the method signature in the DLL/SO file is consistent with the declaration in the Java code.
  1. Performance considerations: Dynamic loading of DLL/SO files may have a certain impact on application startup time. If possible, try to complete this logic in the application initialization phase to avoid impact on real-time performance. sure. To provide you with a sample code for a practical application scenario, I will take a simple web application as an example, which will use Python's Flask framework. In this app, we will create a simple REST API for adding, querying, and deleting users.

First, you need to install Flask:

pip install Flask

You can then create a name called​​, and paste the following code into it:

from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
# Dictionary for storing usersusers = {}
 
@('/user', methods=['POST'])
def add_user():
    data = request.get_json()
    if 'name' not in data or 'age' not in data:
        return jsonify({'error': 'Missing name or age'}), 400
    user_id = len(users) + 1
    users[user_id] = {'name': data['name'], 'age': data['age']}
    return jsonify({'user_id': user_id}), 201
 
@('/user/<int:user_id>', methods=['GET'])
def get_user(user_id):
    if user_id not in users:
        return jsonify({'error': 'User not found'}), 404
    return jsonify(users[user_id]), 200
 
@('/user/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    if user_id not in users:
        return jsonify({'error': 'User not found'}), 404
    del users[user_id]
    return '', 204
 
if __name__ == '__main__':
    (debug=True)

This sample code creates a simple REST API with the following features:

  1. Add a user: By​/user​​Send POST request and pass the containing​name​and​age​​JSON data, you can add a new user. The server will return a newly generated​user_id​​。
  2. Query the user: By​/user/<user_id>​​Send a GET request, which can query with specified​user_id​user information.
  3. Delete users: By​/user/<user_id>​​Send a DELETE request, you can delete the specified one​user_id​​ user.

Please note that this sample code is for teaching purposes only and does not include any security measures (such as authentication, authorization, etc.). In a real production environment, you need to take appropriate security measures to protect your API.

To run this application, execute the following command on the command line:

python

You can then use tools such as curl, Postman, or any HTTP client library to test this API. Since you don't provide specific code, I'll assume you want to understand a common way of introducing code. Here, I will explain the various parts in detail based on a simple Python code example.

Suppose we have the following Python code:

# This is a simple Python program that calculates the sum of two numbers 
def add_numbers(num1, num2):
    """
     This function takes two numbers as arguments and returns their sum.
     """
    result = num1 + num2
    return result
 
# Test functionif __name__ == "__main__":
    number1 = 5
    number2 = 10
    sum_of_numbers = add_numbers(number1, number2)
    print(f"The sum of {number1} and {number2} is {sum_of_numbers}.")

Now, I will explain this code line by line:

  1. # This is a simple Python program for calculating the sum of two numbers
  • This is a line of comments that briefly describe the functionality of the entire program. In Python,​#​The beginning line is considered a comment and will not be executed.
  1. ​def add_numbers(num1, num2):​
  • This line defines a name called​add_numbers​​ function, which accepts two parameters:​num1​and​num2​​. Functions are an effective way to organize code and can be called repeatedly to perform specific tasks.
  1. ​"""​and the following lines
  • This is a multi-line string that is usually used as a document string (or docstring) for a function. It provides more details on how the function works and the expected input. In this example, it explains the function's function.
  1. ​result = num1 + num2​
  • This line of code performs actual addition operations inside the function. It will​num1​and​num2​​Add two parameters and store the result in the name​result​​ in the variable.
  1. ​return result​
  • This line of code will​result​The value of the variable is returned to the code that calls the function. When the function is executed​return​When a statement is made, it stops execution immediately and returns the specified value to the caller.
  1. ​if __name__ == "__main__":​
  • This line of code checks whether the current script is run as a standalone program or is imported as a module. If the script is run independently, then​__name__​The value of the variable will be​"__main__"​, which means that the following code block will be executed. This is a common Python pattern for determining whether test code or main program logic should be run.
  1. The next few lines set two variables (number1andnumber2), calledadd_numbersfunction and useprintThe function outputs the result.
  • ​​number1 = 5​and​number2 = 10​​: These two lines of code assign integers 5 and 10 to variables respectively​number1​and​number2​​。
  • ​​sum_of_numbers = add_numbers(number1, number2)​​: This line of code calls the previously defined​add_numbers​function and​number1​and​number2​Passed to it as a parameter. The return value of the function (i.e. the sum of two numbers) is stored in the variable​sum_of_numbers​​In.
  • ​​print(f"The sum of {number1} and {number2} is {sum_of_numbers}.")​​: Finally, this line of code uses a formatted string (by​f​​Prefix) to output a message, displaying the sum of two numbers. Braces​{}​The contents inside will be replaced by the corresponding variable value.

The above is the detailed content of the method of dynamically loading DLL/SO files in the JAVA Web project. For more information about dynamic loading of JAVA Web DLL/SO files, please follow my other related articles!