How do I create a basic servlet using the HttpServlet class?

By Wayan in Servlet 0 Comment

To create a basic servlet using the HttpServlet class in Jakarta Servlet API, follow these steps:

Steps to Create a Basic Servlet:

  1. Create a Java Class Extending HttpServlet:
    • Your servlet class should extend the HttpServlet class provided in the Jakarta Servlet API.
  2. Define Servlet Annotations or Configuration:
    • Use the @WebServlet annotation to define the servlet and map it to a URL pattern. Alternatively, you can configure it in the web.xml file if annotations are not used.
  3. Override doGet or doPost Methods:
    • Override doGet for handling GET requests and doPost for POST requests (based on the type of request you expect).
  4. Set the Content Type in Response:
    • The response content type can be set using response.setContentType().
  5. Write the Response to Output:
    • Use a PrintWriter object received from response.getWriter() to write the response content.

Code Example:

Here’s a sample implementation for a basic servlet:

package org.kodejava.servlet;

import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "HelloWorldServlet", urlPatterns = {"/hello", "/helloworld"})
public class HelloWorld extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
      response.setContentType("text/html");

      PrintWriter writer = response.getWriter();
      writer.println("<html>");
      writer.println("<head><title>Hello World Servlet</title></head>");
      writer.println("<body>Hello World! How are you doing?</body>");
      writer.println("</html>");
      writer.close();
   }
}

Explanation of Code:

  1. @WebServlet Annotation:
    • name: Specifies the servlet name.
    • urlPatterns: Maps the servlet to specific URL patterns (in this example, /hello).
  2. doGet Method:
    • Handles GET requests sent to /hello.
    • Sets the content type for the response to text/html so that the client knows the returned content is HTML.
    • Dynamically writes an HTML page to the response using the PrintWriter.
  3. Response Lifecycle:
    • Any request to http://<server>:<port>/hello is routed to the doGet method based on the @WebServlet mapping.

Deploying the Servlet in Jakarta EE:

  • Place your servlet class in the Java package structure under src/main/java.
  • Ensure your project is configured to use a Jakarta Servlet container like Apache Tomcat or Jakarta EE compatible application server.
  • Deploy the .war file or run directly if your IDE supports it.

To build the .war file you can follow in steps in this post: How to build WAR file for Jakarta EE Servlet Container?.

Maven dependencies

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.1.0</version>
    <scope>provided</scope>
</dependency>

Maven Central

How to Use the var Keyword for Local Variable Type Inference in Java 10

By Wayan in Basic, Java 10 0 Comment

In Java 10, the var keyword was introduced to allow local variable type inference. This means that when you declare a local variable, the compiler automatically infers its type based on the initialization value. This improves readability and reduces boilerplate code, especially when working with complex types, without compromising type safety.

Here’s a guide on how to use the var keyword:

1. Declaring and Initializing Local Variables with var

The var keyword replaces explicitly specifying the type while declaring local variables. However, you must initialize the variable at the time of declaration, as the compiler needs an expression to infer the type.

// Example of using var keyword
var message = "Hello, Java 10!";  // Inferred as String
var number = 10;                 // Inferred as int
var list = List.of("apple", "banana", "orange"); // Inferred as List<String>

Here, the type of each variable is deduced by the Java compiler:

  • message: String
  • number: int
  • list: List<String>

2. Scopes Where var Can Be Used

The var keyword can only be used in specific contexts:

a. Local Variables in Methods

public void demoVarUsage() {
    var name = "John";      // Inferred as a String
    var age = 30;           // Inferred as an int

    System.out.println(name + " is " + age + " years old.");
}

b. Loop Variables (for-each or traditional for-loops)

// for each loop
var items = List.of("A", "B", "C");
for (var item : items) {
    System.out.println(item);  // item inferred as String
}

// traditional for loop
for (var i = 0; i < 10; i++) {
    System.out.println(i);     // i inferred as int
}

c. Local Variables in Lambda Expressions

var lambda = (String x, String y) -> x + y; // Explicit lambda types
System.out.println(lambda.apply("Java", "10"));

3. Restrictions on var Usage

While var is versatile, there are limitations:

  1. Cannot Be Used Without Initialization 
    var name; // Compilation error: cannot infer type
name = "John";
  2. Cannot Be Used with Null Initializer 
    var something = null; // Compilation error
  3. Cannot Be Used as a Method Parameter, Field, or Return Type
    The var keyword is limited to local variables inside methods and blocks, as well as loop variables. It cannot be used:

    • As a return type of method.
    • As a field in a class.
    • As a method parameter.
    public var getName() {    // Compilation error: 'var' is not allowed here
   return "Java";
}
  4. Cannot Mix Explicit Types and var 
    var name = "John", age = 30; // Compilation error
