Jersey on tl;dr

JAX-RS Providers on Client and on Server

michal@dejavu.sk (Michal Gajdoš) — Tue, 17 Mar 2015 09:15:06 +0000

In this article I’d like to explain two things. First, what to do when you want to restrict JAX-RS providers to be used on, for example, client-side only. And second, what are the issues (and how to solve them) with injecting providers when you create and register instances of them directly.

Jersey CDI Integration – Few Notes and EAR Support

michal@dejavu.sk (Michal Gajdoš) — Wed, 11 Mar 2015 13:35:43 +0000

During our last sprint I was porting support for CDI injections for EARs that contain multiple JAX-RS web applications (WARs). This worked fine in Jersey 1 and it works on WebLogic but we didn’t have support for these kind of deployments directly in Jersey (which means that Glassfish was affected as well) until this very moment. I’d like to share some findings I’ve made while working on this task.

Checkstyle matters to Jersey too …

michal@dejavu.sk (Michal Gajdoš) — Fri, 06 Mar 2015 12:09:38 +0000

Last week Pavel wrote and published an interesting blog post about Why Checkstyle matters … I remember how he was describing his encounter with JeroMQ to me. Especially the part where he wasn’t able to build the project for a few times because of the Checkstyle issues that pop-up right after he executed the build. I found the whole idea behind running code style checks during build appealing as well and decided to do something similar for Jersey.

Performance Improvements of Sub-Resource Locators in Jersey

michal@dejavu.sk (Michal Gajdoš) — Thu, 12 Feb 2015 16:50:12 +0000

There were many performance improvements since Jersey 2 first came out almost 2 years ago. Jakub and I decided to present some of the latest ones in our recent articles. Jakub took a look at general performance gains in Jersey in his Jersey 2 Performance. I’ll try to cover the change we introduced in Jersey 2.16 and that affected processing and performance of sub-resource locators in Jersey applications.

Jersey’s Entity Filtering meets Jackson

michal@dejavu.sk (Michal Gajdoš) — Wed, 04 Feb 2015 09:25:53 +0000

Support for Entity Filtering in Jersey introduces a convenient facility for reducing the amount of data exchanged over the wire between client and server without a need to create specialized data view components. The main idea behind this feature is to give you means that will let you selectively filter out any non-relevant data from the model before sending the data to the other party.

Entity Data Filtering is not a new feature but so far the support was limited to MOXy JSON provider. Since Jersey 2.16, we support also Jackson (2.x) JSON processor and in this article we’re going to take a look into it in more detail.

JAX-RS.next and Reactive Jersey Client – Slides from CZJUG presentations

michal@dejavu.sk (Michal Gajdoš) — Tue, 27 Jan 2015 12:41:41 +0000

Yesterday I was given the opportunity to speak at our local Java User Group meeting (CZJUG). I was covering two topics – JAX-RS.next and Reactive Jersey Client. In this post I’d like to share the used slide-decks and some additional resources.

Intercepting Jersey resource method calls

michal@dejavu.sk (Michal Gajdoš) — Wed, 21 Jan 2015 09:30:29 +0000

Sometimes it would be nice to have a possibility to wrap a resource method call. Imagine a use-case in which you need to process business code, placed in your resource method, in a transaction (open transaction before resource method, commit or rollback transaction at the end) or apply some advanced security constraints. If you’re using JAX-RS together with CDI in your application it’s not a problem to do such things. Fortunately, with Jersey it’s also possible to do those things outside of CDI.

Reactive Jersey Client, Part 3 – Customization

michal@dejavu.sk (Michal Gajdoš) — Wed, 07 Jan 2015 08:15:43 +0000

Reactive Jersey Client API is a generic API allowing end users to utilize the popular reactive programming model when using Jersey Client. This part of the series describes SPI and implementation of support for custom reactive libraries.

Reactive Jersey Client, Part 2 – Usage and Supported Libraries

michal@dejavu.sk (Michal Gajdoš) — Wed, 07 Jan 2015 08:10:43 +0000

Reactive Jersey Client API is a generic API allowing end users to utilize the popular reactive programming model when using Jersey Client. This part of the series describes API, usage and lists all supported reactive libraries.

Reactive Jersey Client, Part 1 – Motivation

michal@dejavu.sk (Michal Gajdoš) — Wed, 07 Jan 2015 08:05:38 +0000

Reactive Jersey Client API is a generic API allowing end users to utilize the popular reactive programming model when using Jersey Client. This part of the series describes motivation behind creating Reactive Jersey Client.

JSON in Query Params or How to Inject Custom Java Types via JAX-RS Parameter Annotations

