DEV Community: Tiago Martinho

A summary on Structured Concurrency in Java

Tiago Martinho — Mon, 18 Dec 2023 17:08:01 +0000

Structured concurrency is currently a preview feature in Java 21 that simplifies concurrent programming by treating groups of related tasks running in different threads as a single unit of work. This approach streamlines error handling, cancellation, and enhances observability, making it easier to build maintainable, reliable, and efficient concurrent applications.

Key Benefits of Structured Concurrency

Simplified concurrent programming: Structured concurrency allows developers to focus on the business at hand instead of orchestrating threading.
Improved error handling and cancellation: By treating tasks as a single unit, structured concurrency makes it easier to handle errors and cancel tasks when necessary.
Enhanced observability: Structured concurrency helps developers better understand the performance impacts and possible bottlenecks in their concurrent applications.

Getting Started with Structured Concurrency

To use the StructuredTaskScope API in Java, you need to enable preview features in your IDE.

Example of Structured Concurrency

Here is an example of using the StructuredTaskScope API (by the way, using an unnamed class, also a preview feature in Java 21):

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.StructuredTaskScope;
import java.util.function.Supplier;

     void main() throws ExecutionException, InterruptedException {
         try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
             Supplier<String> name  = scope.fork(fetchName());
             Supplier<Integer> age = scope.fork(fetchAge());

             scope
                     .join()            // Join both subtasks
                     .throwIfFailed();  // ... and propagate errors

             // Here, both subtasks have succeeded, so compose their results
             System.out.println("Name is " + name.get() + ". Age is " + age.get());
         }
     }

     private Callable<String> fetchName() {
         return () -> "Tiago";
     }

    private Callable<Integer> fetchAge() {
        return () -> 29;
    }

In this example, the StructuredTaskScope.ShutdownOnFailure() instance is used to fork two tasks, fetchName and fetchAge, which run concurrently. The main task waits for both subtasks to complete before continuing. If a subtask fails, the entire task scope is terminated, ensuring that resources are properly cleaned up.
The use of StructuredTaskScope ensures several valuable properties in concurrent programming. Firstly, it implements error handling with short-circuiting, meaning that if either the fetchName() or fetchAge() subtasks fail, the other is promptly cancelled if it has not completed yet, with the ability to customize this behavior using different shutdown policies. Additionally, cancellation propagation is seamlessly managed; if the thread running main() is interrupted before or during the call to join(), both subtasks are automatically cancelled when the thread exits the scope. This contributes to code clarity, as the structure is evident: setting up subtasks, awaiting their completion or cancellation, and making a decision based on the results. Lastly, for observability, a thread dump clearly illustrates the task hierarchy, depicting the threads executing fetchName() and fetchAge() as children of the scope. This enhances transparency and aids in understanding the concurrent execution flow.

Extending the StructuredTaskScope Class

Developers can also create their own subclasses of StructuredTaskScope to customize its behavior. For example, a subclass can override the handleComplete method to define specific actions when a task is completed. The following is an example of a StructuredTaskScope subclass that collects the results of subtasks that complete successfully. It defines the method results() to be used by the main task to retrieve the results.

class MyScope<T> extends StructuredTaskScope<T> {

    private final Queue<T> results = new ConcurrentLinkedQueue<>();

    MyScope() { super(null, Thread.ofVirtual().factory()); }

    @Override
    protected void handleComplete(Subtask<? extends T> subtask) {
        if (subtask.state() == Subtask.State.SUCCESS)
            results.add(subtask.get());
    }

    @Override
    public MyScope<T> join() throws InterruptedException {
        super.join();
        return this;
    }

    // Returns a stream of results from the subtasks that completed successfully
    public Stream<T> results() {
        super.ensureOwnerAndJoined();
        return results.stream();
    }

}

This custom policy can be used like so:

<T> List<T> allSuccessful(List<Callable<T>> tasks) throws InterruptedException {
    try (var scope = new MyScope<T>()) {
        for (var task : tasks) scope.fork(task);
        return scope.join()
                    .results().toList();
    }
}

Conclusion

Structured concurrency is a promising addition to the Java standard API, simplifying concurrent programming and making it easier to build maintainable, reliable, and efficient applications. As this feature progresses from preview to stable, it is poised to unlock new possibilities in concurrent application development.

