Chapter 29. Migration Guide

The most fundamental change in Jersey 2.26 and later is that all the modules (including the client module) are now being built with Java SE 8 and with 1.8 language level.

As a consequential change, one of the modules was dropped, the rx-client-jsr166e. This implementation relied on the ConcurrentHashMapV8 and was made redundant by the JDK upgrade. Please use rx-client-java8 instead.

Spring version used in the extension module was upgraded to 4.2.1.RELEASE. The reason for that is lack of Java 8 support with Spring 3.x versions. Optionally, an extension module for Spring 5 can be used.

Jersey proprietary reactive client API has been dropped and replaced by JAX-RS 2.1 Reactive Client API. The backwards compatibility rule couldn't be respected in this case, since the JAX-RS API are based on what was done in Jersey and there were unresolvable code incompatibilities.

Classes in which HK2 ServiceLocator was simply replaced by InjectionManager and the replacing influenced their public methods:

Support for HK2 Binder in the case of using HK2 Injection Module was implemented but Jersey newly supports a registration its own AbstractBinder and Binder in Application to easily switch from HK2 classes to Jersey ones just by adjusting the imports.

InjectionManager contains a mechanism for registering DI specific injection bindings, in case the application uses CDI, developers should use CDI mechanism, in case the application uses HK2, developers should configure HK2 - ideally via configuring a parent locator that is then passed to Jersey. The custom bindings can be also registered through Application if InjectionManager supports the bindings type that means that InjectionManager#isRegistrable returns true;

In ResourceConfig and ClientConfig configuration methods for auto-discoverable components and meta-components (e.g. Feature) accept InjectionManager and moreover the meta-components accept ManagedObjectFinalizer which ensures a pre-destroy method invocation on registered components.

Method getTemplateObjectFactory in AbstractTemplateProcessor accepts a function that initializes a retrieved template factory from a configuration, usually this function is just a wrapper with underlying InjectionManager invocation.

HK2-specific annotations @Optional, @Immediate, @Unqualified are no longer supported directly in Jersey but can be used if HK2 Injection Module is used.

HK2-specific annotations @PerLookup and @PerThread are migrated to Jersey with an adjusted package.

<dependency>
  <groupId>org.glassfish.jersey.inject</groupId>
  <artifactId>jersey-hk2</artifactId>
  <version>3.0.0</version>
</dependency>

LoggingFilter has been removed. Use LoggingFeature instead. See Logging chapter.

LoggingFilter has been marked as deprecated and will be removed in a subsequent release. Use LoggingFeature instead. See chapter logging.

In previous Jersey versions, if the resource method created a response containing relative URI in the Location http header, the URI was resolved against base uri of the application. This behaviour was not correct, as pointed out by JERSEY-2838. With this change, the URI is, by default, resolved against request base uri.

For example, having a resource at http://server.com/api/management/user, that returns response with Location: foo, while the root of the app is http://server.com/api, the resulting URI will be:

