DEV Community: Muhammad Bin Sikandar

How to Handle the UnsatisfiedLinkError Runtime Error in Java

Muhammad Bin Sikandar — Thu, 10 Aug 2023 06:20:15 +0000

Java is a powerful and secure programming language, but it can be subject to runtime errors. One such error is “UnsatisfiedLinkError”, which can occur when a method or native library is not found or loaded at runtime. This error usually indicates a problem in linking native code with Java code and can be resolved by ensuring that the appropriate native libraries are available and configured correctly.

In this article, we will explore what the “UnsatisfiedLinkError” runtime error is and discuss the ways to handle it in Java.

“UnsatisfiedLinkError” Example in Java



The code written below gives this error:
public class UnsatisfiedLinkErrorExample {
  static {
    System.loadLibrary("nonExistentLibrary");
  }
  public static void main(String[] args) {
    System.out.println("Hello, World!");
  }
}

In this code above:

The “.loadLibrary()” method is used to load “nonExistentLibrary” which does not exist.
In the main method, we have written some code that needed to be executed.
The code gives us an error and won’t execute further because the “UnsatisfiedLinkError” error would show up:

Output

This message indicates that the library is not found in the desired location or is a mismatch in Java version compatibility.

Handle the “UnsatisfiedLinkError” Runtime Error in Java

This error is thrown when a Java program is unable to load a native library that does not exist. It has different extensions on different operating systems such as “.so” in Linux, “.dll” in Windows, and “.dylib” in MacOS.

Whenever users encounter the “UnsatisfiedLinkError” error, it is necessary to check for the underlying errors and implement an appropriate solution.

Some common approaches to handling this error are given below.

1. Check the Library Path
The error occurs when JVM cannot locate the native library in the search path. One needs to ensure the library is present in one of the directories specified in “java.library.path”. While running the Java program, users can manually set up the path by the following below command:



-Djava.library.path=<path_to_directory>

Here “path_to_directory” needs to be specified by you according to the requirement.

2. Verify Library Names and Locations
It must be ensured that the library is named properly and placed in the expected location. The library name in the Java code must match your specified one. Lastly, you need to ensure that the library is easily accessible by the user running the program and has all required permissions enabled.

3. Loading the Library Explicitly
One can load the library manually to have better control over it. Instead of relying on JVM to load the library automatically, you can use the following command line to load it manually:



System.loadLibrary("libraryName")

It loads the library with your specified name and minimizes the errors. Users can have more control to load the library specifying the method and time for loading.

4. Use the Full Library Path
If the path user tries to access is not available in “java.library.path”, the user can access it by using the complete path. Consider the below code line to load the library from the desired path.



System.load("path_to_library")

Here “path_to_library” is the path you need to specify according to your requirement. It fetches the library from your defined path.

5. Handle Platform-specific Libraries
When working with platform-specific libraries, make sure to use the correct version of the library that is compatible with the target platform.

6. Debug and Diagnose
If the above-mentioned methods are not helpful you can use debugging to get more information about the error. By debugging, you can get valuable insight into the library loading process and identify any issues.

The above steps can be utilized to handle the error. A simple demonstration of the error being handled is given below with code examples.

Example: Handling “UnsatisfiedLinkError”
This error can be handled by using a try-catch block and the remaining code would execute successfully.
To handle the “UnsatisfiedLinkError” exception, go through the below specified simple code:



public class HandleUnsatisfiedLinkError {
  static {
    try {
      System.loadLibrary("nonExistentLibrary");
    } catch (UnsatisfiedLinkError e) {
        System.out.println("Error loading native library: " + e.getMessage());
  }
}
  public static void main(String[] args) {
    System.out.println("Hello, World!");
  }
}

The operations performed by the above code are:

The try-catch block is used to handle the “UnsatisfiedLinkError” exception when the library is loading.
If the library is present it will load without causing errors. Otherwise, it will print the error message by “e.getMessage()”.
A main method is created with any piece of code to demonstrate that the remaining code functions smoothly.

Output

Note: Thoroughly test your code after taking appropriate steps to resolve the UnsatisfiedLinkError, so that your Java program runs without any runtime error.

That's all to handle “UnsatisfiedLinkError” in Java.

Conclusion
"UnsatisfiedLinkError" is a Java runtime error that occurs when a program fails to load a required library. To fix this error, you can check the library path, check library names and locations, load the library explicitly, and use the full library path. By following these steps, you can fix the “UnsatisfiedLinkError” error and keep your Java program running smoothly.

What is the Java Signature sign() method with Example

Muhammad Bin Sikandar — Sun, 06 Aug 2023 17:39:25 +0000

Java is a well liked and versatile language being utilize by developers for making mobile desktop and web apps. Java offers a variety of unique features, one of which is the “sign()” method in the Signature class that can be imported from the “security” package. Using this method, developers can create digital signatures that ensure the security and reliability of their programs.