var name = "John";
var age = 30;               // Declare separately
  5. Cannot Infer Ambiguous Types 
    var result = process();  // If `process()` returns Object, type can't be narrowed.

4. Advantages of Using var

  • Improved Code Readability: Reduces verbosity for complex types. 
    var map = new HashMap<String, List<Integer>>(); // Cleaner than HashMap<String, List<Integer>>
  • Consistent with Type Inference: Makes Java more modern and closer to languages like Kotlin, Scala, or C#.

5. Best Practices

  • Avoid overusing var to ensure code remains understandable.
  • Use meaningful names for variables to compensate for the lack of explicit type.
  • Use var only when the type is obvious from the context.

Example Code:

package org.kodejava.basic;

import java.util.List;

public class VarExample {
   public static void main(String[] args) {
      // Using var for various local variable declarations
      var name = "Alice";                        // String
      var age = 25;                              // int
      var fruits = List.of("Apple", "Banana");  // List<String>

      System.out.println(name + " likes " + fruits);

      for (var fruit : fruits) {
         System.out.println(fruit);  // Inferred as String
      }

      var sum = add(10, 20);  // Inferred as int
      System.out.println("Sum: " + sum);
   }

   private static int add(int a, int b) {
      return a + b;
   }
}

Output:

Alice likes [Apple, Banana]
Apple
Banana
Sum: 30

The var keyword is a helpful addition, especially for simplifying local variables with inferred types, keeping code concise and readable while retaining type safety!

How do I chain operations using map and flatMap in Optional?

By Wayan in Util Package 0 Comment

In Java, the Optional class provides methods like map and flatMap to enable functional-style transformations and chaining of operations without explicitly checking for null. Here is an explanation of when and how to use these methods effectively.

1. map

  • The map method is used when you want to transform the value inside the Optional if it is present.
  • It takes a function (Function<? super T, ? extends U>) as an argument and applies it to the value inside the Optional, returning a new Optional<U>.
Optional<String> optionalName = Optional.of("John");

// Use map to transform the value
Optional<Integer> nameLength = optionalName.map(String::length);

System.out.println(nameLength); // Output: Optional[4]

2. flatMap

  • The flatMap method is used when the mapping function itself returns an Optional. This helps avoid creating nested Optional<Optional<U>>.
  • It is commonly used in scenarios where the result of the transformation step is another Optional.
Optional<String> optionalName = Optional.of("John");

// Use flatMap when the mapping function returns Optional
Optional<String> upperCaseName = optionalName.flatMap(name -> Optional.of(name.toUpperCase()));

System.out.println(upperCaseName); // Output: Optional[JOHN]

How to Chain map and flatMap

You can chain map and flatMap when transforming optional values or resolving optional dependencies step-by-step.

Example: Chaining map and flatMap

Imagine you have a class Person that contains an Optional<Address> and an Address that has an Optional<String> representing a zip code. You want to extract the zip code directly from the Person, if it exists.

package org.kodejava.util;

import java.util.Optional;

class Person {
    private Optional<Address> address;

    public Person(Optional<Address> address) {
        this.address = address;
    }

    public Optional<Address> getAddress() {
        return address;
    }
}

class Address {
    private Optional<String> zipCode;

    public Address(Optional<String> zipCode) {
        this.zipCode = zipCode;
    }

    public Optional<String> getZipCode() {
        return zipCode;
    }
}

public class OptionalExample {

    public static void main(String[] args) {
        // Create nested Optional structure
        Optional<String> zipCode = Optional.of("12345");
        Address address = new Address(zipCode);
        Person person = new Person(Optional.of(address));

        // Chain map and flatMap to get the zip code
        Optional<String> zipCodeResult = person.getAddress()
                .flatMap(Address::getZipCode); // Unwrap address and zipCode

        System.out.println(zipCodeResult); // Output: Optional[12345]
    }
}

In this example:

  • person.getAddress() returns an Optional<Address>.
  • flatMap(Address::getZipCode) ensures the zip code is directly returned as an Optional<String> instead of Optional<Optional<String>>.

Comparison of map and flatMap

Method When to Use Output Type
map When the mapping function returns a value (non-Optional). Optional<U>
flatMap When the mapping function returns an Optional. Optional<U> (avoids nesting)

Why the Difference?

The distinction ensures that Optional doesn’t wrap nested Optional values.

  • Using map with a function that returns Optional would result in Optional<Optional<U>>.
  • flatMap flattens this into a single Optional<U>.

Common Mistake:

// Incorrect: results in Optional<Optional<String>>
Optional<Optional<String>> zipCodeResult = person.getAddress()
    .map(Address::getZipCode);

// Correct: use flatMap to avoid nesting
Optional<String> correctZipCodeResult = person.getAddress()
    .flatMap(Address::getZipCode);

Key Takeaways

  1. Use map for simple transformations where the result is a direct value.
  2. Use flatMap where the result of the mapping is itself an Optional.
  3. Chain them together for complex operations on nested optionals, avoiding null checks.

How to Understand the Basics of ISO 8583 Message Structure

By Wayan in jPOS 0 Comment

Understanding the basics of the ISO 8583 message structure can initially be daunting due to its technical nature, but breaking it down into its components makes it much easier to comprehend.

What is ISO 8583?

ISO 8583 is a standard widely used in financial transaction card-based systems (like ATMs and Point of Sale systems). It specifies how financial transaction messages are formatted, transmitted, and structured between systems. Each message represents a specific financial transaction—like a card authorization request or a fund transfer.

Basic Structure of an ISO 8583 Message

An ISO 8583 message is organized into components called Message Type Indicators (MTI), bitmaps, and data elements. Let’s explore these components in detail:

1. Message Type Indicator (MTI)

The MTI is the first part of an ISO 8583 message and is 4 digits long. It identifies the type of financial transaction being processed. These digits represent the following:

  • Digit 1 (Version): Specifies the version of ISO 8583 being used (e.g., 0 for ISO 8583:1987, 1 for ISO 8583:1993).
  • Digit 2 (Message Class): Indicates the type of message (e.g., 1 for authorization message, 2 for financial messages).
  • Digit 3 (Message Function): Determines the message’s purpose (e.g., 0 for a request, 1 for a response).
  • Digit 4 (Transaction Origin): Represents the message’s origin type (e.g., 0 for a system, 2 for an acquirer).

For example, 0200 indicates an authorization request for a transaction.

2. Bitmap

A bitmap is essentially a binary map that indicates which Data Elements (DEs) are present in the message. Each bit in the bitmap corresponds to a specific data element:

  • Primary Bitmap (64 bits): Always present, indicating whether the first 64 data elements are used.
  • Secondary Bitmap (optional, 64 bits): If the primary bitmap’s first bit is “1”, this indicates the use of an additional secondary bitmap for data elements 65–128.

For example, a bitmap like 7230000008020000 in hexadecimal shows which data elements are present and active in the message.

3. Data Elements (DEs)

Data elements hold the transaction-specific data like the amount, account number, date, time, and more. There are 128 standard data elements, organized as follows:

  • Mandatory Elements: These include crucial components such as transaction amount, processing code, etc.
  • Optional Elements: Acquired conditionally and depend on the transaction scenario.

Each data element has two key properties:

  • Data Type (e.g., numeric, alphanumeric): Specifies the type and content.
  • Length (fixed or variable): Defines the format of the element (e.g., fixed length of 10 digits or variable length preceded by a length prefix).
Examples of Common Data Elements:
DE Description Type Length
DE 3 Processing Code Numeric Fixed (6)
DE 4 Transaction Amount Numeric Fixed (12)
DE 7 Transmission Date & Time Numeric Fixed (10)
DE 37 Retrieval Reference Number Alphanumeric Fixed (12)
DE 41 Card Acceptor Terminal ID Alphanumeric Fixed (8)

Message Example Breakdown

Let’s take an example of an ISO 8583 authorization request message:

MTI         : 0200
Primary BMP : 7230000008020000
DE 3        : 001000
DE 4        : 000000010000
DE 7        : 1127220000
DE 11       : 123456
DE 41       : TERM001
DE 49       : USD

This means the message is:
1. MTI (0200): Authorization request.
2. Bitmap: Specifies that DE 3, 4, 7, 11, 41, and 49 are active.
3. Data Elements:

  • Processing Code (DE 3): 001000
  • Amount (DE 4): $100.00
  • Transmission Date & Time (DE 7): 11/27 at 22:00
  • System Trace Audit Number (DE 11): 123456
  • Terminal ID (DE 41): TERM001
  • Currency (DE 49): USD

Steps to Analyze an ISO 8583 Message

  1. Interpret MTI: Understand the type of transaction the message represents.
  2. Decode Bitmap: Identify which data elements are used in the message.
  3. Read Data Elements: Extract and interpret data elements based on the bitmap and structure.

Conclusion

ISO 8583 messages follow a structured yet flexible format. By understanding the key components like the MTI, bitmap, and data elements, you can analyze and process ISO 8583 messages effectively. Tools like parsers or libraries for your preferred programming language can simplify the heavy lifting when working with ISO 8583 in real-world applications.

How do I debug Java networking issues using java.net logging and troubleshooting tools?

By Wayan in Core API, Networking 0 Comment

Debugging Java networking issues often involves using logging utilities provided by the java.net package, diagnostic tools, and third-party utilities. Here’s a detailed guide:

1. Enable Java Networking Logging

Java includes built-in logging capabilities for debugging networking issues. You can use the java.util.logging package to capture logs from the java.net classes.

Enable Debugging Logs for HTTP, HTTPS, and Networking

Add the following system properties when starting your application to enable verbose logging for networking:

-Djava.util.logging.config.file=logging.properties
-Djavax.net.debug=all
-Dhttp.keepAlive=false
-Dsun.net.www.http.HttpClient.level=ALL
-Djava.net.level=ALL

Steps:

  • logging.properties File: Create a logging.properties file if not already available. Configure the logger like this: 
    handlers=java.util.logging.ConsoleHandler
.level=ALL
java.util.logging.ConsoleHandler.level=ALL
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
sun.net.www.protocol.http.HttpURLConnection.level=ALL
sun.net.www.http.HttpClient.level=ALL
java.net.level=ALL
  • Run the JVM: Use the -Djava.util.logging.config.file property to point to this file when starting your Java application.

2. Use Debugging Logs from SSL/TLS

If your networking issue involves HTTPS, enable debug logs for SSL/TLS issues:

  • Add the -Djavax.net.debug=all property to your JVM options.

You can modify the scope by replacing all with specific values, such as:

  • ssl
  • ssl:handshake
  • ssl:keymanager
  • ssl:trustmanager

For example:

-Djavax.net.debug=ssl:handshake

The logs will display details, such as:

  • Certificate validation
  • Handshake details
  • Cipher suites used

3. Manually Add Logging in Application

Add custom logging to capture specific details about network connections in your Java application. For instance, log details about URLs, connections, and responses:

Example Code:

package org.kodejava.net;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;

public class NetworkDebugging {
    private static final Logger LOGGER = Logger.getLogger(NetworkDebugging.class.getName());

    public static void main(String[] args) {
        try {
            URL url = new URL("https://example.com");
            LOGGER.log(Level.INFO, "Connecting to URL: {0}", url);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            connection.setRequestMethod("GET");
            int responseCode = connection.getResponseCode();
            LOGGER.log(Level.INFO, "Response Code: {0}", responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();

                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                LOGGER.log(Level.INFO, "Response: {0}", response.toString());
            } else {
                LOGGER.log(Level.WARNING, "Request failed with code: {0}", responseCode);
            }

        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, "Error during connection", e);
        }
    }
}

Explanation:

  • Logs the URL connection.
  • Tracks HTTP methods and response codes.
  • Captures exceptions for troubleshooting.

4. Java Networking Debugging Techniques

Analyze Connection Configuration

  • Ensure you are using the correct protocol (http or https).
  • Check proxy settings if applicable:
    • Set system properties like:
System.setProperty("http.proxyHost", "your.proxy.host");
System.setProperty("http.proxyPort", "8080");

Test with a Simple Socket Connection

For low-level troubleshooting, test using a Socket connection:

package org.kodejava.net;

import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class SocketDebugging {
    public static void main(String[] args) {
        try (Socket socket = new Socket("example.com", 80)) {
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            Scanner in = new Scanner(socket.getInputStream());

            out.println("GET / HTTP/1.1");
            out.println("Host: example.com");
            out.println("Connection: close");
            out.println();

            while (in.hasNextLine()) {
                System.out.println(in.nextLine());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Use Case:

  • This allows you to debug raw HTTP connections.
  • Analyze whether the issue originates from the server, DNS, or route.

5. External Tools for Troubleshooting

Use external tools for deeper investigation:

  • Wireshark: Monitor raw network traffic.
  • cURL: Test URLs outside Java to isolate application-specific issues.
  • Netcat (nc): Debug and test network connections.

Example cURL command to check an HTTP endpoint:

curl -v https://example.com

6. Check Logs for Common Issues

Inspect the logs generated by java.util.logging or javax.net.debug for patterns of common issues:

  1. Host Unreachable:
    • Possible causes: DNS resolution failure, incorrect URL.
  2. SSLHandshakeException:
    • Possible causes: Invalid certificates (verify truststore setup).
  3. Timeout Issues:
    • Check connection timeout and read timeout parameters:
connection.setConnectTimeout(5000); // 5 seconds
connection.setReadTimeout(5000); // 5 seconds

7. Verify SSL Certificates (If HTTPS)

For HTTPS issues:

  • Use keytool to inspect Java’s Keystore or Truststore:
keytool -list -v -keystore cacerts
  • Import missing certificates into the Truststore:
keytool -import -trustcacerts -file cert.pem -keystore cacerts

8. Monitor JVM Metrics

Use Java monitoring tools like:

  • JConsole
  • VisualVM

Attach these to your running Java application and monitor I/O or thread states.
By following these steps and analyzing the debug outputs, you can effectively diagnose and resolve Java networking issues.