References

https://openjdk.org/jeps/453

Virtual Threads in Java 21

Tiago Martinho — Thu, 02 Nov 2023 10:00:00 +0000

Introduction

For developers entrenched in the complexities of concurrent programming, virtual threads represent more than just another update. It's a potential game-changer, a practical solution to the long-standing challenges of managing multiple tasks efficiently. With the promise of enhanced scalability and performance, these virtual threads are poised to simplify the intricacies of handling concurrent operations, enabling developers to streamline their workflows and optimize resource utilization. In this blog post, we'll take a pragmatic dive into the core functionalities and application of Java 21's virtual threads, examining their real-world implications and the ways in which they can revolutionize the development process. Get ready to uncover a powerful tool that's not just theoretical, but one that holds the promise of significantly improving the practical aspects of your coding endeavors.

What are virtual threads exactly?

Virtual threads represent a significant shift in how the Java Virtual Machine (JVM) handles threads. Unlike traditional threads (called Platform or Native threads), which are mapped directly to operating system (OS) threads, virtual threads are managed by the JVM itself. They are lightweight, highly scalable, and designed to enable more efficient use of system resources.

These virtual threads operate within a shared pool of underlying OS threads, allowing the JVM to manage them dynamically, based on the available resources and the workload. This approach minimizes the overhead associated with creating and managing OS threads, making it possible to handle a much larger number of concurrent tasks without overburdening the system.

By decoupling the association between Java threads and OS threads, virtual threads provide a more flexible and resource-efficient mechanism for managing concurrency in Java applications. This feature enables developers to create a significantly higher number of threads without the performance penalties typically associated with the traditional thread model. Additionally, virtual threads facilitate smoother integration with existing codebases and frameworks, making it easier to optimize the performance of concurrent applications without significant code changes.

How to use virtual threads

The following is a code example on how to use virtual threads using the Threadclass.

Thread.startVirtualThread(() -> {
            System.out.println("Running virtual thread: " + Thread.currentThread().getName());
});

