DEV Community: Anatolii Kozlov

Scripting with Java

Anatolii Kozlov — Sun, 02 Jun 2024 12:41:53 +0000

Introduction

As a developer, you sometimes need to write scripts. If your primary expertise is in Java, you might have considered writing scripts in Java instead of Bash or Python. However, if you've tried this, you quickly realized it's not as straightforward as it seems due to Java's verbosity. In this article, I'll explain why scripting with Java now is possible and, more importantly, practical. I'll also introduce a small utility that allows you to write Java scripts that are simple and powerful.

1. It's Possible

Writing scripts in Java has been possible since Java 11. JEP 330: Launch Single-File Source-Code Programs introduced the ability to run single-file Java scripts without requiring explicit compilation. This feature also allowed adding a shebang to the beginning of the file, enabling scripts to be run directly from the command line.

Even though Java 11 made shebangs possible, nobody started writing scripts in Java because it was cumbersome. Just look at this 'Hello World' example:

#!/usr/bin/env java --source 11

public class Script {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

This leads us logically to the next part of the article.

2. Now It's Simpler

Starting with Java 22 (in preview mode), JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview) allows us to omit the class declaration and reduce the main function declaration from public static void main(String[] args) to simply void main(). This is a significant improvement.

#!/usr/bin/env java --source 22 --enable-preview

void main() {
    System.out.println("Hello World");
}

It will become even simpler in the third iteration of this JEP. Java 23, with JEP 477: Implicitly Declared Classes and Instance Main Methods (Third Preview), will allow writing print(obj), println(obj), and readln(obj) instead of System.out.println(obj), thanks to the automatic import of the java.io.IO package.

3. But It's Still Not Practical

Yeah, the newer versions of Java have reduced much of the verbosity, so writing a 'Hello World' script become easier. The problem becomes apparent when trying to do something more complex. Consider the following example:

Example 1 (HTTP request)
Let's say you want to make an HTTP request and print the result. Here's how it looks:

#!/usr/bin/env java --source 22 --enable-preview

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

void main() throws Exception {
    var url = new URL("https://httpbin.org/get");
    var con = (HttpURLConnection) url.openConnection();
    con.setRequestMethod("GET");
    var in = new BufferedReader(new InputStreamReader(con.getInputStream()));
    String inputLine;
    var content = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        content.append(inputLine);
    }
    in.close();
    con.disconnect();
    System.out.println(content);
}

This is a mess. 11 lines of code in main(), just to make an HTTP request and print the result, + import lines. Using HttpClient introduced in Java 11 doesn't simplify it much:

#!/usr/bin/env java --source 22 --enable-preview

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

