DEV Community: Juan Sedano

Simple web QR maker with zxing and Thymeleaf

Juan Sedano — Mon, 17 Jun 2024 06:00:00 +0000

Encode text into QR Code with zxing and display it using thymeleaf. Live demo here.

You can find the complete code for this here.

This is the method to encode a String into an image, and then encode the image into a base 64 String that represents the png, based around the code in this tutorial.

QRCreator.java

  private String unsafeCreateQRImage(String qrCodeText, int size)
      throws WriterException, IOException {
    // Create the ByteMatrix for the QR-Code that encodes the given String
    Hashtable<EncodeHintType, ErrorCorrectionLevel> hintMap = new Hashtable<>();
    hintMap.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);
    BitMatrix byteMatrix =
        qrCodeWriter.encode(qrCodeText, BarcodeFormat.QR_CODE, size, size, hintMap);
    // Make the BufferedImage that are to hold the QRCode
    int matrixWidth = byteMatrix.getWidth();
    BufferedImage image = new BufferedImage(matrixWidth, matrixWidth, BufferedImage.TYPE_INT_RGB);
    image.createGraphics();

    Graphics2D graphics = (Graphics2D) image.getGraphics();
    graphics.setColor(Color.WHITE);
    graphics.fillRect(0, 0, matrixWidth, matrixWidth);
    // Paint and save the image using the ByteMatrix
    graphics.setColor(Color.BLACK);

    for (int i = 0; i < matrixWidth; i++) {
      for (int j = 0; j < matrixWidth; j++) {
        if (byteMatrix.get(i, j)) {
          graphics.fillRect(i, j, 1, 1);
        }
      }
    }
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ImageIO.write(image, "png", bos);
    byte[] imageBytes = bos.toByteArray();

    Base64.Encoder encoder = Base64.getEncoder();
    return encoder.encodeToString(imageBytes);
  }

Use this on the controller for the thymeleaf templates.

SimpleQRController.java

  @RequestMapping("/")
  public String newRandomSelect(Model model) {
    model.addAttribute("textAndQRImage", new TextAndQRImage());
    return "inputQR";
  }

  @RequestMapping("/show")
  public String showQR(Model model, TextAndQRImage textAndQRImage, HttpSession session) {
    if (Objects.isNull(textAndQRImage.getText()) || textAndQRImage.getText().isEmpty()) {
      return "redirect:/simpleqr/";
    }
    String qrImage = qrCreator.createQRImage(textAndQRImage.getText(), 800);
    if (Objects.isNull(qrImage) || qrImage.isEmpty()) {
      return "redirect:/simpleqr/";
    }
    textAndQRImage.setText(textAndQRImage.getText());
    textAndQRImage.setBase64Image(qrCreator.createQRImage(textAndQRImage.getText(), 800));

    model.addAttribute("textAndQRImage", textAndQRImage);
    return "showQR";
  }

Part of inputQR.html that asks for the text that will be encoded into a QR code.

    <form action="/simpleqr/show" th:object="${textAndQRImage}" method="POST">

        <input type="text" placeholder="input text here" th:field="*{text}">

        <button type="submit">Generate QR</button>
    </form>

And then we display the QR code in showQR.html template.

<body>

    <div>
        <img class="img-responsive" th:src="@{'data:image/png;base64,'+${textAndQRImage.base64Image}}"/>
    </div>

<h2 th:text=${textAndQRImage.text}></h2>
</body>

Download the complete code for this here: simple-qr code. Live demo on: simple-qr live.

Plain Thymeleaf

Juan Sedano — Mon, 17 Apr 2023 06:00:00 +0000

Thymeleaf is an HTML (and more) template engine for Java. This is the core in action with nothing else.

You can find the complete code for this here: only-thymeleaf.

All of this is just putting into a project what has being posted in this stackoverflow answer which in turn was found on this comment on github.

We begin by getting only the core jar for Thymeleaf (the latest one at the time this post was written).

pom.xml

<dependency>
  <groupId>org.thymeleaf</groupId>
  <artifactId>thymeleaf</artifactId>
  <version>3.1.1.RELEASE</version>
</dependency>

Then we create our template inside resources on a directory apptly named templates.

src/main/resources/templates/index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>Thymeleaf hello world</title>
</head>
<body>

<p>First name: <span th:text="${first_name}?: '(no first name specified)'"/>.</p>
<p>Last name: <span th:text="${last_name}?: '(no last name specified)'"/>.</p>

</body>
</html>

Inside the span tag we have th which is how all data attributes starts on Thymeleaf, you can see that it’s declared as a namespace definition above on the html tag. We are also using a variable expression ${} with an Elvis operator ?: which is an special operator that only returns it’s value when the evaluated expression returns null, which means if first_name is null then (no first name specified) will be returned.