// or
Thread.ofVirtual().start(() -> System.out.println("Running virtual thread: " + Thread.currentThread().getName());
thread.join(); // for allowing you to see the message as it waits for the thread to terminate, before the main thread terminates

And the following is a code example on how to use virtual threads using the ExecutorServiceinterface.

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        executor.submit(() -> {
            System.out.println("Running virtual thread with ExecutorService: " + Thread.currentThread().getName());
        });

The last example is the recommended approach due to higher level abstraction and the fact that you don't have to worry about thread management yourself as ExecutorService will reuse threads for multiple tasks, ultimately reducing overhead on creation and destruction of said threads.

Virtual Threads under the hood

Internally, a specialized pool of platform threads, which is essentially a customized fork-join pool, is employed to execute virtual threads. These virtual threads are tethered to specific platform threads from the pool, utilizing them for task execution.

Consider a scenario where your task involves a blocking I/O operation, such as a database request to retrieve user data. It's crucial to prevent the blocking of a platform thread. In such instances, the virtual thread identifies the blocking I/O operation and unmounts itself from the platform thread it's running on. It accomplishes this by moving its context/stack to the heap memory.

More specifically, this detachment is done by a specialized object known as a Continuation, which utilizes its run() method to manage the execution of the virtual thread and, consequently, your task. When a blocking call occurs, a call to Continuation.yield() initiates the process of unmounting the virtual thread from the platform thread and copying its stack to the heap memory. This process can be seen in the following animation:

After the response data is available, the operating system handler responsible for monitoring the data triggers a signal that invokes Continuation.run(). This action involves retrieving the stack of the virtual thread from the heap memory and placing it in the wait list of the original platform thread within the fork-join pool. This can be seen below:

Furthermore, in situations where a thread is busy, and an alternative thread is accessible, the latter may 'steal' the task from the former. This phenomenon allows for the seamless transition of tasks between different platform threads when a thread is busy.

Conclusion

As we've explored throughout this post, the benefits of virtual threads extend beyond mere optimization; they represent a fundamental shift in the way developers approach and implement concurrent operations in Java applications. With the ability to seamlessly integrate with existing codebases and frameworks, virtual threads empower developers to harness the full potential of concurrent programming, enabling the creation of highly responsive, resource-efficient, and scalable applications.
As developers continue to leverage this groundbreaking feature, it is evident that virtual threads will play a pivotal role in shaping the future of high-performance, concurrent applications, ushering in a new era of efficiency and scalability in the world of Java programming.

Useful references

2 minute video that explains virtual threads: https://www.youtube.com/watch?v=bOnIYy3Y5OA

Deep dive video on virtual threads:
https://www.youtube.com/watch?v=5E0LU85EnTI

Oracle documentation on virtual threads:
https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html#GUID-DC4306FC-D6C1-4BCC-AECE-48C32C1A8DAA

Flyway Migrations: Simplifying Database Version Control

Tiago Martinho — Thu, 12 Oct 2023 11:00:00 +0000

Introduction

In today's fast-paced software development world, managing database changes can be a challenging task. Database migrations play a crucial role in keeping the database schema in sync with the application code. One popular tool that simplifies this process is Flyway. In this blog post, we will explore the benefits of using Flyway for database migrations and how it can streamline the version control of your database.

Streamlining Database Migrations with Flyway

Flyway is an open-source database migration tool that provides a simple and reliable solution for managing database changes. It follows a convention-over-configuration approach, making it easy to integrate into your existing projects. With Flyway, you can effortlessly migrate your database schema and keep it in sync with your application code, eliminating the need for manual intervention.

Automating Database Version Control

One of the key advantages of Flyway is its ability to automate database version control. It uses a versioned migration approach, where each migration script is associated with a version number. Flyway maintains a metadata table in the database to keep track of which migrations have been applied. This allows Flyway to apply only the necessary migrations, making it efficient and reliable.

To create a Flyway migration, you need to follow these steps:

Choose the scripting language: Flyway supports multiple scripting languages such as SQL, JavaScript, Groovy, and more. Choose the language that suits your needs.
Create the migration script: Create a new file with a descriptive name and a version number. For example, V1__create_table.sql. This version number is important as Flyway uses it to determine the order in which migrations should be applied.
Write the migration script: In the migration script, you can include SQL statements to create or modify database objects such as tables, columns, indexes, etc. For example, you can use SQL statements like CREATE TABLE, ALTER TABLE, INSERT INTO, etc.
Place the migration script in the appropriate location: Flyway follows a convention where migration scripts are placed in a specific directory. For example, in a Maven project, you can place the migration script in the src/main/resources/db/migration directory.
Run Flyway: Once you have created the migration script, you can run Flyway to apply the migrations. Flyway will automatically detect and execute the pending migrations.

Here's an example of a Flyway migration file:

Filename: V1__create_customers_table.sql

-- Create the "customers" table
CREATE TABLE customers (
    id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

In this example, the migration file creates a table named "customers" with columns for "id", "name", "email", and "created_at". The migration file follows the naming convention of starting with a version number, in this case, "V1", followed by a double underscore "__" and a descriptive name.

You can place this migration file in the appropriate directory for Flyway to detect and execute during the migration process.

Here's an example of how you can run the database migrations using Flyway in Java code:

import org.flywaydb.core.Flyway;

public class DatabaseMigration {
    public static void main(String[] args) {
        // Create a Flyway instance
        Flyway flyway = Flyway.configure().dataSource("jdbc:mysql://localhost:3306/mydb", "username", "password").load();

        // Migrate the database
        flyway.migrate();

        // Print the status after migration
        flyway.info().all().forEach(System.out::println);
    }
}

In this example, we create a Flyway instance and configure it with the necessary database connection details. The migrate() method is then called to apply the pending migrations to the database. Finally, the info() method is used to retrieve the current status of all migrations, which is printed to the console.

Remember to replace "jdbc:mysql://localhost:3306/mydb", "username", and "password" with your actual database connection details.

With this Java code, you can easily incorporate the database migration functionality into your application and ensure that your database schema is always up to date with your application code.

Handling Database Rollbacks

Another noteworthy feature of Flyway is its support for database rollbacks. In case of a failed migration or a need to revert a change, Flyway allows you to easily rollback the applied migrations. By executing the rollback command, Flyway will undo the last applied migration, ensuring that your database remains in a consistent state.

For example, let's say you have applied a migration to create a new table in your database. If you encounter an issue with that migration or need to revert it, you can use the rollback command to undo the changes. Flyway will execute the corresponding "down" migration script, which is the opposite of the "up" migration script that created the table. This way, your database can be reverted to its previous state.

Consider the previous migration file we created V1__create_customers_table.sql that creates a table named customers. If you want to rollback this migration, you can execute the following command:

flyway.undo();

Flyway will identify the last applied migration and execute the corresponding "down" migration script, which will drop the customers table.

Conclusion

Managing database changes is a critical aspect of software development, and Flyway simplifies this process by providing a robust and easy-to-use solution. With Flyway, you can automate database version control, streamline your build process, and handle rollbacks effortlessly. By adopting Flyway for your database migrations, you can ensure that your database schema and application code are always in sync, saving time and reducing the risk of errors.

Interacting with your database with jOOQ

Tiago Martinho — Wed, 04 Oct 2023 08:55:00 +0000

Introduction

In the world of modern software development, interacting with databases is a common requirement. jOOQ, short for Java Object Oriented Querying, is a powerful and popular open-source library that provides a fluent API for building type-safe SQL queries. In this blog post, we will explore the process of setting up jOOQ and making queries using this versatile tool.

Setting Up jOOQ

To begin using jOOQ, we first need to set it up in our project. The first step is to include the jOOQ dependency in our build configuration file. Whether you are using Maven or Gradle, you can easily add the jOOQ dependency by specifying the appropriate coordinates.

Maven:

<dependencies>
    <dependency>
        <groupId>org.jooq</groupId>
        <artifactId>jooq</artifactId>
        <version>3.18.6</version>
    </dependency>
</dependencies>

Gradle:

dependencies {
    implementation 'org.jooq:jooq:3.18.6'
}

Once the dependency is added, we need to generate the jOOQ classes that will represent our database schema. jOOQ provides a code generation tool that can analyze the structure of our database and generate the necessary classes. This tool can be configured through an XML file or programmatically using the jOOQ API.

Here is an example of configuring the code generation tool programmatically:

Configuration configuration = new Configuration()
    .withJdbc(new Jdbc()
        .withDriver("org.postgresql.Driver")
        .withUrl("jdbc:postgresql://localhost:5432/mydatabase")
        .withUser("username")
        .withPassword("password"))
    .withGenerator(new Generator()
        .withDatabase(new Database()
            .withName("org.jooq.meta.postgres.PostgresDatabase")
            .withIncludes(".*")
            .withExcludes("")
            .withInputSchema("public"))
        .withGenerate(new Generate()
            .withPojos(true)
            .withDaos(true)
            .withFluentSetters(true))
        .withTarget(new Target()
            .withPackageName("com.example.jooq.generated")
            .withDirectory("src/main/java")));

GenerationTool.generate(configuration);

After generating the jOOQ classes, we need to establish a connection to our database. jOOQ supports a wide range of database systems, including popular ones like MySQL, PostgreSQL, and Oracle. We can configure the database connection properties in our project's configuration file and use the jOOQ API to establish the connection.

Here is an example of establishing a connection to a PostgreSQL database:

Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "username", "password");

Making Queries with jOOQ

Once we have set up jOOQ and established a connection to our database, we can start making queries using the fluent API provided by jOOQ. jOOQ allows us to write SQL queries in a type-safe and convenient manner, making it easier to work with our database.

To make a query, we first need to create a jOOQ DSLContext object, which serves as the entry point for executing queries.

DSLContext dslContext = DSL.using(connection, SQLDialect.POSTGRES);

We can then use the DSLContext object to build our query by chaining method calls to construct the desired SQL statement.

Here is an example of a simple query that fetches all authors with the name “Tiago” from the AUTHOR table:

Result<Record> result = dslContext.select()
    .from(Tables.AUTHOR)
    .where(Tables.AUTHOR.NAME.eq("Tiago"))
    .fetch();

And we can iterate through the Result like so:

for (Record record : result) {
    int id = record.getValue(Tables.AUTHOR.ID);
    String name = record.getValue(Tables.AUTHOR.NAME);
    System.out.println("Author ID: " + id + ", Name: " + name);
}

Finally, here is an example for inserting a record. In this case:

dslContext.insertInto(Tables.AUTHOR)
    .set(Tables.AUTHOR.ID, 2)
    .set(Tables.AUTHOR.NAME, "Jane Doe")
    .execute();

An alternative syntax for inserting the same record would be:

dslContext.insertInto(Tables.AUTHOR,
        AUTHOR.ID, AUTHOR.NAME)
      .values(100, "Tiago")
      .execute();

Conclusion

jOOQ is a powerful tool that simplifies the process of interacting with databases in Java applications. By providing a fluent API for building type-safe SQL queries, jOOQ makes it easier to write and maintain database code.

In this blog post, we discussed the process of setting up jOOQ and making queries using its intuitive API. With jOOQ, developers can focus more on the business logic of their applications and spend less time dealing with low-level database interactions.

Creating a backend API for uploading files to Amazon S3 and Google Cloud Storage

Tiago Martinho — Wed, 27 Sep 2023 15:00:00 +0000

Introduction

In modern web development, it is common for users to upload files to websites or applications. Whether it's a profile picture, a document, or any other type of file, handling file uploads is an essential part of many web applications. In a previous blogpost we saw how we could use SparkJava to define routes for GET and POST requests. Now we will explore how to parse files sent from the frontend in a POST request and how to store them in cloud providers like Amazon S3 and Google Cloud Platform.

Parsing Files with SparkJava

To handle file uploads in SparkJava, we need to first parse the incoming request to extract the uploaded file. SparkJava provides a convenient way to parse files using the Request object. We can access the uploaded file by calling the raw method on the request and then retrieving the file using its parameter name. Once we have the file, we can perform various operations on it, such as retrieving its name, size, or content.

Here's an example of how to parse a file from the request in SparkJava:

post("/upload", (request, response) -> {
    final var filePart = request.raw().getPart("file");
    // Perform operations on the file
    // e.g. retrieve its name, size, or content
    client.put(part.getSubmittedFileName(), part.getInputStream());
    return "File uploaded successfully";
});

In the above code snippet, we define a POST endpoint at "/upload" that takes in a Request object and a Response object as parameters. Inside the post method, we get the input stream of the uploaded file part by calling getInputStream(). From there, we can perform any necessary operations on the file part like getSubmittedFileName().
The client object is an abstract class or interface that stores the file contents in the cloud provider of your choice. The actual implementation can be instantiated on your resource or controller depending on your application configuration.

Storage client interface

The following is an example of the client interface we described previously.

public interface StorageClient {

   void put(String filename, InputStream inputstream);
}

For simplicity sake we are defining the return type of the method as void but there are advantages in defining some result type class that wraps the results returned by the cloud provider client methods. For example, you can get the uploaded file metadata. It also allows for easier unit testing.

Uploading Files to Amazon S3

After parsing the file in SparkJava, the next step is to upload it to a storage service. To upload files to S3, we need to create an S3 client and specify the bucket where we want to store the file. We can then use the client to upload the file by providing the bucket name, a unique key for the file, and the file's content.

Here's an example of how to upload a file to Amazon S3 using the AWS SDK for Java:

AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
     .withRegion(Regions.EU_WEST_1)
     .withCredentials(
         new AWSStaticCredentialsProvider(
         new BasicAWSCredentials(
                 s3BucketConfig.accessKey, 
                 s3BucketConfig.secretKey)))
     .build();

s3Client.putObject(
    new PutObjectRequest(
        s3BucketConfig.bucketName,
        filename, 
        inputstream));

In the above code snippet, we first create an instance of the Amazon S3 client using the AmazonS3ClientBuilder class. We specify the desired region for the S3 bucket using the withRegion method and instantiate the credentials using the necessary keys from our config. Then, we provide the bucket name from our s3BucketConfig, the filename and the file input stream itself as parameters to the putObject method of the S3 client. This will upload the file to the specified bucket in Amazon S3.
The S3 client can be wrapped in your own client and implement the StorageClient interface we defined previously.

Uploading Files to Google Cloud Storage

A similar process is used to store the file in Google Cloud storage as can be seen below:

final var storage = StorageOptions.newBuilder()
    .setCredentials(cloudStorageConfig.jwtPath)
    .setProjectId(cloudStorageConfig.projectId)
    .build()
    .getService();

final var blob = newBuilder(
    BlobId.of(cloudStorageConfig.bucket, filename)).build();

storage.create(blob, inputStream.readAllBytes());

First we instantiate a Storage object from our cloudStorageConfig which contains the path to our service account key file jwtPath and our google cloud projectId.
Then we create a Blob object using the BlobInfo.newBuilder method. We just need to provide a BlobId which we can instantiate from the bucket where we want to store our files and the filename itself.
Finally, the Storage.create method will upload our file to the cloud storage bucket of our choice.
Like the S3 client, the Google Storage client can be wrapped and implement the StorageClient interface.

Conclusion

Handling file uploads is a crucial aspect of web development, and with SparkJava and Amazon S3 or Google Cloud Storage, it becomes a seamless process. By parsing files with SparkJava and uploading them to the cloud provider of our choice we can securely store files in the cloud and access them whenever needed. This combination of technologies provides a robust solution for managing file uploads in web applications.

So, the next time you need to implement file uploading in your web application, consider using SparkJava and Amazon S3 or Google Cloud Storage for a reliable and scalable solution. By following the examples outlined in this blog post, you'll be able to handle file uploads seamlessly and provide a great user experience.

Exploring the Power of SparkJava

Tiago Martinho — Sun, 17 Sep 2023 17:31:34 +0000

Introduction

In the world of web development, there are countless frameworks available to choose from. Each framework has its own unique features and advantages. One framework that I discovered and have been using for the past 2 years since I joined Revolut is SparkJava. SparkJava is a lightweight web framework that allows you to quickly build web applications. In this blog post, I will explain some of the features and benefits of SparkJava and why I think it’s a great alternative to other, heavier, frameworks.

Simplified Routing and Request Handling

One of the key features that sets SparkJava apart from other frameworks is its simplified routing and request handling. With SparkJava, you can can easily define routes and handle incoming requests with just a few lines of code. The framework provides a clean and intuitive syntax that allows you to quickly map URLs to specific routes and define the corresponding actions to be taken.

Here's an example of how to define a GET method in SparkJava:

import static spark.Spark.*;

public class Main {
    public static void main(String[] args) {
        // Define a route for the "/hello" URL
        get("/hello", (request, response) -> {
            return "Hello, World!";
        });
    }
}

In this example, the get() method is used to define a route for the "/hello" URL. The lambda function (request, response) -> { return "Hello, World!"; } represents the action to be taken when a GET request is made to the "/hello" URL. In this case, it simply returns the string "Hello, World!" as the response.

And a POST method:

import static spark.Spark.*;

public class Main {
    public static void main(String[] args) {
        // Define a route for the "/new-post" URL with POST method
        post("/new-post", (request, response) -> {
            // Get the data from the request and process it
            String postData = request.body();
            // Save the post to the database or perform any other actions
            // ...

            // Return a success message
            return "Post created successfully!";
        });
    }
}

In this example, the post() method is used to define a route for the "/new-post" URL with the POST method. The lambda function (request, response) -> { ... } represents the action to be taken when a POST request is made to the "/new-post" URL. Inside the lambda function, you can access the data from the request using request.body() and process it accordingly. After processing the data, you can save it to the database or perform any other necessary actions. Finally, you can return a success message as the response.

Lightweight and Fast Performance

Another major advantage of SparkJava is its lightweight nature and fast performance. Unlike some other heavyweight frameworks, SparkJava is designed to be minimalistic and lightweight, making it perfect for building apps of any size. Its simplicity and minimal overhead result in faster response times and improved performance.

Comparing SparkJava with other popular frameworks like Spring Boot

When comparing SparkJava with other frameworks like Spring Boot, one advantage of SparkJava is its lightweight nature which allows you to only import the functionality that you need. This is particularly useful when you only care about exposing specific routes in your application. With SparkJava, you can easily define and handle routes without importing unnecessary components or libraries. This helps to keep your application lean and efficient, as you only include the features that are required for your specific use case.

Conclusion

In conclusion, SparkJava is a powerful and lightweight web framework that simplifies the process of building web applications. Its simplicity, fast performance, and extensibility make it a popular choice among developers. Whether you are a beginner or an experienced developer, SparkJava provides an intuitive and efficient way to create robust web applications. So, if you are looking for a framework that strikes the perfect balance between simplicity and functionality, SparkJava might just be the right choice for you.