michal@dejavu.sk (Michal Gajdoš) — Tue, 11 Feb 2014 09:35:29 +0000

Although I am not a big fan of sending JSON in other places than in the message body as the entity, for example in query parameter in case of requests, it’s not a rare use-case and the way how it can be solved in JAX-RS 2.0 gives me a nice opportunity to illustrate usage of two new interfaces, ParamConverterProvider and ParamConverter. You can then re-use this approach to inject other media-types or formats your application relies on via @*Param annotations (@MatrixParam, @QueryParam, @PathParam, @CookieParam, @HeaderParam).

Filtering JAX-RS Entities with Standard Security Annotations

michal@dejavu.sk (Michal Gajdoš) — Tue, 04 Feb 2014 09:35:13 +0000

Few times I’ve ran into a situation in which I wanted to return only a part of entity I was working with, in my service, to the client-side. Feature that would allow me to send this partial set of fields should not only be driven by my own filtering rules but it also should take into consideration application roles the current user is in. It’s not an uncommon use-case I’d say so in Jersey we’d come up with the Entity Filtering concept that would allow you to do such a thing: sending subgraph of entities from server to client (and vice versa), define your own filtering rules and make sure users get only the fields they are supposed to see.

Handling JAX-RS and Bean Validation Errors with MVC

michal@dejavu.sk (Michal Gajdoš) — Tue, 28 Jan 2014 09:35:12 +0000

Since JAX-RS 2.0 you can use Bean Validation to validate inputs received from users and outputs created in your application. It’s a handy feature and in most cases it works great. But what if you’re using also MVC and you want to display custom error page if something goes wrong? Or what if you want to handle Bean Validation issues in a slightly different way than JAX-RS implementation you’re using does? This article will give you some answers to these questions.

Updating Jersey 2 in GlassFish 4

michal@dejavu.sk (Michal Gajdoš) — Tue, 21 Jan 2014 13:35:26 +0000

Different life-cycles of Jersey 2 and GlassFish 4 arise a question how to make sure that ones GlassFish instance contains always the latest version of Jersey. This question is even more important in case you don’t want to download the nightly/promoted build every-time a new version of Jersey is released but you still want to use the latest and greatest Jersey.

Note: The script below is not compatible with Jersey 2.6 at the moment. I’ll update it as soon as possible.

Managed JAX-RS Client

michal@dejavu.sk (Michal Gajdoš) — Thu, 16 Jan 2014 17:35:41 +0000

Common use-case in web-application development is aggregating data from multiple resources, combining them together and returning them to the used as XML/JSON or as a web page. In Java world these (external) resources can be approached via standardized Clients from JAX-RS 2.0. Jersey 2 application can use so-called managed client mechanism that brings a convenient way to create JAX-RS clients and web targets for such resources.

Running Jersey 2 Applications on Heroku

michal@dejavu.sk (Michal Gajdoš) — Thu, 09 Jan 2014 13:50:32 +0000

In this article we’ll create a simple Jersey application deploy it in Jetty servlet container and everything will be hosted on Heroku.

Create an Application

To create a skeleton of Jersey 2 web-app that can be run on Heroku from the jersey-heroku-webapp archetype (available since Jersey 2.5), execute the following Maven command in the directory where you want the new project should be located:

mvn archetype:generate -DarchetypeArtifactId=jersey-heroku-webapp \
    -DarchetypeGroupId=org.glassfish.jersey.archetypes -DinteractiveMode=false \
    -DgroupId=com.example -DartifactId=simple-heroku-webapp -Dpackage=com.example \
    -DarchetypeVersion=2.5.1

Adjust the groupId, package and/or artifactId of your new web application project to your needs or, alternatively, you can change it by updating the new project pom.xml once it gets generated.

Binding JAX-RS Providers to Resource Methods

michal@dejavu.sk (Michal Gajdoš) — Wed, 08 Jan 2014 18:35:02 +0000

When you register providers (such as filters and interceptors) in your application they’re associated and applied to each resource method by default. In other words they’re bound globally. For most cases this approach is sufficient but sometimes, especially when you want to use your provider only with a few methods, it’s not enough. JAX-RS 2.0 brings a solution for this situation: Name and Dynamic Binding.

Registering Resources and Providers in Jersey 2

michal@dejavu.sk (Michal Gajdoš) — Tue, 19 Nov 2013 09:35:26 +0000

There has been some confusion on StackOverflow lately about how to register JAX-RS resource classes and custom providers in Jersey 2. The main problem seemed to be finding and using correct properties and methods to configure a JAX-RS/Jersey application. In this article I’d like to discuss 3 ways how to configure such an application properly.