Spring API Simulator

Controller

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) throws Exception {
        String body = new String(System.in.readAllBytes());
        String name = "guest";

        Matcher matcher = Pattern.compile("\"name\"\\s*:\\s*\"([^\"]+)\"").matcher(body);
        if (matcher.find()) {
            name = matcher.group(1);
        }

        String json = "{\"status\":\"ok\",\"message\":\"Hello " + name + "\",\"framework\":\"Spring\"}";
        System.out.println(json);
    }
}

Request Body (JSON)

Route Args (space separated)

Response

What Is the Spring API Simulator?

This tool lets you write Java code that mimics Spring Boot-style REST controller patterns and test JSON request/response handling directly in your browser. You provide a JSON request body, write a Java handler that processes it, and see the JSON response output instantly without installing Spring Boot or running a local server.

The simulator focuses on the data-processing logic inside a Spring controller method. You can parse incoming JSON using Java's standard library, transform the data, and print a formatted JSON response. This is the same logic you would place inside a @GetMapping or @PostMapping method in a real Spring Boot application.

All code runs on a remote sandboxed server powered by the Piston API. Your browser sends the Java source code and the JSON request body to the server, which compiles and executes the program inside an isolated container and returns the printed output as the simulated API response.

How It Works

Write your Java controller logic in the editor panel. The code reads a JSON request body from standard input, processes the data, and prints a JSON response to standard output.
Enter a JSON request body in the Request Body field. This simulates the payload that would be sent to a Spring Boot API endpoint.
Add route arguments in the Route Args field if your handler expects path variables such as an order ID or resource name.
Click the Run button to send your code and input to the execution server. The server compiles and runs the Java program with your JSON body provided through standard input.
View the response in the Response panel. The output shows whatever your handler prints, which is typically a formatted JSON response object.

Step-by-Step Example

Suppose you want to simulate a Spring controller endpoint that accepts a user's name and returns a greeting with a timestamp. Here is how to do it:

First, type the following code into the editor panel:

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) throws Exception {
        String body = new String(System.in.readAllBytes());
        String name = "guest";

        Matcher m = Pattern.compile("\"name\"\\s*:\\s*\"([^\"]+)\"").matcher(body);
        if (m.find()) {
            name = m.group(1);
        }

        String time = LocalDateTime.now().toString();
        System.out.println("{");
        System.out.println("  \"status\": \"ok\",");
        System.out.println("  \"greeting\": \"Hello " + name + "\",");
        System.out.println("  \"timestamp\": \"" + time + "\",");
        System.out.println("  \"framework\": \"Spring\"");
        System.out.println("}");
    }
}

Next, enter the following JSON in the Request Body field:

{"name": "Asha"}

Now click the Run button. The server compiles and executes your Java handler with the provided JSON body. After a moment, the Response panel displays a JSON object with the greeting and a timestamp.

You can modify the request body or the controller logic and run again to test different scenarios, just as you would iterate on a real Spring Boot controller method.

Use Cases

Learning Spring controller patterns. Understand how Spring Boot REST controllers parse JSON request bodies and construct JSON responses without setting up a full Spring project.
Prototyping API response logic. Quickly test data transformation and validation logic in Java before implementing it in a full Spring Boot application.
Practicing JSON handling in Java. Experiment with regex-based JSON parsing, string formatting, and response construction using Java's standard library.
Teaching REST API concepts. Demonstrate request/response cycles, controller patterns, and JSON formatting in a classroom or tutorial setting.
Testing edge cases. Verify how your handler logic responds to missing fields, empty bodies, or unexpected data types without deploying a Spring Boot application.

Limitations and Notes

No real Spring Boot server. This is a simulation. The Spring framework is not installed or running. You write handler logic in plain Java.
No actual HTTP requests. The JSON body is passed through standard input, not through an HTTP servlet request. Headers, cookies, and query parameters are not available.
No database or JPA. There is no database or Hibernate/JPA support in the sandbox. Simulate data with Java collections instead.
No Maven or Gradle. Build tools and dependency management are not available. Only the Java standard library can be used.
No dependency injection. The Spring IoC container, @Autowired, @Component, and related annotations are not functional in this environment.
Single file execution. Your entire handler must be in one Java file. Multi-file projects and external library imports are not supported.
Execution timeout applies. Programs that run too long or enter infinite loops are terminated automatically.

Frequently Asked Questions

Does this run a real Spring Boot server?

No. This is a simulation that runs Java code to mimic Spring-style controller patterns. No actual Spring Boot server or application context is started.

Does it make actual HTTP requests?

No. The simulator passes your JSON request body as standard input to a Java program. No real HTTP requests or servlet containers are involved.

Do Spring annotations work here?

Annotations like @RestController and @GetMapping are shown as a simulated pattern for learning purposes. The tool does not process actual Spring annotation routing.

Can I use a database or JPA?

No. There is no database or JPA/Hibernate support in the sandbox. You can simulate data using Java collections but cannot connect to any database.

Does dependency injection work?

No. The Spring IoC container is not available. You write plain Java code without @Autowired, @Component, or other dependency injection annotations.

Can I use Maven or Gradle dependencies?

No. Build tools are not available. Only the Java standard library classes can be used in your code.

What is the main use case for this tool?

It is designed for learning Spring-style API controller patterns, practicing JSON request and response handling in Java, and understanding how controllers process data.

Can I return JSON responses?

Yes. You can construct JSON strings in Java and print them to standard output, simulating the JSON response a Spring controller would return.