Webflux Reactive Webclient call with Flux Response and AtomicReference

/**
* This blocking call will return an AtomicReference which contains the response, the first which is received.
* You could also return via your Websocket, by directly passing on the FLux response!
*
* @param client - The Webclient, in this case Netty
* @param input - A String, arbitrary text message (I prefer JSON)
* @return AtomicReference, containing the response
*/
private AtomicReference<List<String>> callFooService(ReactorNettyWebSocketClient client, Flux<String> input) {
AtomicReference<List<String>> actualRef = new AtomicReference<>();

client.execute(getUrl(), session ->
session.send(input.map(session::textMessage))
.thenMany(session.receive().take(1).map(WebSocketMessage::getPayloadAsText))
.collectList()
.doOnNext(actualRef::set)
.then())
.block(TIMEOUT);
assertThat(actualRef.get()).isNotNull();
return actualRef;
}

WebEx Pair Programming Feature

In a Webex meeting both Keyboard and Mouse can be shared.

Anyone can directly control what is on the screen in realtime.
I just tried it with a current customer and it is a tremendous feature:

Top Bar -> Assign+ -> “Pass Keyboard and Mouse Control”

Java equals and hash code Contract

If two objects are equal, the hash code must be the same.

But the same hash code does not guarantee that two objects are equal.

Code example for a proper implementation:

 @Override
    public final boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof MyClassOrInterface)) {
            //some do prefer #getClass but I don't
            return false;
        }
        MyClassOrInterface that = (MyClassOrInterface) o;
        return Objects.equals(this.hashCode(), that.hashCode()) &&
                Objects.equals(name, that.name) &&
                Objects.equals(sessionId, that.sessionId);
    }

    @Override
    public final int hashCode() {
        return Objects.hash(name, sessionId);
    }

Java – How to verify EQUALS and HASH code contracts

Use this:

<!-- Maven -->
<dependency>
    <groupId>nl.jqno.equalsverifier</groupId>
    <artifactId>equalsverifier</artifactId>
    <version>3.0.3</version>
    <scope>test</scope>
</dependency>

Write your test:

@Test
public void onEqualsTrueTheHashCodeHasToBeTheSame() {
    EqualsVerifier.forClass(Foo.class).verify();
}

How to solve Java List add – throwing java.lang.UnsupportedOperationException

Symptom:

You try to add an object to a list. But you get an Exception:

java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractList.add(AbstractList.java:153)

Cause:

List<SomeEvent> eventList = Arrays.asList(event);
//not working, because the list size is fixed

Solution:

List<SomeEvent> eventList = new ArrayList<>(Arrays.asList(event));
//working, because the list size is NOT fixed

Of course, reading the Javadock of public static <T> List<T> asList(…) would have revealed it in advance:

/**
 * Returns a fixed-size list backed by the specified array.

;-D

NGINX configure Websocket in NginX – how to make it available

In the proxy.conf file, at the top, write:

upstream websocket {
        server name_of_my_docker_container:8080;
}

map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
}

server {...

Why this? The Websocket has a constantly open connection with the client. The communication lies above the http protocol. This why we need to enable an „upgrade“ of the connection.

This example addresses a name of a Docker container. It would work with any other url too.

server {
      location / {...
      }
      ...	
      location name_of_my_docker_container {
		rewrite name_of_my_docker_container/(.*) /$1  break;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		proxy_set_header X-NginX-Proxy true;
		proxy_ssl_session_reuse on;
		proxy_set_header Host $http_host;
		proxy_cache_bypass $http_upgrade;
		proxy_redirect off;
		proxy_set_header X-Forwarded-Proto "http";
		proxy_pass http://name_of_my_docker_container:8080;
		
                // These headers need to be set in order 
                // to enable the communication:
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection "Upgrade";

		proxy_set_header Connection '';
		proxy_http_version 1.1;
		chunked_transfer_encoding off;
		proxy_buffering off;
		proxy_cache off;
	}

Calculation Errors and Mistakes in Java – How to calculate correctly

This is a real world example on which money was lost by client. This was not explicable, but I managed to analyze and reconstruct the problem.

The Code you are about to see is NOT the production code, but my own reconstruction of it, with a means to show the problem.

 @Test
    public void testWrong() {

        // GIVEN
        final Integer price = -595;
        final Integer someUnit = 90;

        // WHEN
        int multiplicationResult = price * someUnit;
        // = -53550


        Integer resultAmount = multiplicationResult / 100;
        // = -535
        // …Division failed,
        // decimal places ignored...

        // THEN
        assertTrue(resultAmount == -535);
        // Wrong. Correct: -536.
    }

The specification on which the primitives and float are defined do not allow a correct calculation (mistake 1).

Although primitives cause the most trouble in calculation programming for many people, this example would have worked, if the return type of „multiplicationResult“ would be a double (mistake 2).

But experience shows that even these basics are quite often the main reason for calculation mistakes in Java, so I always recommend a certain way of calculating to avoid them, which I will show below.

@Test
public void testCorrect() {

        // GIVEN
        final Integer price = -595;
        final Integer someUnit = 90;
        // WHEN
        BigDecimal priceBD = new BigDecimal(price);
        BigDecimal someUnitBD = new BigDecimal(someUnit);
        BigDecimal hundred = new BigDecimal(100);

        BigDecimal multiplicationResult = priceBD.multiply(someUnitBD); // = -53550

        // = -535.5 - looks great.
        BigDecimal resultAmountBD = multiplicationResult.divide(hundred);


        final int noDecimalPlaces = 0;
        // rounding mode is vital to get a correct result
        final RoundingMode roundingMode = RoundingMode.HALF_UP;

        // do not forget to define the decimal places...0
        BigDecimal result = resultAmountBD.setScale(noDecimalPlaces, roundingMode);

        // THEN
        assertThat(result.toBigInteger().intValue(), equalTo(-536)); // Correct!

    }

The Big Decimal is calculated by using a String representation. Calculation is done piece by piece. Thus, the specification of float and primitives in general cannot interfere and cause calculation mistakes through number spaces, computing practices of the CPU etc..

Standard IEEE 754 defines Exception Handling and number spaces. It defines, how float and double is processed. Floating Points are meant to approach a certain precision, but without being 100% accurate. It is equivalent to Math/Analysis lambda, which is marking a barrier to come close to, which is never really reached (infinite lambda for instance).

In Summary:

  • Division, multiplication must be done by using a wrapper like BigDecimal.
  • Decimal Places have to be defined
  • Rounding modes have to be defined
  • In case that multiple systems are calculating together (e.g. bank or any other financial institution or software), a contract has to be agreed on. The contract must state how many decimal places are to be used (retail does often use 3 decimal places but only shows 2 on the displays in the shelves). Also the rounding mode plays a vital role in calculation.
  • Never use primitives, even if you are sure that in ‚your specific case‘ it is sufficient
  • Also experienced programmers make these mistakes, which is why I am posting this in my Blog.