Now to bring it all together:src/main/java/dev/jsedano/examples/onlythymeleaf/Main.java

var resolver = new ClassLoaderTemplateResolver();
resolver.setTemplateMode(TemplateMode.HTML);
resolver.setCharacterEncoding("UTF-8");
resolver.setPrefix("/templates/");
resolver.setSuffix(".html");

Since we are not using Spring or nothing to helps us with dependency injection we will create objects the traditional way, setting up the prefix for where the templates will be stored and the suffix for them.

var context = new Context();
if (args.length != 0) {
  context.setVariable("first_name", args[0]);
  if (args.length > 1) {
    context.setVariable("last_name", args[1]);
  }
}

This will be the context which will hold the objects that Thymeleaf will use to generate the html.

var templateEngine = new TemplateEngine();
templateEngine.setTemplateResolver(resolver);

var result = templateEngine.process("index", context);
System.out.println(result);

Here we create a TemplateEngine object and pass the resolver, then we call process on the templateEngine object with the name of the template and the context we created above.

We can create our fat jar running mvn verify and then call it with java -jar ./target/only-thymeleaf-1.0-jar-with-dependencies.jar to print the result of the template processing, if we send variables when we executed we can see how they get replace:

only-thymeleaf % java -jar ./target/only-thyme leaf-1.0-jar-with-dependencies.jar
SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See https://www.slf4j.org/codes.html#noProviders for further details.
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Thymeleaf hello world</title>
</head>
<body>

<p>First name: <span>(no first name specified)</span>.</p>
<p>Last name: <span>(no last name specified)</span>.</p>

</body>
</html>

only-thymeleaf % java -jar ./target/only-thymeleaf-1.0-jar-with-dependencies.jar juan sedano
SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See https://www.slf4j.org/codes.html#noProviders for further details.
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Thymeleaf hello world</title>
</head>
<body>

<p>First name: <span>juan</span>.</p>
<p>Last name: <span>sedano</span>.</p>

</body>
</html>

For more information on Thymeleaf you can go directly to the thymeleaf docs.

Download the complete code for this here: only-thymeleaf.

Lissajous curve Java

Juan Sedano — Fri, 28 Oct 2022 06:00:00 +0000

Just a Lissajous curve on Java displayed on a JFrame.

You can find the complete code for this here: Lissajous.java.

First of all, the code is a complete rip-off from The Go Programming Language book, specifically from this code from chapter 1.

I won’t even pretend to understand the maths on this one, so lets just dive into the code, first we initialize our window:

int size = 100;
JFrame frame = new JFrame("Lissajous");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel();
panel.setPreferredSize(new Dimension(2*size+1, 2*size+1));
frame.add(panel);
frame.pack();
frame.setResizable(false);
frame.setLocationRelativeTo(null);
frame.setVisible(true);

With that we have a non resizable JFrame on the middle of the screen, that terminates the program when closed which contains a JPanel where we can draw, in order to do so we only need the Graphics from the JPanel:

Graphics g = panel.getGraphics();

Then we start shamelessly translating the Go code from the link above to Java:

double cycles = 5;
double angularResolution = 0.001;
long delay = 80;
int frames = 64;
for(;;){
    double frequency = Math.random() * 3.0;
    float phase = 0.0f;
    for( int i = 0; i < frames; i++) {
        g.setColor(Color.BLACK);
        g.fillRect(0,0, panel.getWidth(), panel.getHeight());
        g.setColor(Color.GREEN);
        for(double t = 0.0; t < cycles*2*Math.PI; t+= angularResolution){
            double x = Math.sin(t);
            double y = Math.sin(t * frequency + phase);
            g.drawRect( (size + (int)(x*size+0.5)), (size + (int)(y*size+0.5)),1,1);
        }
        phase += 0.1;
        Thread.sleep(delay);
    }
}

Since its a single file, if we have Java 11 or above we can run it without compiling with:

java Lissajous.java

And we should see this:

Download the complete code for this here: Lissajous.java.

Java Redis pub/sub example with Jedis

Juan Sedano — Mon, 19 Sep 2022 06:00:00 +0000

This is a Redis pub/sub example written in Java using Jedis.

You can find the complete code for this here: Java Redis pub/sub example.
For more neat stuff that Redis can do look here: Redis 2022.

Prerequisites

Download the code
Have an instance of redis-stack running.
Apache Maven 3.8.6
Java 17

Libraries used

We are only using jedis in order to keep the example simple.

Redis Commands used

this is used in order to subscribe to one or more channels:

subscribe channel1 channel2... channelN

unsubscribe

unsubscribe current client to one or more channels:

unsubscribe channel1 channel2... channelN

psubscribe

instead of subscribing to a channel, this allows you to subscribe to one of more patterns:

psubscribe pattern1 pattern2... patternN