In this article, we will focus on the Java Signature sign() method and how to implement it.

What is Digital Signature?
Digital signatures are like special codes that ensure that our document data is safe and has not been subject to any change. In Java, A digital signature can be used to guarantee data accuracy. A unique signature is created for a data piece using encryption techniques. Digital signature creation and verification are made possible by the Java Signature class.

What is the Java Signature “sign()” Method?
The “sign()” function of the Java “Signature” class is an essential component. It creates a digital signature for a specific record. It records the resulting bytes in the output buffer starting at offset. To do this, use the “initSign()” method for regenerating the signing signature.

Syntax



int Sign(byte[] outbuffer, int offset, int len)

Creating a Digital Signature in Java
To create a digital signature there are a series of steps which are to be implemented in the correct order.
Follow the give steps for creating a digital signature.

Step 1. Creating a Signature Instance.
Create an instance of the “Signature” class named as “signature” that is using the “getInstance()” method along with the algorithm as mentioned below:



Signature signature = Signature.getInstance("SHA256WithDSA");

The above code block is using the “SHA-256” hash function along with the “DSA” algorithm for generating and verifying digital signatures.

Step 2. Initializing the Signature Instance
After creating the “signature” object, initialize it for usage. The method used to initialize the signature in Java is the “init()” method.
Here is the code for initialization:



SecureRandom secureRandom = new SecureRandom();
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
KeyPair keyPair = keyPairGenerator.generateKeyPair();
signature.initSign(keyPair.getPrivate(), secureRandom);

The operations performed by the above-given code are:

First, create an instance of the “SecureRandom” class by specifying the object “secureRandom”. It will be utilized to create secure random numbers.
Next, create an object for the “KeyPairGenerator” class that is responsible for generating encryption keys for digital signature algorithms as used in the above example which is “DSA”.
Now, make another object for “keyPair” that will store the keypair generated by the “KeyPairGenerator”.
“signature.initSign(keyPair.getPrivate(), secureRandom);“ initializes an object named “signature” for signing. It is linked with a private key from “keyPair” and a random number generator “secureRandom”. By doing this it becomes ready for signing.

Step 3. Creating a Digital Signature
Now, user can create the digital signature. To do so, call the “update()” method and finish with the call to the “sign()” method. Use the below-specified block to create a digital signature:



byte[] data = "Your_ String".getBytes("UTF-8");
signature.update(data);
byte[] digitalSignature = signature.sign();

In this code:

UTF-8 encoding is used to convert the “Your_String” into a sequence of bytes. The result is recorded in the “data“ variable.
“signature.update(data)” updates the “signature” object with data from the above step. The signature object is responsible for creating a digital signature.
To store the above-generated data, the “signature.sign()” stores the data in an array of “byte[]” type.

Step 4 . Verification of Digital Signature
Verification of a digital signature created by someone else can be done for authentication. Now, initialize a “Signature” instance for verification.
Here is the code:



Signature signature2 = Signature.getInstance("SHA256WithDSA");
signature.initVerify(keyPair.getPublic());

The operation performed by the above-given code is:

First, create an instance for the “Signature” class that will utilize the “getInstance” method that will be used to create or verify the digital signature.
“initVerify()” initializes the verification process using the public key from the “keyPair” object. The “getPublic()” method is used to obtain a public key.

Now, use the public key of the public/private key pair to initialize into verification mode. After initialization, verification of the digital signature can be done by the “Signature” class.
Following is the code snippet:



byte[] data2 = "Your_String".getBytes("UTF-8");
signature2.update(data2);
boolean verified = signature2.verify(digitalSignature);

The operation performed by the above-given code is:

“.getBytes("UTF-8")” method converts the string “Your_String” to a sequence of bytes using UTF-8 encoding.
“update(data2)” method updates the “signature2” object with bytes created in the above step.
“verify(digitalSignature)” is used to verify the signature and store the answer in the boolean format in the variable “verified”.

Complete Code
The complete code must be written in a class by importing the desired packages and classes.
Import the following classes before writing the code:



import java.security.*;
import java.util.Base64;

The function of these packages and their classes are:

“import java.security.*” imports all classes from the security package.
“import java.util.Base64” imports the “Base64” encoding class represents binary data by utilizing the printable characters.

Then, declare a class comprising the below code:



public class DigitalSignature {
  public static void main(String[] args) {
    try {
      Signature signature = Signature.getInstance("SHA256WithDSA");
      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
      SecureRandom secureRandom = new SecureRandom();
      keyPairGenerator.initialize(1024, secureRandom);
      KeyPair keyPair = keyPairGenerator.generateKeyPair();
      signature.initSign(keyPair.getPrivate());
      byte[] data = "Your_String".getBytes("UTF-8");
      signature.update(data);
      byte[] digitalSignature = signature.sign();
      String encodedSignature =     Base64.getEncoder().encodeToString(digitalSignature);
      System.out.println("Digital Signature: " + encodedSignature);
      Signature signature2 = Signature.getInstance("SHA256WithDSA");
      signature2.initVerify(keyPair.getPublic());
      byte[] data2 = "Your_String".getBytes("UTF-8");
      signature2.update(data2);
      boolean verified = signature2.verify(digitalSignature);
      if (verified) {
        System.out.println("Digital Signature Verified!");
      } else {
        System.out.println("Digital Signature Verification Failed!");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Output
The digital signature will show up as shown below and the second line would indicate its verification:

That’s all about the Java Signature “sign()” method.

Conclusion
The “sign()” method is used to create unique digital signatures for data. It ensures data is authentic and original. It changes if the data is modified. Digital signatures play an important role in secure communication and data integrity. This post has described the complete functionality of the Signature “sign()” method along with proper implementation.

How to Handle the Socket Exception in Java

Muhammad Bin Sikandar — Sun, 06 Aug 2023 17:29:17 +0000

Java is a powerful and secure programming language used by developers in web development, and app development. Being a programming language, it is subject to runtime exceptions. These exceptions can be handled to make the code run smoothly. SocketException is a subclass of IO Exception. As the name suggests, it is an exception thrown to show that an error has occurred while creating or accessing the socket. It is a type of exception that needs to be dealt with in a specific way called "throwing" or "handling" using a special code structure called a try-catch block.

In this article, users will get an idea about SocketException in Java, its causes, and how to handle it.

Common Reasons For SocketException
The most frequent cause of SocketException in Java is reading or writing to or from a closed socket
Another reason for this is the termination of the connection before the data has been read into the socket buffer. Several other reasons for SocketException are pointed out below:

Firewall Intervention
Slow Network
Long Idle Connection
Application Error

Firewall Intervention
Network Firewall can terminate the socket connections. If you have any firewall installed try turning it off and then check if the problem has been solved.

Slow Network
Slow Network can be the reason for the SocketException. To tackle the specified problem, extend the connection duration limit. This can greatly reduce the SocketException for slow connections using the following code:

socket.setSoTimeout(40000); // timeout set to 40,000 ms

Long Idle Connection
Another reason for the SocketException can be the long idle connection. It can be terminated from other ends to save resources. The solution to this problem is sending heartbeat messages to prevent an idle state and ensure your work operates consistently.

Application Error
Error or bugs in code can be another reason for the SocketException e.g. a situation where a person tries to send a message to a server after it has been turned off or disconnected from the network.

SocketException Example
First, have a look at what SocketException is and how it is generated. Let's take a simple code example that can generate a SocketException.

Import the necessary package for SocketException:

import java.net.SocketException;

In the above snippet, we have imported the SocketException class from the “net” package of Java. This is used to handle errors when working with network connections. It allows us to deal efficiently with the errors.

Following is the code snippet:

public class SocketExceptionExample {
  public static void main(String[] args) {
    try {
      throw new SocketException("Simulated SocketException");
    } catch (SocketException e) {
       e.printStackTrace();
      }
  }
}

The operation performed by the above-given code is:

Create a class named “SocketExceptionExample”.
Create a main method for the code.
Specify a try-catch block.
In the try block, throw the SocketException as “Simulated SocketException”.
In the catch block, use the SocketException object to fetch the error message and store it in a variable “e”.
Then, use the “printStackTrace()” method to print the error faced.

Output

How to Handle SocketException in Java?
To handle SocketException in Java, let’s take an example of a client-server. For this purpose, first, create a server and connect it with a local host. Then, create a client on the same device that can generate requests on the started server and the exception can be handled to execute the code smoothly.

To handle the SocketException in Java, go through the listed steps.

Step 1. Create a SocketServer Class
Create a class named “SocketServer” that enables the clients to connect and send messages which will be read by the outstream.
To do so, import the following packages:

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.ClassNotFoundException;
import java.net.ServerSocket;
import java.net.Socket;

The function of each class imported from respective packages is

“import java.io.ObjectInputStream” imports the “ObjectInputStream” class which is used to read objects from the input stream.
“import java.io.ObjectOutputStream” imports the “ObjectOutputStream” class used to write objects on the output stream.
“import java.lang.ClassNotFoundException” imports the “ClassNotFoundException”’ class which will handle the situation when a user cannot find the required class.
“import java.net.ServerSocket” imports the “ServerSocket” class utilized to check for incoming network connections.
“import java.net.Socket” imports the “Socket” class which is used to establish a client-side connection with our server.

Code to create and start the "SocketServer" by utilizing the preceding packages:

public class SocketServer {
  private static ServerSocket server;
  private static int port = 9876;
  public static void main(String args[]) throws IOException,    ClassNotFoundException{
       server = new ServerSocket(port);
       while(true){
      System.out.println("Waiting for the client request");   
      Socket socket = server.accept();
      ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
      String message = (String) ois.readObject();
      System.out.println("Message Received: " + message);
      ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
      oos.writeObject("Hello "+message);
      input.close();
      output.close();
      socket.close();
      if(message.equalsIgnoreCase("exit")) break;
    }
  System.out.println("Shutting down Socket server!!");
    server.close();
  }
}

The functions performed by the above code are:

Declare a class named “SocketServer”.
“server = new ServerSocket(port)” declares a private static variable of the “ServerSocket” type for the server.
“private static int port = 9876” declares a static variable named “port” and specifies the port number. assign “9876” to it.
Then, define a main method that can throw the following exceptions “IOException” and “ClassNotFoundException”.
“server = new ServerSocket(port)” creates an object of ServerSocket and assigns it to ‘server’. It is responsible for checking incoming network connections.
Initiate a while loop set at the “true” condition.
“Socket socket = server.accept()” waits for the client to connect and grants access for connecting.
“ObjectInputStream input = new ObjectInputStream(socket.getInputStream())” creates an object named “input” that reads data from the input stream of the client.
“String message = (String) input.readObject()” reads the message from the client and changes the data type to string and stores it in the variable “message”.
“System.out.println("Message Received: " + message)” prints the received message.
“ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream())” creates an object used to write data to the client's output stream.
“output.writeObject("Hello " + message)” gives a response to the client's output stream.
“input.close()” closes the input stream.
“output.close()” closes the output stream.
“socket.close()” closes the socket connection with the client.
“if (message.equalsIgnoreCase("exit")) break” checks if the client sends an ‘exit’ message and terminates the server connection.
“server.close()” closes the server socket.

Step 2. Create a SocketClient Class
Create another class named “SocketClient” to generate requests on the created server. Send some messages to the created server for verification.

The required packages and classes to be imported are:

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

The function of each line is:

“import java.io.IOException” imports “IOException” class which handles errors related to input-output.
The classes from the “.net” package are used to deal with networking connections, working with IP addresses, and dealing with socket connections.

The code to generate the "SocketClient" is provided below:

public class SocketClient {
  public static void main(String[] args) throws UnknownHostException, IOException, ClassNotFoundException, InterruptedException{
      InetAddress host = InetAddress.getLocalHost();
    Socket socket = null;
    ObjectOutputStream output = null;
    ObjectInputStream input = null;
    for(int i=0; i<5;i++){
        socket = new Socket(host.getHostName(), 9876);
        output = new ObjectOutputStream(socket.getOutputStream());
        System.out.println("Connection request to Socket Server");
        if(i==4)output.writeObject("exit");
        else output.writeObject(""+i);
        input = new ObjectInputStream(socket.getInputStream());
        String message = (String) input.readObject();
        System.out.println("Message: " + message);
        input.close();
        output.close();
        Thread.sleep(100);
    }
  }
}

The description for the above-provided code is mentioned below:

Declare a class “SocketClient”.
Declare a “main” method.
“InetAddress.getLocalHost()” is called to get our local machine’s IP address.
A variable “socket” is declared to hold a connection to the server.
“ObjectOutputStream” variable named “output” is used to write data to the server.
The variable called "input" of type "ObjectInputStream" is used to retrieve or get information from the server.
A loop is initiated to execute “5 times”.
A socket connection is built using the machine’s IP address and port number.
Data is sent to the started server via the "output" object.
A notification is displayed to indicate that someone wants to connect with you.
Based on the value of “i”, either the message “exit” is sent to the server or the value of ‘i’.
The received message is printed.
Close the input and output stream.
“Thread.sleep()” method is used to pause the program for 100 milliseconds.

Step 3. Running the SocketServer Class
First, run the “SocketServer” class to start the server.
The following output will appear:

The above output indicates that the server has been started and is waiting for the client to connect.

Step 4. Running the SocketClient Class
Run the “SocketClient” class. It will allow the client to connect with the server started in the above step.
The below output shows that the client has successfully sent the connection request and messages to the server:

Step 5. Server Output After Client Messages
The “SocketServer” class will also accompany some output which shows that the server had established a connection with the client and received all the messages before the termination of the connection:

That’s all about handling SocketException in Java.

Conclusion
SocketException in Java is a checked exception that indicates a socket creation or access error. To handle a SocketException, it is important to identify the cause, implement specific solutions, use try-catch blocks, terminate resources appropriately, and consider implementing error logging to troubleshoot. The complete implemented tutorial has been given to handle the SocketException in Java.