void main() throws Exception {
    var httpClient = HttpClient.newHttpClient();
    var response = httpClient.send(HttpRequest.newBuilder()
                    .uri(URI.create("https://httpbin.org/get"))
                    .build(),
            HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
}

6 lines of code in main(), + import lines.

Example 2 (Terminal command)
Here's another example, invoking a terminal command:

#!/usr/bin/env java --source 22 --enable-preview

import java.io.BufferedReader;
import java.io.InputStreamReader;

void main() throws Exception {
    var process = Runtime.getRuntime().exec("ls -lah");
    var reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
    int exitCode = process.waitFor();
    System.out.println("Exited with code: " + exitCode);
}

Example 3 (Files IO)
Or, working with files... Have you ever tried to delete a directory with all its contents? You'd struggle with walk() and nested try-catch blocks for handling numerous checked exceptions.

All this shows that while Java is powerful, it's not suitable for scripting. But what if I told you it could be?

The problem is that standard mechanisms don't provide default behavior. That's a pity because it simplifies life. Think about why Spring Boot starters became so popular. It includes default behavior. For cases that require detailed configuration, you can always define it, but for most scripting tasks, it's not necessary.

That's why I created a utility that allows you to write Java scripts concisely.

4. Introducing Scripting Utils for Java

Scripting Utils - a single Java file containing several useful wrapper classes with default behavior. Static objects of these wrappers are declared for quick access to functions in this file.

GitHub: https://github.com/AnatoliyKozlov/scripting-utils

To see how convenient this is, let's revisit the examples above using Scripting Utils.

#!/usr/bin/env java --source 22 --enable-preview --class-path /Users/toliyansky/scripting-utils

import static scripting.Utils.*;

void main() {
    var response = http.get("https://httpbin.org/get");
    log.info(response.body());
}

As we can see, we need to add --class-path /Users/toliyansky/scripting-utils to the shebang line and a static import import static scripting.Utils.*;, then we can leverage the full power of Scripting Utils.

Just two lines for an HTTP request and logging the response.

Other examples:

#!/usr/bin/env java --source 22 --enable-preview --class-path /Users/toliyansky/scripting-utils

import static scripting.Utils.*;

void main() {
    var terminalResponse = terminal.execute("ls -lah", 100);
    log.info(terminalResponse.output);
}

Just two lines for executing a command and logging the response.

Scripting Utils includes wrappers for:

http for HTTP requests
terminal for terminal commands
file for file operations
log for logging
thread for threading

Let's look at an example that utilizes the advantages of Scripting Utils.

Imagine our script needs to read a file containing lines in the format <name> <URL>. For each line, it should make an HTTP request and save the result to a file named <name>. As a bonus, let's do this in parallel, because we want to leverage Java's strengths over Bash or Python.

#!/usr/bin/env java --source 22 --enable-preview --class-path /Users/toliyansky/scripting-utils

import static scripting.Utils.*;

void main() {
    var linksFilePath = "links.txt";
    if (!file.exists(linksFilePath)) {
        log.error("File not found: " + linksFilePath);
        return;
    }
    file.readAllLines(linksFilePath)
            .forEach(line -> thread.run(() -> {
                var data = line.split(" ");
                var fileName = data[0];
                var url = data[1];
                var response = http.get(url);
                if (response.statusCode() == 200) {
                    file.rewrite(fileName, response.body());
                    log.info("File " + fileName + " updated from " + url);
                } else {
                    log.warn("File " + fileName + " was not updated. Http code: " + response.statusCode());
                }
            }));
    thread.sleepSeconds(5);
    var terminalResponse = terminal.execute("ls -lah", 100);
    log.info(terminalResponse.output);
}

Only 20 lines of code in main() that do tons of work. It uses the files, http, log, thread, and terminal modules.

Can you imagine the monstrosity this would be without Scripting Utils? Or in Bash 😄? Or in Python?

The downside is that Scripting Utils needs to be installed. The project repository has a one-line command that downloads Utils.java, places it in a specific directory, and compiles it. This only needs to be done once. After that, you can use it in your scripts.

Conclusion

As you can see, Java is actively working towards simplifying the writing of simple programs, including scripts. The numerous JEPs I've mentioned above, and others like JEP 458: Launch Multi-File Source-Code Programs, attest to this. However, even with these simplifications, Java remains not the most convenient language for scripting. With the advent of Scripting Utils, it has become practical as well.

One-page Java cheat sheet

Anatolii Kozlov — Thu, 05 Jan 2023 17:17:26 +0000

Hello everyone 👋

I am glad to present you with the One-page Java cheat sheet.

Link (google doc): One-page Java cheat sheet

Feel free to leave your comments on the google doc or below the post.

Sources:
https://www.geeksforgeeks.org/equals-hashcode-methods-java
https://www.baeldung.com/java-string-pool

One-page Software design cheat sheet

Anatolii Kozlov — Tue, 03 Jan 2023 11:04:00 +0000

Hello everyone 👋

I am glad to present you with the One-page software design cheat sheet. Document involve into:

Programming paradigms
Design principles
Design patterns
Some approaches, terminology, etc

Link (google doc): One-page Software design cheat sheet

Feel free to leave your comments on the google doc or below the post.

Sources:
https://en.wikipedia.org/wiki/Object-oriented_programming
https://en.wikipedia.org/wiki/Aspect-oriented_programming
http://dotnetlearners.com/blogs/inheritance-association-aggregation-composition
https://en.wikipedia.org/wiki/SOLID
https://refactoring.guru/design-patterns/catalog
https://swagger.io/resources/articles/adopting-an-api-first-approach
https://microservices.io/index.html

One-page Database cheat sheet

Anatolii Kozlov — Sat, 31 Dec 2022 13:14:30 +0000

Hello everyone 👋

I am glad to present you with the One-page Database cheat sheet.

Link (google doc): One-page Database cheat sheet

Feel free to leave your comments on the google doc or below the post.

Sources:
https://www.geeksforgeeks.org/acid-properties-in-dbms/
https://www.geeksforgeeks.org/transaction-isolation-levels-dbms/
https://www.geeksforgeeks.org/normal-forms-in-dbms/
https://www.geeksforgeeks.org/indexing-in-databases-set-1/
https://www.scaler.com/topics/sql/advantages-and-disadvantages-of-indexing-in-sql/

One-page HTTP/REST cheat sheet

Anatolii Kozlov — Sun, 25 Dec 2022 18:01:54 +0000

Hello everyone 👋

I am glad to present you with the One-page HTTP/REST cheat sheet.

Link (google doc): One-page HTTP/REST cheat sheet

Feel free to leave your comments on the google doc or below the post.

One-page IT cheat sheets

Anatolii Kozlov — Sun, 25 Dec 2022 18:01:04 +0000

Hello everyone 👋

Today I want to start the series of posts with One-page IT cheat sheets. Main features of it:

One topic occupied only one page;
Page in A4 format;
Cheat sheet contains the most often questions for a job interview.

I hope these cheat sheets will be very suitable for revising your knowledge about some topics before a job interview. Also, the A4 format and very compact structure allow you to print the cheat sheet and stick it on the wall behind your PC for quick access to it during the interview.

This post will be updated whenever I will release a new cheat sheet 😉

List:

HTTP/REST
Database
Software design
Container orchestration (k8s) (coming soon)
Java
Spring Framework (coming soon)
Multithreading/Concurrency (java) (coming soon)

All cheat sheets allow leaving your comments on them. From time to time I will check comments and make corresponding changes.

Good luck with the interview 🤞

Typical Java-Spring microservice

Anatolii Kozlov — Mon, 17 Oct 2022 13:59:59 +0000

Overview

We often create new typical microservice with Java-Spring and many technologies around this stack. Of course, nobody remembers the full structure of all configurations for a project like this. Nobody doesn't write manually configuration of maven plugins or string of DB data source or OpenAPI specification. Anyone always google it, and then paste and edit it for their own case. That's because I created a simple template project for quick access to examples.

Technologies

In this project setup and configured the next technologies.

Java 17
Spring Boot 2.7.4
Maven
Liquibase
H2
JPA
Git
Lombok
Actuator / Prometheus
OpenAPI

Template project

Source code on GitHub

OpenAPI Generation with Spring

Anatolii Kozlov — Mon, 17 Oct 2022 11:11:45 +0000

1 Overview

In this article we consider example of using code generation by OpenAPI specification. This is the API-First approach to building service. Code generator will be used for generating code in java-spring application. Full source code of example project on GitHub

2 Specification

Let's start with writing simple OpenAPI specifications. Here we use an example with 'Get' and 'Create' operations for some Clients.

openapi: 3.0.3
info:
  title: client-api
  description: 'Client API'
  version: 1.0.0
paths:
  /client:
    get:
      parameters:
        - name: id
          in: query
          required: true
          schema:
            type: string
            format: uuid
            description: Client id
      responses:
        200:
          description: Success response with client
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ClientResponse"
    post:
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Client'
        required: true
      responses:
        200:
          description: Success response with client
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ClientResponse"
components:
  schemas:
    ClientResponse:
      type: object
      properties:
        success:
          type: boolean
          description: Operation success flag
        message:
          type: string
          description: Error description
        client:
          $ref: "#/components/schemas/Client"
      required:
        - success
        - message
        - object
    Client:
      type: object
      description: Client data
      properties:
        id:
          type: string
          format: uuid
          description: Client unique id
        name:
          type: string
          description: Client name
          maximum: 32
          minimum: 2
        dateOfBirth:
          type: string
          format: date
        createdAt:
          type: string
          description: Date of client registration
          format: date-time
        banned:
          type: boolean
          description: Ban flag
        countAccounts:
          type: integer
          description: Count of client accounts
          minimum: 0
        serviceRate:
          type: string
          description: Service rate
          enum:
            - "FREE"
            - "STANDARD"
            - "VIP"

3 Setup dependencies

Let's setup OpenAPI generator maven plugin

<plugin>
    <groupId>org.openapitools</groupId>
    <artifactId>openapi-generator-maven-plugin</artifactId>
    <version>6.2.0</version>
    <executions>
        <execution>
            <goals>
                <goal>generate</goal>
            </goals>
            <configuration>
                <inputSpec>${project.basedir}/specs/client-api.yaml</inputSpec>
                <generatorName>spring</generatorName>
                <apiPackage>dev.toliyansky.openapi.api</apiPackage>
                <modelPackage>dev.toliyansky.openapi.model</modelPackage>
            </configuration>
        </execution>
    </executions>
</plugin>

4 Code examples

After run mvn clean install generated classes will be placed into target directory.

To implement the HTTP route we should create a class that extends generated controller.

@RestController
@RequestMapping("/api")
public class ClientController extends ClientApiController {

    private final RandomExceptionService randomExceptionService;

    public ClientController(NativeWebRequest request, RandomExceptionService randomExceptionService) {
        super(request);
        this.randomExceptionService = randomExceptionService;
    }

    @Override
    public ResponseEntity<ClientResponse> clientGet(UUID id) {
        var clientResponse = new ClientResponse();
        try {
            var client = new Client(); // Stub. But in real project get client from service level.
            clientResponse.setSuccess(true);
            clientResponse.setClient(client);
            randomExceptionService.generateException50percentChance();
            return ResponseEntity.ok(clientResponse);
        } catch (Exception e) {
            e.printStackTrace();
            clientResponse.setSuccess(false);
            clientResponse.setMessage(e.getMessage());
            clientResponse.setClient(null);
            return ResponseEntity.internalServerError().body(clientResponse);
        }
    }

    @Override
    public ResponseEntity<ClientResponse> clientPost(Client client) {
        var clientResponse = new ClientResponse();
        try {
            // Do some actions with client in service level.
            client.id(UUID.randomUUID());
            clientResponse.setSuccess(true);
            clientResponse.setClient(client);
            randomExceptionService.generateException50percentChance();
            return ResponseEntity.ok(clientResponse);
        } catch (Exception e) {
            e.printStackTrace();
            clientResponse.setSuccess(false);
            clientResponse.setMessage(e.getMessage());
            clientResponse.setClient(null);
            return ResponseEntity.internalServerError().body(clientResponse);
        }
    }
}

Now we can test it with HTTP request

### Create client
POST http://localhost:8080/api/client
Content-Type: application/json
------
HTTP/1.1 200 
Content-Type: application/json
{
  "success": true,
  "message": null,
  "client": {
    "id": "6796a90a-314a-4667-a7cc-dfbe592b27e5",
    "name": "Anatoliy",
    "dateOfBirth": "2020-01-01",
    "createdAt": "2020-01-01T00:00:00Z",
    "banned": false,
    "countAccounts": 3,
    "serviceRate": "VIP"
  }
}

### Get client by id
GET http://localhost:8080/api/client?id=6796a90a-314a-4667-a7cc-dfbe592b27e5
Accept: application/json
------
HTTP/1.1 200 
Content-Type: application/json
{
  "success": true,
  "message": null,
  "client": {
    "id": "6796a90a-314a-4667-a7cc-dfbe592b27e5",
    "name": "Anatoliy",
    "dateOfBirth": "2020-01-01",
    "createdAt": "2020-01-01T00:00:00Z",
    "banned": false,
    "countAccounts": 3,
    "serviceRate": "VIP"
  }
}

5 Conclusion

In this article, we saw how to generate a java-spring service with an API-First approach with OpenAPI YAML specification and OpenAPI generator maven plugin.

Full source code of example project on GitHub

Code evaluation as a debugging tool

Anatolii Kozlov — Fri, 07 Oct 2022 17:05:40 +0000

In this article, "code evaluation" means - executing code expressions in runtime, like it happens when you pause the application in debug mode in IDEA and use the feature "Evaluate Expression". Let's consider how to implement "code evaluation" in a java application and then explore implemented solutions for using "code evaluation" in the java-spring application.

Use case example

For example, projects in your company use kubernetes. After implementing the new feature you must pass all pipelines to check how it works in the environment with all integrations with other services. And after deploying the service you see that some little things work not properly. And you want to make some little fixes for checking the hypothesis. However, to check it your must pass all pipelines including coding, review, building, deploying, etc.
If you have a tool like code evaluator in the project you can change any code or value of any variable (even the override code of the class method), check changes in runtime, and after checking changes start to fix the code and start pipeline things.
Notice, this tool must exist only in a non-production environment.

Implementation

As is known, groovy is fully compatible with java programming language. Groovy has a dynamic compilation feature, which we will use for "code evaluation" implementation. We will use groovy for "code evaluation", but it will work in any java application. How to add groovy to your java project you can find yourself easily. And now let's consider how to implement "code evaluation".

1) Let's create a groovy class and define a string variable that contains a class with a placeholder.