for example if you subscribe to foo* it means that you will get the messages meant for all the channels that start with foo.

punsubscribe

unsubscribe from one or more patterns:

punsubscribe pattern1 pattern2... patternN

publish

publish sends a message to connected clients, returns the number of clients that got the message.

publish aChannel 'some message'

ping

sends a ping from a client to the server, optionally you can send a message and the ping will echo it.

ping

ping a message

Code walkthrough

We need to extend JedisPubSub in order to give our client functionality.

import redis.clients.jedis.JedisPubSub;

public class LogPubSub extends JedisPubSub {

To keep this example simple we are only going to add very basic functionality, in order to know which client is the one that got the message we are adding a name field.

  private String name;

  public LogPubSub(String name) {
    this.name = name;
  }

For subscribe, unsubscribe, psubscribe, punsubscribe and pong (which is the one that a successful ping triggers) we only print the information:

  public void onSubscribe(String channel, int subscribedChannels) {
    System.out.printf(
        "name: %s method: %s channel: %s subscribedChannels: %d\n",
        name, "onSubscribe", channel, subscribedChannels);
  }

  public void onUnsubscribe(String channel, int subscribedChannels) {
    System.out.printf(
        "name: %s method: %s channel: %s subscribedChannels: %d\n",
        name, "onUnsubscribe", channel, subscribedChannels);
  }

  public void onPUnsubscribe(String pattern, int subscribedChannels) {
    System.out.printf(
        "name: %s method: %s patten: %s subscribedChannels: %d\n",
        name, "onPUnsubscribe", pattern, subscribedChannels);
  }

  public void onPSubscribe(String pattern, int subscribedChannels) {
    System.out.printf(
        "name: %s method: %s patten: %s subscribedChannels: %d\n",
        name, "onPSubscribe", pattern, subscribedChannels);
  }

  public void onPong(String message) {
    System.out.printf("name: %s method: %s message: %s\n", name, "onPong", message);
  }
}

When receiving a message in the client apart from printing the information if the message is a ping then we will do a ping. If receiving the String “exit” we will unsubscribe from that channel or pattern (in the case of client subscribed using psubscribe).

  public void onMessage(String channel, String message) {
    System.out.printf(
        "name: %s method: %s channel: %s message: %s\n", name, "onMessage", channel, message);
    switch (message) {
      case "ping":
        this.ping();
        break;
      case "exit":
        this.unsubscribe(channel);
        break;
      default:
        if (message.indexOf("ping") == 0 && message.indexOf(" ") == 4) {
          this.ping(message.substring(5));
        }
    }
  }

  public void onPMessage(String pattern, String channel, String message) {
    System.out.printf(
        "name: %s method: %s pattern: %s channel: %s message: %s\n",
        name, "onPMessage", pattern, channel, message);
    switch (message) {
      case "ping":
        this.ping();
        break;
      case "exit":
        this.punsubscribe(pattern);
        break;
      default:
        if (message.indexOf("ping") == 0 && message.indexOf(" ") == 4) {
          this.ping(message.substring(5));
        }
    }
  }

Then we only need to make a JedisPooled connection and used it to subscribe to a channel or pattern:

JedisPooled jedis = new JedisPooled("localhost", 6379);
ExecutorService executor = Executors.newFixedThreadPool(4);

executor.execute(() -> jedis.subscribe(new LogPubSub("onlyOne"), "dev.one"));
executor.execute(() -> jedis.subscribe(new LogPubSub("oneAndTwo"), "dev.one", "dev.two"));
executor.execute(() -> jedis.psubscribe(new LogPubSub("pattern"), "dev.*"));

We need to run the subscribe and psubscribe on a thread since those are blocking operations.

In this example we are creating three clients, which we will identify as “onlyOne”, “oneAndTwo” and “pattern”, this doesn’t mean anything to redis, but it will be easier for us to keep track of whats happening.

“onlyOne” is subscribed to channel “dev.one”.
“oneAndTwo” is subscribed to channels “dev.one” and “dev.two”.
“pattern” is subscribed to the pattern “dev.*”.

With this we could send messages using publish on our RedisInsight CLI which should be running on http://localhost:8001/redis-stack/browser if we installed the redis-stack.

But we will also send messages using jedis.

String message = "";
try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
  do {
    message = br.readLine();
    int firstSpace = message.indexOf(' ');
    if (firstSpace > 1) {
      jedis.publish(message.substring(0, firstSpace), message.substring(firstSpace + 1));
    }
  } while (!"close".equals(message));
  jedis.close();
  System.exit(0);
} catch (IOException e) {
  throw new RuntimeException(e);
}

For building the code run mvn package and a far jar will be generated on target and then you can run it like so java -jar RedisPubSub-1.0.jar.

Example run:

... target % java -jar RedisPubSub-1.0.jar
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
name: pattern method: onPSubscribe patten: dev.* subscribedChannels: 1
name: oneAndTwo method: onSubscribe channel: dev.one subscribedChannels: 1
name: oneAndTwo method: onSubscribe channel: dev.two subscribedChannels: 2
dev.one hello
name: pattern method: onPMessage pattern: dev.* channel: dev.one message: hello
name: oneAndTwo method: onMessage channel: dev.one message: hello
dev.five hello to you
name: pattern method: onPMessage pattern: dev.* channel: dev.five message: hello to you
dev.two also to you
name: pattern method: onPMessage pattern: dev.* channel: dev.two message: also to you
name: oneAndTwo method: onMessage channel: dev.two message: also to you
dev.six exit
name: pattern method: onPMessage pattern: dev.* channel: dev.six message: exit
name: pattern method: onPUnsubscribe patten: dev.* subscribedChannels: 0
dev.two exit
name: oneAndTwo method: onMessage channel: dev.two message: exit
name: oneAndTwo method: onUnsubscribe channel: dev.two subscribedChannels: 1
dev.one ping say my name
name: oneAndTwo method: onMessage channel: dev.one message: ping say my name
name: oneAndTwo method: onPong message: say my name
dev.two are you alive?
dev.five no one is listening here
dev.one this one is alive
name: oneAndTwo method: onMessage channel: dev.one message: this one is alive
dev.one exit
name: oneAndTwo method: onMessage channel: dev.one message: exit
name: oneAndTwo method: onUnsubscribe channel: dev.one subscribedChannels: 0
dev.one not anymore
close
... target %

Download the complete code for this here: Java Redis pub/sub example.

Redis 2022

Juan Sedano — Sat, 17 Sep 2022 06:00:00 +0000

What is Redis (Remote Dictionary Server) on 2022. What can we do with it. How to scale. How to run it on the cloud.

What is Redis?

Redis is a key value store, just like a hash table. It can be used in-memory as cache and data will not be persisted or it can persist the data and be use as data storage. Keys can have a length to up to 512 MB.

It can also be used as a message queue / message broker.

Supported data types

Redis supports several data types

Type	Max Size	Description
Strings	512 MB	Bytes, text, serialized objects, binary arrays
Lists	2^32 - 1 (4,294,967,295) elements.	Linked list of Redis Strings
Sets	2^32 - 1 (4,294,967,295) members.	Unordered unique Redis Strings
Sorted Sets	Not specified	Every String has also an integer weight that you must set up
Hashes	4,294,967,295 (2^32 - 1) field-value pairs	Hash table
Streams	Not specified	Used to track real time events and allows consumers and consumer groups to read them

Special use cases types

Geospatial

Allows to store coordinates and perform operations such as finding the closest one.

HyperLogLog

Not gonna even try to summarize this one, read this instead.

Bitmaps

Use a String like a bit vector, allows performing bitwise operations.

Bitfields

Allows storing, atomic read, write and read operations for 1 bit unsigned integers to 63 signed bit integers.

Additional support

RedisJSON

Adds facilities to store json documents and adds operations to be able to access / update fields using JSONPath.

RedisGraph

A graph database.

RedisTimeSeries

Module that adds a time series data structure to Redis, allowing querying by start / end time.

RedisBloom

Probabilistic data structures.

RedisInsight

Visual support that helps optimizing your stuff on Redis.

Message queues with Redis Pub/Sub

We can use Redis to create channels, send messages to the channels and have subscribers that recive the message.

Redis on the cloud

redis cloud

We can use a hosted service using the offer from Redis on Redis Cloud.

Or you can install it following guides detailed here.

aws

AWS only supports Redis as an in memmory database, but you could try to install it on a service like EC2 and put a separate storage to persist.

gcp

Google cloud platform currently does not suppert persisting the data out of the box.

azure

Apparently you can persist using out of the box redis services on azure, but they dont recomend it.

Scalabity

You can scale horizontally using Redis Cluster where you have a master that replicates the information between replicas, but it doesn’t guarantees that you are not going to lose data, if you are unlucky that a replica is randomly selected as master and then it goes down before propagating the changes, it can lose data, unless you configure it so that the master has to acknowledge having replicated the information, but then you have to accept a hit on your performance.

Security

Redis recomends that redis is only used on trusted environments where only trusted clients can access it.

Removies

Juan Sedano — Mon, 29 Aug 2022 06:43:00 +0000

Overview of My Submission

This is an API made with Spring Web, uses springdoc-openapi-ui to expose a swagger-ui on http://localhost:8080/swagger-ui/index.html

Using datasets from kaggle we load up Redis with movies and TV show information and then it provides endpoints to query the database.

jedis is used to interact with Redis.

Submission Category:

Wacky Wildcards

Language Used

Java/Spring

Link to Code

jsedano / removies

Removies

Removies is an api that lets you search movies and tv shows information from a database of movies from several streaming services.

How it works

How the data is stored:

The data is stored as JSON documents using RedisJSON

public void insert(String key, MediaDTO mediaDTO) {
  jedisPooled.jsonSet(key, gson.toJson(mediaDTO))
}

MediaDTO is the object to be inserted but first it needs to be represented as JSON so we use gson for that.

How the data is accessed:

To access data several indexes need to be created Then RediSearch is used to make queries.

jedisPooled.ftSearch(
    "titleIdx", new Query("@title:(" + cleanTitle + ")").returnFields("title"));
}

How to run it locally?

Prerequisites

Have an instance of redis-stack running.
Apache Maven 3.8.6
Java 17

Local installation

Download the following…

View on GitHub

Additional Resources / Info

For reading the datasets opencsv is used.
More libraries used:

gson
lombok

Datasets used:

You can find the code and how to run it on https://github.com/jsedano/removies.

Check out Redis OM, client libraries for working with Redis as a multi-model database.
Use RedisInsight to visualize your data in Redis.
Sign up for a free Redis database.

A custom annotation to apply currying in Java

Juan Sedano — Sun, 26 Jun 2022 06:00:00 +0000

I created a custom annotation in order to apply currying to a method or constructor.

You can find the complete code for this here: curry.

For more information on currying check this post and for a background on annotations in Java check this one.

First we create the annotation:

@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
public @interface Curry {}

We only need the annotation to be processed and then discarded (we don’t need to have it available at run time or recorded on the .class) so we use @Retention(RetentionPolicy.SOURCE).

This annotation will only be used on methods and constructors so we set those as the Target on @Target({ElementType.METHOD, ElementType.CONSTRUCTOR}).

Then we create a processor for the annotation:

@SupportedAnnotationTypes("dev.jsedano.curry.annotation.Curry")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
@AutoService(Processor.class)
public class CurryProcessor extends AbstractProcessor {

Using @SupportedAnnotationTypes("dev.jsedano.curry.annotation.Curry") we say that this processor will only look for that particular annotation.

@SupportedSourceVersion(SourceVersion.RELEASE_17) here we are saying the Java version supported.

The last one is pretty interesting, @AutoService(Processor.class) is from a Google library called auto-service. In order for the Java compiler to use a processor the class needs to be declared inside the jar on the META-INF/servicesdirectory on the javax.annotation.processing.Processor file, the auto-service library does that for you.

Then we need to implement the process method on out custom processor.

public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

Inside our class we get the processingEnv object that provides us with functionality such as getMessager() that we use to print a warning message on compile time when the @Curry annotation is used on a method with 1 or more than 10 parameters:

otherMethods.stream()
    .forEach(
        e ->
            processingEnv
                .getMessager()
                .printMessage(
                    Diagnostic.Kind.MANDATORY_WARNING,
                    "incorrect number of parameters, allowed only between 2 and 1O, will not generate code for this one",
                    e));

We also have this one getFiler() which allows us to create Java source files:

JavaFileObject builderFile = processingEnv.getFiler().createSourceFile(builderClassName);

On the tests module of the project we declare some methods with the @Curry annotation, for example this constructor:

@Curry
public AnnotatedClass(
    boolean aBoolean, List<String> aStringList, int aNumber, char aChar, float aFloat) {
  this.aBoolean = aBoolean;
  this.aStringList = aStringList;
  this.aNumber = aNumber;
  this.aChar = aChar;
  this.aFloat = aFloat;
}

After running mvn clean verify on the parent module we can see the autogenerated code under target/generated-sources/annotations/dev.jsedano.curry.tests:

public static java.util.function.Function<java.lang.Boolean,java.util.function.Function<java.util.List<java.lang.String>,java.util.function.Function<java.lang.Integer,java.util.function.Function<java.lang.Character,java.util.function.Function<java.lang.Float,dev.jsedano.curry.tests.AnnotatedClass>>>>> pentaConstructor(dev.jsedano.curry.util.function.PentaFunction<java.lang.Boolean,java.util.List<java.lang.String>,java.lang.Integer,java.lang.Character,java.lang.Float,dev.jsedano.curry.tests.AnnotatedClass> function) {
    return v0->v1->v2->v3->v4-> function.apply(v0,v1,v2,v3,v4);
}

It is not pretty looking, but we can use it to then curry the five parameter constructor of the example class:

var pentaConstructor = AnnotatedClassCurryer.pentaConstructor(AnnotatedClass::new);

You can see another example here, but if you want to compile it you need to do mvn clean install on the curryer module of curry.

@Curry
public static String wget(
    int connectionTimeout,
    int readTimeout,
    boolean followRedirects,
    String requestMethod,
    String address) {
  try {
    URL url = new URL(address);
    HttpURLConnection con = (HttpURLConnection) url.openConnection();
    con.setRequestMethod(requestMethod);
    con.setConnectTimeout(connectionTimeout);
    con.setReadTimeout(readTimeout);
    con.setInstanceFollowRedirects(followRedirects);
    BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer content = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
      content.append(inputLine);
    }
    in.close();
    return address + " " + content.toString();
  } catch (Exception e) {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    e.printStackTrace(pw);
    String stackTrace = sw.toString();
    return address + " " + stackTrace.substring(0, stackTrace.indexOf("\n"));
  }
}

Then we can set the values we need in a curried way and use it:

public static void main(String[] args) {
  var get =
      WgetVersion2Curryer.wget(WgetVersion2::wget)
          .apply(100)
          .apply(100)
          .apply(false)
          .apply("GET");

  List.of(
          "https://www.google.com",
          "https://www.wikipedia.org",
          "asdf",
          "https://docs.oracle.com/javase/10/docs/api/java/net/package-summary.html",
          "https://jsedano.dev",
          "https://raw.githubusercontent.com/center-key/clabe-validator/main/clabe.ts")
      .parallelStream()
      .map(get)
      .forEach(System.out::println);
}

Download the complete code from this post here: curry.

Java @Annotations

Juan Sedano — Sat, 18 Jun 2022 06:00:00 +0000

If you have been using Java for about a week (probably even less) chances are you have already seen some annotations. Let’s review some stuff about them.

As explained on https://docs.oracle.com/javase/tutorial/java/annotations/ we can use annotations to:

Give information to the compiler : so we can detect errors or even suppress warnings.
Compile-time and deployment-time processing : we can generate code, xml files and so on.
Runtime processing : some annotations can be reviewed at runtime (using reflection).

Annotations can be used anywhere you use a type.

One interesting fact is that annotations can potentially generate code, but they can not modify it. If you use tools like lombok you know that they actually modify the code, but they usually achieve this by accessing internal libraries.

Annotations are defined with the @interface keyword like so:

public @interface Version {
  int mayor();
  int minor();
}

They can receive any primitive types, enums, other annotations and arrays of those previously mentioned. Let’s define an enum:

public enum Usage {
  UTILITY,
  DTO,
  DAO,
  SERVICE
}

Then let’s create another annotation:

public @interface Info {
  String[] authors();
  Usage usage();
  Version version();
}

Now we use it:

@Info(
    authors = {"jsedano", "weirderror"},
    usage = Usage.UTILITY,
    version = @Version(mayor = 1, minor = 0))
public class VeryUtil {}

You can specify if the annotation needs to be retained by the virtual machine at run time or not; or even if they are to be discarded by the compiler. This is achieved by using a meta-annotation, meta-annotations are annotations that are applied to another annotations.

You can also define where the annotation can be used, for example in methods, in constructors and so on.

Let’s look at how the @Override annotation is defined (@Override is a predefined annotation that is use to mark methods that are using method overriding):

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

As you can see the meta-annotation @Target is used to say that this particular annotation can only be used above a method declaration and the @Retention annotation is saying that this annotation will not be recorded in the class file and will not be available at runtime.

In order to actually define functionality for an annotation type we need to implement an AbstractProcessor.

Currying in Java

Juan Sedano — Mon, 13 Jun 2022 06:00:00 +0000

Let’s see some examples of how to achieve currying in Java.

You can find the complete code for this here: curry_example.jsh.

Currying is taking a function with n parameters and returning a function with one parameter that returns a function with one parameter until you reach the n parameters of the original function and then you get the result.

The following method gets the curried version of a method with the signature:

int methodName(int a, int b)

And returns the curried version:

public static Function<Integer, Function<Integer, Integer>> toCurry(
    BiFunction<Integer, Integer, Integer> function) {
  return v -> v1 -> function.apply(v, v1);
}

Then we can use it to get curried versions of such methods:

var curriedAdd = toCurry(Math::addExact);
var curriedMultiply = toCurry(Math::multiplyExact);

And use them like this:

System.out.format("curriedAdd(2)(10): %d\n",curriedAdd.apply(2).apply(10));
System.out.format("curriedMultiply(2)(10): %d\n",curriedMultiply.apply(2).apply(10));

In the following example we use the curried versions to first add 1 and then multiply by 2 all the elements of a stream

var add1 = toCurry(Math::addExact).apply(1);
var multiplyBy2 = toCurry(Math::multiplyExact).apply(2);
List.of(0, 1, 2, 3, 4).stream().map(add1).map(multiplyBy2).forEach(System.out::println);

We can use currying as a form of partial application, imagine we have the following method:

public static String wget(
    int connectionTimeout,
    int readTimeout,
    boolean followRedirects,
    String requestMethod,
    String address) {
  try {
    URL url = new URL(address);
    HttpURLConnection con = (HttpURLConnection) url.openConnection();
    con.setRequestMethod(requestMethod);
    con.setConnectTimeout(connectionTimeout);
    con.setReadTimeout(readTimeout);
    con.setInstanceFollowRedirects(followRedirects);
    return address + " " + con.getResponseCode();
  } catch (Exception e) {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    e.printStackTrace(pw);
    String stackTrace = sw.toString();
    return address + " " + stackTrace.substring(0, stackTrace.indexOf("\n"));
  }
}

This method returns the http status or part of the exception if any was thrown.

If we use it like that we would have to be setting all the parameters everytime we want to use the function, but if we have a curried version:

public static Function<Integer, Function<Boolean, Function<String, Function<String, String>>>>
    cwget(int v) {
  return v1 -> v2 -> v3 -> v4 -> wget(v, v1, v2, v3, v4);
}

We could then set the parameters we have:

var get = cwget(100).apply(100).apply(false).apply("GET");

And then just fill the renaming parameter when using the function:

List.of(
        "https://www.google.com",
        "https://www.wikipedia.org",
        "asdf",
        "https://docs.oracle.com/javase/10/docs/api/java/net/package-summary.html",
        "https://jsedano.dev",
        "https://raw.githubusercontent.com/center-key/clabe-validator/main/clabe.ts")
    .parallelStream()
    .map(get)
    .forEach(System.out::println);

Download the complete code from this post here: curry_example.jsh.

Remove duplicates in unordered array with Java using streams

Juan Sedano — Sat, 28 May 2022 06:00:00 +0000

Heres how to remove duplicates from an unordered primitive int array on Java using streams.

You can find the complete code for this here: remove_dupes_unordered_the_smart_way.jsh.

Consider the following straight forward problem, you receive a primitive int array and you need to return a new array only containing the unique elements.

Because we are using streams since 2014 and we know that a Set does not accept duplicates, we only need to collect the array into a set and back into an array.

int[] removeDupes(int arr[]) {
    return Arrays.stream(arr)
        .boxed()
        .collect(Collectors.toSet()).stream()
        .mapToInt(Integer::intValue).toArray();
}

The boxed method just returns an Integer stream instead of a primitive one.

Download the complete code from this post here: remove_dupes_unordered_the_smart_way.jsh.

Remove duplicates in ordered array Java

Juan Sedano — Mon, 05 Jul 2021 06:00:00 +0000

Heres how to remove duplicates from an ordered primitive int array on Java.

You can find the complete code for this here: remove_dupes.jsh.

Consider the following problem, you have to remove the duplicates from an ordered integer array in place. Since you cant actually change the length of a primitive array in java without declaring a new one, you will return the new length the array would have without the duplicates.

In order to solve this in O(n) time and O(1) space we are going to use a two pointer technique. We will have j that will increase by one in every iteration and i which will increase only if its different from the value which j points to, ignoring every duplicate found.

This doesnt account for a null, or less than a lenght 2 array (in which case we could start j at 0).

The pre-increment could be less readable but just remember that ++variable means we are increasing first and then using the variable.

int removeDupes(int arr[]) {
    int i = 0;
    for(int j = 1; j < arr.length; j++) {
        if(arr[i] != arr[j]) {
            arr[++i] = arr[j];
        }
    }
    return ++i;
}

Download the complete code from this post here: remove_dupes.jsh.

Binary search trees

Juan Sedano — Sun, 30 May 2021 06:00:00 +0000

A binary search tree is a binary tree where the left subtree has smaller elements and the right subtree has larger elements.

You can find the complete code for this and other data structures here: data structures and algorithms

What is a tree anyway

A tree is an undirected graph that satisfies any of the following definitions:

Acyclic connected graph.

Connected graph with N nodes and N-1 edges.

2 vertices 1 path (A graph in which any 2 vertices are connected by just one path).

Stuff we have to know

Rooted tree: Theres a root node and we hold a reference to it, we can choose any node as the root node.

Root node: It has no parent, but sometimes is useful to say that the parent of the root node is itself.

Child: Node that extends from another node, a Parent is the inverse of this.

Leaf node: Node with no children.

Subtree: Tree contained in another tree.

Binary tree: Every node has at most 2 children.

Binary search tree: Satisfies the BST invariant, left subtree has smaller elements and right subtree has larger elements.

Complexity of common operations

Operation	Average	Worst
insert(element)	O(log(n))	O(n)
remove(element)	O(log(n))	O(n)
search(element)	O(log(n))	O(n)

Implementation

Binary Tree Node

This is what the class that we will be using as node looks like (setters and getters omitted).