Please note, that the trailing slash is significant, so that if the URI ends with a slash ( http://server.com/api/management/user/), the output will be:

Alternatively, the entire URI resolving logic can be switched off by newly introduced ServerProperties.LOCATION_HEADER_RELATIVE_URI_RESOLUTION_DISABLED property. If the value is true, Jersey will not change the URI contained in the Location header at all (even if this behaviour may not match with behaviour described in JavaDoc).

New parameter, org.glassfish.hk2.api.ServiceLocator, has been added to ExternalRequestScope methods. This is to allow 3rd party component providers to hook up with the actual HK2 locator in case of multiple Jersey applications are running in parallel within a single 3rd party component container. The change was driven by CDI/Servlet requirements.

New method, close, has been added to ResourceFinder. Its intention is to release allocated/opened resources (such as streams) without a need to iterate through the whole ResourceFinder.

org.glassfish.jersey.apache.connector.ApacheClientProperties - constant SSL_CONFIG has been removed. Use ClientBuilder methods to configure SSL in a Client instance.

org.glassfish.jersey.jetty.connector.JettyClientProperties - constant SSL_CONFIG has been removed. Use ClientBuilder methods to configure SSL in a Client instance.

FreemarkerMvcFeature.TEMPLATES_BASE_PATH - constant has been unified across MVC modules and the deprecated one has been removed. Use FreemarkerMvcFeature.TEMPLATE_BASE_PATH or property jersey.config.server.mvc.templateBasePath.freemarker instead.

JspMvcFeature.TEMPLATES_BASE_PATH - constant has been unified across MVC modules and the deprecated one has been removed. Use JspMvcFeature.TEMPLATE_BASE_PATH or property jersey.config.server.mvc.templateBasePath.jsp instead.

Integration of executor providers for Jersey runtime has been unified and refactored. As a result, the org.glassfish.jersey.spi.RequestExecutorProvider and org.glassfish.jersey.spi.RuntimeThreadProvider SPIs have been removed from Jersey. A new, common & generic executor service providers have been introduced instead: ExecutorServiceProvider and ScheduledExecutorServiceProvider. These new providers are used to support custom qualified executor service injection, including the refactored use cases of client asynchronous request execution, server-side managed asynchronous request processing as well as server-side background task scheduler.

org.glassfish.jersey.apache.connector.ApacheClientProperties - constant SSL_CONFIG has been marked as deprecated and will be removed in a subsequent release. Use ClientBuilder methods to configure SSL in a Client instance.

org.glassfish.jersey.jetty.connector.JettyClientProperties - constant SSL_CONFIG has been marked as deprecated and will be removed in a subsequent release. Use ClientBuilder methods to configure SSL in a Client instance.

JAX-B support modularization might cause breaking changes for those users relying on JAX-B and directly referring to the Jersey core-common module:

                                <dependency> <groupId>org.glassfish.jersey.core</groupId> <artifactId>jersey-common</artifactId>
                                <version>${pre-2.16-version}</version> </dependency>

The following needs to be included in addition from version 2.16 on:

                                <dependency> <groupId>org.glassfish.jersey.media</groupId> <artifactId>jersey-media-jaxb</artifactId>
                                <version>3.0.0</version> </dependency>

MediaType's quality source parameters (qs) reuse the same parsing as quality parameters. This means that values higher than 1.0 throw ParseException. I.e. following example is not allowed any more:

                                @Path("/") @Produces("text/html;qs=5") // wrong 'qs' value public class Bookstore { ... }
                            

CDI support improvement caused breaking changes for those users directly referring to the following CDI supporting Jersey module in maven:

                                <dependency> <groupId>org.glassfish.jersey.containers.glassfish</groupId> <artifactId>jersey-gf-cdi</artifactId>
                                <version>${pre-2.15-version}</version> </dependency>

The above dependency needs to be replaced with:

                                <dependency> <groupId>org.glassfish.jersey.ext.cdi</groupId> <artifactId>jersey-cdi1x</artifactId>
                                <version>3.0.0</version> </dependency>

The following needs to be included in addition if you want to leverage CDI JTA support:

                                <dependency> <groupId>org.glassfish.jersey.ext.cdi</groupId> <artifactId>jersey-cdi1x-transaction</artifactId>
                                <version>3.0.0</version> </dependency>

Jersey client-side HttpAuthenticationFeature API.

Jersey server-side DestroyListener (formerly ExtendedMonitoringStatisticsListener), which has been slightly refactored and is now a separate interface (e.g. not extendingMonitoringStatisticsListener), hence providing better compatibility with lambdas.

Because of a bug fix for issue JERSEY-2602, we re-generate WADL classes from wadl.xsd to make sure the getters for boolean properties starts with is instead of get as in Jersey 1 and Jersey <= 2.6.

For performance purposes a new server property ServerProperties.MONITORING_ENABLED has been introduced. It is possible to enable just basic almost static monitoring information using the property. It allows to inject ApplicationInfo object, renamed original class org.glassfish.jersey.server.monitoring.ApplicationStatistics. And MonitoringStatistics no more have a reference to ApplicationStatistics, method getApplicationStatistics() has been removed.

org.glassfish.jersey.server.model.ResourceModelContext (not used)

org.glassfish.jersey.server.model.ResourceModelListener (not used)

Some of the feature specific configuration properties (disable WADL, disable BV, disable JSON-Processing, enable Monitoring), and their server/client counterparts, are no longer affected by a value of properties CommonProperties.FEATURE_AUTO_DISCOVERY_DISABLE or CommonProperties.METAINF_SERVICES_LOOKUP_DISABLE. The specific properties have to be used to change default behaviour of mentioned features (e.g. ServerProperties.WADL_FEATURE_DISABLE).

Automatic registration of MessageBodyWriter, MessageBodyReaders and ExceptionMappers via META-INF/services mechanism has been removed. Disabling the automatic registration of providers via META-INF/services may affect 3rd party libraries (i.e. Jackson 2.x) that are using this mechanism to register its providers. In order to restore this functionality the org.glassfish.jersey.ext:jersey-metainf-services has to be added on the classpath. Otherwise such providers has to be registered manually.

The Jackson JSON Jersey module has been updated to use Jackson 2.x instead of Jackson 1.x. This means that all the code that has been using Jackson 1.x for JSON (de)serialization has to be migrated to Jackson 2.x.

Because of a bug fix for issue JERSEY-2458, there has been a slight change in the behavior of UriInfo getPath and getPathSegments methods. The getPath methods no longer return a path prefixed with a slash ('/'), instead they now correctly return a request path relative to the base request URI. Also, the UriInfo now correctly handles requests which URI contains empty path segments (e.g.http://localhost///a/b//c). These empty path segments are now correctly included in the lists returned by the UriInfo.getPathSegments methods.

SseFeature now gets automatically discovered and enabled if the SSE module is present on the class path. This behavior can be suppressed by setting DISABLE_SSE property to true. The behavior can also be selectively suppressed in either client or server runtime by setting the DISABLE_SSE_CLIENT or DISABLE_SSE_SERVER property respectively.

Deprecated getDestroyTime method has been removed from org.glassfish.jersey.server.monitoring.ApplicationStatistics. To get the application shutdown information, a ContainerLifecycleListener should be registered and its onShutdown method implemented to listen to and process the application shutdown event.

Method triggerEvent(RequestEvent.Type) has been removed from the public ContainerRequest API. This method has never been intended for public, application-level use.

In Jersey 2.7 and earlier it was (under certain conditions) possible to supply custom TestContainerFactory as part of the tested JAX-RS / Jersey application. This factory would be picked and used by JerseyTest to instantiate TestContainer that will host the tested application. This feature was unreliable and redundant. As such, support for the feature has been removed. To specify a custom TestContainerFactory to be used by your JerseyTest subclass, please override the JerseyTest.getTestContainerFactory method instead. Overriding getTestContainerFactory now remains the only reliable way of specifying custom TestContainerFactory implementation to be used in your tests.

Protected method setTestContainerFactory has been removed from the JerseyTest API as calling the method had no effect on the TestContainerFactory instance used by the JerseyTest subclass.

Protected method getClient has been removed from the JerseyTest API. To configure test client instances, please override the configureClient method instead.

Utility methods JerseyTest that provide access to pre-configured Client and WebTarget instances ( client(), target(...)) have been made final to prevent overriding in subclasses and thus ensure consistency of the jersey test framework functionality.

JerseyTest constructor JerseyTest(Class<? extends Application>) has been made deprecated and will be removed in the subsequent Jersey release.

It was previously possible to pass in a custom ContainerProvider that was supposed to deploy and run the application as one of the JAX-RS / Jersey application providers. This ability has been removed without any substitute as the concept was fundamentally flawed. Typical use cases should not be affected by this change.

Factory methods createHttpServer which take Jersey ApplicationHandler as one of the input parameters have been removed from the Jersey container factory API as inherently broken. This impacts GrizzlyHttpServerFactory, JdkHttpServerFactory, JettyHttpContainerFactory and SimpleContainerFactory implementations. The methods that take ResourceConfig as input parameter should be used instead. Typical use cases should not be affected by this change.

Method registerAdditionalBinders on ApplicationHandler has been removed from the public API. Please use the specific ApplicationHandler constructor that accepts custom HK2 binders instead.

Several configuration properties were renamed, especially those having client and server versions along with the common version in CommonProperties. Please see following table for complete reference:

The old names are still working for now, but are deprecated. There is a fallback mechanism implemented while reading the property and each get, that resolves the value from the old-named property, will log a CONFIG level warning.

Until version 2.6, Jersey was compiled with Java SE 6. This has changes in Jersey 2.7. Now almost all Jersey components are compiled with Java SE 7 target. It means, that you will need at least Java SE 7 to be able to compile and run your application that is using latest Jersey. Only core-common and core-client modules are still compiled with Java class version runnable with Java SE 6.

MVC support: method writeTo of TemplateProcessor was modified by adding an argument MultivaluedMap<String, Object> httpHeaders. This is an incompatible change (the method was modified directly in the interface). All Jersey provided MVC implementation were adjusted but if you have your own MVC implementation then you need to modify the method signature of the implementation.

A minor JAX-RS incompatibility issue has been recently discovered and reported (see JERSEY-2387). As part of the fix, minor breaking changes related to URI resolving and creation have been introduced in the behavior of UriBuilder, Link.Builder and WebTarget classes. It is no longer possible to successfully build a new URI instance from a UriBuilder that contains unresolved template parameters. An IllegalArgumentException will be thrown in such case, as mandated by JAX-RS API javadoc. Similarly, it is not possible to successfully create a Link instance from a URI template with unresolved template parameters. Also, it is not possible to successfully send a request on a WebTarget that represents a URI template that does not have all the template parameters properly resolved. Any attempt to do so will fail with an exception. Note that this also applies to any managed clients injected into JAX-RS server-side components using Uri annotation.

In Jersey 2.6 and earlier, producing a URI from an incompletely resolved URI template would succeed and all unresolved template parameter locations would be encoded without change into the resulting URI, for example "/path/{param}" would be implicitly encoded as "/path/%7Bparam%7D". While we do not expect our users to depend on this functionality, if the former behavior is desired for some reason, UriComponent.encodeTemplateNames method can be used instead:

                                URI.create(UriComponent.encodeTemplateNames(UriBuilder.fromUri("/path/{param}").toTemplate()));
                            

or simply

                                URI.create(UriComponent.encodeTemplateNames("/path/{param}"));
                            

org.glassfish.jersey.message.internal.HttpDateFormat - method getPreferedDateFormat() has been marked as deprecated due to typo in the name. New method getPreferredDateFormat() should be used instead.

org.glassfish.jersey.client.filter.HttpBasicAuthFilter and org.glassfish.jersey.client.filter.HttpDigestAuthFilter (use HttpAuthenticationFeature instead)

org.glassfish.jersey.apache.connector.ApacheClientProperties.HTTP_PARAMS (use org.glassfish.jersey.apache.connector.ApacheClientProperties#REQUEST_CONFIG instead), org.glassfish.jersey.apache.connector.ApacheClientProperties.PROXY_URI, org.glassfish.jersey.apache.connector.ApacheClientProperties.PROXY_USERNAME, org.glassfish.jersey.apache.connector.ApacheClientProperties.PROXY_PASSWORD (use corresponding ClientProperties instead.

org.glassfish.jersey.server.validation.ValidationConfig.setMessageInterpolator org.glassfish.jersey.server.validation.ValidationConfig.setTraversableResolver org.glassfish.jersey.server.validation.ValidationConfig.setConstraintValidatorFactory org.glassfish.jersey.server.validation.ValidationConfig.setParameterNameProvider (use corresponding methods of the same class without "set" prefix in the method names).

org.glassfish.jersey.server.mvc.MvcProperties (use properties of org.glassfish.jersey.server.mvc.MvcFeature instead).

MVC does not allow to specify the resolving class. Resolving class is used to create a path of the template. Changes are:

Annotation attribute Class<?> org.glassfish.jersey.server.mvc.Template.resolvingClass() (the attribute was obsolete and therefore removed. Resolving class now always the resource class in which the MVC resource method is defined).

resolvingClass was removed from Viewable. The constructor no longer accepts this argument and there is no getter for this field.

org.glassfish.jersey.server.mvc.freemarker.FreemarkerProperties (use FreemarkerMvcFeature instead)

org.glassfish.jersey.server.mvc.jsp.JspProperties (use JspMvcFeature instead)

org.glassfish.jersey.server.model.RuntimeResource.getFirstParentResource() (use Resource.getParent() instead).

Client chunked encoding configuration behaviour has changed:

Jersey client uses chunked encoding (streaming) for serialization of the entity as a default option. Before Jersey 2.5 release entity buffering has been used by default. The size of the chunk can still be controlled by ClientProperties.CHUNKED_ENCODING_SIZE property, this property however no longer enforces the use of chunked encoding. To control request entity buffering and chunked transfer coding selection, please utilize use the new ClientProperties.REQUEST_ENTITY_PROCESSING property. The behaviour of the property is however not unified across the available Connector implementations and depends on the connector implementation configured for the Client instance. Default connector produced by HttpUrlConnectorProvider still uses buffering as default options due to bugs in HttpURLConnection. On the other hand, Jetty HTTP Client based connectors produced by JettyConnectorProvider do not support chunked encoding at all.

Please note that this is not a newly introduced limitation - it's merely an official acknowledgement of the fact that different connectors have different capabilities and limitations - something that has always been part of the individual connector implementations, it just was not publicly acknowledged.

New ConnectorProvider SPI has been introduced to decouple Connector instantiation from Client instance boot-strapping. As such, the connector(Connector) method has been removed from ClientConfig API. It has been replaced with a newly introduced connectorProvider(ConnectorProvider) method.

org.glassfish.jersey.client.HttpUrlConnector has been removed from the public API. HttpUrlConnectorProvider should be used to produce HttpURLConnection connector instances instead.

ClientProperties.HTTP_URL_CONNECTION_SET_METHOD_WORKAROUND property has been moved to the new HttpUrlConnectorProvider has been introduced in Jersey 2.4) has been moved to the new HttpUrlConnectorProvider class as this property is specific to the connector instances created by HttpUrlConnectorProvider only. The property has been also renamed to HttpUrlConnector.SET_METHOD_WORKAROUND. The name of the property remains the same - jersey.config.client.httpUrlConnection.setMethodWorkaround.

ClientProperties.HTTP_URL_CONNECTOR_FIX_LENGTH_STREAMING property (that class as this property is specific to the connector instances created by HttpUrlConnectorProvider only. The property has been also renamed to HttpUrlConnectorProvider.USE_FIXED_LENGTH_STREAMING and the new property name is jersey.config.client.httpUrlConnector.useFixedLengthStreaming.

org.glassfish.jersey.grizzly.connector.GrizzlyConnector has been removed from the public API. GrizzlyConnectorProvider should be used to produce Grizzly Asynchronous HTTP Client connector instances instead.

Public constructor has been removed from the org.glassfish.jersey.apache.connector.ApacheConnector; API. ApacheConnectorProvider should be used to provide Apache HTTP Client connector instances instead.

Public constructor has been removed from the org.glassfish.jersey.jetty.connector.JettyConnector; API. JettyConnectorProvider should be used to provide Jetty HTTP Client connector instances instead.

Renamed property CACHING_TEMPLATES_ENABLED in MustacheMvcFeature from jersey.config.server.mvc.caching.mustache.enabled to jersey.config.server.mvc.caching.mustache.

Authentication filters org.glassfish.jersey.client.filter.HttpBasicAuthFilter and org.glassfish.jersey.client.filter.HttpDigestAuthFilter were deprecated and replaced by HttpAuthenticationFeature.

The ContainerLifecycleListener invokes event onStartup and onShutdown also when application is being started or stopped because of application redeploy. The interface was marked as a Beta now.

The monitoring statistics method ApplicationStatistics.getDestroyTime() is deprecated and returns always null. Use ContainerLifecycleListener to listen on application destroy and get the destroy time.

org.glassfish.jersey.spi.ResponseExecutorsProvider contract has been completely removed from the Jersey SPI as it was inconsistently used by Jersey runtime and we did not find a suitable use case where a custom response executor would make sense. While we have no indication that the removed SPI is used in the Jersey community, please do not hesitate to contact us in case you think that you have a valid use case where the use of a custom response executor makes sense.

org.glassfish.jersey.spi.RequestsExecutorsProvider contract has been renamed to org.glassfish.jersey.spi.RequestsExecutorsProvider. It has been also extended with an additional releaseRequestingExecutor method to address executor shutdown handling issues reported in JERSEY-2205. As such, any custom implementation of the SPI is now required to implement the new method. (Note that the SPI has been removed in Jersey 2.18 - see the Jersey 2.18 release migration guide section for more details.)