Microservices messaging on Oracle Cloud using Apache Kafka

Here is a blog I posted on the Oracle Cloud Developer Solutions portal. This is the first of a two-part series which shows asynchronous messaging b/w microservices with the help of a simple example (application)

high-level-arch.jpg

 

Technical components

Oracle Cloud

Open source

  • Apache Kafka: scalable pub-sub message hub
  • Jersey: Used to implement REST and SSE services. Uses Grizzly as a (pluggable) runtime/container

Cheers!

 

Posted in Cloud, Java, Oracle Application Container Cloud, Oracle Cloud, Oracle PaaS | Tagged , , , , , , , , | Leave a comment

(eBook) ‘REST assured with JAX-RS’ now available on Gitbook

title_page.jpg

 

 

You can now read REST assured with JAX-RS online on Gitbook, or grab the PDF from Leanpub.. Happy reading!

Posted in Java, Java EE | Tagged , , , , | Leave a comment

Using Asynchronous timeouts in the Java WebSocket API

Sending messages in an asynchronous manner avoid blocking the sending thread. This is a great where your solution needs to scale in order to support a large number of clients.

But there is a limit on how long can we wait for the asynchronous process to complete

The Java WebSocket API gives you a few options in this regard

Async Timeout support

  • first and foremost, there is a notion of a timeout and this can be configured using the setSendTimeout method in the RemoteEndpoint.Async interface
  • secondly, the failure result manifests itself using the Future object or java.websocket.SendResult

How do timeouts manifest ?

It depends on which strategy you’re using in order to send your messages

  • Callback based
  • Future (java.util.concurrent) based

In case you are using the java.websocket.SendHandler i.e. the callback handler route, the timeout exception details will be available via SendResult.getException()

If you chose to use the Future to track the completion, calling it get method will result in a java.util.concurrent.ExecutionException

Further reading

Cheers!

Posted in Java, Java EE | Tagged , , , , , | Leave a comment

Started a new blog: Simply Distributed

Hello readers!

Happy to announce that I have recently initiated another blog – Simply Distributed. Some things to note about the blog

  • it will revolve around topics in the Distributed Systems domain
  • focus on real world distributed computing products & solutions (e.g. Kafka, Zookeeper etc.)

Some more info here… and also check out the first blog post on Apache Kafka

Cheers and happy reading!

Posted in Java EE | Tagged , | Leave a comment

Dynamic provider registration in JAX-RS

The DynamicFeature class in JAX-RS (2.0) allows you to register providers

  • Dynamically i.e. without any pre-defined binding strategy (e.g. annotations)
  • Based on criteria i.e. to help decide which provider to bind to which JAX-RS resource(s)

The JAX-RS implementation detects and executes the DynamicFeature implementations at deployment time

Here is an example where we instruct the JAX-RS run time to dynamically bind the AuthenticationFilter (a JAX-RS post construct filter) to be applied when a PUT is invoked on UserResource (which is a JAX-RS resource class)

Criteria based

Criteria is provided by ResourceInfo and it’s based on 2 attributes

  • the resource class, and
  • the resource method

Dynamic

The dynamic registration is achieved using FeatureContext whose register method can be used to bind the provider

Note

  • @Provider usage is needed for automatic discovery by the JAX-RS run time
  • Applicable for – filters, interceptors and  any Feature
  • In case of filters, the following applicability criteria apply
    • Post matching (@PreMatching filters excluded)
    • Server side filters i.e. ClientRequestFilter and ClientResponseFilter cannot be registered using this method
  • Once used, it overrides other bindings (static or using @NameBinding)

Further reading

Posted in Java, Java EE | Tagged , , , , | Leave a comment

WebSocket and CDI integration.. again..

In one of my older blog posts, I had written about what does not work as far as WebSocket and CDI integration within the Java EE Platform 😉 This one talks about what’s possible with CDI in terms of

  • Dependency Injection
  • Interceptors

Before you dig in, here is a summary

Feature Supported in EJB Annotated WebSocket endpoint ? Supported in Plain WebSocket endpoint ?
Inject CDI managed beans yes yes
Use CDI interceptors yes yes

DI support

It is possible to inject CDI managed beans in WebSocket endpoints. All injection targets are supported i.e. field, constructor, method

 

Interceptor support

You can use interceptors to implement cross-cutting concerns in for the business methods in your WebSocket endpoints

Good to know

Now that you have an idea about how WebSockets work with CDI in terms of Dependency injection and Interceptors, here are some other points

  • DI and interceptors are supported for both server and client endpoints running within a JavaEE container
  • DI and interceptors are supported for both annotated and programatic endpoints running within a JavaEE container
  • container managed injection features are not available to WebSocket endpoints which override the container implemented initialization (using the ServerEndpointConfig.Configurator)

Additional reading

 

Cheers!

Posted in Java, Java EE | Tagged , , , , , , , | 3 Comments

Integrating Oracle Application Container & Database Cloud using ‘Service Bindings’

blog-logo.jpg

Don’t forget to check out my new blog post on the Oracle Cloud Developer solutions community portal ! It demonstrates usage of Oracle Application Container Cloud and Database Cloud service. To be precise, it covers the following

  • An introduction to Service bindings (in Application Container Cloud) including setup + configuration and leveraging them to integrate with Oracle Database Cloud service
  • Developing a sample (Java SE based) application using JPA (Eclipselink implementation) for persistence and JAX-RS (Jersey framework) to expose a REST API
  • Build, package and deploy the solution to the Application Container cloud using its REST APIs

Cheers!

Posted in Java, Java EE, Oracle Application Container Cloud, Oracle Cloud, Oracle PaaS | Tagged , , , , , , , | Leave a comment

Configuring WebSocket server endpoints

WebSocket Server endpoint configuration

Before we dive into the details, here is a quick snapshot of the related interfaces

Class/Interface Description
ServerEndpointConfig A derivative of EndpointConfig interface which is specific for configuration related to server side WebSocket endpoints
ServerEndpointConfig.Configurator An interface whose custom implementation allows sharing of global (for all endpoints) available logic/state as well opportunity to intercept the WebSocket handshake process (via method override)
ServerEndpointConfig.Builder Used only for programmatic server endpoints to build a ServerEndpointConfig instance

From here on, we’ll explore the configuration strategies for annotated and programmatic server endpoints

Configuring annotated server endpoints

Annotated server endpoints are configured implicitly via the elements of the @ServerEndpoint annotation. The WebSocket container picks up the value from the annotation elements and creates an instance of EndpointConfig behind the scenes. This instance is automatically injected (at run time by the WebSocket container) as a parameter of the @OnOpen method

Configuring programmatic server endpoints

Programmatic endpoints need (explicit) coding as far as configuration is concerned. This is because of the fact that programmatic endpoints are deployed differently and need an instance of ServerEndpointConfig

Please look at this blog post for details of the deployment aspects for programmatic WebSocket endpoints

Here is where the fluent builder ServerEndpointConfig.Builder comes into picture. Let’s look at an example which deomnstrates it’s usage

The big picture

Annotated and programmatic endpoint configuration are handled differently, but the end result is the same. Below is a table which shows the mapping b/w corresponding element of the @ServerEndpoint annotation, the corresponding method in ServerEndpointConfig as well as appropriate the method in the ServerEndpointConfig.Builder

@ServerEndpoint annotation element ServerEndpointConfig method ServerEndpointConfig.Builder method
value getPath() create(Class<?> endpointClass, String path)
configurator getConfigurator() configurator(ServerEndpointConfig.Configurator serverEndpointConfigurator)
decoders getDecoders() decoders(List<Class<? extends Decoder>> decoders)
encoders getEncoders() encoders(List<Class<? extends Encoder>> encoders)
subprotocols getSubprotocols() subprotocols(List<String> subprotocols)

Cheers!

Posted in Java, Java EE | Tagged , , , , | Leave a comment

Difference b/w Cache Writer and Cache entry listener

In one of my previous blogs, I gave an overview of Cache Loader+Writer as well as Cache entry listeners. The difference b/w a Cache Loader and Cache create/update entry listener is obvious and their roles are clearly differentiated

  1. a loader pulls the value from an external source
  2. populates the cache and
  3. the respective listener is then invoked

There is no question/doubt on whether one can be substituted for the other

But…

Cache Writer and the Cache create/update entry listener are similar (at least at first glance) – both are invoked when an entry is created/updated in a specific cache

So the obvious Qs are

  • why should you use one over the other?
  • can we not use cache entry listener to integrate/sync up an external source when the a cache entry is updated/created ?

The important difference is

If the Cache Writer throws an exception, then the entry does not get stored in the cache (think of this as a rollback of sorts). But, in the case of an entry listener, an exception does not effect the value stored in the cache i.e. the created/updated cache entry remains untouched

Cheers!

Posted in Java, Java EE | Tagged , , , , , , | 2 Comments

Simple sample: Dockerized Java app using a maven plugin

It’s good to be able to build Docker images directly from artifacts (JAR, WAR etc.) produced by Maven builds. One useful tool is the Spotify Docker Maven plugin which can help with this

This example (available on Github)

  • uses Jersey Grizzly connector to build a simple REST app
  • packages this as a (Uber) JAR using Maven
  • the maven build process pushes this as a Docker image (thanks to the plugin)

The pom.xml itself incorporates the Docker related configuration which is generally encapsulated in a Dockerfile (this mode is supported by the plugin as well). Here is a snippet..

pom-for-spotify-docker-maven-plugin

Hope this gives you a simple yet useful starting point

Cheers!

 

Posted in Docker, Java | Tagged , , , , , | Leave a comment