def EXPRESSION_CLASS_TEMPLATE = """
package dev.toliyansky.eval.service
class ExpressionClass implements java.util.function.Supplier<Object> {
    def get() {
        %s
    }
}
"""

package must be with the same package where this code will call.

2) Let's compile and load a class from the first paragraph.
For instance, you can place the code below in the REST controller, it will allow getting a text for evaluation expression from the request body.

def finalClassCode = String.format(EXPRESSION_CLASS_TEMPLATE, code)
def supplier = groovyClassLoader.parseClass(finalClassCode)
                                .getDeclaredConstructor()
                                .newInstance() as Supplier<Object>
def result = supplier.get()

On the first line, we replace %s with code that will be dynamically compiled and executed in runtime.

On the second line, we compile and instantiate the class from the first paragraph. Notice that instantiated class casted to the Supplier for the ability to call the method with text that you want to evaluate. Supplier<Object> is ideal for this purpose because it doesn't have parameters and has a return statement.

Implemented solution

If you don't want to mess around with implementing dynamic compilation and plugging up groovy into your project then you can use implemented spring boot starter with implemented "code evaluation" feature: evaluator-spring-boot-starter
After adding this starter dependency to your project you can evaluate code through http://host:port/eval with UI.
You can evaluate any text by sending HTTP requests. If you are interested in this project check readme on GitHub.

UI Screenshots

Example with dynamically overriding code of method in runtime. It can be any bean in your application, such us controllers or services.

Also as a bonus, this solution provides the possibility to execute Bash, Cmd, or PowerShell commands. It allows debug not only your application but even checking or changing some environments where your application started.