Skip navigation
This project is read only now. Read more.

A couple of months ago, we announced the move of the RESTEasy Spring Boot starter to RESTEasy organization on GitHub. We also mentioned that soon a new version of the starter would have been available... and here we are today, presenting release 2.0.0.Final, which

  • integrates Spring Boot 2 (currently 2.0.3.RELEASE version)
  • relies on the latest RESTEasy 3.x series (currently 3.6.0.Final version).

The artifacts are available on Maven central repository, as well as the JBoss repository. Feel free to pull them and give them a try.


Now that we've seen RxJava support in RESTEasy, we're ready to build on more reactive applications to illustrate common reactive use-cases.


Let's create an application with several types of requests, that we collect statistics on, such as the number of times each request has been called. And let's store those statistics in a Redis instance. For that we will use the Vert.x Redis client because it supports RxJava out of the box.


A sample application


So we will be importing the following Maven modules:


<!-- For RESTEasy -->
<!-- For RESTEasy's support of RxJava 2 -->
<!-- For the Vert.x Redis client -->
<!-- For the Vert.x RxJava 2 support -->


Now, in order to make sure I get a single Redis client for my application, I will have to make it injectable by RESTEasy with the @Context annotation, and there's no support for pluggable injection in JAX-RS so it's a little convoluted, but we can achieve that with the help of this custom Feature:


public class RedisFeature implements Feature {

  private RedisClient redis;

  public RedisFeature(){
    // connect to the local Redis
    redis = RedisClient.create(Vertx.vertx());

  public boolean configure(FeatureContext context) {
    // this is tied to the deployment, which is what we want for the redis client
    if(context.getConfiguration().getRuntimeType() == RuntimeType.CLIENT)
      return false;
    Dispatcher dispatcher = ResteasyProviderFactory.getContextData(Dispatcher.class);
    if(dispatcher == null) {
      // this can happen, but it means we're not able to find a deployment
      return false;
    dispatcher.getDefaultContextObjects().put(RedisClient.class, redis);
    return true;


We can now write our three requests that collect usage statistics (they inject the RedisClient):


public class Resource {
  private RedisClient redis;

  public Single<String> req1() {
    return redis.rxIncr("req1.count").map(count -> "Req1 count: "+count);

  public Single<String> req2() {
    return redis.rxIncr("req2.count").map(count -> "Req2 count: "+count);

  public Single<String> req3() {
    return redis.rxIncr("req3.count").map(count -> "Req3 count: "+count);


As you can see we count usage in the Redis keys req1.count, req2.count and req3.count.


Now, if we want to display them, we have to get all three values, which either means a lot of nesting with RxJava, or (better) using the operator:


public Single<String> info(){
  return"req1.count"), redis.rxGet("req2.count"), redis.rxGet("req3.count"),
    (req1, req2, req3) -> "Request 1: "+req1+"\nRequest 2: "+req2+"\nRequest 2: "+req3);  


As you can see, with RxJava, getting several values is a little more verbose than if we were doing it in blocking style. In fact, in real applications it is very common to start most requests with actions that depend on resolving a few asynchronous values. They can be waiting for database results, querying caches, or even obtaining permission lists, but eventually, lots of your requests will start with a call to get the values you need in your request. That's annoying, and when they are often the same values, that's just plain boilerplate.


The solution


What if RESTEasy could take all those async values that you need, and resolve them before it called your resource method? This is called asynchronous injection, and the latest RESTEasy does just that.


The async values we want to be resolved are originally of type Single<String>, so their resolved value is of type String. In order to get async injection, we annotate our injected resolved value with @Context, and RESTEasy will look up a ContextInjector that is declared to resolve values to String. In our case, we declare our ContextInjector to resolve values from type Single<String> to String, but any async type is supported, thanks to the existing support for pluggable async types.


Once we've declared our ContextInjector, RESTEasy will call it to get the Single<String> that provides the String we want asynchronously injected, and will wait for the async value to be resolved, and only then proceed to inject it in your resource method. This way, when you start your resource method, you already have all your async values resolved!


For our example, we're going to describe our redis queries with the @RedisQuery annotation:


public @interface RedisQuery {
  String value();


Now we can write our new resource method that wants these redis queries injected:


public String infoInjection(@Context @RedisQuery("req1.count") String req1,
    @Context @RedisQuery("req2.count") String req2,
    @Context @RedisQuery("req3.count") String req3){
  return "Request 1: "+req1+"\nRequest 2: "+req2+"\nRequest 2: "+req3;


And all we have to do for that async injection to work is to declare our ContextInjector:


public class RedisInjector implements ContextInjector<Single<String>, String> {

  public Single<String> resolve(Class<?> rawType, Type genericType, Annotation[] annotations) {
    RedisClient redisClient = ResteasyProviderFactory.getContextData(RedisClient.class);
    for (Annotation annotation : annotations) {
      if(annotation.annotationType() == RedisQuery.class) {
        String query = ((RedisQuery) annotation).value();
         // let's inject !
        return redisClient.rxGet(query);
    // not for us: try other injectors
    return null;


As you can see, we just have to declare that our ContextInjector can provide values of type String via an async type Single<String>, and check the annotations on the injection point to figure out what query to run.


As I mentioned previously, this is not limited to async values of type Single, because any async value type is supported via plugins, and in fact only CompletionStage is supported by default (Single being provided by the resteasy-rxjava2 module we're using).



We've removed yet another common cause of boilerplate: rejoice!


Async injection was added in the latest 4.0.0.Beta4 release (RESTEASY-1905). Go ahead and try it out while it's fresh!

You might have recently read about the very interesting new features being developed these days in RESTEasy... great, the time has come to deliver them in a couple of releases!

Last week, RESTEasy 3.6.0.Final and 4.0.0.Beta4 have been tagged, built and published; here is a list of the most relevant additions coming with them:

  • client and server side reactive extensions [1][2]
  • parameter annotations with default names [3][4]
  • JettyClientEngine to use jetty-client with JAX-RS Client [5]
  • SPI to modify resource metadata [6]


Moreover, 4.0.0.Beta4, also feature the first part of the changes for the tracing system [7] and asynchronous container filters [8] support.

Both releases are available on the usual Maven repository, feel free to try them out!

3.6.0.Final is also being pulled into WildFly master, targetting inclusion in WildFly 14 release.



[1] Asynchronous, reactive, rxjava and beyond!

[2] Chapter 39. Reactive programming support

[3] New DRY-er annotations for parameters

[4] Chapter 13. Improved @…Param annotations

[5] Chapter 50. RESTEasy Client API

[6] Chapter 18. Resources metadata configuration

[7] A brief introduction to the RESTEasy Tracing Feature

[8] New: Asynchronous container filters

Filter Blog

By date:
By tag: