Prettify JSON in 4 lines with JSON-P

JSon Processing API was a great step for standardization of JSON in Java world and its API is surprisingly smooth to prettify a JSon payload.

@CacheResult: JCache + CDI to the rescue of microservices?

JCache API comes with several built in interceptors for CDI making its usage decoupled from the cache API itself and more user friendly.

Let’s have a look to this API.

CacheResult: the method execution killer

Probable one of the most common use cache is to avoid to pay the cost of a method each time you call it.

Reasons can be as different as:

• Computation done by the method is expensive
• The method contacts a remote service and you want to cut off the implied latency
• The method accesses a rate limited resource
• ….

In this cache @CacheResult brings a nice and easy to setup solution. Simply decorating the method with @CacheResult you will avoid the actual method invocation after the first call and while it is cached.

Basic usage

Here a sample using a service simulating a slow method:

Loggers integrations love method reference (java 8)

Integrating loggers with some frameworks sometimes requires to wire some stream (OutputStream typically) to the logger itself.

Most of the time you pass to your “LoggerOutputStream” a Logger instance and a Level – or you have some condition in the implementation to select the level.

This is not a hard task but for some loggers you need a big switch to handle the level. Code is quite noisy for pretty much nothing.

With Java 8 the implementation is pretty simple, just use a method reference and that is it!

Nice thing is you can automatically type it “Consumer<String>.

Here is a sample with maven Log API:

import java.io.IOException;
import java.io.OutputStream;
import java.util.function.Consumer;

import static java.util.Optional.of;

public class LoggerOutputStream extends OutputStream {
    private static final int BUFFER_SIZE = 1024;

    private byte[] buffer;
    private int count;
    private int bufferLen;

    private final Consumer<String> log;

    public LoggerOutputStream(final Consumer<String> log) {
        this.log = log;
        this.bufferLen = BUFFER_SIZE;
        this.buffer = new byte[bufferLen];
        this.count = 0;
    }

    @Override
    public void write(final int b) throws IOException {
        if (b == 0 || b == '\n') {
            flush();
            return;
        }

        if (count == bufferLen) {
            final byte[] newBuf = new byte[bufferLen + BUFFER_SIZE];
            System.arraycopy(buffer, 0, newBuf, 0, bufferLen);
            buffer = newBuf;
            bufferLen = newBuf.length;
        }

        buffer[count] = (byte) b;
        count++;
    }

    @Override
    public void flush() {
        of(count).filter(c -> c > 0).ifPresent(c -> {
            log.accept(new String(buffer, 0, c));
            count = 0;
        });
    }

    @Override
    public void close() {
        flush();
    }
}

And the usage is then pretty simple as well:

// getLog() is available in a Mojo = maven plugin
OutputStream out = new LoggerOutputStream(getLog()::info);

The interesting part is a bit hidden but you need to look for the method ref usage (log.accept(new String(buffer, 0, c));) where actually without it you would get a big switch to handle it so it is a nice win regarding the simplicity of the code and its evolutivity!