class BinaryNode<T extends Comparable<? super T>> {
    private BinaryNode<T> leftChild;
    private BinaryNode<T> rightChild;
    private T data;

    public BinaryNode(T data) {
        this.data = data;
    }

Insertion

A common theme is that we are going to have a public method and a private method. If rootNode is null then it means that the tree is empty and we just set that new value as the root node of the tree.

If the root node already exists we call our private insertion method.

public boolean insert(T data) {
    if(rootNode == null) {
        rootNode = new BinaryNode<>(data);
        length++;
        return true;
    }
    return insert(new BinaryNode<T>(data), rootNode);
}

Here we make sure to comply with the BST invariant and traverse the tree accordingly, smaller elements on the left, larger elements on the right.

If we find a leaf node then we set the new node as the child, incrementing the length of the tree and returning true to signify that the insertion was successful.

This implementation of the BST wont allow for duplicates, if we find one we return false.

private boolean insert(BinaryNode<T> newNode, BinaryNode<T> node) {
    if(newNode.getData().compareTo(node.getData()) < 0) {
        if(node.getLeftChild() == null) {
            node.setLeftChild(newNode);
            length ++;
            return true;
        }
        return insert(newNode, node.getLeftChild());
    }

    if(newNode.getData().compareTo(node.getData()) > 0) {
        if(node.getRightChild() == null) {
            node.setRightChild(newNode);
            length ++;
            return true;
        }
        return insert(newNode, node.getRightChild());
    }

    return false;
}

Contains

This method will let us know if a value is present in our BST, we have a public method that receives the value to look for:

public boolean contains(T data){
    return contains(data, rootNode);
}

And we have a private method that goes inside the tree looking for the value.

private boolean contains(T data, BinaryNode<T> node) {
    if(node == null) {
        return false;
    }

    if(data.compareTo(node.getData()) < 0) {
        return contains(data, node.getLeftChild());
    }

    if(data.compareTo(node.getData()) > 0) {
        return contains(data, node.getRightChild());
    }

    return true;
}

Removal

In the public version of remove we receive the value to remove, we save the current size of the tree and then we call the recursive private version, if the new size is different then it means the value was removed.

public boolean remove(T data) {
    int originalLength = length;
    rootNode = remove(data, rootNode);
    return originalLength != length;
}

The recursive removal is very interesting, as we traverse the tree the recursive method also returns the correct child for the parent node. For example if we are going inside the right sub tree we do:

node.setRightChild(remove(data, node.getRightChild()));

If we never find the value we want to remove we are just re-setting the children of the nodes we are traversing, but if we find a match we need to account for three cases.

The node we want to remove is a leaf node.
Has only a left or right child.
Has both children.

For the first two cases we just return the opposite child, for example this is the case where the left child is null:

if(node.getLeftChild() == null) {
    BinaryNode<T> rightChild = node.getRightChild();
    node.setData(null);
    node = null;
    length--;
    return rightChild;
}

This also handles the case where we have a leaf node, for a node with a right child we would return the left child.

The last case, where a node has both children is tricky since we have to find a node that complies with the BST invariant.

There are two ways to ensure we comply with the BST invariant we can either find the leftmost child of the right node or the rightmost of the left node. In this implementation we go for the leftmost node of the right child using the following method:

private BinaryNode<T> getLeftmost(BinaryNode<T> node) {
    while(node.getLeftChild() != null) {
        node = node.getLeftChild();
    }
    return node;
}

After that we copy the value to the node we are removing and then go inside the subtree in order to delete the node, since its the leftmost node we know that is going to fall in the case of a removal of a leaf node.

BinaryNode<T> tmp = getLeftmost(node.getRightChild());
node.setData(tmp.getData());
node.setRightChild(remove(tmp.getData(), node.getRightChild()));

This is the complete code for the remove method.

private BinaryNode<T> remove(T data, BinaryNode<T> node) {
    if(node == null) {
        return null;
    }

    if(data.compareTo(node.getData()) < 0) {
        node.setLeftChild(remove(data, node.getLeftChild()));

    } else if(data.compareTo(node.getData()) > 0) {
        node.setRightChild(remove(data, node.getRightChild()));

    } else {
        if(node.getLeftChild() == null) {
            BinaryNode<T> rightChild = node.getRightChild();
            node.setData(null);
            node = null;
            length--;
            return rightChild;
        }
        if(node.getRightChild() == null) {
            BinaryNode<T> leftChild = node.getLeftChild();
            node.setData(null);
            node = null;
            length--;
            return leftChild;
        }
        BinaryNode<T> tmp = getLeftmost(node.getRightChild());
        node.setData(tmp.getData());
        node.setRightChild(remove(tmp.getData(), node.getRightChild()));
    }
    return node;
}

Download the complete code for this and other data structures here: data structures and algorithms.